Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

55 files changed, 9457 insertions, 0 deletions

diff --git a/xbmc/addons/interfaces/gui/CMakeLists.txt b/xbmc/addons/interfaces/gui/CMakeLists.txt
new file mode 100644
index 0000000..3508b82
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(SOURCES GUITranslator.cpp
+            General.cpp
+            ListItem.cpp
+            Window.cpp)
+
+set(HEADERS GUITranslator.h
+            General.h
+            ListItem.h
+            Window.h)
+
+core_add_library(addons_interfaces_gui)
diff --git a/xbmc/addons/interfaces/gui/GUITranslator.cpp b/xbmc/addons/interfaces/gui/GUITranslator.cpp
new file mode 100644
index 0000000..2db2601
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/GUITranslator.cpp
@@ -0,0 +1,969 @@
+/*
+ *  Copyright (C) 2005-2020 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUITranslator.h"
+
+#include "input/actions/ActionIDs.h"
+
+using namespace ADDON;
+
+ADDON_ACTION CAddonGUITranslator::TranslateActionIdToAddon(int kodiId)
+{
+  switch (kodiId)
+  {
+    case ACTION_NONE:
+      return ADDON_ACTION_NONE;
+    case ACTION_MOVE_LEFT:
+      return ADDON_ACTION_MOVE_LEFT;
+    case ACTION_MOVE_RIGHT:
+      return ADDON_ACTION_MOVE_RIGHT;
+    case ACTION_MOVE_UP:
+      return ADDON_ACTION_MOVE_UP;
+    case ACTION_MOVE_DOWN:
+      return ADDON_ACTION_MOVE_DOWN;
+    case ACTION_PAGE_UP:
+      return ADDON_ACTION_PAGE_UP;
+    case ACTION_PAGE_DOWN:
+      return ADDON_ACTION_PAGE_DOWN;
+    case ACTION_SELECT_ITEM:
+      return ADDON_ACTION_SELECT_ITEM;
+    case ACTION_HIGHLIGHT_ITEM:
+      return ADDON_ACTION_HIGHLIGHT_ITEM;
+    case ACTION_PARENT_DIR:
+      return ADDON_ACTION_PARENT_DIR;
+    case ACTION_PREVIOUS_MENU:
+      return ADDON_ACTION_PREVIOUS_MENU;
+    case ACTION_SHOW_INFO:
+      return ADDON_ACTION_SHOW_INFO;
+    case ACTION_PAUSE:
+      return ADDON_ACTION_PAUSE;
+    case ACTION_STOP:
+      return ADDON_ACTION_STOP;
+    case ACTION_NEXT_ITEM:
+      return ADDON_ACTION_NEXT_ITEM;
+    case ACTION_PREV_ITEM:
+      return ADDON_ACTION_PREV_ITEM;
+    case ACTION_FORWARD:
+      return ADDON_ACTION_FORWARD;
+    case ACTION_REWIND:
+      return ADDON_ACTION_REWIND;
+    case ACTION_SHOW_GUI:
+      return ADDON_ACTION_SHOW_GUI;
+    case ACTION_ASPECT_RATIO:
+      return ADDON_ACTION_ASPECT_RATIO;
+    case ACTION_STEP_FORWARD:
+      return ADDON_ACTION_STEP_FORWARD;
+    case ACTION_STEP_BACK:
+      return ADDON_ACTION_STEP_BACK;
+    case ACTION_BIG_STEP_FORWARD:
+      return ADDON_ACTION_BIG_STEP_FORWARD;
+    case ACTION_BIG_STEP_BACK:
+      return ADDON_ACTION_BIG_STEP_BACK;
+    case ACTION_SHOW_OSD:
+      return ADDON_ACTION_SHOW_OSD;
+    case ACTION_SHOW_SUBTITLES:
+      return ADDON_ACTION_SHOW_SUBTITLES;
+    case ACTION_NEXT_SUBTITLE:
+      return ADDON_ACTION_NEXT_SUBTITLE;
+    case ACTION_PLAYER_DEBUG:
+      return ADDON_ACTION_PLAYER_DEBUG;
+    case ACTION_NEXT_PICTURE:
+      return ADDON_ACTION_NEXT_PICTURE;
+    case ACTION_PREV_PICTURE:
+      return ADDON_ACTION_PREV_PICTURE;
+    case ACTION_ZOOM_OUT:
+      return ADDON_ACTION_ZOOM_OUT;
+    case ACTION_ZOOM_IN:
+      return ADDON_ACTION_ZOOM_IN;
+    case ACTION_TOGGLE_SOURCE_DEST:
+      return ADDON_ACTION_TOGGLE_SOURCE_DEST;
+    case ACTION_SHOW_PLAYLIST:
+      return ADDON_ACTION_SHOW_PLAYLIST;
+    case ACTION_QUEUE_ITEM:
+      return ADDON_ACTION_QUEUE_ITEM;
+    case ACTION_REMOVE_ITEM:
+      return ADDON_ACTION_REMOVE_ITEM;
+    case ACTION_SHOW_FULLSCREEN:
+      return ADDON_ACTION_SHOW_FULLSCREEN;
+    case ACTION_ZOOM_LEVEL_NORMAL:
+      return ADDON_ACTION_ZOOM_LEVEL_NORMAL;
+    case ACTION_ZOOM_LEVEL_1:
+      return ADDON_ACTION_ZOOM_LEVEL_1;
+    case ACTION_ZOOM_LEVEL_2:
+      return ADDON_ACTION_ZOOM_LEVEL_2;
+    case ACTION_ZOOM_LEVEL_3:
+      return ADDON_ACTION_ZOOM_LEVEL_3;
+    case ACTION_ZOOM_LEVEL_4:
+      return ADDON_ACTION_ZOOM_LEVEL_4;
+    case ACTION_ZOOM_LEVEL_5:
+      return ADDON_ACTION_ZOOM_LEVEL_5;
+    case ACTION_ZOOM_LEVEL_6:
+      return ADDON_ACTION_ZOOM_LEVEL_6;
+    case ACTION_ZOOM_LEVEL_7:
+      return ADDON_ACTION_ZOOM_LEVEL_7;
+    case ACTION_ZOOM_LEVEL_8:
+      return ADDON_ACTION_ZOOM_LEVEL_8;
+    case ACTION_ZOOM_LEVEL_9:
+      return ADDON_ACTION_ZOOM_LEVEL_9;
+    case ACTION_CALIBRATE_SWAP_ARROWS:
+      return ADDON_ACTION_CALIBRATE_SWAP_ARROWS;
+    case ACTION_CALIBRATE_RESET:
+      return ADDON_ACTION_CALIBRATE_RESET;
+    case ACTION_ANALOG_MOVE:
+      return ADDON_ACTION_ANALOG_MOVE;
+    case ACTION_ROTATE_PICTURE_CW:
+      return ADDON_ACTION_ROTATE_PICTURE_CW;
+    case ACTION_ROTATE_PICTURE_CCW:
+      return ADDON_ACTION_ROTATE_PICTURE_CCW;
+    case ACTION_SUBTITLE_DELAY_MIN:
+      return ADDON_ACTION_SUBTITLE_DELAY_MIN;
+    case ACTION_SUBTITLE_DELAY_PLUS:
+      return ADDON_ACTION_SUBTITLE_DELAY_PLUS;
+    case ACTION_AUDIO_DELAY_MIN:
+      return ADDON_ACTION_AUDIO_DELAY_MIN;
+    case ACTION_AUDIO_DELAY_PLUS:
+      return ADDON_ACTION_AUDIO_DELAY_PLUS;
+    case ACTION_AUDIO_NEXT_LANGUAGE:
+      return ADDON_ACTION_AUDIO_NEXT_LANGUAGE;
+    case ACTION_CHANGE_RESOLUTION:
+      return ADDON_ACTION_CHANGE_RESOLUTION;
+    case REMOTE_0:
+      return ADDON_ACTION_REMOTE_0;
+    case REMOTE_1:
+      return ADDON_ACTION_REMOTE_1;
+    case REMOTE_2:
+      return ADDON_ACTION_REMOTE_2;
+    case REMOTE_3:
+      return ADDON_ACTION_REMOTE_3;
+    case REMOTE_4:
+      return ADDON_ACTION_REMOTE_4;
+    case REMOTE_5:
+      return ADDON_ACTION_REMOTE_5;
+    case REMOTE_6:
+      return ADDON_ACTION_REMOTE_6;
+    case REMOTE_7:
+      return ADDON_ACTION_REMOTE_7;
+    case REMOTE_8:
+      return ADDON_ACTION_REMOTE_8;
+    case REMOTE_9:
+      return ADDON_ACTION_REMOTE_9;
+    case ACTION_PLAYER_PROCESS_INFO:
+      return ADDON_ACTION_PLAYER_PROCESS_INFO;
+    case ACTION_PLAYER_PROGRAM_SELECT:
+      return ADDON_ACTION_PLAYER_PROGRAM_SELECT;
+    case ACTION_PLAYER_RESOLUTION_SELECT:
+      return ADDON_ACTION_PLAYER_RESOLUTION_SELECT;
+    case ACTION_SMALL_STEP_BACK:
+      return ADDON_ACTION_SMALL_STEP_BACK;
+    case ACTION_PLAYER_FORWARD:
+      return ADDON_ACTION_PLAYER_FORWARD;
+    case ACTION_PLAYER_REWIND:
+      return ADDON_ACTION_PLAYER_REWIND;
+    case ACTION_PLAYER_PLAY:
+      return ADDON_ACTION_PLAYER_PLAY;
+    case ACTION_DELETE_ITEM:
+      return ADDON_ACTION_DELETE_ITEM;
+    case ACTION_COPY_ITEM:
+      return ADDON_ACTION_COPY_ITEM;
+    case ACTION_MOVE_ITEM:
+      return ADDON_ACTION_MOVE_ITEM;
+    case ACTION_TAKE_SCREENSHOT:
+      return ADDON_ACTION_TAKE_SCREENSHOT;
+    case ACTION_RENAME_ITEM:
+      return ADDON_ACTION_RENAME_ITEM;
+    case ACTION_VOLUME_UP:
+      return ADDON_ACTION_VOLUME_UP;
+    case ACTION_VOLUME_DOWN:
+      return ADDON_ACTION_VOLUME_DOWN;
+    case ACTION_VOLAMP:
+      return ADDON_ACTION_VOLAMP;
+    case ACTION_MUTE:
+      return ADDON_ACTION_MUTE;
+    case ACTION_NAV_BACK:
+      return ADDON_ACTION_NAV_BACK;
+    case ACTION_VOLAMP_UP:
+      return ADDON_ACTION_VOLAMP_UP;
+    case ACTION_VOLAMP_DOWN:
+      return ADDON_ACTION_VOLAMP_DOWN;
+    case ACTION_CREATE_EPISODE_BOOKMARK:
+      return ADDON_ACTION_CREATE_EPISODE_BOOKMARK;
+    case ACTION_CREATE_BOOKMARK:
+      return ADDON_ACTION_CREATE_BOOKMARK;
+    case ACTION_CHAPTER_OR_BIG_STEP_FORWARD:
+      return ADDON_ACTION_CHAPTER_OR_BIG_STEP_FORWARD;
+    case ACTION_CHAPTER_OR_BIG_STEP_BACK:
+      return ADDON_ACTION_CHAPTER_OR_BIG_STEP_BACK;
+    case ACTION_CYCLE_SUBTITLE:
+      return ADDON_ACTION_CYCLE_SUBTITLE;
+    case ACTION_MOUSE_LEFT_CLICK:
+      return ADDON_ACTION_MOUSE_LEFT_CLICK;
+    case ACTION_MOUSE_RIGHT_CLICK:
+      return ADDON_ACTION_MOUSE_RIGHT_CLICK;
+    case ACTION_MOUSE_MIDDLE_CLICK:
+      return ADDON_ACTION_MOUSE_MIDDLE_CLICK;
+    case ACTION_MOUSE_DOUBLE_CLICK:
+      return ADDON_ACTION_MOUSE_DOUBLE_CLICK;
+    case ACTION_MOUSE_WHEEL_UP:
+      return ADDON_ACTION_MOUSE_WHEEL_UP;
+    case ACTION_MOUSE_WHEEL_DOWN:
+      return ADDON_ACTION_MOUSE_WHEEL_DOWN;
+    case ACTION_MOUSE_DRAG:
+      return ADDON_ACTION_MOUSE_DRAG;
+    case ACTION_MOUSE_MOVE:
+      return ADDON_ACTION_MOUSE_MOVE;
+    case ACTION_MOUSE_LONG_CLICK:
+      return ADDON_ACTION_MOUSE_LONG_CLICK;
+    case ACTION_MOUSE_DRAG_END:
+      return ADDON_ACTION_MOUSE_DRAG_END;
+    case ACTION_BACKSPACE:
+      return ADDON_ACTION_BACKSPACE;
+    case ACTION_SCROLL_UP:
+      return ADDON_ACTION_SCROLL_UP;
+    case ACTION_SCROLL_DOWN:
+      return ADDON_ACTION_SCROLL_DOWN;
+    case ACTION_ANALOG_FORWARD:
+      return ADDON_ACTION_ANALOG_FORWARD;
+    case ACTION_ANALOG_REWIND:
+      return ADDON_ACTION_ANALOG_REWIND;
+    case ACTION_MOVE_ITEM_UP:
+      return ADDON_ACTION_MOVE_ITEM_UP;
+    case ACTION_MOVE_ITEM_DOWN:
+      return ADDON_ACTION_MOVE_ITEM_DOWN;
+    case ACTION_CONTEXT_MENU:
+      return ADDON_ACTION_CONTEXT_MENU;
+    case ACTION_SHIFT:
+      return ADDON_ACTION_SHIFT;
+    case ACTION_SYMBOLS:
+      return ADDON_ACTION_SYMBOLS;
+    case ACTION_CURSOR_LEFT:
+      return ADDON_ACTION_CURSOR_LEFT;
+    case ACTION_CURSOR_RIGHT:
+      return ADDON_ACTION_CURSOR_RIGHT;
+    case ACTION_BUILT_IN_FUNCTION:
+      return ADDON_ACTION_BUILT_IN_FUNCTION;
+    case ACTION_SHOW_OSD_TIME:
+      return ADDON_ACTION_SHOW_OSD_TIME;
+    case ACTION_ANALOG_SEEK_FORWARD:
+      return ADDON_ACTION_ANALOG_SEEK_FORWARD;
+    case ACTION_ANALOG_SEEK_BACK:
+      return ADDON_ACTION_ANALOG_SEEK_BACK;
+    case ACTION_VIS_PRESET_SHOW:
+      return ADDON_ACTION_VIS_PRESET_SHOW;
+    case ACTION_VIS_PRESET_NEXT:
+      return ADDON_ACTION_VIS_PRESET_NEXT;
+    case ACTION_VIS_PRESET_PREV:
+      return ADDON_ACTION_VIS_PRESET_PREV;
+    case ACTION_VIS_PRESET_LOCK:
+      return ADDON_ACTION_VIS_PRESET_LOCK;
+    case ACTION_VIS_PRESET_RANDOM:
+      return ADDON_ACTION_VIS_PRESET_RANDOM;
+    case ACTION_VIS_RATE_PRESET_PLUS:
+      return ADDON_ACTION_VIS_RATE_PRESET_PLUS;
+    case ACTION_VIS_RATE_PRESET_MINUS:
+      return ADDON_ACTION_VIS_RATE_PRESET_MINUS;
+    case ACTION_SHOW_VIDEOMENU:
+      return ADDON_ACTION_SHOW_VIDEOMENU;
+    case ACTION_ENTER:
+      return ADDON_ACTION_ENTER;
+    case ACTION_INCREASE_RATING:
+      return ADDON_ACTION_INCREASE_RATING;
+    case ACTION_DECREASE_RATING:
+      return ADDON_ACTION_DECREASE_RATING;
+    case ACTION_NEXT_SCENE:
+      return ADDON_ACTION_NEXT_SCENE;
+    case ACTION_PREV_SCENE:
+      return ADDON_ACTION_PREV_SCENE;
+    case ACTION_NEXT_LETTER:
+      return ADDON_ACTION_NEXT_LETTER;
+    case ACTION_PREV_LETTER:
+      return ADDON_ACTION_PREV_LETTER;
+    case ACTION_JUMP_SMS2:
+      return ADDON_ACTION_JUMP_SMS2;
+    case ACTION_JUMP_SMS3:
+      return ADDON_ACTION_JUMP_SMS3;
+    case ACTION_JUMP_SMS4:
+      return ADDON_ACTION_JUMP_SMS4;
+    case ACTION_JUMP_SMS5:
+      return ADDON_ACTION_JUMP_SMS5;
+    case ACTION_JUMP_SMS6:
+      return ADDON_ACTION_JUMP_SMS6;
+    case ACTION_JUMP_SMS7:
+      return ADDON_ACTION_JUMP_SMS7;
+    case ACTION_JUMP_SMS8:
+      return ADDON_ACTION_JUMP_SMS8;
+    case ACTION_JUMP_SMS9:
+      return ADDON_ACTION_JUMP_SMS9;
+    case ACTION_FILTER_CLEAR:
+      return ADDON_ACTION_FILTER_CLEAR;
+    case ACTION_FILTER_SMS2:
+      return ADDON_ACTION_FILTER_SMS2;
+    case ACTION_FILTER_SMS3:
+      return ADDON_ACTION_FILTER_SMS3;
+    case ACTION_FILTER_SMS4:
+      return ADDON_ACTION_FILTER_SMS4;
+    case ACTION_FILTER_SMS5:
+      return ADDON_ACTION_FILTER_SMS5;
+    case ACTION_FILTER_SMS6:
+      return ADDON_ACTION_FILTER_SMS6;
+    case ACTION_FILTER_SMS7:
+      return ADDON_ACTION_FILTER_SMS7;
+    case ACTION_FILTER_SMS8:
+      return ADDON_ACTION_FILTER_SMS8;
+    case ACTION_FILTER_SMS9:
+      return ADDON_ACTION_FILTER_SMS9;
+    case ACTION_FIRST_PAGE:
+      return ADDON_ACTION_FIRST_PAGE;
+    case ACTION_LAST_PAGE:
+      return ADDON_ACTION_LAST_PAGE;
+    case ACTION_AUDIO_DELAY:
+      return ADDON_ACTION_AUDIO_DELAY;
+    case ACTION_SUBTITLE_DELAY:
+      return ADDON_ACTION_SUBTITLE_DELAY;
+    case ACTION_MENU:
+      return ADDON_ACTION_MENU;
+    case ACTION_SET_RATING:
+      return ADDON_ACTION_SET_RATING;
+    case ACTION_RECORD:
+      return ADDON_ACTION_RECORD;
+    case ACTION_PASTE:
+      return ADDON_ACTION_PASTE;
+    case ACTION_NEXT_CONTROL:
+      return ADDON_ACTION_NEXT_CONTROL;
+    case ACTION_PREV_CONTROL:
+      return ADDON_ACTION_PREV_CONTROL;
+    case ACTION_CHANNEL_SWITCH:
+      return ADDON_ACTION_CHANNEL_SWITCH;
+    case ACTION_CHANNEL_UP:
+      return ADDON_ACTION_CHANNEL_UP;
+    case ACTION_CHANNEL_DOWN:
+      return ADDON_ACTION_CHANNEL_DOWN;
+    case ACTION_NEXT_CHANNELGROUP:
+      return ADDON_ACTION_NEXT_CHANNELGROUP;
+    case ACTION_PREVIOUS_CHANNELGROUP:
+      return ADDON_ACTION_PREVIOUS_CHANNELGROUP;
+    case ACTION_PVR_PLAY:
+      return ADDON_ACTION_PVR_PLAY;
+    case ACTION_PVR_PLAY_TV:
+      return ADDON_ACTION_PVR_PLAY_TV;
+    case ACTION_PVR_PLAY_RADIO:
+      return ADDON_ACTION_PVR_PLAY_RADIO;
+    case ACTION_PVR_SHOW_TIMER_RULE:
+      return ADDON_ACTION_PVR_SHOW_TIMER_RULE;
+    case ACTION_CHANNEL_NUMBER_SEP:
+      return ADDON_ACTION_CHANNEL_NUMBER_SEP;
+    case ACTION_PVR_ANNOUNCE_REMINDERS:
+      return ADDON_ACTION_PVR_ANNOUNCE_REMINDERS;
+    case ACTION_TOGGLE_FULLSCREEN:
+      return ADDON_ACTION_TOGGLE_FULLSCREEN;
+    case ACTION_TOGGLE_WATCHED:
+      return ADDON_ACTION_TOGGLE_WATCHED;
+    case ACTION_SCAN_ITEM:
+      return ADDON_ACTION_SCAN_ITEM;
+    case ACTION_TOGGLE_DIGITAL_ANALOG:
+      return ADDON_ACTION_TOGGLE_DIGITAL_ANALOG;
+    case ACTION_RELOAD_KEYMAPS:
+      return ADDON_ACTION_RELOAD_KEYMAPS;
+    case ACTION_GUIPROFILE_BEGIN:
+      return ADDON_ACTION_GUIPROFILE_BEGIN;
+    case ACTION_TELETEXT_RED:
+      return ADDON_ACTION_TELETEXT_RED;
+    case ACTION_TELETEXT_GREEN:
+      return ADDON_ACTION_TELETEXT_GREEN;
+    case ACTION_TELETEXT_YELLOW:
+      return ADDON_ACTION_TELETEXT_YELLOW;
+    case ACTION_TELETEXT_BLUE:
+      return ADDON_ACTION_TELETEXT_BLUE;
+    case ACTION_INCREASE_PAR:
+      return ADDON_ACTION_INCREASE_PAR;
+    case ACTION_DECREASE_PAR:
+      return ADDON_ACTION_DECREASE_PAR;
+    case ACTION_VSHIFT_UP:
+      return ADDON_ACTION_VSHIFT_UP;
+    case ACTION_VSHIFT_DOWN:
+      return ADDON_ACTION_VSHIFT_DOWN;
+    case ACTION_PLAYER_PLAYPAUSE:
+      return ADDON_ACTION_PLAYER_PLAYPAUSE;
+    case ACTION_SUBTITLE_VSHIFT_UP:
+      return ADDON_ACTION_SUBTITLE_VSHIFT_UP;
+    case ACTION_SUBTITLE_VSHIFT_DOWN:
+      return ADDON_ACTION_SUBTITLE_VSHIFT_DOWN;
+    case ACTION_SUBTITLE_ALIGN:
+      return ADDON_ACTION_SUBTITLE_ALIGN;
+    case ACTION_FILTER:
+      return ADDON_ACTION_FILTER;
+    case ACTION_SWITCH_PLAYER:
+      return ADDON_ACTION_SWITCH_PLAYER;
+    case ACTION_STEREOMODE_NEXT:
+      return ADDON_ACTION_STEREOMODE_NEXT;
+    case ACTION_STEREOMODE_PREVIOUS:
+      return ADDON_ACTION_STEREOMODE_PREVIOUS;
+    case ACTION_STEREOMODE_TOGGLE:
+      return ADDON_ACTION_STEREOMODE_TOGGLE;
+    case ACTION_STEREOMODE_SELECT:
+      return ADDON_ACTION_STEREOMODE_SELECT;
+    case ACTION_STEREOMODE_TOMONO:
+      return ADDON_ACTION_STEREOMODE_TOMONO;
+    case ACTION_STEREOMODE_SET:
+      return ADDON_ACTION_STEREOMODE_SET;
+    case ACTION_SETTINGS_RESET:
+      return ADDON_ACTION_SETTINGS_RESET;
+    case ACTION_SETTINGS_LEVEL_CHANGE:
+      return ADDON_ACTION_SETTINGS_LEVEL_CHANGE;
+    case ACTION_TRIGGER_OSD:
+      return ADDON_ACTION_TRIGGER_OSD;
+    case ACTION_INPUT_TEXT:
+      return ADDON_ACTION_INPUT_TEXT;
+    case ACTION_VOLUME_SET:
+      return ADDON_ACTION_VOLUME_SET;
+    case ACTION_TOGGLE_COMMSKIP:
+      return ADDON_ACTION_TOGGLE_COMMSKIP;
+    case ACTION_BROWSE_SUBTITLE:
+     return ADDON_ACTION_BROWSE_SUBTITLE;
+    case ACTION_PLAYER_RESET:
+      return ADDON_ACTION_PLAYER_RESET;
+    case ACTION_TOGGLE_FONT:
+      return ADDON_ACTION_TOGGLE_FONT;
+    case ACTION_VIDEO_NEXT_STREAM:
+      return ADDON_ACTION_VIDEO_NEXT_STREAM;
+    case ACTION_QUEUE_ITEM_NEXT:
+      return ADDON_ACTION_QUEUE_ITEM_NEXT;
+    case ACTION_HDR_TOGGLE:
+      return ADDON_ACTION_HDR_TOGGLE;
+    case ACTION_VOICE_RECOGNIZE:
+      return ADDON_ACTION_VOICE_RECOGNIZE;
+    case ACTION_TOUCH_TAP:
+      return ADDON_ACTION_TOUCH_TAP;
+    case ACTION_TOUCH_TAP_TEN:
+      return ADDON_ACTION_TOUCH_TAP_TEN;
+    case ACTION_TOUCH_LONGPRESS:
+      return ADDON_ACTION_TOUCH_LONGPRESS;
+    case ACTION_TOUCH_LONGPRESS_TEN:
+      return ADDON_ACTION_TOUCH_LONGPRESS_TEN;
+    case ACTION_GESTURE_NOTIFY:
+      return ADDON_ACTION_GESTURE_NOTIFY;
+    case ACTION_GESTURE_BEGIN:
+      return ADDON_ACTION_GESTURE_BEGIN;
+    case ACTION_GESTURE_ZOOM:
+      return ADDON_ACTION_GESTURE_ZOOM;
+    case ACTION_GESTURE_ROTATE:
+      return ADDON_ACTION_GESTURE_ROTATE;
+    case ACTION_GESTURE_PAN:
+      return ADDON_ACTION_GESTURE_PAN;
+    case ACTION_GESTURE_ABORT:
+      return ADDON_ACTION_GESTURE_ABORT;
+    case ACTION_GESTURE_SWIPE_LEFT:
+      return ADDON_ACTION_GESTURE_SWIPE_LEFT;
+    case ACTION_GESTURE_SWIPE_LEFT_TEN:
+      return ADDON_ACTION_GESTURE_SWIPE_LEFT_TEN;
+    case ACTION_GESTURE_SWIPE_RIGHT:
+      return ADDON_ACTION_GESTURE_SWIPE_RIGHT;
+    case ACTION_GESTURE_SWIPE_RIGHT_TEN:
+      return ADDON_ACTION_GESTURE_SWIPE_RIGHT_TEN;
+    case ACTION_GESTURE_SWIPE_UP:
+      return ADDON_ACTION_GESTURE_SWIPE_UP;
+    case ACTION_GESTURE_SWIPE_UP_TEN:
+      return ADDON_ACTION_GESTURE_SWIPE_UP_TEN;
+    case ACTION_GESTURE_SWIPE_DOWN:
+      return ADDON_ACTION_GESTURE_SWIPE_DOWN;
+    case ACTION_GESTURE_SWIPE_DOWN_TEN:
+      return ADDON_ACTION_GESTURE_SWIPE_DOWN_TEN;
+    case ACTION_GESTURE_END:
+      return ADDON_ACTION_GESTURE_END;
+    case ACTION_ANALOG_MOVE_X_LEFT:
+      return ADDON_ACTION_ANALOG_MOVE_X_LEFT;
+    case ACTION_ANALOG_MOVE_X_RIGHT:
+      return ADDON_ACTION_ANALOG_MOVE_X_RIGHT;
+    case ACTION_ANALOG_MOVE_Y_UP:
+      return ADDON_ACTION_ANALOG_MOVE_Y_UP;
+    case ACTION_ANALOG_MOVE_Y_DOWN:
+      return ADDON_ACTION_ANALOG_MOVE_Y_DOWN;
+    case ACTION_ERROR:
+      return ADDON_ACTION_ERROR;
+    case ACTION_NOOP:
+    default:
+      return ADDON_ACTION_NOOP;
+  }
+}
+
+int CAddonGUITranslator::TranslateActionIdToKodi(ADDON_ACTION addonId)
+{
+  switch (addonId)
+  {
+    case ADDON_ACTION_NONE:
+      return ACTION_NONE;
+    case ADDON_ACTION_MOVE_LEFT:
+      return ACTION_MOVE_LEFT;
+    case ADDON_ACTION_MOVE_RIGHT:
+      return ACTION_MOVE_RIGHT;
+    case ADDON_ACTION_MOVE_UP:
+      return ACTION_MOVE_UP;
+    case ADDON_ACTION_MOVE_DOWN:
+      return ACTION_MOVE_DOWN;
+    case ADDON_ACTION_PAGE_UP:
+      return ACTION_PAGE_UP;
+    case ADDON_ACTION_PAGE_DOWN:
+      return ACTION_PAGE_DOWN;
+    case ADDON_ACTION_SELECT_ITEM:
+      return ACTION_SELECT_ITEM;
+    case ADDON_ACTION_HIGHLIGHT_ITEM:
+      return ACTION_HIGHLIGHT_ITEM;
+    case ADDON_ACTION_PARENT_DIR:
+      return ACTION_PARENT_DIR;
+    case ADDON_ACTION_PREVIOUS_MENU:
+      return ACTION_PREVIOUS_MENU;
+    case ADDON_ACTION_SHOW_INFO:
+      return ACTION_SHOW_INFO;
+    case ADDON_ACTION_PAUSE:
+      return ACTION_PAUSE;
+    case ADDON_ACTION_STOP:
+      return ACTION_STOP;
+    case ADDON_ACTION_NEXT_ITEM:
+      return ACTION_NEXT_ITEM;
+    case ADDON_ACTION_PREV_ITEM:
+      return ACTION_PREV_ITEM;
+    case ADDON_ACTION_FORWARD:
+      return ACTION_FORWARD;
+    case ADDON_ACTION_REWIND:
+      return ACTION_REWIND;
+    case ADDON_ACTION_SHOW_GUI:
+      return ACTION_SHOW_GUI;
+    case ADDON_ACTION_ASPECT_RATIO:
+      return ACTION_ASPECT_RATIO;
+    case ADDON_ACTION_STEP_FORWARD:
+      return ACTION_STEP_FORWARD;
+    case ADDON_ACTION_STEP_BACK:
+      return ACTION_STEP_BACK;
+    case ADDON_ACTION_BIG_STEP_FORWARD:
+      return ACTION_BIG_STEP_FORWARD;
+    case ADDON_ACTION_BIG_STEP_BACK:
+      return ACTION_BIG_STEP_BACK;
+    case ADDON_ACTION_SHOW_OSD:
+      return ACTION_SHOW_OSD;
+    case ADDON_ACTION_SHOW_SUBTITLES:
+      return ACTION_SHOW_SUBTITLES;
+    case ADDON_ACTION_NEXT_SUBTITLE:
+      return ACTION_NEXT_SUBTITLE;
+    case ADDON_ACTION_PLAYER_DEBUG:
+      return ACTION_PLAYER_DEBUG;
+    case ADDON_ACTION_NEXT_PICTURE:
+      return ACTION_NEXT_PICTURE;
+    case ADDON_ACTION_PREV_PICTURE:
+      return ACTION_PREV_PICTURE;
+    case ADDON_ACTION_ZOOM_OUT:
+      return ACTION_ZOOM_OUT;
+    case ADDON_ACTION_ZOOM_IN:
+      return ACTION_ZOOM_IN;
+    case ADDON_ACTION_TOGGLE_SOURCE_DEST:
+      return ACTION_TOGGLE_SOURCE_DEST;
+    case ADDON_ACTION_SHOW_PLAYLIST:
+      return ACTION_SHOW_PLAYLIST;
+    case ADDON_ACTION_QUEUE_ITEM:
+      return ACTION_QUEUE_ITEM;
+    case ADDON_ACTION_REMOVE_ITEM:
+      return ACTION_REMOVE_ITEM;
+    case ADDON_ACTION_SHOW_FULLSCREEN:
+      return ACTION_SHOW_FULLSCREEN;
+    case ADDON_ACTION_ZOOM_LEVEL_NORMAL:
+      return ACTION_ZOOM_LEVEL_NORMAL;
+    case ADDON_ACTION_ZOOM_LEVEL_1:
+      return ACTION_ZOOM_LEVEL_1;
+    case ADDON_ACTION_ZOOM_LEVEL_2:
+      return ACTION_ZOOM_LEVEL_2;
+    case ADDON_ACTION_ZOOM_LEVEL_3:
+      return ACTION_ZOOM_LEVEL_3;
+    case ADDON_ACTION_ZOOM_LEVEL_4:
+      return ACTION_ZOOM_LEVEL_4;
+    case ADDON_ACTION_ZOOM_LEVEL_5:
+      return ACTION_ZOOM_LEVEL_5;
+    case ADDON_ACTION_ZOOM_LEVEL_6:
+      return ACTION_ZOOM_LEVEL_6;
+    case ADDON_ACTION_ZOOM_LEVEL_7:
+      return ACTION_ZOOM_LEVEL_7;
+    case ADDON_ACTION_ZOOM_LEVEL_8:
+      return ACTION_ZOOM_LEVEL_8;
+    case ADDON_ACTION_ZOOM_LEVEL_9:
+      return ACTION_ZOOM_LEVEL_9;
+    case ADDON_ACTION_CALIBRATE_SWAP_ARROWS:
+      return ACTION_CALIBRATE_SWAP_ARROWS;
+    case ADDON_ACTION_CALIBRATE_RESET:
+      return ACTION_CALIBRATE_RESET;
+    case ADDON_ACTION_ANALOG_MOVE:
+      return ACTION_ANALOG_MOVE;
+    case ADDON_ACTION_ROTATE_PICTURE_CW:
+      return ACTION_ROTATE_PICTURE_CW;
+    case ADDON_ACTION_ROTATE_PICTURE_CCW:
+      return ACTION_ROTATE_PICTURE_CCW;
+    case ADDON_ACTION_SUBTITLE_DELAY_MIN:
+      return ACTION_SUBTITLE_DELAY_MIN;
+    case ADDON_ACTION_SUBTITLE_DELAY_PLUS:
+      return ACTION_SUBTITLE_DELAY_PLUS;
+    case ADDON_ACTION_AUDIO_DELAY_MIN:
+      return ACTION_AUDIO_DELAY_MIN;
+    case ADDON_ACTION_AUDIO_DELAY_PLUS:
+      return ACTION_AUDIO_DELAY_PLUS;
+    case ADDON_ACTION_AUDIO_NEXT_LANGUAGE:
+      return ACTION_AUDIO_NEXT_LANGUAGE;
+    case ADDON_ACTION_CHANGE_RESOLUTION:
+      return ACTION_CHANGE_RESOLUTION;
+    case ADDON_ACTION_REMOTE_0:
+      return REMOTE_0;
+    case ADDON_ACTION_REMOTE_1:
+      return REMOTE_1;
+    case ADDON_ACTION_REMOTE_2:
+      return REMOTE_2;
+    case ADDON_ACTION_REMOTE_3:
+      return REMOTE_3;
+    case ADDON_ACTION_REMOTE_4:
+      return REMOTE_4;
+    case ADDON_ACTION_REMOTE_5:
+      return REMOTE_5;
+    case ADDON_ACTION_REMOTE_6:
+      return REMOTE_6;
+    case ADDON_ACTION_REMOTE_7:
+      return REMOTE_7;
+    case ADDON_ACTION_REMOTE_8:
+      return REMOTE_8;
+    case ADDON_ACTION_REMOTE_9:
+      return REMOTE_9;
+    case ADDON_ACTION_PLAYER_PROCESS_INFO:
+      return ACTION_PLAYER_PROCESS_INFO;
+    case ADDON_ACTION_PLAYER_PROGRAM_SELECT:
+      return ACTION_PLAYER_PROGRAM_SELECT;
+    case ADDON_ACTION_PLAYER_RESOLUTION_SELECT:
+      return ACTION_PLAYER_RESOLUTION_SELECT;
+    case ADDON_ACTION_SMALL_STEP_BACK:
+      return ACTION_SMALL_STEP_BACK;
+    case ADDON_ACTION_PLAYER_FORWARD:
+      return ACTION_PLAYER_FORWARD;
+    case ADDON_ACTION_PLAYER_REWIND:
+      return ACTION_PLAYER_REWIND;
+    case ADDON_ACTION_PLAYER_PLAY:
+      return ACTION_PLAYER_PLAY;
+    case ADDON_ACTION_DELETE_ITEM:
+      return ACTION_DELETE_ITEM;
+    case ADDON_ACTION_COPY_ITEM:
+      return ACTION_COPY_ITEM;
+    case ADDON_ACTION_MOVE_ITEM:
+      return ACTION_MOVE_ITEM;
+    case ADDON_ACTION_TAKE_SCREENSHOT:
+      return ACTION_TAKE_SCREENSHOT;
+    case ADDON_ACTION_RENAME_ITEM:
+      return ACTION_RENAME_ITEM;
+    case ADDON_ACTION_VOLUME_UP:
+      return ACTION_VOLUME_UP;
+    case ADDON_ACTION_VOLUME_DOWN:
+      return ACTION_VOLUME_DOWN;
+    case ADDON_ACTION_VOLAMP:
+      return ACTION_VOLAMP;
+    case ADDON_ACTION_MUTE:
+      return ACTION_MUTE;
+    case ADDON_ACTION_NAV_BACK:
+      return ACTION_NAV_BACK;
+    case ADDON_ACTION_VOLAMP_UP:
+      return ACTION_VOLAMP_UP;
+    case ADDON_ACTION_VOLAMP_DOWN:
+      return ACTION_VOLAMP_DOWN;
+    case ADDON_ACTION_CREATE_EPISODE_BOOKMARK:
+      return ACTION_CREATE_EPISODE_BOOKMARK;
+    case ADDON_ACTION_CREATE_BOOKMARK:
+      return ACTION_CREATE_BOOKMARK;
+    case ADDON_ACTION_CHAPTER_OR_BIG_STEP_FORWARD:
+      return ACTION_CHAPTER_OR_BIG_STEP_FORWARD;
+    case ADDON_ACTION_CHAPTER_OR_BIG_STEP_BACK:
+      return ACTION_CHAPTER_OR_BIG_STEP_BACK;
+    case ADDON_ACTION_CYCLE_SUBTITLE:
+      return ACTION_CYCLE_SUBTITLE;
+    case ADDON_ACTION_MOUSE_LEFT_CLICK:
+      return ACTION_MOUSE_LEFT_CLICK;
+    case ADDON_ACTION_MOUSE_RIGHT_CLICK:
+      return ACTION_MOUSE_RIGHT_CLICK;
+    case ADDON_ACTION_MOUSE_MIDDLE_CLICK:
+      return ACTION_MOUSE_MIDDLE_CLICK;
+    case ADDON_ACTION_MOUSE_DOUBLE_CLICK:
+      return ACTION_MOUSE_DOUBLE_CLICK;
+    case ADDON_ACTION_MOUSE_WHEEL_UP:
+      return ACTION_MOUSE_WHEEL_UP;
+    case ADDON_ACTION_MOUSE_WHEEL_DOWN:
+      return ACTION_MOUSE_WHEEL_DOWN;
+    case ADDON_ACTION_MOUSE_DRAG:
+      return ACTION_MOUSE_DRAG;
+    case ADDON_ACTION_MOUSE_MOVE:
+      return ACTION_MOUSE_MOVE;
+    case ADDON_ACTION_MOUSE_LONG_CLICK:
+      return ACTION_MOUSE_LONG_CLICK;
+    case ADDON_ACTION_MOUSE_DRAG_END:
+      return ACTION_MOUSE_DRAG_END;
+    case ADDON_ACTION_BACKSPACE:
+      return ACTION_BACKSPACE;
+    case ADDON_ACTION_SCROLL_UP:
+      return ACTION_SCROLL_UP;
+    case ADDON_ACTION_SCROLL_DOWN:
+      return ACTION_SCROLL_DOWN;
+    case ADDON_ACTION_ANALOG_FORWARD:
+      return ACTION_ANALOG_FORWARD;
+    case ADDON_ACTION_ANALOG_REWIND:
+      return ACTION_ANALOG_REWIND;
+    case ADDON_ACTION_MOVE_ITEM_UP:
+      return ACTION_MOVE_ITEM_UP;
+    case ADDON_ACTION_MOVE_ITEM_DOWN:
+      return ACTION_MOVE_ITEM_DOWN;
+    case ADDON_ACTION_CONTEXT_MENU:
+      return ACTION_CONTEXT_MENU;
+    case ADDON_ACTION_SHIFT:
+      return ACTION_SHIFT;
+    case ADDON_ACTION_SYMBOLS:
+      return ACTION_SYMBOLS;
+    case ADDON_ACTION_CURSOR_LEFT:
+      return ACTION_CURSOR_LEFT;
+    case ADDON_ACTION_CURSOR_RIGHT:
+      return ACTION_CURSOR_RIGHT;
+    case ADDON_ACTION_BUILT_IN_FUNCTION:
+      return ACTION_BUILT_IN_FUNCTION;
+    case ADDON_ACTION_SHOW_OSD_TIME:
+      return ACTION_SHOW_OSD_TIME;
+    case ADDON_ACTION_ANALOG_SEEK_FORWARD:
+      return ACTION_ANALOG_SEEK_FORWARD;
+    case ADDON_ACTION_ANALOG_SEEK_BACK:
+      return ACTION_ANALOG_SEEK_BACK;
+    case ADDON_ACTION_VIS_PRESET_SHOW:
+      return ACTION_VIS_PRESET_SHOW;
+    case ADDON_ACTION_VIS_PRESET_NEXT:
+      return ACTION_VIS_PRESET_NEXT;
+    case ADDON_ACTION_VIS_PRESET_PREV:
+      return ACTION_VIS_PRESET_PREV;
+    case ADDON_ACTION_VIS_PRESET_LOCK:
+      return ACTION_VIS_PRESET_LOCK;
+    case ADDON_ACTION_VIS_PRESET_RANDOM:
+      return ACTION_VIS_PRESET_RANDOM;
+    case ADDON_ACTION_VIS_RATE_PRESET_PLUS:
+      return ACTION_VIS_RATE_PRESET_PLUS;
+    case ADDON_ACTION_VIS_RATE_PRESET_MINUS:
+      return ACTION_VIS_RATE_PRESET_MINUS;
+    case ADDON_ACTION_SHOW_VIDEOMENU:
+      return ACTION_SHOW_VIDEOMENU;
+    case ADDON_ACTION_ENTER:
+      return ACTION_ENTER;
+    case ADDON_ACTION_INCREASE_RATING:
+      return ACTION_INCREASE_RATING;
+    case ADDON_ACTION_DECREASE_RATING:
+      return ACTION_DECREASE_RATING;
+    case ADDON_ACTION_NEXT_SCENE:
+      return ACTION_NEXT_SCENE;
+    case ADDON_ACTION_PREV_SCENE:
+      return ACTION_PREV_SCENE;
+    case ADDON_ACTION_NEXT_LETTER:
+      return ACTION_NEXT_LETTER;
+    case ADDON_ACTION_PREV_LETTER:
+      return ACTION_PREV_LETTER;
+    case ADDON_ACTION_JUMP_SMS2:
+      return ACTION_JUMP_SMS2;
+    case ADDON_ACTION_JUMP_SMS3:
+      return ACTION_JUMP_SMS3;
+    case ADDON_ACTION_JUMP_SMS4:
+      return ACTION_JUMP_SMS4;
+    case ADDON_ACTION_JUMP_SMS5:
+      return ACTION_JUMP_SMS5;
+    case ADDON_ACTION_JUMP_SMS6:
+      return ACTION_JUMP_SMS6;
+    case ADDON_ACTION_JUMP_SMS7:
+      return ACTION_JUMP_SMS7;
+    case ADDON_ACTION_JUMP_SMS8:
+      return ACTION_JUMP_SMS8;
+    case ADDON_ACTION_JUMP_SMS9:
+      return ACTION_JUMP_SMS9;
+    case ADDON_ACTION_FILTER_CLEAR:
+      return ACTION_FILTER_CLEAR;
+    case ADDON_ACTION_FILTER_SMS2:
+      return ACTION_FILTER_SMS2;
+    case ADDON_ACTION_FILTER_SMS3:
+      return ACTION_FILTER_SMS3;
+    case ADDON_ACTION_FILTER_SMS4:
+      return ACTION_FILTER_SMS4;
+    case ADDON_ACTION_FILTER_SMS5:
+      return ACTION_FILTER_SMS5;
+    case ADDON_ACTION_FILTER_SMS6:
+      return ACTION_FILTER_SMS6;
+    case ADDON_ACTION_FILTER_SMS7:
+      return ACTION_FILTER_SMS7;
+    case ADDON_ACTION_FILTER_SMS8:
+      return ACTION_FILTER_SMS8;
+    case ADDON_ACTION_FILTER_SMS9:
+      return ACTION_FILTER_SMS9;
+    case ADDON_ACTION_FIRST_PAGE:
+      return ACTION_FIRST_PAGE;
+    case ADDON_ACTION_LAST_PAGE:
+      return ACTION_LAST_PAGE;
+    case ADDON_ACTION_AUDIO_DELAY:
+      return ACTION_AUDIO_DELAY;
+    case ADDON_ACTION_SUBTITLE_DELAY:
+      return ACTION_SUBTITLE_DELAY;
+    case ADDON_ACTION_MENU:
+      return ACTION_MENU;
+    case ADDON_ACTION_SET_RATING:
+      return ACTION_SET_RATING;
+    case ADDON_ACTION_RECORD:
+      return ACTION_RECORD;
+    case ADDON_ACTION_PASTE:
+      return ACTION_PASTE;
+    case ADDON_ACTION_NEXT_CONTROL:
+      return ACTION_NEXT_CONTROL;
+    case ADDON_ACTION_PREV_CONTROL:
+      return ACTION_PREV_CONTROL;
+    case ADDON_ACTION_CHANNEL_SWITCH:
+      return ACTION_CHANNEL_SWITCH;
+    case ADDON_ACTION_CHANNEL_UP:
+      return ACTION_CHANNEL_UP;
+    case ADDON_ACTION_CHANNEL_DOWN:
+      return ACTION_CHANNEL_DOWN;
+    case ADDON_ACTION_NEXT_CHANNELGROUP:
+      return ACTION_NEXT_CHANNELGROUP;
+    case ADDON_ACTION_PREVIOUS_CHANNELGROUP:
+      return ACTION_PREVIOUS_CHANNELGROUP;
+    case ADDON_ACTION_PVR_PLAY:
+      return ACTION_PVR_PLAY;
+    case ADDON_ACTION_PVR_PLAY_TV:
+      return ACTION_PVR_PLAY_TV;
+    case ADDON_ACTION_PVR_PLAY_RADIO:
+      return ACTION_PVR_PLAY_RADIO;
+    case ADDON_ACTION_PVR_SHOW_TIMER_RULE:
+      return ACTION_PVR_SHOW_TIMER_RULE;
+    case ADDON_ACTION_CHANNEL_NUMBER_SEP:
+      return ACTION_CHANNEL_NUMBER_SEP;
+    case ADDON_ACTION_PVR_ANNOUNCE_REMINDERS:
+      return ACTION_PVR_ANNOUNCE_REMINDERS;
+    case ADDON_ACTION_TOGGLE_FULLSCREEN:
+      return ACTION_TOGGLE_FULLSCREEN;
+    case ADDON_ACTION_TOGGLE_WATCHED:
+      return ACTION_TOGGLE_WATCHED;
+    case ADDON_ACTION_SCAN_ITEM:
+      return ACTION_SCAN_ITEM;
+    case ADDON_ACTION_TOGGLE_DIGITAL_ANALOG:
+      return ACTION_TOGGLE_DIGITAL_ANALOG;
+    case ADDON_ACTION_RELOAD_KEYMAPS:
+      return ACTION_RELOAD_KEYMAPS;
+    case ADDON_ACTION_GUIPROFILE_BEGIN:
+      return ACTION_GUIPROFILE_BEGIN;
+    case ADDON_ACTION_TELETEXT_RED:
+      return ACTION_TELETEXT_RED;
+    case ADDON_ACTION_TELETEXT_GREEN:
+      return ACTION_TELETEXT_GREEN;
+    case ADDON_ACTION_TELETEXT_YELLOW:
+      return ACTION_TELETEXT_YELLOW;
+    case ADDON_ACTION_TELETEXT_BLUE:
+      return ACTION_TELETEXT_BLUE;
+    case ADDON_ACTION_INCREASE_PAR:
+      return ACTION_INCREASE_PAR;
+    case ADDON_ACTION_DECREASE_PAR:
+      return ACTION_DECREASE_PAR;
+    case ADDON_ACTION_VSHIFT_UP:
+      return ACTION_VSHIFT_UP;
+    case ADDON_ACTION_VSHIFT_DOWN:
+      return ACTION_VSHIFT_DOWN;
+    case ADDON_ACTION_PLAYER_PLAYPAUSE:
+      return ACTION_PLAYER_PLAYPAUSE;
+    case ADDON_ACTION_SUBTITLE_VSHIFT_UP:
+      return ACTION_SUBTITLE_VSHIFT_UP;
+    case ADDON_ACTION_SUBTITLE_VSHIFT_DOWN:
+      return ACTION_SUBTITLE_VSHIFT_DOWN;
+    case ADDON_ACTION_SUBTITLE_ALIGN:
+      return ACTION_SUBTITLE_ALIGN;
+    case ADDON_ACTION_FILTER:
+      return ACTION_FILTER;
+    case ADDON_ACTION_SWITCH_PLAYER:
+      return ACTION_SWITCH_PLAYER;
+    case ADDON_ACTION_STEREOMODE_NEXT:
+      return ACTION_STEREOMODE_NEXT;
+    case ADDON_ACTION_STEREOMODE_PREVIOUS:
+      return ACTION_STEREOMODE_PREVIOUS;
+    case ADDON_ACTION_STEREOMODE_TOGGLE:
+      return ACTION_STEREOMODE_TOGGLE;
+    case ADDON_ACTION_STEREOMODE_SELECT:
+      return ACTION_STEREOMODE_SELECT;
+    case ADDON_ACTION_STEREOMODE_TOMONO:
+      return ACTION_STEREOMODE_TOMONO;
+    case ADDON_ACTION_STEREOMODE_SET:
+      return ACTION_STEREOMODE_SET;
+    case ADDON_ACTION_SETTINGS_RESET:
+      return ACTION_SETTINGS_RESET;
+    case ADDON_ACTION_SETTINGS_LEVEL_CHANGE:
+      return ACTION_SETTINGS_LEVEL_CHANGE;
+    case ADDON_ACTION_TRIGGER_OSD:
+      return ACTION_TRIGGER_OSD;
+    case ADDON_ACTION_INPUT_TEXT:
+      return ACTION_INPUT_TEXT;
+    case ADDON_ACTION_VOLUME_SET:
+      return ACTION_VOLUME_SET;
+    case ADDON_ACTION_TOGGLE_COMMSKIP:
+      return ACTION_TOGGLE_COMMSKIP;
+    case ADDON_ACTION_BROWSE_SUBTITLE:
+     return ACTION_BROWSE_SUBTITLE;
+    case ADDON_ACTION_PLAYER_RESET:
+      return ACTION_PLAYER_RESET;
+    case ADDON_ACTION_TOGGLE_FONT:
+      return ACTION_TOGGLE_FONT;
+    case ADDON_ACTION_VIDEO_NEXT_STREAM:
+      return ACTION_VIDEO_NEXT_STREAM;
+    case ADDON_ACTION_QUEUE_ITEM_NEXT:
+      return ACTION_QUEUE_ITEM_NEXT;
+    case ADDON_ACTION_HDR_TOGGLE:
+      return ACTION_HDR_TOGGLE;
+    case ADDON_ACTION_VOICE_RECOGNIZE:
+      return ACTION_VOICE_RECOGNIZE;
+    case ADDON_ACTION_TOUCH_TAP:
+      return ACTION_TOUCH_TAP;
+    case ADDON_ACTION_TOUCH_TAP_TEN:
+      return ACTION_TOUCH_TAP_TEN;
+    case ADDON_ACTION_TOUCH_LONGPRESS:
+      return ACTION_TOUCH_LONGPRESS;
+    case ADDON_ACTION_TOUCH_LONGPRESS_TEN:
+      return ACTION_TOUCH_LONGPRESS_TEN;
+    case ADDON_ACTION_GESTURE_NOTIFY:
+      return ACTION_GESTURE_NOTIFY;
+    case ADDON_ACTION_GESTURE_BEGIN:
+      return ACTION_GESTURE_BEGIN;
+    case ADDON_ACTION_GESTURE_ZOOM:
+      return ACTION_GESTURE_ZOOM;
+    case ADDON_ACTION_GESTURE_ROTATE:
+      return ACTION_GESTURE_ROTATE;
+    case ADDON_ACTION_GESTURE_PAN:
+      return ACTION_GESTURE_PAN;
+    case ADDON_ACTION_GESTURE_ABORT:
+      return ACTION_GESTURE_ABORT;
+    case ADDON_ACTION_GESTURE_SWIPE_LEFT:
+      return ACTION_GESTURE_SWIPE_LEFT;
+    case ADDON_ACTION_GESTURE_SWIPE_LEFT_TEN:
+      return ACTION_GESTURE_SWIPE_LEFT_TEN;
+    case ADDON_ACTION_GESTURE_SWIPE_RIGHT:
+      return ACTION_GESTURE_SWIPE_RIGHT;
+    case ADDON_ACTION_GESTURE_SWIPE_RIGHT_TEN:
+      return ACTION_GESTURE_SWIPE_RIGHT_TEN;
+    case ADDON_ACTION_GESTURE_SWIPE_UP:
+      return ACTION_GESTURE_SWIPE_UP;
+    case ADDON_ACTION_GESTURE_SWIPE_UP_TEN:
+      return ACTION_GESTURE_SWIPE_UP_TEN;
+    case ADDON_ACTION_GESTURE_SWIPE_DOWN:
+      return ACTION_GESTURE_SWIPE_DOWN;
+    case ADDON_ACTION_GESTURE_SWIPE_DOWN_TEN:
+      return ACTION_GESTURE_SWIPE_DOWN_TEN;
+    case ADDON_ACTION_GESTURE_END:
+      return ACTION_GESTURE_END;
+    case ADDON_ACTION_ANALOG_MOVE_X_LEFT:
+      return ACTION_ANALOG_MOVE_X_LEFT;
+    case ADDON_ACTION_ANALOG_MOVE_X_RIGHT:
+      return ACTION_ANALOG_MOVE_X_RIGHT;
+    case ADDON_ACTION_ANALOG_MOVE_Y_UP:
+      return ACTION_ANALOG_MOVE_Y_UP;
+    case ADDON_ACTION_ANALOG_MOVE_Y_DOWN:
+      return ACTION_ANALOG_MOVE_Y_DOWN;
+    case ADDON_ACTION_ERROR:
+      return ACTION_ERROR;
+    case ADDON_ACTION_NOOP:
+    default:
+      return ACTION_NOOP;
+  }
+}
diff --git a/xbmc/addons/interfaces/gui/GUITranslator.h b/xbmc/addons/interfaces/gui/GUITranslator.h
new file mode 100644
index 0000000..8bd6b5c
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/GUITranslator.h
@@ -0,0 +1,41 @@
+/*
+ *  Copyright (C) 2005-2020 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/input/action_ids.h"
+
+namespace ADDON
+{
+
+/*!
+ * \brief Translates data types from GUI API to the corresponding format in Kodi.
+ *
+ * This class is stateless.
+ */
+class CAddonGUITranslator
+{
+  CAddonGUITranslator() = delete;
+
+public:
+  /*!
+   * \brief Translate Kodi's action id's to addon
+   * \param kodiId Kodi's action identifier
+   * \return Addon action identifier
+   */
+  static ADDON_ACTION TranslateActionIdToAddon(int kodiId);
+
+  /*!
+   * \brief Translate addon's action id's to Kodi
+   * \param addonId Addon's action identifier
+   * \return Kodi action identifier
+   */
+  static int TranslateActionIdToKodi(ADDON_ACTION addonId);
+};
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/General.cpp b/xbmc/addons/interfaces/gui/General.cpp
new file mode 100644
index 0000000..a0a5583
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/General.cpp
@@ -0,0 +1,252 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "General.h"
+
+#include "ListItem.h"
+#include "ServiceBroker.h"
+#include "Window.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/General.h"
+#include "controls/Button.h"
+#include "controls/Edit.h"
+#include "controls/FadeLabel.h"
+#include "controls/Image.h"
+#include "controls/Label.h"
+#include "controls/Progress.h"
+#include "controls/RadioButton.h"
+#include "controls/Rendering.h"
+#include "controls/SettingsSlider.h"
+#include "controls/Slider.h"
+#include "controls/Spin.h"
+#include "controls/TextBox.h"
+#include "dialogs/ContextMenu.h"
+#include "dialogs/ExtendedProgressBar.h"
+#include "dialogs/FileBrowser.h"
+#include "dialogs/Keyboard.h"
+#include "dialogs/Numeric.h"
+#include "dialogs/OK.h"
+#include "dialogs/Progress.h"
+#include "dialogs/Select.h"
+#include "dialogs/TextViewer.h"
+#include "dialogs/YesNo.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "utils/log.h"
+
+#include <mutex>
+
+namespace ADDON
+{
+int Interface_GUIGeneral::m_iAddonGUILockRef = 0;
+
+void Interface_GUIGeneral::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui = new AddonToKodiFuncTable_kodi_gui();
+
+  Interface_GUIControlButton::Init(addonInterface);
+  Interface_GUIControlEdit::Init(addonInterface);
+  Interface_GUIControlFadeLabel::Init(addonInterface);
+  Interface_GUIControlImage::Init(addonInterface);
+  Interface_GUIControlLabel::Init(addonInterface);
+  Interface_GUIControlProgress::Init(addonInterface);
+  Interface_GUIControlRadioButton::Init(addonInterface);
+  Interface_GUIControlAddonRendering::Init(addonInterface);
+  Interface_GUIControlSettingsSlider::Init(addonInterface);
+  Interface_GUIControlSlider::Init(addonInterface);
+  Interface_GUIControlSpin::Init(addonInterface);
+  Interface_GUIControlTextBox::Init(addonInterface);
+  Interface_GUIDialogContextMenu::Init(addonInterface);
+  Interface_GUIDialogExtendedProgress::Init(addonInterface);
+  Interface_GUIDialogFileBrowser::Init(addonInterface);
+  Interface_GUIDialogKeyboard::Init(addonInterface);
+  Interface_GUIDialogNumeric::Init(addonInterface);
+  Interface_GUIDialogOK::Init(addonInterface);
+  Interface_GUIDialogProgress::Init(addonInterface);
+  Interface_GUIDialogSelect::Init(addonInterface);
+  Interface_GUIDialogTextViewer::Init(addonInterface);
+  Interface_GUIDialogYesNo::Init(addonInterface);
+  Interface_GUIListItem::Init(addonInterface);
+  Interface_GUIWindow::Init(addonInterface);
+
+  addonInterface->toKodi->kodi_gui->general = new AddonToKodiFuncTable_kodi_gui_general();
+
+  addonInterface->toKodi->kodi_gui->general->lock = lock;
+  addonInterface->toKodi->kodi_gui->general->unlock = unlock;
+  addonInterface->toKodi->kodi_gui->general->get_screen_height = get_screen_height;
+  addonInterface->toKodi->kodi_gui->general->get_screen_width = get_screen_width;
+  addonInterface->toKodi->kodi_gui->general->get_video_resolution = get_video_resolution;
+  addonInterface->toKodi->kodi_gui->general->get_current_window_dialog_id =
+      get_current_window_dialog_id;
+  addonInterface->toKodi->kodi_gui->general->get_current_window_id = get_current_window_id;
+  addonInterface->toKodi->kodi_gui->general->get_hw_context = get_hw_context;
+  addonInterface->toKodi->kodi_gui->general->get_adjust_refresh_rate_status =
+      get_adjust_refresh_rate_status;
+}
+
+void Interface_GUIGeneral::DeInit(AddonGlobalInterface* addonInterface)
+{
+  if (addonInterface->toKodi && /* <-- needed as long as the old addon way is used */
+      addonInterface->toKodi->kodi_gui)
+  {
+    Interface_GUIControlButton::DeInit(addonInterface);
+    Interface_GUIControlEdit::DeInit(addonInterface);
+    Interface_GUIControlFadeLabel::DeInit(addonInterface);
+    Interface_GUIControlImage::DeInit(addonInterface);
+    Interface_GUIControlLabel::DeInit(addonInterface);
+    Interface_GUIControlProgress::DeInit(addonInterface);
+    Interface_GUIControlRadioButton::DeInit(addonInterface);
+    Interface_GUIControlAddonRendering::DeInit(addonInterface);
+    Interface_GUIControlSettingsSlider::DeInit(addonInterface);
+    Interface_GUIControlSlider::DeInit(addonInterface);
+    Interface_GUIControlSpin::DeInit(addonInterface);
+    Interface_GUIControlTextBox::DeInit(addonInterface);
+    Interface_GUIDialogContextMenu::DeInit(addonInterface);
+    Interface_GUIDialogExtendedProgress::DeInit(addonInterface);
+    Interface_GUIDialogFileBrowser::DeInit(addonInterface);
+    Interface_GUIDialogKeyboard::DeInit(addonInterface);
+    Interface_GUIDialogNumeric::DeInit(addonInterface);
+    Interface_GUIDialogOK::DeInit(addonInterface);
+    Interface_GUIDialogProgress::DeInit(addonInterface);
+    Interface_GUIDialogSelect::DeInit(addonInterface);
+    Interface_GUIDialogTextViewer::DeInit(addonInterface);
+    Interface_GUIDialogYesNo::DeInit(addonInterface);
+    Interface_GUIListItem::DeInit(addonInterface);
+    Interface_GUIWindow::DeInit(addonInterface);
+
+    delete addonInterface->toKodi->kodi_gui->general;
+    delete addonInterface->toKodi->kodi_gui;
+    addonInterface->toKodi->kodi_gui = nullptr;
+  }
+}
+
+//@{
+void Interface_GUIGeneral::lock()
+{
+  if (m_iAddonGUILockRef == 0)
+    CServiceBroker::GetWinSystem()->GetGfxContext().lock();
+  ++m_iAddonGUILockRef;
+}
+
+void Interface_GUIGeneral::unlock()
+{
+  if (m_iAddonGUILockRef > 0)
+  {
+    --m_iAddonGUILockRef;
+    if (m_iAddonGUILockRef == 0)
+      CServiceBroker::GetWinSystem()->GetGfxContext().unlock();
+  }
+}
+//@}
+
+//@{
+int Interface_GUIGeneral::get_screen_height(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return -1;
+  }
+
+  return CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight();
+}
+
+int Interface_GUIGeneral::get_screen_width(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return -1;
+  }
+
+  return CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth();
+}
+
+int Interface_GUIGeneral::get_video_resolution(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return -1;
+  }
+
+  return (int)CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution();
+}
+//@}
+
+//@{
+int Interface_GUIGeneral::get_current_window_dialog_id(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return -1;
+  }
+
+  std::unique_lock<CCriticalSection> gl(CServiceBroker::GetWinSystem()->GetGfxContext());
+  return CServiceBroker::GetGUI()->GetWindowManager().GetTopmostModalDialog();
+}
+
+int Interface_GUIGeneral::get_current_window_id(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return -1;
+  }
+
+  std::unique_lock<CCriticalSection> gl(CServiceBroker::GetWinSystem()->GetGfxContext());
+  return CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow();
+}
+
+ADDON_HARDWARE_CONTEXT Interface_GUIGeneral::get_hw_context(KODI_HANDLE kodiBase)
+{
+  return CServiceBroker::GetWinSystem()->GetHWContext();
+}
+
+AdjustRefreshRateStatus Interface_GUIGeneral::get_adjust_refresh_rate_status(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__);
+    return ADJUST_REFRESHRATE_STATUS_OFF;
+  }
+
+  switch (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
+      CSettings::SETTING_VIDEOPLAYER_ADJUSTREFRESHRATE))
+  {
+    case AdjustRefreshRate::ADJUST_REFRESHRATE_OFF:
+      return ADJUST_REFRESHRATE_STATUS_OFF;
+      break;
+    case AdjustRefreshRate::ADJUST_REFRESHRATE_ON_START:
+      return ADJUST_REFRESHRATE_STATUS_ON_START;
+      break;
+    case AdjustRefreshRate::ADJUST_REFRESHRATE_ON_STARTSTOP:
+      return ADJUST_REFRESHRATE_STATUS_ON_STARTSTOP;
+      break;
+    case AdjustRefreshRate::ADJUST_REFRESHRATE_ALWAYS:
+      return ADJUST_REFRESHRATE_STATUS_ALWAYS;
+      break;
+    default:
+      CLog::Log(LOGERROR, "kodi::gui::{} - Unhandled Adjust refresh rate setting", __func__);
+      return ADJUST_REFRESHRATE_STATUS_OFF;
+      break;
+  }
+}
+
+//@}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/General.h b/xbmc/addons/interfaces/gui/General.h
new file mode 100644
index 0000000..146d4f7
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/General.h
@@ -0,0 +1,62 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/general.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h"
+   */
+  struct Interface_GUIGeneral
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note For add of new functions use the "_" style to identify direct a
+     * add-on callback function. Everything with CamelCase is only for the
+     * usage in Kodi only.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void lock();
+    static void unlock();
+
+    static int get_screen_height(KODI_HANDLE kodiBase);
+    static int get_screen_width(KODI_HANDLE kodiBase);
+    static int get_video_resolution(KODI_HANDLE kodiBase);
+    static int get_current_window_dialog_id(KODI_HANDLE kodiBase);
+    static int get_current_window_id(KODI_HANDLE kodiBase);
+    static ADDON_HARDWARE_CONTEXT get_hw_context(KODI_HANDLE kodiBase);
+    static AdjustRefreshRateStatus get_adjust_refresh_rate_status(KODI_HANDLE kodiBase);
+    //@}
+
+  private:
+    static int m_iAddonGUILockRef;
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/ListItem.cpp b/xbmc/addons/interfaces/gui/ListItem.cpp
new file mode 100644
index 0000000..c91e451
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/ListItem.cpp
@@ -0,0 +1,428 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ListItem.h"
+
+#include "FileItem.h"
+#include "General.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/ListItem.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIListItem::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->listItem = new AddonToKodiFuncTable_kodi_gui_listItem();
+
+  addonInterface->toKodi->kodi_gui->listItem->create = create;
+  addonInterface->toKodi->kodi_gui->listItem->destroy = destroy;
+  addonInterface->toKodi->kodi_gui->listItem->get_label = get_label;
+  addonInterface->toKodi->kodi_gui->listItem->set_label = set_label;
+  addonInterface->toKodi->kodi_gui->listItem->get_label2 = get_label2;
+  addonInterface->toKodi->kodi_gui->listItem->set_label2 = set_label2;
+  addonInterface->toKodi->kodi_gui->listItem->get_art = get_art;
+  addonInterface->toKodi->kodi_gui->listItem->set_art = set_art;
+  addonInterface->toKodi->kodi_gui->listItem->get_path = get_path;
+  addonInterface->toKodi->kodi_gui->listItem->set_path = set_path;
+  addonInterface->toKodi->kodi_gui->listItem->get_property = get_property;
+  addonInterface->toKodi->kodi_gui->listItem->set_property = set_property;
+  addonInterface->toKodi->kodi_gui->listItem->select = select;
+  addonInterface->toKodi->kodi_gui->listItem->is_selected = is_selected;
+}
+
+void Interface_GUIListItem::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->listItem;
+}
+
+KODI_GUI_LISTITEM_HANDLE Interface_GUIListItem::create(KODI_HANDLE kodiBase,
+                                                       const char* label,
+                                                       const char* label2,
+                                                       const char* path)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "ADDON::Interface_GUIListItem::{} - invalid data", __func__);
+    return nullptr;
+  }
+
+  CFileItemPtr* item = new CFileItemPtr(new CFileItem());
+  if (label)
+    item->get()->SetLabel(label);
+  if (label2)
+    item->get()->SetLabel2(label2);
+  if (path)
+    item->get()->SetPath(path);
+
+  return item;
+}
+
+void Interface_GUIListItem::destroy(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "ADDON::Interface_GUIListItem::{} - invalid data", __func__);
+    return;
+  }
+
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (item)
+    delete item;
+}
+
+char* Interface_GUIListItem::get_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return nullptr;
+  }
+
+  char* ret;
+  Interface_GUIGeneral::lock();
+  ret = strdup(item->get()->GetLabel().c_str());
+  Interface_GUIGeneral::unlock();
+  return ret;
+}
+
+void Interface_GUIListItem::set_label(KODI_HANDLE kodiBase,
+                                      KODI_GUI_LISTITEM_HANDLE handle,
+                                      const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  item->get()->SetLabel(label);
+  Interface_GUIGeneral::unlock();
+}
+
+char* Interface_GUIListItem::get_label2(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return nullptr;
+  }
+
+  char* ret;
+  Interface_GUIGeneral::lock();
+  ret = strdup(item->get()->GetLabel2().c_str());
+  Interface_GUIGeneral::unlock();
+  return ret;
+}
+
+void Interface_GUIListItem::set_label2(KODI_HANDLE kodiBase,
+                                       KODI_GUI_LISTITEM_HANDLE handle,
+                                       const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  item->get()->SetLabel2(label);
+  Interface_GUIGeneral::unlock();
+}
+
+char* Interface_GUIListItem::get_art(KODI_HANDLE kodiBase,
+                                     KODI_GUI_LISTITEM_HANDLE handle,
+                                     const char* type)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !type)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', type='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(type),
+              addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return nullptr;
+  }
+
+  char* ret;
+  Interface_GUIGeneral::lock();
+  ret = strdup(item->get()->GetArt(type).c_str());
+  Interface_GUIGeneral::unlock();
+  return ret;
+}
+
+void Interface_GUIListItem::set_art(KODI_HANDLE kodiBase,
+                                    KODI_GUI_LISTITEM_HANDLE handle,
+                                    const char* type,
+                                    const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !type || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', type= "
+              "'{}', label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(type),
+              static_cast<const void*>(label), addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  item->get()->SetArt(type, label);
+  Interface_GUIGeneral::unlock();
+}
+
+char* Interface_GUIListItem::get_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return nullptr;
+  }
+
+  char* ret;
+  Interface_GUIGeneral::lock();
+  ret = strdup(item->get()->GetPath().c_str());
+  Interface_GUIGeneral::unlock();
+  return ret;
+}
+
+
+void Interface_GUIListItem::set_path(KODI_HANDLE kodiBase,
+                                     KODI_GUI_LISTITEM_HANDLE handle,
+                                     const char* path)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !path)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', path='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(path),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  item->get()->SetPath(path);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIListItem::set_property(KODI_HANDLE kodiBase,
+                                         KODI_GUI_LISTITEM_HANDLE handle,
+                                         const char* key,
+                                         const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !key || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}', value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              static_cast<const void*>(value), addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  item->get()->SetProperty(lowerKey, CVariant(value));
+  Interface_GUIGeneral::unlock();
+}
+
+char* Interface_GUIListItem::get_property(KODI_HANDLE kodiBase,
+                                          KODI_GUI_LISTITEM_HANDLE handle,
+                                          const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return nullptr;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  char* ret = strdup(item->get()->GetProperty(lowerKey).asString().c_str());
+  Interface_GUIGeneral::unlock();
+
+  return ret;
+}
+
+void Interface_GUIListItem::select(KODI_HANDLE kodiBase,
+                                   KODI_GUI_LISTITEM_HANDLE handle,
+                                   bool select)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  item->get()->Select(select);
+  Interface_GUIGeneral::unlock();
+}
+
+bool Interface_GUIListItem::is_selected(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CFileItemPtr* item = static_cast<CFileItemPtr*>(handle);
+  if (!addon || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  if (item->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'",
+              __func__, addon->ID());
+    return false;
+  }
+
+  Interface_GUIGeneral::lock();
+  bool ret = item->get()->IsSelected();
+  Interface_GUIGeneral::unlock();
+
+  return ret;
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/ListItem.h b/xbmc/addons/interfaces/gui/ListItem.h
new file mode 100644
index 0000000..70e5c6a
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/ListItem.h
@@ -0,0 +1,76 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h"
+   */
+  struct Interface_GUIListItem
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static KODI_GUI_LISTITEM_HANDLE create(KODI_HANDLE kodiBase,
+                                           const char* label,
+                                           const char* label2,
+                                           const char* path);
+    static void destroy(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle);
+    static void set_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* label);
+    static char* get_label2(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle);
+    static void set_label2(KODI_HANDLE kodiBase,
+                           KODI_GUI_LISTITEM_HANDLE handle,
+                           const char* label);
+    static char* get_art(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* type);
+    static void set_art(KODI_HANDLE kodiBase,
+                        KODI_GUI_LISTITEM_HANDLE handle,
+                        const char* type,
+                        const char* image);
+    static char* get_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle);
+    static void set_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* path);
+    static char* get_property(KODI_HANDLE kodiBase,
+                              KODI_GUI_LISTITEM_HANDLE handle,
+                              const char* key);
+    static void set_property(KODI_HANDLE kodiBase,
+                             KODI_GUI_LISTITEM_HANDLE handle,
+                             const char* key,
+                             const char* value);
+    static void select(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, bool select);
+    static bool is_selected(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/Window.cpp b/xbmc/addons/interfaces/gui/Window.cpp
new file mode 100644
index 0000000..307c339
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/Window.cpp
@@ -0,0 +1,1499 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "addons/kodi-dev-kit/include/kodi/gui/Window.h"
+
+#include "FileItem.h"
+#include "GUITranslator.h"
+#include "General.h"
+#include "ServiceBroker.h"
+#include "Window.h"
+#include "addons/Skin.h"
+#include "addons/addoninfo/AddonInfo.h"
+#include "addons/addoninfo/AddonType.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "application/Application.h"
+#include "controls/Rendering.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIRenderingControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/TextureManager.h"
+#include "input/Key.h"
+#include "messaging/ApplicationMessenger.h"
+#include "utils/FileUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIWindow::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->window = new AddonToKodiFuncTable_kodi_gui_window();
+
+  /* Window creation functions */
+  addonInterface->toKodi->kodi_gui->window->create = create;
+  addonInterface->toKodi->kodi_gui->window->destroy = destroy;
+  addonInterface->toKodi->kodi_gui->window->set_callbacks = set_callbacks;
+  addonInterface->toKodi->kodi_gui->window->show = show;
+  addonInterface->toKodi->kodi_gui->window->close = close;
+  addonInterface->toKodi->kodi_gui->window->do_modal = do_modal;
+
+  /* Window control functions */
+  addonInterface->toKodi->kodi_gui->window->set_focus_id = set_focus_id;
+  addonInterface->toKodi->kodi_gui->window->get_focus_id = get_focus_id;
+  addonInterface->toKodi->kodi_gui->window->set_control_label = set_control_label;
+  addonInterface->toKodi->kodi_gui->window->set_control_visible = set_control_visible;
+  addonInterface->toKodi->kodi_gui->window->set_control_selected = set_control_selected;
+
+  /* Window property functions */
+  addonInterface->toKodi->kodi_gui->window->set_property = set_property;
+  addonInterface->toKodi->kodi_gui->window->set_property_int = set_property_int;
+  addonInterface->toKodi->kodi_gui->window->set_property_bool = set_property_bool;
+  addonInterface->toKodi->kodi_gui->window->set_property_double = set_property_double;
+  addonInterface->toKodi->kodi_gui->window->get_property = get_property;
+  addonInterface->toKodi->kodi_gui->window->get_property_int = get_property_int;
+  addonInterface->toKodi->kodi_gui->window->get_property_bool = get_property_bool;
+  addonInterface->toKodi->kodi_gui->window->get_property_double = get_property_double;
+  addonInterface->toKodi->kodi_gui->window->clear_properties = clear_properties;
+  addonInterface->toKodi->kodi_gui->window->clear_property = clear_property;
+
+  /* List item functions */
+  addonInterface->toKodi->kodi_gui->window->clear_item_list = clear_item_list;
+  addonInterface->toKodi->kodi_gui->window->add_list_item = add_list_item;
+  addonInterface->toKodi->kodi_gui->window->remove_list_item_from_position =
+      remove_list_item_from_position;
+  addonInterface->toKodi->kodi_gui->window->remove_list_item = remove_list_item;
+  addonInterface->toKodi->kodi_gui->window->get_list_item = get_list_item;
+  addonInterface->toKodi->kodi_gui->window->set_current_list_position = set_current_list_position;
+  addonInterface->toKodi->kodi_gui->window->get_current_list_position = get_current_list_position;
+  addonInterface->toKodi->kodi_gui->window->get_list_size = get_list_size;
+  addonInterface->toKodi->kodi_gui->window->set_container_property = set_container_property;
+  addonInterface->toKodi->kodi_gui->window->set_container_content = set_container_content;
+  addonInterface->toKodi->kodi_gui->window->get_current_container_id = get_current_container_id;
+
+  /* Various functions */
+  addonInterface->toKodi->kodi_gui->window->mark_dirty_region = mark_dirty_region;
+
+  /* GUI control access functions */
+  addonInterface->toKodi->kodi_gui->window->get_control_button = get_control_button;
+  addonInterface->toKodi->kodi_gui->window->get_control_edit = get_control_edit;
+  addonInterface->toKodi->kodi_gui->window->get_control_fade_label = get_control_fade_label;
+  addonInterface->toKodi->kodi_gui->window->get_control_image = get_control_image;
+  addonInterface->toKodi->kodi_gui->window->get_control_label = get_control_label;
+  addonInterface->toKodi->kodi_gui->window->get_control_progress = get_control_progress;
+  addonInterface->toKodi->kodi_gui->window->get_control_radio_button = get_control_radio_button;
+  addonInterface->toKodi->kodi_gui->window->get_control_render_addon = get_control_render_addon;
+  addonInterface->toKodi->kodi_gui->window->get_control_settings_slider =
+      get_control_settings_slider;
+  addonInterface->toKodi->kodi_gui->window->get_control_slider = get_control_slider;
+  addonInterface->toKodi->kodi_gui->window->get_control_spin = get_control_spin;
+  addonInterface->toKodi->kodi_gui->window->get_control_text_box = get_control_text_box;
+}
+
+void Interface_GUIWindow::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->window;
+}
+
+/*!
+ * Window creation functions
+ */
+//@{
+KODI_GUI_WINDOW_HANDLE Interface_GUIWindow::create(KODI_HANDLE kodiBase,
+                                                   const char* xml_filename,
+                                                   const char* default_skin,
+                                                   bool as_dialog,
+                                                   bool is_media)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon || !xml_filename || !default_skin)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (xml_filename='{}', "
+              "default_skin='{}') on addon '{}'",
+              __func__, static_cast<const void*>(xml_filename),
+              static_cast<const void*>(default_skin), addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  if (as_dialog && is_media)
+  {
+    CLog::Log(LOGWARNING,
+              "Interface_GUIWindow::{}: {}/{} - addon tries to create dialog as media window who "
+              "not allowed, contact Developer '{}' of this addon",
+              __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), addon->Author());
+  }
+
+  RESOLUTION_INFO res;
+  std::string strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res);
+
+  if (!CFileUtils::Exists(strSkinPath))
+  {
+    std::string str("none");
+    ADDON::AddonInfoPtr addonInfo =
+        std::make_shared<ADDON::CAddonInfo>(str, ADDON::AddonType::SKIN);
+
+    // Check for the matching folder for the skin in the fallback skins folder
+    std::string fallbackPath = URIUtils::AddFileToFolder(addon->Path(), "resources", "skins");
+    std::string basePath = URIUtils::AddFileToFolder(fallbackPath, g_SkinInfo->ID());
+
+    strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res, basePath);
+
+    // Check for the matching folder for the skin in the fallback skins folder (if it exists)
+    if (CFileUtils::Exists(basePath))
+    {
+      addonInfo->SetPath(basePath);
+      const std::shared_ptr<ADDON::CSkinInfo> skinInfo =
+          std::make_shared<ADDON::CSkinInfo>(addonInfo, res);
+      skinInfo->Start();
+      strSkinPath = skinInfo->GetSkinPath(xml_filename, &res);
+    }
+
+    if (!CFileUtils::Exists(strSkinPath))
+    {
+      // Finally fallback to the DefaultSkin as it didn't exist in either the Kodi Skin folder or the fallback skin folder
+      addonInfo->SetPath(URIUtils::AddFileToFolder(fallbackPath, default_skin));
+      const std::shared_ptr<ADDON::CSkinInfo> skinInfo =
+          std::make_shared<ADDON::CSkinInfo>(addonInfo, res);
+
+      skinInfo->Start();
+      strSkinPath = skinInfo->GetSkinPath(xml_filename, &res);
+      if (!CFileUtils::Exists(strSkinPath))
+      {
+        CLog::Log(LOGERROR,
+                  "Interface_GUIWindow::{}: {}/{} - XML File '{}' for Window is missing, contact "
+                  "Developer '{}' of this addon",
+                  __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), strSkinPath,
+                  addon->Author());
+        return nullptr;
+      }
+    }
+  }
+
+  int id = GetNextAvailableWindowId();
+  if (id < 0)
+    return nullptr;
+
+  CGUIWindow* window;
+  if (!as_dialog)
+    window = new CGUIAddonWindow(id, strSkinPath, addon, is_media);
+  else
+    window = new CGUIAddonWindowDialog(id, strSkinPath, addon);
+
+  Interface_GUIGeneral::lock();
+  CServiceBroker::GetGUI()->GetWindowManager().Add(window);
+  Interface_GUIGeneral::unlock();
+
+  if (!CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id))
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - Requested window id '{}' does not exist for addon '{}'",
+              __func__, id, addon->ID());
+    delete window;
+    return nullptr;
+  }
+  window->SetCoordsRes(res);
+  return window;
+}
+
+void Interface_GUIWindow::destroy(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  CGUIWindow* pWindow =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->GetID());
+  if (pWindow)
+  {
+    // first change to an existing window
+    if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == pAddonWindow->GetID() &&
+        !g_application.m_bStop)
+    {
+      if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->m_oldWindowId))
+        CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId);
+      else // old window does not exist anymore, switch to home
+        CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_HOME);
+    }
+    // Free any window properties
+    pAddonWindow->ClearProperties();
+    // free the window's resources and unload it (free all guicontrols)
+    pAddonWindow->FreeResources(true);
+
+    CServiceBroker::GetGUI()->GetWindowManager().Remove(pAddonWindow->GetID());
+  }
+  delete pAddonWindow;
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_callbacks(
+    KODI_HANDLE kodiBase,
+    KODI_GUI_WINDOW_HANDLE handle,
+    KODI_GUI_CLIENT_HANDLE clienthandle,
+    bool (*CBOnInit)(KODI_GUI_CLIENT_HANDLE),
+    bool (*CBOnFocus)(KODI_GUI_CLIENT_HANDLE, int),
+    bool (*CBOnClick)(KODI_GUI_CLIENT_HANDLE, int),
+    bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE, ADDON_ACTION),
+    void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE, int, gui_context_menu_pair*, unsigned int*),
+    bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE, int, unsigned int))
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !clienthandle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (handle='{}', clienthandle='{}') "
+              "on addon '{}'",
+              __func__, handle, clienthandle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->m_clientHandle = clienthandle;
+  pAddonWindow->CBOnInit = CBOnInit;
+  pAddonWindow->CBOnClick = CBOnClick;
+  pAddonWindow->CBOnFocus = CBOnFocus;
+  pAddonWindow->CBOnAction = CBOnAction;
+  pAddonWindow->CBGetContextButtons = CBGetContextButtons;
+  pAddonWindow->CBOnContextButton = CBOnContextButton;
+  Interface_GUIGeneral::unlock();
+}
+
+bool Interface_GUIWindow::show(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId &&
+      pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow())
+    pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow();
+
+  Interface_GUIGeneral::lock();
+  if (pAddonWindow->IsDialog())
+    dynamic_cast<CGUIAddonWindowDialog*>(pAddonWindow)->Show(true, false);
+  else
+    CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID());
+  Interface_GUIGeneral::unlock();
+
+  return true;
+}
+
+bool Interface_GUIWindow::close(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  pAddonWindow->PulseActionEvent();
+
+  Interface_GUIGeneral::lock();
+
+  // if it's a dialog, we have to close it a bit different
+  if (pAddonWindow->IsDialog())
+    dynamic_cast<CGUIAddonWindowDialog*>(pAddonWindow)->Show(false);
+  else
+    CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId);
+  pAddonWindow->m_oldWindowId = 0;
+
+  Interface_GUIGeneral::unlock();
+
+  return true;
+}
+
+bool Interface_GUIWindow::do_modal(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  if (pAddonWindow->GetID() == CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow())
+    return true;
+
+  if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId &&
+      pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow())
+    pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow();
+
+  Interface_GUIGeneral::lock();
+  if (pAddonWindow->IsDialog())
+    dynamic_cast<CGUIAddonWindowDialog*>(pAddonWindow)->Show(true, true);
+  else
+    CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID());
+  Interface_GUIGeneral::unlock();
+
+  return true;
+}
+//@}
+
+/*!
+ * Window control functions
+ */
+//@{
+bool Interface_GUIWindow::set_focus_id(KODI_HANDLE kodiBase,
+                                       KODI_GUI_WINDOW_HANDLE handle,
+                                       int control_id)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  if (!pAddonWindow->GetControl(control_id))
+  {
+    CLog::Log(LOGERROR, "Interface_GUIWindow - {}: {} - Control does not exist in window", __func__,
+              addon->Name());
+    return false;
+  }
+
+  Interface_GUIGeneral::lock();
+  CGUIMessage msg(GUI_MSG_SETFOCUS, pAddonWindow->m_windowId, control_id);
+  pAddonWindow->OnMessage(msg);
+  Interface_GUIGeneral::unlock();
+
+  return true;
+}
+
+int Interface_GUIWindow::get_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  Interface_GUIGeneral::lock();
+  int control_id = pAddonWindow->GetFocusedControlID();
+  Interface_GUIGeneral::unlock();
+
+  if (control_id == -1)
+    CLog::Log(LOGERROR, "Interface_GUIWindow - {}: {} - No control in this window has focus",
+              __func__, addon->Name());
+
+  return control_id;
+}
+
+void Interface_GUIWindow::set_control_label(KODI_HANDLE kodiBase,
+                                            KODI_GUI_WINDOW_HANDLE handle,
+                                            int control_id,
+                                            const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  CGUIMessage msg(GUI_MSG_LABEL_SET, pAddonWindow->m_windowId, control_id);
+  msg.SetLabel(label);
+  pAddonWindow->OnMessage(msg);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_control_visible(KODI_HANDLE kodiBase,
+                                              KODI_GUI_WINDOW_HANDLE handle,
+                                              int control_id,
+                                              bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  CGUIMessage msg(visible ? GUI_MSG_VISIBLE : GUI_MSG_HIDDEN, pAddonWindow->m_windowId, control_id);
+  pAddonWindow->OnMessage(msg);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_control_selected(KODI_HANDLE kodiBase,
+                                               KODI_GUI_WINDOW_HANDLE handle,
+                                               int control_id,
+                                               bool selected)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  CGUIMessage msg(selected ? GUI_MSG_SET_SELECTED : GUI_MSG_SET_DESELECTED,
+                  pAddonWindow->m_windowId, control_id);
+  pAddonWindow->OnMessage(msg);
+  Interface_GUIGeneral::unlock();
+}
+//@}
+
+/*!
+ * Window property functions
+ */
+//@{
+void Interface_GUIWindow::set_property(KODI_HANDLE kodiBase,
+                                       KODI_GUI_WINDOW_HANDLE handle,
+                                       const char* key,
+                                       const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}', value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              static_cast<const void*>(value), addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetProperty(lowerKey, value);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_property_int(KODI_HANDLE kodiBase,
+                                           KODI_GUI_WINDOW_HANDLE handle,
+                                           const char* key,
+                                           int value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetProperty(lowerKey, value);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_property_bool(KODI_HANDLE kodiBase,
+                                            KODI_GUI_WINDOW_HANDLE handle,
+                                            const char* key,
+                                            bool value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetProperty(lowerKey, value);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_property_double(KODI_HANDLE kodiBase,
+                                              KODI_GUI_WINDOW_HANDLE handle,
+                                              const char* key,
+                                              double value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetProperty(lowerKey, value);
+  Interface_GUIGeneral::unlock();
+}
+
+char* Interface_GUIWindow::get_property(KODI_HANDLE kodiBase,
+                                        KODI_GUI_WINDOW_HANDLE handle,
+                                        const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  std::string value = pAddonWindow->GetProperty(lowerKey).asString();
+  Interface_GUIGeneral::unlock();
+
+  return strdup(value.c_str());
+}
+
+int Interface_GUIWindow::get_property_int(KODI_HANDLE kodiBase,
+                                          KODI_GUI_WINDOW_HANDLE handle,
+                                          const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  int value = static_cast<int>(pAddonWindow->GetProperty(lowerKey).asInteger());
+  Interface_GUIGeneral::unlock();
+
+  return value;
+}
+
+bool Interface_GUIWindow::get_property_bool(KODI_HANDLE kodiBase,
+                                            KODI_GUI_WINDOW_HANDLE handle,
+                                            const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  bool value = pAddonWindow->GetProperty(lowerKey).asBoolean();
+  Interface_GUIGeneral::unlock();
+
+  return value;
+}
+
+double Interface_GUIWindow::get_property_double(KODI_HANDLE kodiBase,
+                                                KODI_GUI_WINDOW_HANDLE handle,
+                                                const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return 0.0;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  double value = pAddonWindow->GetProperty(lowerKey).asDouble();
+  Interface_GUIGeneral::unlock();
+
+  return value;
+}
+
+void Interface_GUIWindow::clear_properties(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->ClearProperties();
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::clear_property(KODI_HANDLE kodiBase,
+                                         KODI_GUI_WINDOW_HANDLE handle,
+                                         const char* key)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  std::string lowerKey = key;
+  StringUtils::ToLower(lowerKey);
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetProperty(lowerKey, "");
+  Interface_GUIGeneral::unlock();
+}
+//@}
+
+/*!
+ * List item functions
+ */
+//@{
+void Interface_GUIWindow::clear_item_list(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->ClearList();
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::add_list_item(KODI_HANDLE kodiBase,
+                                        KODI_GUI_WINDOW_HANDLE handle,
+                                        KODI_GUI_LISTITEM_HANDLE item,
+                                        int list_position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "item='{}') on addon '{}'",
+              __func__, kodiBase, handle, item, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CFileItemPtr* pItem(static_cast<CFileItemPtr*>(item));
+  if (pItem->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIWindow::{} - empty list item called on addon '{}'", __func__,
+              addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->AddItem(pItem, list_position);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::remove_list_item_from_position(KODI_HANDLE kodiBase,
+                                                         KODI_GUI_WINDOW_HANDLE handle,
+                                                         int list_position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->RemoveItem(list_position);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::remove_list_item(KODI_HANDLE kodiBase,
+                                           KODI_GUI_WINDOW_HANDLE handle,
+                                           KODI_GUI_LISTITEM_HANDLE item)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !item)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "item='{}') on addon '{}'",
+              __func__, kodiBase, handle, item, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CFileItemPtr* pItem(static_cast<CFileItemPtr*>(item));
+  if (pItem->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIWindow::{} - empty list item called on addon '{}'", __func__,
+              addon->ID());
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->RemoveItem(pItem);
+  Interface_GUIGeneral::unlock();
+}
+
+KODI_GUI_LISTITEM_HANDLE Interface_GUIWindow::get_list_item(KODI_HANDLE kodiBase,
+                                                            KODI_GUI_WINDOW_HANDLE handle,
+                                                            int list_position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  Interface_GUIGeneral::lock();
+  CFileItemPtr* pItem(pAddonWindow->GetListItem(list_position));
+  if (pItem == nullptr || pItem->get() == nullptr)
+  {
+    CLog::Log(LOGERROR, "ADDON::Interface_GUIWindow - {}: {} - Index out of range", __func__,
+              addon->Name());
+
+    if (pItem)
+    {
+      delete pItem;
+      pItem = nullptr;
+    }
+  }
+  Interface_GUIGeneral::unlock();
+
+  return pItem;
+}
+
+void Interface_GUIWindow::set_current_list_position(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_WINDOW_HANDLE handle,
+                                                    int list_position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetCurrentListPosition(list_position);
+  Interface_GUIGeneral::unlock();
+}
+
+int Interface_GUIWindow::get_current_list_position(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  Interface_GUIGeneral::lock();
+  int listPos = pAddonWindow->GetCurrentListPosition();
+  Interface_GUIGeneral::unlock();
+
+  return listPos;
+}
+
+int Interface_GUIWindow::get_list_size(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  Interface_GUIGeneral::lock();
+  int listSize = pAddonWindow->GetListSize();
+  Interface_GUIGeneral::unlock();
+
+  return listSize;
+}
+
+void Interface_GUIWindow::set_container_property(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_WINDOW_HANDLE handle,
+                                                 const char* key,
+                                                 const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !key || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "key='{}', value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(key),
+              static_cast<const void*>(value), addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetContainerProperty(key, value);
+  Interface_GUIGeneral::unlock();
+}
+
+void Interface_GUIWindow::set_container_content(KODI_HANDLE kodiBase,
+                                                KODI_GUI_WINDOW_HANDLE handle,
+                                                const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(value),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->SetContainerContent(value);
+  Interface_GUIGeneral::unlock();
+}
+
+int Interface_GUIWindow::get_current_container_id(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  Interface_GUIGeneral::lock();
+  int id = pAddonWindow->GetCurrentContainerControlId();
+  Interface_GUIGeneral::unlock();
+
+  return id;
+}
+//@}
+
+/*!
+ * Various functions
+ */
+//@{
+void Interface_GUIWindow::mark_dirty_region(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  pAddonWindow->MarkDirtyRegion();
+  Interface_GUIGeneral::unlock();
+}
+//@}
+
+/*!
+ * GUI control access functions
+ */
+//@{
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_button(KODI_HANDLE kodiBase,
+                                                                KODI_GUI_WINDOW_HANDLE handle,
+                                                                int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_BUTTON,
+                    "button");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_edit(KODI_HANDLE kodiBase,
+                                                              KODI_GUI_WINDOW_HANDLE handle,
+                                                              int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_EDIT, "edit");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_fade_label(KODI_HANDLE kodiBase,
+                                                                    KODI_GUI_WINDOW_HANDLE handle,
+                                                                    int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_FADELABEL,
+                    "fade label");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_image(KODI_HANDLE kodiBase,
+                                                               KODI_GUI_WINDOW_HANDLE handle,
+                                                               int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_IMAGE, "image");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_label(KODI_HANDLE kodiBase,
+                                                               KODI_GUI_WINDOW_HANDLE handle,
+                                                               int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_LABEL, "label");
+}
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_progress(KODI_HANDLE kodiBase,
+                                                                  KODI_GUI_WINDOW_HANDLE handle,
+                                                                  int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_PROGRESS,
+                    "progress");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_radio_button(KODI_HANDLE kodiBase,
+                                                                      KODI_GUI_WINDOW_HANDLE handle,
+                                                                      int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_RADIO,
+                    "radio button");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_render_addon(KODI_HANDLE kodiBase,
+                                                                      KODI_GUI_WINDOW_HANDLE handle,
+                                                                      int control_id)
+{
+  CGUIControl* pGUIControl = static_cast<CGUIControl*>(GetControl(
+      kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_RENDERADDON, "renderaddon"));
+  if (!pGUIControl)
+    return nullptr;
+
+  CGUIAddonRenderingControl* pRenderControl =
+      new CGUIAddonRenderingControl(dynamic_cast<CGUIRenderingControl*>(pGUIControl));
+  return pRenderControl;
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_settings_slider(
+    KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SETTINGS_SLIDER,
+                    "settings slider");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_slider(KODI_HANDLE kodiBase,
+                                                                KODI_GUI_WINDOW_HANDLE handle,
+                                                                int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SLIDER,
+                    "slider");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_spin(KODI_HANDLE kodiBase,
+                                                              KODI_GUI_WINDOW_HANDLE handle,
+                                                              int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SPINEX, "spin");
+}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_text_box(KODI_HANDLE kodiBase,
+                                                                  KODI_GUI_WINDOW_HANDLE handle,
+                                                                  int control_id)
+{
+  return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_TEXTBOX,
+                    "textbox");
+}
+//@}
+
+KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::GetControl(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_WINDOW_HANDLE handle,
+                                                        int control_id,
+                                                        const char* function,
+                                                        CGUIControl::GUICONTROLTYPES type,
+                                                        const std::string& typeName)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonWindow* pAddonWindow = static_cast<CGUIAddonWindow*>(handle);
+  if (!addon || !pAddonWindow)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on "
+              "addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return pAddonWindow->GetAddonControl(control_id, type, typeName);
+}
+
+int Interface_GUIWindow::GetNextAvailableWindowId()
+{
+  Interface_GUIGeneral::lock();
+
+  // if window WINDOW_ADDON_END is in use it means addon can't create more windows
+  if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_ADDON_END))
+  {
+    Interface_GUIGeneral::unlock();
+    CLog::Log(LOGERROR,
+              "Interface_GUIWindow::{} - Maximum number of windows for binary addons reached",
+              __func__);
+    return -1;
+  }
+
+  // window id's WINDOW_ADDON_START - WINDOW_ADDON_END are reserved for addons
+  // get first window id that is not in use
+  int id = WINDOW_ADDON_START;
+  while (id < WINDOW_ADDON_END &&
+         CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id) != nullptr)
+    id++;
+
+  Interface_GUIGeneral::unlock();
+  return id;
+}
+
+CGUIAddonWindow::CGUIAddonWindow(int id, const std::string& strXML, CAddonDll* addon, bool isMedia)
+  : CGUIMediaWindow(id, strXML.c_str()),
+    m_clientHandle{nullptr},
+    CBOnInit{nullptr},
+    CBOnFocus{nullptr},
+    CBOnClick{nullptr},
+    CBOnAction{nullptr},
+    CBGetContextButtons{nullptr},
+    CBOnContextButton{nullptr},
+    m_windowId(id),
+    m_oldWindowId(0),
+    m_actionEvent(true),
+    m_addon(addon),
+    m_isMedia(isMedia)
+{
+  m_loadType = LOAD_ON_GUI_INIT;
+}
+
+CGUIControl* CGUIAddonWindow::GetAddonControl(int controlId,
+                                              CGUIControl::GUICONTROLTYPES type,
+                                              const std::string& typeName)
+{
+  // Load window resources, if not already done, to have related xml content
+  // present and to let control find it
+  if (!m_windowLoaded)
+  {
+    if (!Initialize())
+    {
+      CLog::Log(LOGERROR,
+                "CGUIAddonGUI_Window::{}: {} - Window initialize failed by control id '{}' request "
+                "for '{}'",
+                __func__, m_addon->Name(), controlId, typeName);
+      return nullptr;
+    }
+  }
+
+  CGUIControl* pGUIControl = GetControl(controlId);
+  if (!pGUIControl)
+  {
+    CLog::Log(LOGERROR,
+              "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' for '{}' not present!",
+              __func__, m_addon->Name(), controlId, typeName);
+    return nullptr;
+  }
+  else if (pGUIControl->GetControlType() != type)
+  {
+    CLog::Log(LOGERROR,
+              "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' not the type '{}'!",
+              __func__, m_addon->Name(), controlId, typeName);
+    return nullptr;
+  }
+
+  return pGUIControl;
+}
+
+bool CGUIAddonWindow::OnAction(const CAction& action)
+{
+  // Let addon decide whether it wants to handle action first
+  if (CBOnAction &&
+      CBOnAction(m_clientHandle, CAddonGUITranslator::TranslateActionIdToAddon(action.GetID())))
+    return true;
+
+  return CGUIWindow::OnAction(action);
+}
+
+bool CGUIAddonWindow::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      return CGUIMediaWindow::OnMessage(message);
+    }
+    break;
+
+    case GUI_MSG_WINDOW_INIT:
+    {
+      CGUIMediaWindow::OnMessage(message);
+
+      if (CBOnInit)
+        CBOnInit(m_clientHandle);
+      return true;
+    }
+    break;
+
+    case GUI_MSG_FOCUSED:
+    {
+      if (m_viewControl.HasControl(message.GetControlId()) &&
+          m_viewControl.GetCurrentControl() != message.GetControlId())
+      {
+        m_viewControl.SetFocused();
+        return true;
+      }
+      // check if our focused control is one of our category buttons
+      int iControl = message.GetControlId();
+      if (CBOnFocus)
+        CBOnFocus(m_clientHandle, iControl);
+    }
+    break;
+
+    case GUI_MSG_NOTIFY_ALL:
+    {
+      // most messages from GUI_MSG_NOTIFY_ALL break container content, whitelist working ones.
+      if (message.GetParam1() == GUI_MSG_PAGE_CHANGE ||
+          message.GetParam1() == GUI_MSG_WINDOW_RESIZE)
+        return CGUIMediaWindow::OnMessage(message);
+      return true;
+    }
+
+    case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      if (iControl && iControl != this->GetID())
+      {
+        CGUIControl* controlClicked = this->GetControl(iControl);
+
+        // The old python way used to check list AND SELECITEM method or if its a button, checkmark.
+        // Its done this way for now to allow other controls without a python version like togglebutton to still raise a onAction event
+        if (controlClicked) // Will get problems if we the id is not on the window and we try to do GetControlType on it. So check to make sure it exists
+        {
+          if ((controlClicked->IsContainer() && (message.GetParam1() == ACTION_SELECT_ITEM ||
+                                                 message.GetParam1() == ACTION_MOUSE_LEFT_CLICK)) ||
+              !controlClicked->IsContainer())
+          {
+            if (CBOnClick)
+              return CBOnClick(m_clientHandle, iControl);
+          }
+          else if (controlClicked->IsContainer() &&
+                   (message.GetParam1() == ACTION_MOUSE_RIGHT_CLICK ||
+                    message.GetParam1() == ACTION_CONTEXT_MENU))
+          {
+            if (CBOnAction)
+            {
+              // Check addon want to handle right click for a context menu, if
+              // not used from addon becomes "GetContextButtons(...)" called.
+              if (CBOnAction(m_clientHandle, ADDON_ACTION_CONTEXT_MENU))
+                return true;
+            }
+          }
+        }
+      }
+    }
+    break;
+  }
+
+  return CGUIMediaWindow::OnMessage(message);
+}
+
+void CGUIAddonWindow::AllocResources(bool forceLoad /*= false */)
+{
+  std::string tmpDir = URIUtils::GetDirectory(GetProperty("xmlfile").asString());
+  std::string fallbackMediaPath;
+  URIUtils::GetParentPath(tmpDir, fallbackMediaPath);
+  URIUtils::RemoveSlashAtEnd(fallbackMediaPath);
+  m_mediaDir = fallbackMediaPath;
+
+  CServiceBroker::GetGUI()->GetTextureManager().AddTexturePath(m_mediaDir);
+  CGUIMediaWindow::AllocResources(forceLoad);
+  CServiceBroker::GetGUI()->GetTextureManager().RemoveTexturePath(m_mediaDir);
+}
+
+void CGUIAddonWindow::Render()
+{
+  CServiceBroker::GetGUI()->GetTextureManager().AddTexturePath(m_mediaDir);
+  CGUIMediaWindow::Render();
+  CServiceBroker::GetGUI()->GetTextureManager().RemoveTexturePath(m_mediaDir);
+}
+
+void CGUIAddonWindow::AddItem(CFileItemPtr* fileItem, int itemPosition)
+{
+  if (itemPosition == -1 || itemPosition > m_vecItems->Size())
+  {
+    m_vecItems->Add(*fileItem);
+  }
+  else if (itemPosition < -1 && !(itemPosition - 1 < m_vecItems->Size()))
+  {
+    m_vecItems->AddFront(*fileItem, 0);
+  }
+  else
+  {
+    m_vecItems->AddFront(*fileItem, itemPosition);
+  }
+  m_viewControl.SetItems(*m_vecItems);
+  UpdateButtons();
+}
+
+void CGUIAddonWindow::RemoveItem(int itemPosition)
+{
+  m_vecItems->Remove(itemPosition);
+  m_viewControl.SetItems(*m_vecItems);
+  UpdateButtons();
+}
+
+void CGUIAddonWindow::RemoveItem(CFileItemPtr* fileItem)
+{
+  m_vecItems->Remove(fileItem->get());
+  m_viewControl.SetItems(*m_vecItems);
+  UpdateButtons();
+}
+
+int CGUIAddonWindow::GetCurrentListPosition()
+{
+  return m_viewControl.GetSelectedItem();
+}
+
+void CGUIAddonWindow::SetCurrentListPosition(int item)
+{
+  m_viewControl.SetSelectedItem(item);
+}
+
+int CGUIAddonWindow::GetListSize()
+{
+  return m_vecItems->Size();
+}
+
+CFileItemPtr* CGUIAddonWindow::GetListItem(int position)
+{
+  if (position < 0 || position >= m_vecItems->Size())
+    return nullptr;
+  return new CFileItemPtr(m_vecItems->Get(position));
+}
+
+void CGUIAddonWindow::ClearList()
+{
+  ClearFileItems();
+
+  m_viewControl.SetItems(*m_vecItems);
+  UpdateButtons();
+}
+
+void CGUIAddonWindow::SetContainerProperty(const std::string& key, const std::string& value)
+{
+  m_vecItems->SetProperty(key, value);
+}
+
+void CGUIAddonWindow::SetContainerContent(const std::string& value)
+{
+  m_vecItems->SetContent(value);
+}
+
+int CGUIAddonWindow::GetCurrentContainerControlId()
+{
+  return m_viewControl.GetCurrentControl();
+}
+
+void CGUIAddonWindow::GetContextButtons(int itemNumber, CContextButtons& buttons)
+{
+  gui_context_menu_pair c_buttons[ADDON_MAX_CONTEXT_ENTRIES] = {};
+  unsigned int size = ADDON_MAX_CONTEXT_ENTRIES;
+  if (CBGetContextButtons)
+  {
+    CBGetContextButtons(m_clientHandle, itemNumber, c_buttons, &size);
+    for (unsigned int i = 0; i < size; ++i)
+      buttons.push_back(std::pair<unsigned int, std::string>(c_buttons[i].id, c_buttons[i].name));
+  }
+}
+
+bool CGUIAddonWindow::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
+{
+  if (CBOnContextButton)
+    return CBOnContextButton(m_clientHandle, itemNumber, static_cast<unsigned int>(button));
+  return false;
+}
+
+void CGUIAddonWindow::WaitForActionEvent(unsigned int timeout)
+{
+  m_actionEvent.Wait(std::chrono::milliseconds(timeout));
+  m_actionEvent.Reset();
+}
+
+void CGUIAddonWindow::PulseActionEvent()
+{
+  m_actionEvent.Set();
+}
+
+void CGUIAddonWindow::SetupShares()
+{
+  UpdateButtons();
+}
+
+
+CGUIAddonWindowDialog::CGUIAddonWindowDialog(int id, const std::string& strXML, CAddonDll* addon)
+  : CGUIAddonWindow(id, strXML, addon, false), m_bRunning(false)
+{
+}
+
+void CGUIAddonWindowDialog::Show(bool show /* = true */, bool modal /* = true*/)
+{
+  if (modal)
+  {
+    unsigned int count = CServiceBroker::GetWinSystem()->GetGfxContext().exit();
+    CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0,
+                                               static_cast<void*>(this));
+    CServiceBroker::GetWinSystem()->GetGfxContext().restore(count);
+  }
+  else
+    CServiceBroker::GetAppMessenger()->PostMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0,
+                                               static_cast<void*>(this));
+}
+
+void CGUIAddonWindowDialog::Show_Internal(bool show /* = true */)
+{
+  if (show)
+  {
+    m_bRunning = true;
+    CServiceBroker::GetGUI()->GetWindowManager().RegisterDialog(this);
+
+    // activate this window...
+    CGUIMessage msg(GUI_MSG_WINDOW_INIT, 0, 0, WINDOW_INVALID, GetID());
+    OnMessage(msg);
+
+    // this dialog is derived from GUIMediaWindow
+    // make sure it is rendered last
+    m_renderOrder = RENDER_ORDER_DIALOG;
+    while (m_bRunning)
+    {
+      if (!ProcessRenderLoop(false))
+        break;
+    }
+  }
+  else // hide
+  {
+    m_bRunning = false;
+
+    CGUIMessage msg(GUI_MSG_WINDOW_DEINIT, 0, 0);
+    OnMessage(msg);
+
+    CServiceBroker::GetGUI()->GetWindowManager().RemoveDialog(GetID());
+  }
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/Window.h b/xbmc/addons/interfaces/gui/Window.h
new file mode 100644
index 0000000..dad0737
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/Window.h
@@ -0,0 +1,278 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/window.h"
+#include "threads/Event.h"
+#include "windows/GUIMediaWindow.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+  struct gui_context_menu_pair;
+
+  namespace ADDON
+  {
+  class CAddonDll;
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/Window.h"
+   */
+  struct Interface_GUIWindow
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    /* Window creation functions */
+    static KODI_GUI_WINDOW_HANDLE create(KODI_HANDLE kodiBase,
+                                         const char* xml_filename,
+                                         const char* default_skin,
+                                         bool as_dialog,
+                                         bool is_media);
+    static void destroy(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static void set_callbacks(KODI_HANDLE kodiBase,
+                              KODI_GUI_WINDOW_HANDLE handle,
+                              KODI_GUI_CLIENT_HANDLE clienthandle,
+                              bool (*CBInit)(KODI_GUI_CLIENT_HANDLE),
+                              bool (*CBFocus)(KODI_GUI_CLIENT_HANDLE, int),
+                              bool (*CBClick)(KODI_GUI_CLIENT_HANDLE, int),
+                              bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE, ADDON_ACTION),
+                              void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE,
+                                                          int,
+                                                          gui_context_menu_pair*,
+                                                          unsigned int*),
+                              bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE, int, unsigned int));
+    static bool show(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static bool close(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static bool do_modal(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+
+    /* Window control functions */
+    static bool set_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id);
+    static int get_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static void set_control_label(KODI_HANDLE kodiBase,
+                                  KODI_GUI_WINDOW_HANDLE handle,
+                                  int control_id,
+                                  const char* label);
+    static void set_control_visible(KODI_HANDLE kodiBase,
+                                    KODI_GUI_WINDOW_HANDLE handle,
+                                    int control_id,
+                                    bool visible);
+    static void set_control_selected(KODI_HANDLE kodiBase,
+                                     KODI_GUI_WINDOW_HANDLE handle,
+                                     int control_id,
+                                     bool selected);
+
+    /* Window property functions */
+    static void set_property(KODI_HANDLE kodiBase,
+                             KODI_GUI_WINDOW_HANDLE handle,
+                             const char* key,
+                             const char* value);
+    static void set_property_int(KODI_HANDLE kodiBase,
+                                 KODI_GUI_WINDOW_HANDLE handle,
+                                 const char* key,
+                                 int value);
+    static void set_property_bool(KODI_HANDLE kodiBase,
+                                  KODI_GUI_WINDOW_HANDLE handle,
+                                  const char* key,
+                                  bool value);
+    static void set_property_double(KODI_HANDLE kodiBase,
+                                    KODI_GUI_WINDOW_HANDLE handle,
+                                    const char* key,
+                                    double value);
+    static char* get_property(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key);
+    static int get_property_int(KODI_HANDLE kodiBase,
+                                KODI_GUI_WINDOW_HANDLE handle,
+                                const char* key);
+    static bool get_property_bool(KODI_HANDLE kodiBase,
+                                  KODI_GUI_WINDOW_HANDLE handle,
+                                  const char* key);
+    static double get_property_double(KODI_HANDLE kodiBase,
+                                      KODI_GUI_WINDOW_HANDLE handle,
+                                      const char* key);
+    static void clear_properties(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static void clear_property(KODI_HANDLE kodiBase,
+                               KODI_GUI_WINDOW_HANDLE handle,
+                               const char* key);
+
+    /* List item functions */
+    static void clear_item_list(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static void add_list_item(KODI_HANDLE kodiBase,
+                              KODI_GUI_WINDOW_HANDLE handle,
+                              KODI_GUI_LISTITEM_HANDLE item,
+                              int list_position);
+    static void remove_list_item_from_position(KODI_HANDLE kodiBase,
+                                               KODI_GUI_WINDOW_HANDLE handle,
+                                               int list_position);
+    static void remove_list_item(KODI_HANDLE kodiBase,
+                                 KODI_GUI_WINDOW_HANDLE handle,
+                                 KODI_GUI_LISTITEM_HANDLE item);
+    static KODI_GUI_LISTITEM_HANDLE get_list_item(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_WINDOW_HANDLE handle,
+                                                  int list_position);
+    static void set_current_list_position(KODI_HANDLE kodiBase,
+                                          KODI_GUI_WINDOW_HANDLE handle,
+                                          int list_position);
+    static int get_current_list_position(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static int get_list_size(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+    static void set_container_property(KODI_HANDLE kodiBase,
+                                       KODI_GUI_WINDOW_HANDLE handle,
+                                       const char* key,
+                                       const char* value);
+    static void set_container_content(KODI_HANDLE kodiBase,
+                                      KODI_GUI_WINDOW_HANDLE handle,
+                                      const char* value);
+    static int get_current_container_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+
+    /* Various functions */
+    static void mark_dirty_region(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle);
+
+    /* GUI control access functions */
+    static KODI_GUI_CONTROL_HANDLE get_control_button(KODI_HANDLE kodiBase,
+                                                      KODI_GUI_WINDOW_HANDLE handle,
+                                                      int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_edit(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_WINDOW_HANDLE handle,
+                                                    int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_fade_label(KODI_HANDLE kodiBase,
+                                                          KODI_GUI_WINDOW_HANDLE handle,
+                                                          int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_image(KODI_HANDLE kodiBase,
+                                                     KODI_GUI_WINDOW_HANDLE handle,
+                                                     int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_label(KODI_HANDLE kodiBase,
+                                                     KODI_GUI_WINDOW_HANDLE handle,
+                                                     int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_radio_button(KODI_HANDLE kodiBase,
+                                                            KODI_GUI_WINDOW_HANDLE handle,
+                                                            int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_progress(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_WINDOW_HANDLE handle,
+                                                        int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_render_addon(KODI_HANDLE kodiBase,
+                                                            KODI_GUI_WINDOW_HANDLE handle,
+                                                            int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_settings_slider(KODI_HANDLE kodiBase,
+                                                               KODI_GUI_WINDOW_HANDLE handle,
+                                                               int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_slider(KODI_HANDLE kodiBase,
+                                                      KODI_GUI_WINDOW_HANDLE handle,
+                                                      int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_spin(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_WINDOW_HANDLE handle,
+                                                    int control_id);
+    static KODI_GUI_CONTROL_HANDLE get_control_text_box(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_WINDOW_HANDLE handle,
+                                                        int control_id);
+    //@}
+
+  private:
+    static KODI_GUI_CONTROL_HANDLE GetControl(KODI_HANDLE kodiBase,
+                                              KODI_GUI_WINDOW_HANDLE handle,
+                                              int control_id,
+                                              const char* function,
+                                              CGUIControl::GUICONTROLTYPES type,
+                                              const std::string& typeName);
+    static int GetNextAvailableWindowId();
+  };
+
+  class CGUIAddonWindow : public CGUIMediaWindow
+  {
+    friend struct Interface_GUIWindow;
+
+  public:
+    CGUIAddonWindow(int id, const std::string& strXML, ADDON::CAddonDll* addon, bool isMedia);
+    ~CGUIAddonWindow() override = default;
+
+    bool OnMessage(CGUIMessage& message) override;
+    bool OnAction(const CAction& action) override;
+    void AllocResources(bool forceLoad = false) override;
+    void Render() override;
+    bool IsMediaWindow() const override { return m_isMedia; }
+
+    /* Addon to Kodi call functions */
+    void PulseActionEvent();
+    void AddItem(CFileItemPtr* fileItem, int itemPosition);
+    void RemoveItem(int itemPosition);
+    void RemoveItem(CFileItemPtr* fileItem);
+    void ClearList();
+    CFileItemPtr* GetListItem(int position);
+    int GetListSize();
+    int GetCurrentListPosition();
+    void SetCurrentListPosition(int item);
+    void SetContainerProperty(const std::string& key, const std::string& value);
+    void SetContainerContent(const std::string& value);
+    int GetCurrentContainerControlId();
+    CGUIControl* GetAddonControl(int controlId,
+                                 CGUIControl::GUICONTROLTYPES type,
+                                 const std::string& typeName);
+
+  protected:
+    void GetContextButtons(int itemNumber, CContextButtons& buttons) override;
+    bool OnContextButton(int itemNumber, CONTEXT_BUTTON button) override;
+    void SetupShares() override;
+
+    /* kodi to addon callback function addresses */
+    KODI_GUI_CLIENT_HANDLE m_clientHandle;
+    bool (*CBOnInit)(KODI_GUI_CLIENT_HANDLE cbhdl);
+    bool (*CBOnFocus)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId);
+    bool (*CBOnClick)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId);
+    bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE cbhdl, ADDON_ACTION actionId);
+    void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE cbhdl,
+                                int itemNumber,
+                                gui_context_menu_pair* buttons,
+                                unsigned int* size);
+    bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE cbhdl, int itemNumber, unsigned int button);
+
+    const int m_windowId;
+    int m_oldWindowId;
+
+  private:
+    void WaitForActionEvent(unsigned int timeout);
+
+    CEvent m_actionEvent;
+    ADDON::CAddonDll* m_addon;
+    std::string m_mediaDir;
+    bool m_isMedia;
+  };
+
+  class CGUIAddonWindowDialog : public CGUIAddonWindow
+  {
+  public:
+    CGUIAddonWindowDialog(int id, const std::string& strXML, ADDON::CAddonDll* addon);
+
+    bool IsDialogRunning() const override { return m_bRunning; }
+    bool IsDialog() const override { return true; }
+    bool IsModalDialog() const override { return true; }
+
+    void Show(bool show = true, bool modal = true);
+    void Show_Internal(bool show = true);
+
+  private:
+    bool m_bRunning;
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Button.cpp b/xbmc/addons/interfaces/gui/controls/Button.cpp
new file mode 100644
index 0000000..24a9994
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Button.cpp
@@ -0,0 +1,146 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Button.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Button.h"
+#include "guilib/GUIButtonControl.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlButton::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_button =
+      new AddonToKodiFuncTable_kodi_gui_control_button();
+
+  addonInterface->toKodi->kodi_gui->control_button->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_button->set_enabled = set_enabled;
+
+  addonInterface->toKodi->kodi_gui->control_button->set_label = set_label;
+  addonInterface->toKodi->kodi_gui->control_button->get_label = get_label;
+
+  addonInterface->toKodi->kodi_gui->control_button->set_label2 = set_label2;
+  addonInterface->toKodi->kodi_gui->control_button->get_label2 = get_label2;
+}
+
+void Interface_GUIControlButton::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_button;
+}
+
+void Interface_GUIControlButton::set_visible(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlButton::set_enabled(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             bool enabled)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enabled);
+}
+
+void Interface_GUIControlButton::set_label(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetLabel(label);
+}
+
+char* Interface_GUIControlButton::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetLabel().c_str());
+}
+
+void Interface_GUIControlButton::set_label2(KODI_HANDLE kodiBase,
+                                            KODI_GUI_CONTROL_HANDLE handle,
+                                            const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetLabel2(label);
+}
+
+char* Interface_GUIControlButton::get_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIButtonControl* control = static_cast<CGUIButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetLabel2().c_str());
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Button.h b/xbmc/addons/interfaces/gui/controls/Button.h
new file mode 100644
index 0000000..221ae4e
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Button.h
@@ -0,0 +1,56 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Button.h"
+   */
+  struct Interface_GUIControlButton
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/CMakeLists.txt b/xbmc/addons/interfaces/gui/controls/CMakeLists.txt
new file mode 100644
index 0000000..0a708c6
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/CMakeLists.txt
@@ -0,0 +1,27 @@
+set(SOURCES Button.cpp
+            Edit.cpp
+            FadeLabel.cpp
+            Image.cpp
+            Label.cpp
+            Progress.cpp
+            RadioButton.cpp
+            Rendering.cpp
+            SettingsSlider.cpp
+            Slider.cpp
+            Spin.cpp
+            TextBox.cpp)
+
+set(HEADERS Button.h
+            Edit.h
+            FadeLabel.h
+            Image.h
+            Label.h
+            Progress.h
+            RadioButton.h
+            Rendering.h
+            SettingsSlider.h
+            Slider.h
+            Spin.h
+            TextBox.h)
+
+core_add_library(addons_interfaces_gui_controls)
diff --git a/xbmc/addons/interfaces/gui/controls/Edit.cpp b/xbmc/addons/interfaces/gui/controls/Edit.cpp
new file mode 100644
index 0000000..b537279
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Edit.cpp
@@ -0,0 +1,239 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Edit.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Edit.h"
+#include "guilib/GUIEditControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlEdit::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_edit = new AddonToKodiFuncTable_kodi_gui_control_edit();
+
+  addonInterface->toKodi->kodi_gui->control_edit->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_edit->set_enabled = set_enabled;
+  addonInterface->toKodi->kodi_gui->control_edit->set_input_type = set_input_type;
+  addonInterface->toKodi->kodi_gui->control_edit->set_label = set_label;
+  addonInterface->toKodi->kodi_gui->control_edit->get_label = get_label;
+  addonInterface->toKodi->kodi_gui->control_edit->set_text = set_text;
+  addonInterface->toKodi->kodi_gui->control_edit->get_text = get_text;
+  addonInterface->toKodi->kodi_gui->control_edit->set_cursor_position = set_cursor_position;
+  addonInterface->toKodi->kodi_gui->control_edit->get_cursor_position = get_cursor_position;
+}
+
+void Interface_GUIControlEdit::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_edit;
+}
+
+void Interface_GUIControlEdit::set_visible(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlEdit::set_enabled(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           bool enable)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enable);
+}
+
+void Interface_GUIControlEdit::set_input_type(KODI_HANDLE kodiBase,
+                                              KODI_GUI_CONTROL_HANDLE handle,
+                                              int type,
+                                              const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "heading='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(heading),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIEditControl::INPUT_TYPE kodiType;
+  switch (static_cast<AddonGUIInputType>(type))
+  {
+    case ADDON_INPUT_TYPE_TEXT:
+      kodiType = CGUIEditControl::INPUT_TYPE_TEXT;
+      break;
+    case ADDON_INPUT_TYPE_NUMBER:
+      kodiType = CGUIEditControl::INPUT_TYPE_NUMBER;
+      break;
+    case ADDON_INPUT_TYPE_SECONDS:
+      kodiType = CGUIEditControl::INPUT_TYPE_SECONDS;
+      break;
+    case ADDON_INPUT_TYPE_TIME:
+      kodiType = CGUIEditControl::INPUT_TYPE_TIME;
+      break;
+    case ADDON_INPUT_TYPE_DATE:
+      kodiType = CGUIEditControl::INPUT_TYPE_DATE;
+      break;
+    case ADDON_INPUT_TYPE_IPADDRESS:
+      kodiType = CGUIEditControl::INPUT_TYPE_IPADDRESS;
+      break;
+    case ADDON_INPUT_TYPE_PASSWORD:
+      kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD;
+      break;
+    case ADDON_INPUT_TYPE_PASSWORD_MD5:
+      kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_MD5;
+      break;
+    case ADDON_INPUT_TYPE_SEARCH:
+      kodiType = CGUIEditControl::INPUT_TYPE_SEARCH;
+      break;
+    case ADDON_INPUT_TYPE_FILTER:
+      kodiType = CGUIEditControl::INPUT_TYPE_FILTER;
+      break;
+    case ADDON_INPUT_TYPE_READONLY:
+    default:
+      kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_NUMBER_VERIFY_NEW;
+  }
+
+  control->SetInputType(kodiType, heading);
+}
+
+void Interface_GUIControlEdit::set_label(KODI_HANDLE kodiBase,
+                                         KODI_GUI_CONTROL_HANDLE handle,
+                                         const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetLabel(label);
+}
+
+char* Interface_GUIControlEdit::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetLabel().c_str());
+}
+
+void Interface_GUIControlEdit::set_text(KODI_HANDLE kodiBase,
+                                        KODI_GUI_CONTROL_HANDLE handle,
+                                        const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "text='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(text),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetLabel2(text);
+}
+
+char* Interface_GUIControlEdit::get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetLabel2().c_str());
+}
+
+void Interface_GUIControlEdit::set_cursor_position(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_CONTROL_HANDLE handle,
+                                                   unsigned int position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetCursorPosition(position);
+}
+
+unsigned int Interface_GUIControlEdit::get_cursor_position(KODI_HANDLE kodiBase,
+                                                           KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIEditControl* control = static_cast<CGUIEditControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0;
+  }
+
+  return control->GetCursorPosition();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Edit.h b/xbmc/addons/interfaces/gui/controls/Edit.h
new file mode 100644
index 0000000..9dda1e2
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Edit.h
@@ -0,0 +1,67 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Edit.h"
+   */
+  struct Interface_GUIControlEdit
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void set_input_type(KODI_HANDLE kodiBase,
+                               KODI_GUI_CONTROL_HANDLE handle,
+                               int type,
+                               const char* heading);
+
+    static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text);
+    static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_cursor_position(KODI_HANDLE kodiBase,
+                                    KODI_GUI_CONTROL_HANDLE handle,
+                                    unsigned int position);
+    static unsigned int get_cursor_position(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp b/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp
new file mode 100644
index 0000000..13c5604
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp
@@ -0,0 +1,130 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "FadeLabel.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/FadeLabel.h"
+#include "guilib/GUIFadeLabelControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlFadeLabel::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_fade_label =
+      new AddonToKodiFuncTable_kodi_gui_control_fade_label();
+
+  addonInterface->toKodi->kodi_gui->control_fade_label->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_fade_label->add_label = add_label;
+  addonInterface->toKodi->kodi_gui->control_fade_label->get_label = get_label;
+  addonInterface->toKodi->kodi_gui->control_fade_label->set_scrolling = set_scrolling;
+  addonInterface->toKodi->kodi_gui->control_fade_label->reset = reset;
+}
+
+void Interface_GUIControlFadeLabel::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_fade_label;
+}
+
+void Interface_GUIControlFadeLabel::set_visible(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle,
+                                                bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIFadeLabelControl* control = static_cast<CGUIFadeLabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlFadeLabel::add_label(KODI_HANDLE kodiBase,
+                                              KODI_GUI_CONTROL_HANDLE handle,
+                                              const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIFadeLabelControl* control = static_cast<CGUIFadeLabelControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}', label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_ADD, control->GetParentID(), control->GetID());
+  msg.SetLabel(label);
+  control->OnMessage(msg);
+}
+
+char* Interface_GUIControlFadeLabel::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIFadeLabelControl* control = static_cast<CGUIFadeLabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  CGUIMessage msg(GUI_MSG_ITEM_SELECTED, control->GetParentID(), control->GetID());
+  control->OnMessage(msg);
+  std::string text = msg.GetLabel();
+  return strdup(text.c_str());
+}
+
+void Interface_GUIControlFadeLabel::set_scrolling(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  bool scroll)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIFadeLabelControl* control = static_cast<CGUIFadeLabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetScrolling(scroll);
+}
+
+void Interface_GUIControlFadeLabel::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIFadeLabelControl* control = static_cast<CGUIFadeLabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID());
+  control->OnMessage(msg);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/FadeLabel.h b/xbmc/addons/interfaces/gui/controls/FadeLabel.h
new file mode 100644
index 0000000..2c3cd68
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/FadeLabel.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/FadeLabel.h"
+   */
+  struct Interface_GUIControlFadeLabel
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+    static void set_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool selected);
+
+    static void add_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_scrolling(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool scroll);
+    static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Image.cpp b/xbmc/addons/interfaces/gui/controls/Image.cpp
new file mode 100644
index 0000000..88f368c
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Image.cpp
@@ -0,0 +1,92 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Image.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Image.h"
+#include "guilib/GUIImage.h"
+#include "utils/log.h"
+
+using namespace KODI;
+
+namespace ADDON
+{
+
+void Interface_GUIControlImage::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_image =
+      new AddonToKodiFuncTable_kodi_gui_control_image();
+
+  addonInterface->toKodi->kodi_gui->control_image->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_image->set_filename = set_filename;
+  addonInterface->toKodi->kodi_gui->control_image->set_color_diffuse = set_color_diffuse;
+}
+
+void Interface_GUIControlImage::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_image;
+}
+
+void Interface_GUIControlImage::set_visible(KODI_HANDLE kodiBase,
+                                            KODI_GUI_CONTROL_HANDLE handle,
+                                            bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIImage* control = static_cast<CGUIImage*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlImage::set_filename(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             const char* filename,
+                                             bool use_cache)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIImage* control = static_cast<CGUIImage*>(handle);
+  if (!addon || !control || !filename)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "filename='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(filename),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFileName(filename, false, use_cache);
+}
+
+void Interface_GUIControlImage::set_color_diffuse(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  uint32_t colorDiffuse)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIImage* control = static_cast<CGUIImage*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetColorDiffuse(GUILIB::GUIINFO::CGUIInfoColor(colorDiffuse));
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Image.h b/xbmc/addons/interfaces/gui/controls/Image.h
new file mode 100644
index 0000000..b12bece
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Image.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Image.h"
+   */
+  struct Interface_GUIControlImage
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_filename(KODI_HANDLE kodiBase,
+                             KODI_GUI_CONTROL_HANDLE handle,
+                             const char* filename,
+                             bool use_cache);
+    static void set_color_diffuse(KODI_HANDLE kodiBase,
+                                  KODI_GUI_CONTROL_HANDLE handle,
+                                  uint32_t color_diffuse);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Label.cpp b/xbmc/addons/interfaces/gui/controls/Label.cpp
new file mode 100644
index 0000000..3922e3f
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Label.cpp
@@ -0,0 +1,92 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Label.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Label.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUILabelControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlLabel::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_label =
+      new AddonToKodiFuncTable_kodi_gui_control_label();
+
+  addonInterface->toKodi->kodi_gui->control_label->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_label->set_label = set_label;
+  addonInterface->toKodi->kodi_gui->control_label->get_label = get_label;
+}
+
+void Interface_GUIControlLabel::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_label;
+}
+
+void Interface_GUIControlLabel::set_visible(KODI_HANDLE kodiBase,
+                                            KODI_GUI_CONTROL_HANDLE handle,
+                                            bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUILabelControl* control = static_cast<CGUILabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlLabel::set_label(KODI_HANDLE kodiBase,
+                                          KODI_GUI_CONTROL_HANDLE handle,
+                                          const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUILabelControl* control = static_cast<CGUILabelControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID());
+  msg.SetLabel(label);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+char* Interface_GUIControlLabel::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUILabelControl* control = static_cast<CGUILabelControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetDescription().c_str());
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Label.h b/xbmc/addons/interfaces/gui/controls/Label.h
new file mode 100644
index 0000000..020c3d5
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Label.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Label.h"
+   */
+  struct Interface_GUIControlLabel
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+
+    static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Progress.cpp b/xbmc/addons/interfaces/gui/controls/Progress.cpp
new file mode 100644
index 0000000..639d079
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Progress.cpp
@@ -0,0 +1,88 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Progress.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Progress.h"
+#include "guilib/GUIProgressControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlProgress::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_progress =
+      new AddonToKodiFuncTable_kodi_gui_control_progress();
+
+  addonInterface->toKodi->kodi_gui->control_progress->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_progress->set_percentage = set_percentage;
+  addonInterface->toKodi->kodi_gui->control_progress->get_percentage = get_percentage;
+}
+
+void Interface_GUIControlProgress::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_progress;
+}
+
+void Interface_GUIControlProgress::set_visible(KODI_HANDLE kodiBase,
+                                               KODI_GUI_CONTROL_HANDLE handle,
+                                               bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIProgressControl* control = static_cast<CGUIProgressControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlProgress::set_percentage(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  float percent)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIProgressControl* control = static_cast<CGUIProgressControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetPercentage(percent);
+}
+
+float Interface_GUIControlProgress::get_percentage(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIProgressControl* control = static_cast<CGUIProgressControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetPercentage();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Progress.h b/xbmc/addons/interfaces/gui/controls/Progress.h
new file mode 100644
index 0000000..c3368fa
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Progress.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Progress.h"
+   */
+  struct Interface_GUIControlProgress
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+
+    static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent);
+    static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/RadioButton.cpp b/xbmc/addons/interfaces/gui/controls/RadioButton.cpp
new file mode 100644
index 0000000..9d3b826
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/RadioButton.cpp
@@ -0,0 +1,146 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "RadioButton.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/RadioButton.h"
+#include "guilib/GUIRadioButtonControl.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlRadioButton::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_radio_button =
+      new AddonToKodiFuncTable_kodi_gui_control_radio_button();
+
+  addonInterface->toKodi->kodi_gui->control_radio_button->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_radio_button->set_enabled = set_enabled;
+
+  addonInterface->toKodi->kodi_gui->control_radio_button->set_label = set_label;
+  addonInterface->toKodi->kodi_gui->control_radio_button->get_label = get_label;
+
+  addonInterface->toKodi->kodi_gui->control_radio_button->set_selected = set_selected;
+  addonInterface->toKodi->kodi_gui->control_radio_button->is_selected = is_selected;
+}
+
+void Interface_GUIControlRadioButton::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_radio_button;
+}
+
+void Interface_GUIControlRadioButton::set_visible(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlRadioButton::set_enabled(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  bool enabled)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enabled);
+}
+
+void Interface_GUIControlRadioButton::set_label(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle,
+                                                const char* label)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}', label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetLabel(label);
+}
+
+char* Interface_GUIControlRadioButton::get_label(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetLabel().c_str());
+}
+
+void Interface_GUIControlRadioButton::set_selected(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_CONTROL_HANDLE handle,
+                                                   bool selected)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetSelected(selected);
+}
+
+bool Interface_GUIControlRadioButton::is_selected(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIRadioButtonControl* control = static_cast<CGUIRadioButtonControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return false;
+  }
+
+  return control->IsSelected();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/RadioButton.h b/xbmc/addons/interfaces/gui/controls/RadioButton.h
new file mode 100644
index 0000000..dd7ed4e
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/RadioButton.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/RadioButton.h"
+   */
+  struct Interface_GUIControlRadioButton
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label);
+    static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool selected);
+    static bool is_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Rendering.cpp b/xbmc/addons/interfaces/gui/controls/Rendering.cpp
new file mode 100644
index 0000000..a26a27f
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Rendering.cpp
@@ -0,0 +1,148 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Rendering.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/interfaces/gui/General.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Rendering.h"
+#include "guilib/GUIRenderingControl.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlAddonRendering::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_rendering =
+      new AddonToKodiFuncTable_kodi_gui_control_rendering();
+
+  addonInterface->toKodi->kodi_gui->control_rendering->set_callbacks = set_callbacks;
+  addonInterface->toKodi->kodi_gui->control_rendering->destroy = destroy;
+}
+
+void Interface_GUIControlAddonRendering::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_rendering;
+}
+
+void Interface_GUIControlAddonRendering::set_callbacks(
+    KODI_HANDLE kodiBase,
+    KODI_GUI_CONTROL_HANDLE handle,
+    KODI_GUI_CLIENT_HANDLE clienthandle,
+    bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT),
+    void (*renderCB)(KODI_GUI_CLIENT_HANDLE),
+    void (*stopCB)(KODI_GUI_CLIENT_HANDLE),
+    bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE))
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonRenderingControl* control = static_cast<CGUIAddonRenderingControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlAddonRendering::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  control->m_clientHandle = clienthandle;
+  control->CBCreate = createCB;
+  control->CBRender = renderCB;
+  control->CBStop = stopCB;
+  control->CBDirty = dirtyCB;
+  control->m_addon = addon;
+  Interface_GUIGeneral::unlock();
+
+  control->m_control->InitCallback(control);
+}
+
+void Interface_GUIControlAddonRendering::destroy(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUIAddonRenderingControl* control = static_cast<CGUIAddonRenderingControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlAddonRendering::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  Interface_GUIGeneral::lock();
+  static_cast<CGUIAddonRenderingControl*>(handle)->Delete();
+  Interface_GUIGeneral::unlock();
+}
+
+
+CGUIAddonRenderingControl::CGUIAddonRenderingControl(CGUIRenderingControl* control)
+  : CBCreate{nullptr},
+    CBRender{nullptr},
+    CBStop{nullptr},
+    CBDirty{nullptr},
+    m_clientHandle{nullptr},
+    m_addon{nullptr},
+    m_control{control},
+    m_refCount{1}
+{
+}
+
+bool CGUIAddonRenderingControl::Create(int x, int y, int w, int h, void* device)
+{
+  if (CBCreate)
+  {
+    if (CBCreate(m_clientHandle, x, y, w, h, device))
+    {
+      ++m_refCount;
+      return true;
+    }
+  }
+  return false;
+}
+
+void CGUIAddonRenderingControl::Render()
+{
+  if (CBRender)
+  {
+    CBRender(m_clientHandle);
+  }
+}
+
+void CGUIAddonRenderingControl::Stop()
+{
+  if (CBStop)
+  {
+    CBStop(m_clientHandle);
+  }
+
+  --m_refCount;
+  if (m_refCount <= 0)
+    delete this;
+}
+
+void CGUIAddonRenderingControl::Delete()
+{
+  --m_refCount;
+  if (m_refCount <= 0)
+    delete this;
+}
+
+bool CGUIAddonRenderingControl::IsDirty()
+{
+  bool ret = true;
+  if (CBDirty)
+  {
+    ret = CBDirty(m_clientHandle);
+  }
+  return ret;
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Rendering.h b/xbmc/addons/interfaces/gui/controls/Rendering.h
new file mode 100644
index 0000000..dbd82d8
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Rendering.h
@@ -0,0 +1,89 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h"
+#include "guilib/IRenderingCallback.h"
+
+class CGUIRenderingControl;
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  class CAddonDll;
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Rendering.h"
+   */
+  struct Interface_GUIControlAddonRendering
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_callbacks(
+        KODI_HANDLE kodiBase,
+        KODI_GUI_CONTROL_HANDLE handle,
+        KODI_GUI_CLIENT_HANDLE clienthandle,
+        bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT),
+        void (*renderCB)(KODI_GUI_CLIENT_HANDLE),
+        void (*stopCB)(KODI_GUI_CLIENT_HANDLE),
+        bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE));
+    static void destroy(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    //@}
+  };
+
+  class CGUIAddonRenderingControl : public IRenderingCallback
+  {
+    friend struct Interface_GUIControlAddonRendering;
+
+  public:
+    explicit CGUIAddonRenderingControl(CGUIRenderingControl* pControl);
+    ~CGUIAddonRenderingControl() override = default;
+
+    bool Create(int x, int y, int w, int h, void* device) override;
+    void Render() override;
+    void Stop() override;
+    bool IsDirty() override;
+    virtual void Delete();
+
+  protected:
+    bool (*CBCreate)(KODI_GUI_CLIENT_HANDLE cbhdl, int x, int y, int w, int h, void* device);
+    void (*CBRender)(KODI_GUI_CLIENT_HANDLE cbhdl);
+    void (*CBStop)(KODI_GUI_CLIENT_HANDLE cbhdl);
+    bool (*CBDirty)(KODI_GUI_CLIENT_HANDLE cbhdl);
+
+    KODI_GUI_CLIENT_HANDLE m_clientHandle;
+    CAddonDll* m_addon;
+    CGUIRenderingControl* m_control;
+    int m_refCount;
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp b/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp
new file mode 100644
index 0000000..c847a64
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp
@@ -0,0 +1,311 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "SettingsSlider.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/SettingsSlider.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUISettingsSliderControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlSettingsSlider::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_settings_slider =
+      new AddonToKodiFuncTable_kodi_gui_control_settings_slider();
+
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_enabled = set_enabled;
+
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_text = set_text;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->reset = reset;
+
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_range = set_int_range;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_value = set_int_value;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->get_int_value = get_int_value;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_interval = set_int_interval;
+
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_percentage = set_percentage;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->get_percentage = get_percentage;
+
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_range = set_float_range;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_value = set_float_value;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->get_float_value = get_float_value;
+  addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_interval =
+      set_float_interval;
+}
+
+void Interface_GUIControlSettingsSlider::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_settings_slider;
+}
+
+void Interface_GUIControlSettingsSlider::set_visible(KODI_HANDLE kodiBase,
+                                                     KODI_GUI_CONTROL_HANDLE handle,
+                                                     bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlSettingsSlider::set_enabled(KODI_HANDLE kodiBase,
+                                                     KODI_GUI_CONTROL_HANDLE handle,
+                                                     bool enabled)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enabled);
+}
+
+void Interface_GUIControlSettingsSlider::set_text(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}', text='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(text),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID());
+  msg.SetLabel(text);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+void Interface_GUIControlSettingsSlider::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID());
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+void Interface_GUIControlSettingsSlider::set_int_range(KODI_HANDLE kodiBase,
+                                                       KODI_GUI_CONTROL_HANDLE handle,
+                                                       int start,
+                                                       int end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_INT);
+  control->SetRange(start, end);
+}
+
+void Interface_GUIControlSettingsSlider::set_int_value(KODI_HANDLE kodiBase,
+                                                       KODI_GUI_CONTROL_HANDLE handle,
+                                                       int value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_INT);
+  control->SetIntValue(value);
+}
+
+int Interface_GUIControlSettingsSlider::get_int_value(KODI_HANDLE kodiBase,
+                                                      KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  return control->GetIntValue();
+}
+
+void Interface_GUIControlSettingsSlider::set_int_interval(KODI_HANDLE kodiBase,
+                                                          KODI_GUI_CONTROL_HANDLE handle,
+                                                          int interval)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetIntInterval(interval);
+}
+
+void Interface_GUIControlSettingsSlider::set_percentage(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_CONTROL_HANDLE handle,
+                                                        float percent)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE);
+  control->SetPercentage(percent);
+}
+
+float Interface_GUIControlSettingsSlider::get_percentage(KODI_HANDLE kodiBase,
+                                                         KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetPercentage();
+}
+
+void Interface_GUIControlSettingsSlider::set_float_range(KODI_HANDLE kodiBase,
+                                                         KODI_GUI_CONTROL_HANDLE handle,
+                                                         float start,
+                                                         float end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_FLOAT);
+  control->SetFloatRange(start, end);
+}
+
+void Interface_GUIControlSettingsSlider::set_float_value(KODI_HANDLE kodiBase,
+                                                         KODI_GUI_CONTROL_HANDLE handle,
+                                                         float value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_FLOAT);
+  control->SetFloatValue(value);
+}
+
+float Interface_GUIControlSettingsSlider::get_float_value(KODI_HANDLE kodiBase,
+                                                          KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetFloatValue();
+}
+
+void Interface_GUIControlSettingsSlider::set_float_interval(KODI_HANDLE kodiBase,
+                                                            KODI_GUI_CONTROL_HANDLE handle,
+                                                            float interval)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISettingsSliderControl* control = static_cast<CGUISettingsSliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFloatInterval(interval);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/SettingsSlider.h b/xbmc/addons/interfaces/gui/controls/SettingsSlider.h
new file mode 100644
index 0000000..425c275
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/SettingsSlider.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/SettingsSlider.h"
+   */
+  struct Interface_GUIControlSettingsSlider
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text);
+    static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_int_range(KODI_HANDLE kodiBase,
+                              KODI_GUI_CONTROL_HANDLE handle,
+                              int start,
+                              int end);
+    static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value);
+    static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_int_interval(KODI_HANDLE kodiBase,
+                                 KODI_GUI_CONTROL_HANDLE handle,
+                                 int interval);
+
+    static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent);
+    static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_float_range(KODI_HANDLE kodiBase,
+                                KODI_GUI_CONTROL_HANDLE handle,
+                                float start,
+                                float end);
+    static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value);
+    static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_float_interval(KODI_HANDLE kodiBase,
+                                   KODI_GUI_CONTROL_HANDLE handle,
+                                   float interval);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Slider.cpp b/xbmc/addons/interfaces/gui/controls/Slider.cpp
new file mode 100644
index 0000000..73502d8
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Slider.cpp
@@ -0,0 +1,305 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Slider.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Slider.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUISliderControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlSlider::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_slider =
+      new AddonToKodiFuncTable_kodi_gui_control_slider();
+
+  addonInterface->toKodi->kodi_gui->control_slider->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_slider->set_enabled = set_enabled;
+
+  addonInterface->toKodi->kodi_gui->control_slider->reset = reset;
+  addonInterface->toKodi->kodi_gui->control_slider->get_description = get_description;
+
+  addonInterface->toKodi->kodi_gui->control_slider->set_int_range = set_int_range;
+  addonInterface->toKodi->kodi_gui->control_slider->set_int_value = set_int_value;
+  addonInterface->toKodi->kodi_gui->control_slider->get_int_value = get_int_value;
+  addonInterface->toKodi->kodi_gui->control_slider->set_int_interval = set_int_interval;
+
+  addonInterface->toKodi->kodi_gui->control_slider->set_percentage = set_percentage;
+  addonInterface->toKodi->kodi_gui->control_slider->get_percentage = get_percentage;
+
+  addonInterface->toKodi->kodi_gui->control_slider->set_float_range = set_float_range;
+  addonInterface->toKodi->kodi_gui->control_slider->set_float_value = set_float_value;
+  addonInterface->toKodi->kodi_gui->control_slider->get_float_value = get_float_value;
+  addonInterface->toKodi->kodi_gui->control_slider->set_float_interval = set_float_interval;
+}
+
+void Interface_GUIControlSlider::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_slider;
+}
+
+void Interface_GUIControlSlider::set_visible(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlSlider::set_enabled(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             bool enabled)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enabled);
+}
+
+void Interface_GUIControlSlider::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID());
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+char* Interface_GUIControlSlider::get_description(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetDescription().c_str());
+}
+
+void Interface_GUIControlSlider::set_int_range(KODI_HANDLE kodiBase,
+                                               KODI_GUI_CONTROL_HANDLE handle,
+                                               int start,
+                                               int end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_INT);
+  control->SetRange(start, end);
+}
+
+void Interface_GUIControlSlider::set_int_value(KODI_HANDLE kodiBase,
+                                               KODI_GUI_CONTROL_HANDLE handle,
+                                               int value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_INT);
+  control->SetIntValue(value);
+}
+
+int Interface_GUIControlSlider::get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  return control->GetIntValue();
+}
+
+void Interface_GUIControlSlider::set_int_interval(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  int interval)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetIntInterval(interval);
+}
+
+void Interface_GUIControlSlider::set_percentage(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle,
+                                                float percent)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE);
+  control->SetPercentage(percent);
+}
+
+float Interface_GUIControlSlider::get_percentage(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetPercentage();
+}
+
+void Interface_GUIControlSlider::set_float_range(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle,
+                                                 float start,
+                                                 float end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_FLOAT);
+  control->SetFloatRange(start, end);
+}
+
+void Interface_GUIControlSlider::set_float_value(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle,
+                                                 float value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(SLIDER_CONTROL_TYPE_FLOAT);
+  control->SetFloatValue(value);
+}
+
+float Interface_GUIControlSlider::get_float_value(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetFloatValue();
+}
+
+void Interface_GUIControlSlider::set_float_interval(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_CONTROL_HANDLE handle,
+                                                    float interval)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISliderControl* control = static_cast<CGUISliderControl*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFloatInterval(interval);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Slider.h b/xbmc/addons/interfaces/gui/controls/Slider.h
new file mode 100644
index 0000000..30afbaf
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Slider.h
@@ -0,0 +1,78 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Slider.h"
+   */
+  struct Interface_GUIControlSlider
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static char* get_description(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_int_range(KODI_HANDLE kodiBase,
+                              KODI_GUI_CONTROL_HANDLE handle,
+                              int start,
+                              int end);
+    static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value);
+    static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_int_interval(KODI_HANDLE kodiBase,
+                                 KODI_GUI_CONTROL_HANDLE handle,
+                                 int interval);
+
+    static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent);
+    static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_float_range(KODI_HANDLE kodiBase,
+                                KODI_GUI_CONTROL_HANDLE handle,
+                                float start,
+                                float end);
+    static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value);
+    static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_float_interval(KODI_HANDLE kodiBase,
+                                   KODI_GUI_CONTROL_HANDLE handle,
+                                   float interval);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/Spin.cpp b/xbmc/addons/interfaces/gui/controls/Spin.cpp
new file mode 100644
index 0000000..b9eb6ea
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Spin.cpp
@@ -0,0 +1,346 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Spin.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/Spin.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUISpinControlEx.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlSpin::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_spin = new AddonToKodiFuncTable_kodi_gui_control_spin();
+
+  addonInterface->toKodi->kodi_gui->control_spin->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_spin->set_enabled = set_enabled;
+
+  addonInterface->toKodi->kodi_gui->control_spin->set_text = set_text;
+  addonInterface->toKodi->kodi_gui->control_spin->reset = reset;
+  addonInterface->toKodi->kodi_gui->control_spin->set_type = set_type;
+
+  addonInterface->toKodi->kodi_gui->control_spin->add_string_label = add_string_label;
+  addonInterface->toKodi->kodi_gui->control_spin->set_string_value = set_string_value;
+  addonInterface->toKodi->kodi_gui->control_spin->get_string_value = get_string_value;
+
+  addonInterface->toKodi->kodi_gui->control_spin->add_int_label = add_int_label;
+  addonInterface->toKodi->kodi_gui->control_spin->set_int_range = set_int_range;
+  addonInterface->toKodi->kodi_gui->control_spin->set_int_value = set_int_value;
+  addonInterface->toKodi->kodi_gui->control_spin->get_int_value = get_int_value;
+
+  addonInterface->toKodi->kodi_gui->control_spin->set_float_range = set_float_range;
+  addonInterface->toKodi->kodi_gui->control_spin->set_float_value = set_float_value;
+  addonInterface->toKodi->kodi_gui->control_spin->get_float_value = get_float_value;
+  addonInterface->toKodi->kodi_gui->control_spin->set_float_interval = set_float_interval;
+}
+
+void Interface_GUIControlSpin::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_spin;
+}
+
+void Interface_GUIControlSpin::set_visible(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlSpin::set_enabled(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           bool enabled)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetEnabled(enabled);
+}
+
+void Interface_GUIControlSpin::set_text(KODI_HANDLE kodiBase,
+                                        KODI_GUI_CONTROL_HANDLE handle,
+                                        const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "text='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(text),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID());
+  msg.SetLabel(text);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+void Interface_GUIControlSpin::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID());
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+void Interface_GUIControlSpin::set_type(KODI_HANDLE kodiBase,
+                                        KODI_GUI_CONTROL_HANDLE handle,
+                                        int type)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetType(type);
+}
+
+void Interface_GUIControlSpin::add_string_label(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle,
+                                                const char* label,
+                                                const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control || !label || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}', value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              static_cast<const void*>(value), addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->AddLabel(std::string(label), std::string(value));
+}
+
+void Interface_GUIControlSpin::set_string_value(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle,
+                                                const char* value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control || !value)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "value='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(value),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetStringValue(std::string(value));
+}
+
+char* Interface_GUIControlSpin::get_string_value(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetStringValue().c_str());
+}
+
+void Interface_GUIControlSpin::add_int_label(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             const char* label,
+                                             int value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control || !label)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', "
+              "label='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(label),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->AddLabel(std::string(label), value);
+}
+
+void Interface_GUIControlSpin::set_int_range(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             int start,
+                                             int end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetRange(start, end);
+}
+
+void Interface_GUIControlSpin::set_int_value(KODI_HANDLE kodiBase,
+                                             KODI_GUI_CONTROL_HANDLE handle,
+                                             int value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetValue(value);
+}
+
+int Interface_GUIControlSpin::get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return -1;
+  }
+
+  return control->GetValue();
+}
+
+void Interface_GUIControlSpin::set_float_range(KODI_HANDLE kodiBase,
+                                               KODI_GUI_CONTROL_HANDLE handle,
+                                               float start,
+                                               float end)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFloatRange(start, end);
+}
+
+void Interface_GUIControlSpin::set_float_value(KODI_HANDLE kodiBase,
+                                               KODI_GUI_CONTROL_HANDLE handle,
+                                               float value)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFloatValue(value);
+}
+
+float Interface_GUIControlSpin::get_float_value(KODI_HANDLE kodiBase,
+                                                KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return 0.0f;
+  }
+
+  return control->GetFloatValue();
+}
+
+void Interface_GUIControlSpin::set_float_interval(KODI_HANDLE kodiBase,
+                                                  KODI_GUI_CONTROL_HANDLE handle,
+                                                  float interval)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUISpinControlEx* control = static_cast<CGUISpinControlEx*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') "
+              "on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetFloatInterval(interval);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/Spin.h b/xbmc/addons/interfaces/gui/controls/Spin.h
new file mode 100644
index 0000000..1c7102e
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/Spin.h
@@ -0,0 +1,86 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Spin.h"
+   */
+  struct Interface_GUIControlSpin
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled);
+
+    static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text);
+    static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_type(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int type);
+
+    static void add_string_label(KODI_HANDLE kodiBase,
+                                 KODI_GUI_CONTROL_HANDLE handle,
+                                 const char* label,
+                                 const char* value);
+    static void add_int_label(KODI_HANDLE kodiBase,
+                              KODI_GUI_CONTROL_HANDLE handle,
+                              const char* label,
+                              int value);
+
+    static void set_string_value(KODI_HANDLE kodiBase,
+                                 KODI_GUI_CONTROL_HANDLE handle,
+                                 const char* value);
+    static char* get_string_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_int_range(KODI_HANDLE kodiBase,
+                              KODI_GUI_CONTROL_HANDLE handle,
+                              int start,
+                              int end);
+    static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value);
+    static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+
+    static void set_float_range(KODI_HANDLE kodiBase,
+                                KODI_GUI_CONTROL_HANDLE handle,
+                                float start,
+                                float end);
+    static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value);
+    static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_float_interval(KODI_HANDLE kodiBase,
+                                   KODI_GUI_CONTROL_HANDLE handle,
+                                   float interval);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/controls/TextBox.cpp b/xbmc/addons/interfaces/gui/controls/TextBox.cpp
new file mode 100644
index 0000000..44c5f89
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/TextBox.cpp
@@ -0,0 +1,147 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "TextBox.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/controls/TextBox.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUITextBox.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIControlTextBox::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->control_text_box =
+      new AddonToKodiFuncTable_kodi_gui_control_text_box();
+
+  addonInterface->toKodi->kodi_gui->control_text_box->set_visible = set_visible;
+  addonInterface->toKodi->kodi_gui->control_text_box->reset = reset;
+  addonInterface->toKodi->kodi_gui->control_text_box->set_text = set_text;
+  addonInterface->toKodi->kodi_gui->control_text_box->get_text = get_text;
+  addonInterface->toKodi->kodi_gui->control_text_box->scroll = scroll;
+  addonInterface->toKodi->kodi_gui->control_text_box->set_auto_scrolling = set_auto_scrolling;
+}
+
+void Interface_GUIControlTextBox::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->control_text_box;
+}
+
+void Interface_GUIControlTextBox::set_visible(KODI_HANDLE kodiBase,
+                                              KODI_GUI_CONTROL_HANDLE handle,
+                                              bool visible)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetVisible(visible);
+}
+
+void Interface_GUIControlTextBox::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID());
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+void Interface_GUIControlTextBox::set_text(KODI_HANDLE kodiBase,
+                                           KODI_GUI_CONTROL_HANDLE handle,
+                                           const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}', text='{}') on addon '{}'",
+              __func__, kodiBase, handle, static_cast<const void*>(text),
+              addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID());
+  msg.SetLabel(text);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID());
+}
+
+char* Interface_GUIControlTextBox::get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return nullptr;
+  }
+
+  return strdup(control->GetDescription().c_str());
+}
+
+void Interface_GUIControlTextBox::scroll(KODI_HANDLE kodiBase,
+                                         KODI_GUI_CONTROL_HANDLE handle,
+                                         unsigned int position)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->Scroll(position);
+}
+
+void Interface_GUIControlTextBox::set_auto_scrolling(
+    KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  CGUITextBox* control = static_cast<CGUITextBox*>(handle);
+  if (!addon || !control)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', "
+              "handle='{}') on addon '{}'",
+              __func__, kodiBase, handle, addon ? addon->ID() : "unknown");
+    return;
+  }
+
+  control->SetAutoScrolling(delay, time, repeat);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/controls/TextBox.h b/xbmc/addons/interfaces/gui/controls/TextBox.h
new file mode 100644
index 0000000..09c2ff4
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/controls/TextBox.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold general gui functions and initialize also all other gui related types not
+   * related to a instance type and usable for every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/TextBox.h"
+   */
+  struct Interface_GUIControlTextBox
+  {
+
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible);
+    static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text);
+    static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle);
+    static void scroll(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, unsigned int position);
+    static void set_auto_scrolling(
+        KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt b/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt
new file mode 100644
index 0000000..4dad4e9
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt
@@ -0,0 +1,23 @@
+set(SOURCES ContextMenu.cpp
+            ExtendedProgressBar.cpp
+            FileBrowser.cpp
+            Keyboard.cpp
+            Numeric.cpp
+            OK.cpp
+            Progress.cpp
+            Select.cpp
+            TextViewer.cpp
+            YesNo.cpp)
+
+set(HEADERS ContextMenu.h
+            ExtendedProgressBar.h
+            FileBrowser.h
+            Keyboard.h
+            Numeric.h
+            OK.h
+            Progress.h
+            Select.h
+            TextViewer.h
+            YesNo.h)
+
+core_add_library(addons_interfaces_gui_dialogs)
diff --git a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp
new file mode 100644
index 0000000..e0e5684
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp
@@ -0,0 +1,67 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ContextMenu.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h"
+#include "dialogs/GUIDialogContextMenu.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogContextMenu::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogContextMenu =
+      new AddonToKodiFuncTable_kodi_gui_dialogContextMenu();
+
+  addonInterface->toKodi->kodi_gui->dialogContextMenu->open = open;
+}
+
+void Interface_GUIDialogContextMenu::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogContextMenu;
+}
+
+int Interface_GUIDialogContextMenu::open(KODI_HANDLE kodiBase,
+                                         const char* heading,
+                                         const char* entries[],
+                                         unsigned int size)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogContextMenu::{} - invalid data", __func__);
+    return -1;
+  }
+
+  CGUIDialogContextMenu* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogContextMenu>(
+          WINDOW_DIALOG_CONTEXT_MENU);
+  if (!heading || !entries || !dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogContextMenu::{} - invalid handler data (heading='{}', "
+              "entries='{}', dialog='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(entries),
+              kodiBase, addon->ID());
+    return -1;
+  }
+
+  CContextButtons choices;
+  for (unsigned int i = 0; i < size; ++i)
+    choices.Add(i, entries[i]);
+
+  return dialog->Show(choices);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h
new file mode 100644
index 0000000..7b41a28
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h"
+   */
+  struct Interface_GUIDialogContextMenu
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static int open(KODI_HANDLE kodiBase,
+                    const char* heading,
+                    const char* entries[],
+                    unsigned int size);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp
new file mode 100644
index 0000000..9e7f7a7
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp
@@ -0,0 +1,305 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ExtendedProgressBar.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h"
+#include "dialogs/GUIDialogExtendedProgressBar.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogExtendedProgress::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress =
+      new AddonToKodiFuncTable_kodi_gui_dialogExtendedProgress();
+
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->new_dialog = new_dialog;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->delete_dialog = delete_dialog;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_title = get_title;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_title = set_title;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_text = get_text;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_text = set_text;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->is_finished = is_finished;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->mark_finished = mark_finished;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_percentage = get_percentage;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_percentage = set_percentage;
+  addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_progress = set_progress;
+}
+
+void Interface_GUIDialogExtendedProgress::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogExtendedProgress;
+}
+
+KODI_GUI_HANDLE Interface_GUIDialogExtendedProgress::new_dialog(KODI_HANDLE kodiBase,
+                                                                const char* title)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return nullptr;
+  }
+
+  // setup the progress dialog
+  CGUIDialogExtendedProgressBar* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogExtendedProgressBar>(
+          WINDOW_DIALOG_EXT_PROGRESS);
+  if (!title || !dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid handler data (title='{}', "
+              "dialog='{}') on addon '{}'",
+              __func__, static_cast<const void*>(title), static_cast<void*>(dialog), addon->ID());
+    return nullptr;
+  }
+
+  CGUIDialogProgressBarHandle* dlgProgressHandle = dialog->GetHandle(title);
+  return dlgProgressHandle;
+}
+
+void Interface_GUIDialogExtendedProgress::delete_dialog(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->MarkFinished();
+}
+
+char* Interface_GUIDialogExtendedProgress::get_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return nullptr;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return nullptr;
+  }
+
+  return strdup(static_cast<CGUIDialogProgressBarHandle*>(handle)->Title().c_str());
+}
+
+void Interface_GUIDialogExtendedProgress::set_title(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_HANDLE handle,
+                                                    const char* title)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle || !title)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}', "
+              "title='{}') on addon '{}'",
+              __func__, handle, static_cast<const void*>(title), addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->SetTitle(title);
+}
+
+char* Interface_GUIDialogExtendedProgress::get_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return nullptr;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return nullptr;
+  }
+
+  return strdup(static_cast<CGUIDialogProgressBarHandle*>(handle)->Text().c_str());
+}
+
+void Interface_GUIDialogExtendedProgress::set_text(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_HANDLE handle,
+                                                   const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}', "
+              "text='{}') on addon '{}'",
+              __func__, handle, static_cast<const void*>(text), addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->SetText(text);
+}
+
+bool Interface_GUIDialogExtendedProgress::is_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return false;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return false;
+  }
+
+  return static_cast<CGUIDialogProgressBarHandle*>(handle)->IsFinished();
+}
+
+void Interface_GUIDialogExtendedProgress::mark_finished(KODI_HANDLE kodiBase,
+                                                        KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->MarkFinished();
+}
+
+float Interface_GUIDialogExtendedProgress::get_percentage(KODI_HANDLE kodiBase,
+                                                          KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return 0.0f;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return 0.0f;
+  }
+
+  return static_cast<CGUIDialogProgressBarHandle*>(handle)->Percentage();
+}
+
+void Interface_GUIDialogExtendedProgress::set_percentage(KODI_HANDLE kodiBase,
+                                                         KODI_GUI_HANDLE handle,
+                                                         float percentage)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->SetPercentage(percentage);
+}
+
+void Interface_GUIDialogExtendedProgress::set_progress(KODI_HANDLE kodiBase,
+                                                       KODI_GUI_HANDLE handle,
+                                                       int currentItem,
+                                                       int itemCount)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data",
+              __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on "
+              "addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgressBarHandle*>(handle)->SetProgress(currentItem, itemCount);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h
new file mode 100644
index 0000000..66ccb49
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h
@@ -0,0 +1,63 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h"
+   */
+  struct Interface_GUIDialogExtendedProgress
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static KODI_GUI_HANDLE new_dialog(KODI_HANDLE kodiBase, const char* title);
+    static void delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static char* get_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void set_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* title);
+    static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void set_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* text);
+    static bool is_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void mark_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, float percentage);
+    static void set_progress(KODI_HANDLE kodiBase,
+                             KODI_GUI_HANDLE handle,
+                             int currentItem,
+                             int itemCount);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp
new file mode 100644
index 0000000..84d6443
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp
@@ -0,0 +1,403 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "FileBrowser.h"
+
+#include "URL.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h"
+#include "dialogs/GUIDialogFileBrowser.h"
+#include "settings/MediaSourceSettings.h"
+#include "storage/MediaManager.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogFileBrowser::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser =
+      new AddonToKodiFuncTable_kodi_gui_dialogFileBrowser();
+
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_directory =
+      show_and_get_directory;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file = show_and_get_file;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_from_dir =
+      show_and_get_file_from_dir;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_list =
+      show_and_get_file_list;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_source = show_and_get_source;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image = show_and_get_image;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image_list =
+      show_and_get_image_list;
+  addonInterface->toKodi->kodi_gui->dialogFileBrowser->clear_file_list = clear_file_list;
+}
+
+void Interface_GUIDialogFileBrowser::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogFileBrowser;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_directory(KODI_HANDLE kodiBase,
+                                                            const char* shares,
+                                                            const char* heading,
+                                                            const char* path_in,
+                                                            char** path_out,
+                                                            bool write_only)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!shares || !heading || !path_in || !path_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', "
+              "heading='{}', path_in='{}', path_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(shares), static_cast<const void*>(heading),
+              static_cast<const void*>(path_in), static_cast<void*>(path_out), addon->ID());
+    return false;
+  }
+
+  std::string strPath = path_in;
+
+  VECSOURCES vecShares;
+  GetVECShares(vecShares, shares, strPath);
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetDirectory(vecShares, heading, strPath, write_only);
+  if (bRet)
+    *path_out = strdup(strPath.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_file(KODI_HANDLE kodiBase,
+                                                       const char* shares,
+                                                       const char* mask,
+                                                       const char* heading,
+                                                       const char* path_in,
+                                                       char** path_out,
+                                                       bool use_thumbs,
+                                                       bool use_file_directories)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!shares || !mask || !heading || !path_in || !path_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', mask='{}', "
+              "heading='{}', path_in='{}', path_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(shares), static_cast<const void*>(mask),
+              static_cast<const void*>(heading), static_cast<const void*>(path_in),
+              static_cast<void*>(path_out), addon->ID());
+    return false;
+  }
+
+  std::string strPath = path_in;
+
+  VECSOURCES vecShares;
+  GetVECShares(vecShares, shares, strPath);
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(vecShares, mask, heading, strPath, use_thumbs,
+                                                    use_file_directories);
+  if (bRet)
+    *path_out = strdup(strPath.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_file_from_dir(KODI_HANDLE kodiBase,
+                                                                const char* directory,
+                                                                const char* mask,
+                                                                const char* heading,
+                                                                const char* path_in,
+                                                                char** path_out,
+                                                                bool use_thumbs,
+                                                                bool use_file_directories,
+                                                                bool single_list)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!directory || !mask || !heading || !path_in || !path_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (directory='{}', "
+              "mask='{}', heading='{}', path_in='{}', path_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(directory), static_cast<const void*>(mask),
+              static_cast<const void*>(heading), static_cast<const void*>(path_in),
+              static_cast<void*>(path_out), addon->ID());
+    return false;
+  }
+
+  std::string strPath = path_in;
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(directory, mask, heading, strPath, use_thumbs,
+                                                    use_file_directories, single_list);
+  if (bRet)
+    *path_out = strdup(strPath.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_file_list(KODI_HANDLE kodiBase,
+                                                            const char* shares,
+                                                            const char* mask,
+                                                            const char* heading,
+                                                            char*** file_list,
+                                                            unsigned int* entries,
+                                                            bool use_thumbs,
+                                                            bool use_file_directories)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!shares || !mask || !heading || !file_list || !entries)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', mask='{}', "
+              "heading='{}', file_list='{}', entries='{}') on addon '{}'",
+              __func__, static_cast<const void*>(shares), static_cast<const void*>(mask),
+              static_cast<const void*>(heading), static_cast<void*>(file_list),
+              static_cast<void*>(entries), addon->ID());
+    return false;
+  }
+
+  VECSOURCES vecShares;
+  GetVECShares(vecShares, shares, "");
+
+  std::vector<std::string> pathsInt;
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetFileList(vecShares, mask, heading, pathsInt,
+                                                        use_thumbs, use_file_directories);
+  if (bRet)
+  {
+    *entries = pathsInt.size();
+    *file_list = static_cast<char**>(malloc(*entries * sizeof(char*)));
+    for (unsigned int i = 0; i < *entries; ++i)
+      (*file_list)[i] = strdup(pathsInt[i].c_str());
+  }
+  else
+    *entries = 0;
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_source(KODI_HANDLE kodiBase,
+                                                         const char* path_in,
+                                                         char** path_out,
+                                                         bool allowNetworkShares,
+                                                         const char* additionalShare,
+                                                         const char* strType)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!strType || !additionalShare || !path_in || !path_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (additionalShare='{}', "
+              "strType='{}', path_in='{}', path_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(additionalShare),
+              static_cast<const void*>(strType), static_cast<const void*>(path_in),
+              static_cast<void*>(path_out), addon->ID());
+    return false;
+  }
+
+  std::string strPath = path_in;
+
+  VECSOURCES vecShares;
+  if (additionalShare)
+    GetVECShares(vecShares, additionalShare, strPath);
+  bool bRet =
+      CGUIDialogFileBrowser::ShowAndGetSource(strPath, allowNetworkShares, &vecShares, strType);
+  if (bRet)
+    *path_out = strdup(strPath.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_image(KODI_HANDLE kodiBase,
+                                                        const char* shares,
+                                                        const char* heading,
+                                                        const char* path_in,
+                                                        char** path_out)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!shares || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', "
+              "heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(shares), static_cast<const void*>(heading),
+              addon->ID());
+    return false;
+  }
+
+  std::string strPath = path_in;
+
+  VECSOURCES vecShares;
+  GetVECShares(vecShares, shares, strPath);
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetImage(vecShares, heading, strPath);
+  if (bRet)
+    *path_out = strdup(strPath.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogFileBrowser::show_and_get_image_list(KODI_HANDLE kodiBase,
+                                                             const char* shares,
+                                                             const char* heading,
+                                                             char*** file_list,
+                                                             unsigned int* entries)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!shares || !heading || !file_list || !entries)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', "
+              "heading='{}', file_list='{}', entries='{}') on addon '{}'",
+              __func__, static_cast<const void*>(shares), static_cast<const void*>(heading),
+              static_cast<void*>(file_list), static_cast<void*>(entries), addon->ID());
+    return false;
+  }
+
+  VECSOURCES vecShares;
+  GetVECShares(vecShares, shares, "");
+
+  std::vector<std::string> pathsInt;
+  bool bRet = CGUIDialogFileBrowser::ShowAndGetImageList(vecShares, heading, pathsInt);
+  if (bRet)
+  {
+    *entries = pathsInt.size();
+    *file_list = static_cast<char**>(malloc(*entries * sizeof(char*)));
+    for (unsigned int i = 0; i < *entries; ++i)
+      (*file_list)[i] = strdup(pathsInt[i].c_str());
+  }
+  else
+    *entries = 0;
+  return bRet;
+}
+
+void Interface_GUIDialogFileBrowser::clear_file_list(KODI_HANDLE kodiBase,
+                                                     char*** file_list,
+                                                     unsigned int entries)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__);
+    return;
+  }
+
+  if (*file_list)
+  {
+    for (unsigned int i = 0; i < entries; ++i)
+      free((*file_list)[i]);
+    free(*file_list);
+    *file_list = nullptr;
+  }
+  else
+  {
+
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogFileBrowser::{} - invalid handler data (file_list='{}') on "
+              "addon '{}'",
+              __func__, static_cast<void*>(file_list), addon->ID());
+  }
+}
+
+void Interface_GUIDialogFileBrowser::GetVECShares(VECSOURCES& vecShares,
+                                                  const std::string& strShares,
+                                                  const std::string& strPath)
+{
+  std::size_t found;
+  found = strShares.find("local");
+  if (found != std::string::npos)
+    CServiceBroker::GetMediaManager().GetLocalDrives(vecShares);
+  found = strShares.find("network");
+  if (found != std::string::npos)
+    CServiceBroker::GetMediaManager().GetNetworkLocations(vecShares);
+  found = strShares.find("removable");
+  if (found != std::string::npos)
+    CServiceBroker::GetMediaManager().GetRemovableDrives(vecShares);
+  found = strShares.find("programs");
+  if (found != std::string::npos)
+  {
+    VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("programs");
+    if (sources != nullptr)
+      vecShares.insert(vecShares.end(), sources->begin(), sources->end());
+  }
+  found = strShares.find("files");
+  if (found != std::string::npos)
+  {
+    VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("files");
+    if (sources != nullptr)
+      vecShares.insert(vecShares.end(), sources->begin(), sources->end());
+  }
+  found = strShares.find("music");
+  if (found != std::string::npos)
+  {
+    VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("music");
+    if (sources != nullptr)
+      vecShares.insert(vecShares.end(), sources->begin(), sources->end());
+  }
+  found = strShares.find("video");
+  if (found != std::string::npos)
+  {
+    VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("video");
+    if (sources != nullptr)
+      vecShares.insert(vecShares.end(), sources->begin(), sources->end());
+  }
+  found = strShares.find("pictures");
+  if (found != std::string::npos)
+  {
+    VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("pictures");
+    if (sources != nullptr)
+      vecShares.insert(vecShares.end(), sources->begin(), sources->end());
+  }
+
+  if (vecShares.empty())
+  {
+    CMediaSource share;
+    std::string basePath = strPath;
+    std::string tempPath;
+    while (URIUtils::GetParentPath(basePath, tempPath))
+      basePath = tempPath;
+    share.strPath = basePath;
+    // don't include the user details in the share name
+    CURL url(share.strPath);
+    share.strName = url.GetWithoutUserDetails();
+    vecShares.push_back(share);
+  }
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h
new file mode 100644
index 0000000..c2193f3
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h
@@ -0,0 +1,116 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h"
+
+#include <string>
+#include <vector>
+
+class CMediaSource;
+
+typedef std::vector<CMediaSource> VECSOURCES;
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h"
+   */
+  struct Interface_GUIDialogFileBrowser
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static bool show_and_get_directory(KODI_HANDLE kodiBase,
+                                       const char* shares,
+                                       const char* heading,
+                                       const char* path_in,
+                                       char** path_out,
+                                       bool write_only);
+
+    static bool show_and_get_file(KODI_HANDLE kodiBase,
+                                  const char* shares,
+                                  const char* mask,
+                                  const char* heading,
+                                  const char* path_in,
+                                  char** path_out,
+                                  bool use_thumbs,
+                                  bool use_file_directories);
+
+    static bool show_and_get_file_from_dir(KODI_HANDLE kodiBase,
+                                           const char* directory,
+                                           const char* mask,
+                                           const char* heading,
+                                           const char* path_in,
+                                           char** path_out,
+                                           bool use_thumbs,
+                                           bool use_file_directories,
+                                           bool singleList);
+
+    static bool show_and_get_file_list(KODI_HANDLE kodiBase,
+                                       const char* shares,
+                                       const char* mask,
+                                       const char* heading,
+                                       char*** file_list,
+                                       unsigned int* entries,
+                                       bool use_thumbs,
+                                       bool use_file_directories);
+
+    static bool show_and_get_source(KODI_HANDLE kodiBase,
+                                    const char* path_in,
+                                    char** path_out,
+                                    bool allow_network_shares,
+                                    const char* additional_share,
+                                    const char* type);
+
+    static bool show_and_get_image(KODI_HANDLE kodiBase,
+                                   const char* shares,
+                                   const char* heading,
+                                   const char* path_in,
+                                   char** path_out);
+
+    static bool show_and_get_image_list(KODI_HANDLE kodiBase,
+                                        const char* shares,
+                                        const char* heading,
+                                        char*** file_list,
+                                        unsigned int* entries);
+
+    static void clear_file_list(KODI_HANDLE kodiBase, char*** file_list, unsigned int entries);
+    //@}
+
+  private:
+    static void GetVECShares(VECSOURCES& vecShares,
+                             const std::string& strShares,
+                             const std::string& strPath);
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp b/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp
new file mode 100644
index 0000000..7ec56ab
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp
@@ -0,0 +1,319 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Keyboard.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogKeyboard::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogKeyboard =
+      new AddonToKodiFuncTable_kodi_gui_dialogKeyboard();
+
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input_with_head =
+      show_and_get_input_with_head;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input = show_and_get_input;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_new_password_with_head =
+      show_and_get_new_password_with_head;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_new_password =
+      show_and_get_new_password;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_new_password_with_head =
+      show_and_verify_new_password_with_head;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_new_password =
+      show_and_verify_new_password;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_password =
+      show_and_verify_password;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_filter = show_and_get_filter;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->send_text_to_active_keyboard =
+      send_text_to_active_keyboard;
+  addonInterface->toKodi->kodi_gui->dialogKeyboard->is_keyboard_activated = is_keyboard_activated;
+}
+
+void Interface_GUIDialogKeyboard::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogKeyboard;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_get_input_with_head(KODI_HANDLE kodiBase,
+                                                               const char* text_in,
+                                                               char** text_out,
+                                                               const char* heading,
+                                                               bool allow_empty_result,
+                                                               bool hidden_input,
+                                                               unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!text_in || !text_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', "
+              "text_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(text_in), static_cast<void*>(text_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = text_in;
+  bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, CVariant{heading}, allow_empty_result,
+                                                   hidden_input, auto_close_ms);
+  if (bRet)
+    *text_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_get_input(KODI_HANDLE kodiBase,
+                                                     const char* text_in,
+                                                     char** text_out,
+                                                     bool allow_empty_result,
+                                                     unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!text_in || !text_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', "
+              "text_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(text_in), static_cast<void*>(text_out),
+              addon->ID());
+    return false;
+  }
+
+  std::string str = text_in;
+  bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, allow_empty_result, auto_close_ms);
+  if (bRet)
+    *text_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_get_new_password_with_head(KODI_HANDLE kodiBase,
+                                                                      const char* password_in,
+                                                                      char** password_out,
+                                                                      const char* heading,
+                                                                      bool allow_empty_result,
+                                                                      unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!password_in || !password_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', "
+              "password_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(password_in), static_cast<void*>(password_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = password_in;
+  bool bRet =
+      CGUIKeyboardFactory::ShowAndGetNewPassword(str, heading, allow_empty_result, auto_close_ms);
+  if (bRet)
+    *password_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_get_new_password(KODI_HANDLE kodiBase,
+                                                            const char* password_in,
+                                                            char** password_out,
+                                                            unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!password_in || !password_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', "
+              "password_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(password_in), static_cast<void*>(password_out),
+              addon->ID());
+    return false;
+  }
+
+  std::string str = password_in;
+  bool bRet = CGUIKeyboardFactory::ShowAndGetNewPassword(str, auto_close_ms);
+  if (bRet)
+    *password_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_verify_new_password_with_head(KODI_HANDLE kodiBase,
+                                                                         char** password_out,
+                                                                         const char* heading,
+                                                                         bool allowEmpty,
+                                                                         unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!password_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (password_out='{}', "
+              "heading='{}') on addon '{}'",
+              __func__, static_cast<void*>(password_out), static_cast<const void*>(heading),
+              addon->ID());
+    return false;
+  }
+
+  std::string str;
+  bool bRet =
+      CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, heading, allowEmpty, auto_close_ms);
+  if (bRet)
+    *password_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_verify_new_password(KODI_HANDLE kodiBase,
+                                                               char** password_out,
+                                                               unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!password_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (password_out='{}') on "
+              "addon '{}'",
+              __func__, static_cast<void*>(password_out), addon->ID());
+    return false;
+  }
+
+  std::string str;
+  bool bRet = CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, auto_close_ms);
+  if (bRet)
+    *password_out = strdup(str.c_str());
+  return bRet;
+}
+
+int Interface_GUIDialogKeyboard::show_and_verify_password(KODI_HANDLE kodiBase,
+                                                          const char* password_in,
+                                                          char** password_out,
+                                                          const char* heading,
+                                                          int retries,
+                                                          unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!password_in || !password_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', "
+              "password_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(password_in), static_cast<void*>(password_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = password_in;
+  int iRet = CGUIKeyboardFactory::ShowAndVerifyPassword(str, heading, retries, auto_close_ms);
+  if (iRet)
+    *password_out = strdup(str.c_str());
+  return iRet;
+}
+
+bool Interface_GUIDialogKeyboard::show_and_get_filter(KODI_HANDLE kodiBase,
+                                                      const char* text_in,
+                                                      char** text_out,
+                                                      bool searching,
+                                                      unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!text_in || !text_out)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', "
+              "text_out='{}') on addon '{}'",
+              __func__, static_cast<const void*>(text_in), static_cast<void*>(text_out),
+              addon->ID());
+    return false;
+  }
+
+
+  std::string str = text_in;
+  bool bRet = CGUIKeyboardFactory::ShowAndGetFilter(str, searching, auto_close_ms);
+  if (bRet)
+    *text_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogKeyboard::send_text_to_active_keyboard(KODI_HANDLE kodiBase,
+                                                               const char* text,
+                                                               bool close_keyboard)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  return CGUIKeyboardFactory::SendTextToActiveKeyboard(text, close_keyboard);
+}
+
+bool Interface_GUIDialogKeyboard::is_keyboard_activated(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__);
+    return false;
+  }
+
+  return CGUIKeyboardFactory::isKeyboardActivated();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Keyboard.h b/xbmc/addons/interfaces/gui/dialogs/Keyboard.h
new file mode 100644
index 0000000..fb7d6b9
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Keyboard.h
@@ -0,0 +1,94 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h"
+   */
+  struct Interface_GUIDialogKeyboard
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static bool show_and_get_input_with_head(KODI_HANDLE kodiBase,
+                                             const char* text_in,
+                                             char** text_out,
+                                             const char* heading,
+                                             bool allow_empty_result,
+                                             bool hidden_input,
+                                             unsigned int auto_close_ms);
+    static bool show_and_get_input(KODI_HANDLE kodiBase,
+                                   const char* text_in,
+                                   char** text_out,
+                                   bool allow_empty_result,
+                                   unsigned int auto_close_ms);
+    static bool show_and_get_new_password_with_head(KODI_HANDLE kodiBase,
+                                                    const char* password_in,
+                                                    char** password_out,
+                                                    const char* heading,
+                                                    bool allow_empty_result,
+                                                    unsigned int auto_close_ms);
+    static bool show_and_get_new_password(KODI_HANDLE kodiBase,
+                                          const char* password_in,
+                                          char** password_out,
+                                          unsigned int auto_close_ms);
+    static bool show_and_verify_new_password_with_head(KODI_HANDLE kodiBase,
+                                                       char** password_out,
+                                                       const char* heading,
+                                                       bool allowEmpty,
+                                                       unsigned int auto_close_ms);
+    static bool show_and_verify_new_password(KODI_HANDLE kodiBase,
+                                             char** password_out,
+                                             unsigned int auto_close_ms);
+    static int show_and_verify_password(KODI_HANDLE kodiBase,
+                                        const char* password_in,
+                                        char** password_out,
+                                        const char* heading,
+                                        int retries,
+                                        unsigned int auto_close_ms);
+    static bool show_and_get_filter(KODI_HANDLE kodiBase,
+                                    const char* text_in,
+                                    char** text_out,
+                                    bool searching,
+                                    unsigned int auto_close_ms);
+    static bool send_text_to_active_keyboard(KODI_HANDLE kodiBase,
+                                             const char* text,
+                                             bool close_keyboard);
+    static bool is_keyboard_activated(KODI_HANDLE kodiBase);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp b/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp
new file mode 100644
index 0000000..a78aa4a
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp
@@ -0,0 +1,270 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Numeric.h"
+
+#include "XBDateTime.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h"
+#include "dialogs/GUIDialogNumeric.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogNumeric::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogNumeric =
+      new AddonToKodiFuncTable_kodi_gui_dialogNumeric();
+
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_new_password =
+      show_and_verify_new_password;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_password =
+      show_and_verify_password;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_input = show_and_verify_input;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_time = show_and_get_time;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_date = show_and_get_date;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_ip_address =
+      show_and_get_ip_address;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_number = show_and_get_number;
+  addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_seconds = show_and_get_seconds;
+}
+
+void Interface_GUIDialogNumeric::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogNumeric;
+}
+
+bool Interface_GUIDialogNumeric::show_and_verify_new_password(KODI_HANDLE kodiBase, char** password)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  std::string str;
+  bool bRet = CGUIDialogNumeric::ShowAndVerifyNewPassword(str);
+  if (bRet)
+    *password = strdup(str.c_str());
+  return bRet;
+}
+
+int Interface_GUIDialogNumeric::show_and_verify_password(KODI_HANDLE kodiBase,
+                                                         const char* password,
+                                                         const char* heading,
+                                                         int retries)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return -1;
+  }
+
+  if (!password || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (password='{}', heading='{}') "
+              "on addon '{}'",
+              __func__, static_cast<const void*>(password), static_cast<const void*>(heading),
+              addon->ID());
+    return -1;
+  }
+
+  std::string pw(password);
+  return CGUIDialogNumeric::ShowAndVerifyPassword(pw, heading, retries);
+}
+
+bool Interface_GUIDialogNumeric::show_and_verify_input(KODI_HANDLE kodiBase,
+                                                       const char* verify_in,
+                                                       char** verify_out,
+                                                       const char* heading,
+                                                       bool verify_input)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!verify_in || !verify_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (verify_in='{}', "
+              "verify_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(verify_in), static_cast<void*>(verify_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = verify_in;
+  if (CGUIDialogNumeric::ShowAndVerifyInput(str, heading, verify_input) ==
+      InputVerificationResult::SUCCESS)
+  {
+    *verify_out = strdup(str.c_str());
+    return true;
+  }
+  return false;
+}
+
+bool Interface_GUIDialogNumeric::show_and_get_time(KODI_HANDLE kodiBase,
+                                                   tm* time,
+                                                   const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!time || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (time='{}', heading='{}') on "
+              "addon '{}'",
+              __func__, static_cast<void*>(time), static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  KODI::TIME::SystemTime systemTime;
+  CDateTime dateTime(*time);
+  dateTime.GetAsSystemTime(systemTime);
+  if (CGUIDialogNumeric::ShowAndGetTime(systemTime, heading))
+  {
+    dateTime = systemTime;
+    dateTime.GetAsTm(*time);
+    return true;
+  }
+  return false;
+}
+
+bool Interface_GUIDialogNumeric::show_and_get_date(KODI_HANDLE kodiBase,
+                                                   tm* date,
+                                                   const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!date || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (date='{}', heading='{}') on "
+              "addon '{}'",
+              __func__, static_cast<void*>(date), static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  KODI::TIME::SystemTime systemTime;
+  CDateTime dateTime(*date);
+  dateTime.GetAsSystemTime(systemTime);
+  if (CGUIDialogNumeric::ShowAndGetDate(systemTime, heading))
+  {
+    dateTime = systemTime;
+    dateTime.GetAsTm(*date);
+    return true;
+  }
+  return false;
+}
+
+bool Interface_GUIDialogNumeric::show_and_get_ip_address(KODI_HANDLE kodiBase,
+                                                         const char* ip_address_in,
+                                                         char** ip_address_out,
+                                                         const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!ip_address_in || !ip_address_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (ip_address_in='{}', "
+              "ip_address_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(ip_address_in), static_cast<void*>(ip_address_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string strIP = ip_address_in;
+  bool bRet = CGUIDialogNumeric::ShowAndGetIPAddress(strIP, heading);
+  if (bRet)
+    *ip_address_out = strdup(strIP.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogNumeric::show_and_get_number(KODI_HANDLE kodiBase,
+                                                     const char* number_in,
+                                                     char** number_out,
+                                                     const char* heading,
+                                                     unsigned int auto_close_ms)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!number_in || !number_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (number_in='{}', "
+              "number_out='{}', heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(number_in), static_cast<void*>(number_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = number_in;
+  bool bRet = CGUIDialogNumeric::ShowAndGetNumber(str, heading, auto_close_ms);
+  if (bRet)
+    *number_out = strdup(str.c_str());
+  return bRet;
+}
+
+bool Interface_GUIDialogNumeric::show_and_get_seconds(KODI_HANDLE kodiBase,
+                                                      const char* time_in,
+                                                      char** time_out,
+                                                      const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!time_in || !time_out || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogNumeric::{} - invalid handler data (time_in='{}', time_out='{}', "
+              "heading='{}') on addon '{}'",
+              __func__, static_cast<const void*>(time_in), static_cast<void*>(time_out),
+              static_cast<const void*>(heading), addon->ID());
+    return false;
+  }
+
+  std::string str = time_in;
+  bool bRet = CGUIDialogNumeric::ShowAndGetSeconds(str, heading);
+  if (bRet)
+    *time_out = strdup(str.c_str());
+  return bRet;
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Numeric.h b/xbmc/addons/interfaces/gui/dialogs/Numeric.h
new file mode 100644
index 0000000..a54ad52
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Numeric.h
@@ -0,0 +1,74 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h"
+   */
+  struct Interface_GUIDialogNumeric
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static bool show_and_verify_new_password(KODI_HANDLE kodiBase, char** password);
+    static int show_and_verify_password(KODI_HANDLE kodiBase,
+                                        const char* password,
+                                        const char* heading,
+                                        int retries);
+    static bool show_and_verify_input(KODI_HANDLE kodiBase,
+                                      const char* verify_in,
+                                      char** verify_out,
+                                      const char* heading,
+                                      bool verify_input);
+    static bool show_and_get_time(KODI_HANDLE kodiBase, tm* time, const char* heading);
+    static bool show_and_get_date(KODI_HANDLE kodiBase, tm* date, const char* heading);
+    static bool show_and_get_ip_address(KODI_HANDLE kodiBase,
+                                        const char* ip_address_in,
+                                        char** ip_address_out,
+                                        const char* heading);
+    static bool show_and_get_number(KODI_HANDLE kodiBase,
+                                    const char* number_in,
+                                    char** number_out,
+                                    const char* heading,
+                                    unsigned int auto_close_ms);
+    static bool show_and_get_seconds(KODI_HANDLE kodiBase,
+                                     const char* time_in,
+                                     char** time_out,
+                                     const char* heading);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/OK.cpp b/xbmc/addons/interfaces/gui/dialogs/OK.cpp
new file mode 100644
index 0000000..90e9d69
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/OK.cpp
@@ -0,0 +1,73 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "OK.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+using namespace KODI::MESSAGING;
+
+namespace ADDON
+{
+
+void Interface_GUIDialogOK::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogOK = new AddonToKodiFuncTable_kodi_gui_dialogOK();
+
+  addonInterface->toKodi->kodi_gui->dialogOK->show_and_get_input_single_text =
+      show_and_get_input_single_text;
+  addonInterface->toKodi->kodi_gui->dialogOK->show_and_get_input_line_text =
+      show_and_get_input_line_text;
+}
+
+void Interface_GUIDialogOK::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogOK;
+}
+
+void Interface_GUIDialogOK::show_and_get_input_single_text(KODI_HANDLE kodiBase,
+                                                           const char* heading,
+                                                           const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon || !heading || !text)
+  {
+    CLog::Log(
+        LOGERROR, "Interface_GUIDialogOK:{} - invalid data (addon='{}', heading='{}', text='{}')",
+        __func__, kodiBase, static_cast<const void*>(heading), static_cast<const void*>(text));
+    return;
+  }
+
+  HELPERS::ShowOKDialogText(CVariant{heading}, CVariant{text});
+}
+
+void Interface_GUIDialogOK::show_and_get_input_line_text(KODI_HANDLE kodiBase,
+                                                         const char* heading,
+                                                         const char* line0,
+                                                         const char* line1,
+                                                         const char* line2)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon || !heading || !line0 || !line1 || !line2)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogOK::{} - invalid data (addon='{}', heading='{}', line0='{}', "
+              "line1='{}', line2='{}')",
+              __func__, kodiBase, static_cast<const void*>(heading),
+              static_cast<const void*>(line0), static_cast<const void*>(line1),
+              static_cast<const void*>(line2));
+    return;
+  }
+  HELPERS::ShowOKDialogLines(CVariant{heading}, CVariant{line0}, CVariant{line1}, CVariant{line2});
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/OK.h b/xbmc/addons/interfaces/gui/dialogs/OK.h
new file mode 100644
index 0000000..fd13719
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/OK.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h"
+   */
+  struct Interface_GUIDialogOK
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note For add of new functions use the "_" style to identify direct a
+     * add-on callback function. Everything with CamelCase is only for the
+     * usage in Kodi only.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void show_and_get_input_single_text(KODI_HANDLE kodiBase,
+                                               const char* heading,
+                                               const char* text);
+    static void show_and_get_input_line_text(KODI_HANDLE kodiBase,
+                                             const char* heading,
+                                             const char* line0,
+                                             const char* line1,
+                                             const char* line2);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Progress.cpp b/xbmc/addons/interfaces/gui/dialogs/Progress.cpp
new file mode 100644
index 0000000..ff6c742
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Progress.cpp
@@ -0,0 +1,328 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Progress.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h"
+#include "dialogs/GUIDialogProgress.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogProgress::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogProgress =
+      new AddonToKodiFuncTable_kodi_gui_dialogProgress();
+
+  addonInterface->toKodi->kodi_gui->dialogProgress->new_dialog = new_dialog;
+  addonInterface->toKodi->kodi_gui->dialogProgress->delete_dialog = delete_dialog;
+  addonInterface->toKodi->kodi_gui->dialogProgress->open = open;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_heading = set_heading;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_line = set_line;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_can_cancel = set_can_cancel;
+  addonInterface->toKodi->kodi_gui->dialogProgress->is_canceled = is_canceled;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_percentage = set_percentage;
+  addonInterface->toKodi->kodi_gui->dialogProgress->get_percentage = get_percentage;
+  addonInterface->toKodi->kodi_gui->dialogProgress->show_progress_bar = show_progress_bar;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_progress_max = set_progress_max;
+  addonInterface->toKodi->kodi_gui->dialogProgress->set_progress_advance = set_progress_advance;
+  addonInterface->toKodi->kodi_gui->dialogProgress->abort = abort;
+}
+
+void Interface_GUIDialogProgress::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogProgress;
+}
+
+KODI_GUI_HANDLE Interface_GUIDialogProgress::new_dialog(KODI_HANDLE kodiBase)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return nullptr;
+  }
+
+  CGUIDialogProgress* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(
+          WINDOW_DIALOG_PROGRESS);
+  if (!dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (dialog='{}') on addon '{}'",
+              __func__, static_cast<void*>(dialog), addon->ID());
+    return nullptr;
+  }
+
+  return dialog;
+}
+
+void Interface_GUIDialogProgress::delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->Close();
+}
+
+void Interface_GUIDialogProgress::open(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->Open();
+}
+
+void Interface_GUIDialogProgress::set_heading(KODI_HANDLE kodiBase,
+                                              KODI_GUI_HANDLE handle,
+                                              const char* heading)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle || !heading)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}', heading='{}') "
+              "on addon '{}'",
+              __func__, handle, static_cast<const void*>(heading), addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetHeading(heading);
+}
+
+void Interface_GUIDialogProgress::set_line(KODI_HANDLE kodiBase,
+                                           KODI_GUI_HANDLE handle,
+                                           unsigned int line,
+                                           const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle || !text)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}', text='{}') on "
+              "addon '{}'",
+              __func__, handle, static_cast<const void*>(text), addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetLine(line, text);
+}
+
+void Interface_GUIDialogProgress::set_can_cancel(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_HANDLE handle,
+                                                 bool canCancel)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetCanCancel(canCancel);
+}
+
+bool Interface_GUIDialogProgress::is_canceled(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return false;
+  }
+
+  return static_cast<CGUIDialogProgress*>(handle)->IsCanceled();
+}
+
+void Interface_GUIDialogProgress::set_percentage(KODI_HANDLE kodiBase,
+                                                 KODI_GUI_HANDLE handle,
+                                                 int percentage)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetPercentage(percentage);
+}
+
+int Interface_GUIDialogProgress::get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return 0;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return 0;
+  }
+
+  return static_cast<CGUIDialogProgress*>(handle)->GetPercentage();
+}
+
+void Interface_GUIDialogProgress::show_progress_bar(KODI_HANDLE kodiBase,
+                                                    KODI_GUI_HANDLE handle,
+                                                    bool onOff)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->ShowProgressBar(onOff);
+}
+
+void Interface_GUIDialogProgress::set_progress_max(KODI_HANDLE kodiBase,
+                                                   KODI_GUI_HANDLE handle,
+                                                   int max)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetProgressMax(max);
+}
+
+void Interface_GUIDialogProgress::set_progress_advance(KODI_HANDLE kodiBase,
+                                                       KODI_GUI_HANDLE handle,
+                                                       int nSteps)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return;
+  }
+
+  static_cast<CGUIDialogProgress*>(handle)->SetProgressAdvance(nSteps);
+}
+
+bool Interface_GUIDialogProgress::abort(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!handle)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'",
+              __func__, handle, addon->ID());
+    return false;
+  }
+
+  return static_cast<CGUIDialogProgress*>(handle)->Abort();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Progress.h b/xbmc/addons/interfaces/gui/dialogs/Progress.h
new file mode 100644
index 0000000..ba31f3c
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Progress.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h"
+   */
+  struct Interface_GUIDialogProgress
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static KODI_GUI_HANDLE new_dialog(KODI_HANDLE kodiBase);
+    static void delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void open(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void set_heading(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* heading);
+    static void set_line(KODI_HANDLE kodiBase,
+                         KODI_GUI_HANDLE handle,
+                         unsigned int line,
+                         const char* text);
+    static void set_can_cancel(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool canCancel);
+    static bool is_canceled(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int percentage);
+    static int get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    static void show_progress_bar(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool bOnOff);
+    static void set_progress_max(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int max);
+    static void set_progress_advance(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int nSteps);
+    static bool abort(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Select.cpp b/xbmc/addons/interfaces/gui/dialogs/Select.cpp
new file mode 100644
index 0000000..7ad6ed6
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Select.cpp
@@ -0,0 +1,143 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Select.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h"
+#include "dialogs/GUIDialogSelect.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogSelect::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogSelect = new AddonToKodiFuncTable_kodi_gui_dialogSelect();
+
+  addonInterface->toKodi->kodi_gui->dialogSelect->open = open;
+  addonInterface->toKodi->kodi_gui->dialogSelect->open_multi_select = open_multi_select;
+}
+
+void Interface_GUIDialogSelect::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogSelect;
+}
+
+int Interface_GUIDialogSelect::open(KODI_HANDLE kodiBase,
+                                    const char* heading,
+                                    const char* entries[],
+                                    unsigned int size,
+                                    int selected,
+                                    unsigned int autoclose)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogSelect::{} - invalid data", __func__);
+    return -1;
+  }
+
+  CGUIDialogSelect* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
+          WINDOW_DIALOG_SELECT);
+  if (!heading || !entries || !dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogSelect::{} - invalid handler data (heading='{}', entries='{}', "
+              "dialog='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(entries),
+              static_cast<void*>(dialog), addon->ID());
+    return -1;
+  }
+
+  dialog->Reset();
+  dialog->SetHeading(CVariant{heading});
+
+  for (unsigned int i = 0; i < size; ++i)
+    dialog->Add(entries[i]);
+
+  if (selected > 0)
+    dialog->SetSelected(selected);
+  if (autoclose > 0)
+    dialog->SetAutoClose(autoclose);
+
+  dialog->Open();
+  return dialog->GetSelectedItem();
+}
+
+
+bool Interface_GUIDialogSelect::open_multi_select(KODI_HANDLE kodiBase,
+                                                  const char* heading,
+                                                  const char* entryIDs[],
+                                                  const char* entryNames[],
+                                                  bool entriesSelected[],
+                                                  unsigned int size,
+                                                  unsigned int autoclose)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogMultiSelect::{} - invalid data", __func__);
+    return false;
+  }
+
+  CGUIDialogSelect* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
+          WINDOW_DIALOG_SELECT);
+  if (!heading || !entryIDs || !entryNames || !entriesSelected || !dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogMultiSelect::{} - invalid handler data (heading='{}', "
+              "entryIDs='{}', entryNames='{}', entriesSelected='{}', dialog='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(entryIDs),
+              static_cast<const void*>(entryNames), static_cast<void*>(entriesSelected),
+              static_cast<void*>(dialog), addon->ID());
+    return false;
+  }
+
+  dialog->Reset();
+  dialog->SetMultiSelection(true);
+  dialog->SetHeading(CVariant{heading});
+
+  std::vector<int> selectedIndexes;
+
+  for (unsigned int i = 0; i < size; ++i)
+  {
+    dialog->Add(entryNames[i]);
+    if (entriesSelected[i])
+      selectedIndexes.push_back(i);
+  }
+
+  dialog->SetSelected(selectedIndexes);
+  if (autoclose > 0)
+    dialog->SetAutoClose(autoclose);
+
+  dialog->Open();
+  if (dialog->IsConfirmed())
+  {
+    for (unsigned int i = 0; i < size; ++i)
+      entriesSelected[i] = false;
+
+    selectedIndexes = dialog->GetSelectedItems();
+
+    for (unsigned int i = 0; i < selectedIndexes.size(); ++i)
+    {
+      if (selectedIndexes[i])
+        entriesSelected[selectedIndexes[i]] = true;
+    }
+  }
+
+  return true;
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/Select.h b/xbmc/addons/interfaces/gui/dialogs/Select.h
new file mode 100644
index 0000000..5f2d0ef
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/Select.h
@@ -0,0 +1,62 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h"
+   */
+  struct Interface_GUIDialogSelect
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static int open(KODI_HANDLE kodiBase,
+                    const char* heading,
+                    const char* entries[],
+                    unsigned int size,
+                    int selected,
+                    unsigned int autoclose);
+    static bool open_multi_select(KODI_HANDLE kodiBase,
+                                  const char* heading,
+                                  const char* entryIDs[],
+                                  const char* entryNames[],
+                                  bool entriesSelected[],
+                                  unsigned int size,
+                                  unsigned int autoclose);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp b/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp
new file mode 100644
index 0000000..637975a
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp
@@ -0,0 +1,64 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "TextViewer.h"
+
+#include "ServiceBroker.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h"
+#include "dialogs/GUIDialogTextViewer.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+namespace ADDON
+{
+
+void Interface_GUIDialogTextViewer::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogTextViewer =
+      new AddonToKodiFuncTable_kodi_gui_dialogTextViewer();
+
+  addonInterface->toKodi->kodi_gui->dialogTextViewer->open = open;
+}
+
+void Interface_GUIDialogTextViewer::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogTextViewer;
+}
+
+void Interface_GUIDialogTextViewer::open(KODI_HANDLE kodiBase,
+                                         const char* heading,
+                                         const char* text)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogTextViewer::{} - invalid data", __func__);
+    return;
+  }
+
+  CGUIDialogTextViewer* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogTextViewer>(
+          WINDOW_DIALOG_TEXT_VIEWER);
+  if (!heading || !text || !dialog)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogTextViewer::{} - invalid handler data (heading='{}', text='{}', "
+              "dialog='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(text),
+              static_cast<void*>(dialog), addon->ID());
+    return;
+  }
+
+  dialog->SetHeading(heading);
+  dialog->SetText(text);
+  dialog->Open();
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/TextViewer.h b/xbmc/addons/interfaces/gui/dialogs/TextViewer.h
new file mode 100644
index 0000000..873dbbb
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/TextViewer.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h"
+   */
+  struct Interface_GUIDialogTextViewer
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static void open(KODI_HANDLE kodiBase, const char* heading, const char* text);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */
diff --git a/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp b/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp
new file mode 100644
index 0000000..89dea58
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp
@@ -0,0 +1,136 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "YesNo.h"
+
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "messaging/helpers/DialogHelper.h"
+#include "utils/log.h"
+
+using namespace KODI::MESSAGING;
+using KODI::MESSAGING::HELPERS::DialogResponse;
+
+namespace ADDON
+{
+
+void Interface_GUIDialogYesNo::Init(AddonGlobalInterface* addonInterface)
+{
+  addonInterface->toKodi->kodi_gui->dialogYesNo = new AddonToKodiFuncTable_kodi_gui_dialogYesNo();
+
+  addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_single_text =
+      show_and_get_input_single_text;
+  addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_line_text =
+      show_and_get_input_line_text;
+  addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_line_button_text =
+      show_and_get_input_line_button_text;
+}
+
+void Interface_GUIDialogYesNo::DeInit(AddonGlobalInterface* addonInterface)
+{
+  delete addonInterface->toKodi->kodi_gui->dialogYesNo;
+}
+
+bool Interface_GUIDialogYesNo::show_and_get_input_single_text(KODI_HANDLE kodiBase,
+                                                              const char* heading,
+                                                              const char* text,
+                                                              bool* canceled,
+                                                              const char* noLabel,
+                                                              const char* yesLabel)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!heading || !text || !canceled || !noLabel || !yesLabel)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', text='{}', "
+              "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(text),
+              static_cast<void*>(canceled), static_cast<const void*>(noLabel),
+              static_cast<const void*>(yesLabel), addon->ID());
+    return false;
+  }
+
+  DialogResponse result = HELPERS::ShowYesNoDialogText(heading, text, noLabel, yesLabel);
+  *canceled = (result == DialogResponse::CHOICE_CANCELLED);
+  return (result == DialogResponse::CHOICE_YES);
+}
+
+bool Interface_GUIDialogYesNo::show_and_get_input_line_text(KODI_HANDLE kodiBase,
+                                                            const char* heading,
+                                                            const char* line0,
+                                                            const char* line1,
+                                                            const char* line2,
+                                                            const char* noLabel,
+                                                            const char* yesLabel)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!heading || !line0 || !line1 || !line2 || !noLabel || !yesLabel)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', line0='{}', "
+              "line1='{}', line2='{}', "
+              "noLabel='{}', yesLabel='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(line0),
+              static_cast<const void*>(line1), static_cast<const void*>(line2),
+              static_cast<const void*>(noLabel), static_cast<const void*>(yesLabel), addon->ID());
+    return false;
+  }
+
+  return HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel) ==
+         DialogResponse::CHOICE_YES;
+}
+
+bool Interface_GUIDialogYesNo::show_and_get_input_line_button_text(KODI_HANDLE kodiBase,
+                                                                   const char* heading,
+                                                                   const char* line0,
+                                                                   const char* line1,
+                                                                   const char* line2,
+                                                                   bool* canceled,
+                                                                   const char* noLabel,
+                                                                   const char* yesLabel)
+{
+  CAddonDll* addon = static_cast<CAddonDll*>(kodiBase);
+  if (!addon)
+  {
+    CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__);
+    return false;
+  }
+
+  if (!heading || !line0 || !line1 || !line2 || !canceled || !noLabel || !yesLabel)
+  {
+    CLog::Log(LOGERROR,
+              "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', line0='{}', "
+              "line1='{}', line2='{}', "
+              "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'",
+              __func__, static_cast<const void*>(heading), static_cast<const void*>(line0),
+              static_cast<const void*>(line1), static_cast<const void*>(line2),
+              static_cast<const void*>(canceled), static_cast<const void*>(noLabel),
+              static_cast<const void*>(yesLabel), addon->ID());
+    return false;
+  }
+
+  DialogResponse result =
+      HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel);
+  *canceled = (result == DialogResponse::CHOICE_CANCELLED);
+  return (result == DialogResponse::CHOICE_YES);
+}
+
+} /* namespace ADDON */
diff --git a/xbmc/addons/interfaces/gui/dialogs/YesNo.h b/xbmc/addons/interfaces/gui/dialogs/YesNo.h
new file mode 100644
index 0000000..84e5d73
--- /dev/null
+++ b/xbmc/addons/interfaces/gui/dialogs/YesNo.h
@@ -0,0 +1,72 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h"
+
+extern "C"
+{
+
+  struct AddonGlobalInterface;
+
+  namespace ADDON
+  {
+
+  /*!
+   * @brief Global gui Add-on to Kodi callback functions
+   *
+   * To hold functions not related to a instance type and usable for
+   * every add-on type.
+   *
+   * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h"
+   */
+  struct Interface_GUIDialogYesNo
+  {
+    static void Init(AddonGlobalInterface* addonInterface);
+    static void DeInit(AddonGlobalInterface* addonInterface);
+
+    /*!
+     * @brief callback functions from add-on to kodi
+     *
+     * @note To add a new function use the "_" style to directly identify an
+     * add-on callback function. Everything with CamelCase is only to be used
+     * in Kodi.
+     *
+     * The parameter `kodiBase` is used to become the pointer for a `CAddonDll`
+     * class.
+     */
+    //@{
+    static bool show_and_get_input_single_text(KODI_HANDLE kodiBase,
+                                               const char* heading,
+                                               const char* text,
+                                               bool* canceled,
+                                               const char* noLabel,
+                                               const char* yesLabel);
+
+    static bool show_and_get_input_line_text(KODI_HANDLE kodiBase,
+                                             const char* heading,
+                                             const char* line0,
+                                             const char* line1,
+                                             const char* line2,
+                                             const char* noLabel,
+                                             const char* yesLabel);
+
+    static bool show_and_get_input_line_button_text(KODI_HANDLE kodiBase,
+                                                    const char* heading,
+                                                    const char* line0,
+                                                    const char* line1,
+                                                    const char* line2,
+                                                    bool* canceled,
+                                                    const char* noLabel,
+                                                    const char* yesLabel);
+    //@}
+  };
+
+  } /* namespace ADDON */
+} /* extern "C" */