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

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

64 files changed, 11582 insertions, 0 deletions

diff --git a/xbmc/dialogs/CMakeLists.txt b/xbmc/dialogs/CMakeLists.txt
new file mode 100644
index 0000000..bd14222
--- /dev/null
+++ b/xbmc/dialogs/CMakeLists.txt
@@ -0,0 +1,69 @@
+set(SOURCES GUIDialogBoxBase.cpp
+            GUIDialogBusy.cpp
+            GUIDialogBusyNoCancel.cpp
+            GUIDialogButtonMenu.cpp
+            GUIDialogCache.cpp
+            GUIDialogColorPicker.cpp
+            GUIDialogContextMenu.cpp
+            GUIDialogExtendedProgressBar.cpp
+            GUIDialogFileBrowser.cpp
+            GUIDialogGamepad.cpp
+            GUIDialogKaiToast.cpp
+            GUIDialogKeyboardGeneric.cpp
+            GUIDialogKeyboardTouch.cpp
+            GUIDialogMediaFilter.cpp
+            GUIDialogMediaSource.cpp
+            GUIDialogNumeric.cpp
+            GUIDialogOK.cpp
+            GUIDialogPlayerControls.cpp
+            GUIDialogPlayerProcessInfo.cpp
+            GUIDialogProgress.cpp
+            GUIDialogSeekBar.cpp
+            GUIDialogSelect.cpp
+            GUIDialogSimpleMenu.cpp
+            GUIDialogSlider.cpp
+            GUIDialogSmartPlaylistEditor.cpp
+            GUIDialogSmartPlaylistRule.cpp
+            GUIDialogSubMenu.cpp
+            GUIDialogTextViewer.cpp
+            GUIDialogVolumeBar.cpp
+            GUIDialogYesNo.cpp)
+
+set(HEADERS GUIDialogBoxBase.h
+            GUIDialogBusy.h
+            GUIDialogBusyNoCancel.h
+            GUIDialogButtonMenu.h
+            GUIDialogCache.h
+            GUIDialogColorPicker.h
+            GUIDialogContextMenu.h
+            GUIDialogExtendedProgressBar.h
+            GUIDialogFileBrowser.h
+            GUIDialogGamepad.h
+            GUIDialogKaiToast.h
+            GUIDialogKeyboardGeneric.h
+            GUIDialogKeyboardTouch.h
+            GUIDialogMediaFilter.h
+            GUIDialogMediaSource.h
+            GUIDialogNumeric.h
+            GUIDialogOK.h
+            GUIDialogPlayerControls.h
+            GUIDialogPlayerProcessInfo.h
+            GUIDialogProgress.h
+            GUIDialogSeekBar.h
+            GUIDialogSelect.h
+            GUIDialogSimpleMenu.h
+            GUIDialogSlider.h
+            GUIDialogSmartPlaylistEditor.h
+            GUIDialogSmartPlaylistRule.h
+            GUIDialogSubMenu.h
+            GUIDialogTextViewer.h
+            GUIDialogVolumeBar.h
+            GUIDialogYesNo.h
+            IGUIVolumeBarCallback.h)
+
+if(ENABLE_OPTICAL)
+  list(APPEND SOURCES GUIDialogPlayEject.cpp)
+  list(APPEND HEADERS GUIDialogPlayEject.h)
+endif()
+
+core_add_library(dialogs)
diff --git a/xbmc/dialogs/GUIDialogBoxBase.cpp b/xbmc/dialogs/GUIDialogBoxBase.cpp
new file mode 100644
index 0000000..1d87949
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBoxBase.cpp
@@ -0,0 +1,187 @@
+/*
+ *  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 "GUIDialogBoxBase.h"
+
+#include "guilib/GUIMessage.h"
+#include "guilib/LocalizeStrings.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+
+#include <mutex>
+
+#define CONTROL_HEADING 1
+#define CONTROL_LINES_START 2
+#define CONTROL_TEXTBOX     9
+
+CGUIDialogBoxBase::CGUIDialogBoxBase(int id, const std::string &xmlFile)
+    : CGUIDialog(id, xmlFile)
+{
+  m_bConfirmed = false;
+  m_loadType = KEEP_IN_MEMORY;
+  m_hasTextbox = false;
+}
+
+CGUIDialogBoxBase::~CGUIDialogBoxBase(void) = default;
+
+bool CGUIDialogBoxBase::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      CGUIDialog::OnMessage(message);
+      m_bConfirmed = false;
+      return true;
+    }
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+bool CGUIDialogBoxBase::IsConfirmed() const
+{
+  return m_bConfirmed;
+}
+
+void CGUIDialogBoxBase::SetHeading(const CVariant& heading)
+{
+  std::string label = GetLocalized(heading);
+  std::unique_lock<CCriticalSection> lock(m_section);
+  if (label != m_strHeading)
+  {
+    m_strHeading = label;
+    SetInvalid();
+  }
+}
+
+void CGUIDialogBoxBase::SetLine(unsigned int iLine, const CVariant& line)
+{
+  std::string label = GetLocalized(line);
+  std::unique_lock<CCriticalSection> lock(m_section);
+  std::vector<std::string> lines = StringUtils::Split(m_text, '\n');
+  if (iLine >= lines.size())
+    lines.resize(iLine+1);
+  lines[iLine] = label;
+  std::string text = StringUtils::Join(lines, "\n");
+  SetText(text);
+}
+
+void CGUIDialogBoxBase::SetText(const CVariant& text)
+{
+  std::string label = GetLocalized(text);
+  std::unique_lock<CCriticalSection> lock(m_section);
+  StringUtils::Trim(label, "\n");
+  if (label != m_text)
+  {
+    m_text = label;
+    SetInvalid();
+  }
+}
+
+void CGUIDialogBoxBase::SetChoice(int iButton, const CVariant &choice) // iButton == 0 for no, 1 for yes
+{
+  if (iButton < 0 || iButton >= DIALOG_MAX_CHOICES)
+    return;
+
+  std::string label = GetLocalized(choice);
+  std::unique_lock<CCriticalSection> lock(m_section);
+  if (label != m_strChoices[iButton])
+  {
+    m_strChoices[iButton] = label;
+    SetInvalid();
+  }
+}
+
+void CGUIDialogBoxBase::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  if (m_bInvalidated)
+  { // take a copy of our labels to save holding the lock for too long
+    std::string heading, text;
+    std::vector<std::string> choices;
+    choices.reserve(DIALOG_MAX_CHOICES);
+    {
+      std::unique_lock<CCriticalSection> lock(m_section);
+      heading = m_strHeading;
+      text = m_text;
+      for (const std::string& choice : m_strChoices)
+        choices.push_back(choice);
+    }
+    SET_CONTROL_LABEL(CONTROL_HEADING, heading);
+    if (m_hasTextbox)
+    {
+      SET_CONTROL_LABEL(CONTROL_TEXTBOX, text);
+    }
+    else
+    {
+      std::vector<std::string> lines = StringUtils::Split(text, "\n", DIALOG_MAX_LINES);
+      lines.resize(DIALOG_MAX_LINES);
+      for (size_t i = 0 ; i < lines.size(); ++i)
+        SET_CONTROL_LABEL(CONTROL_LINES_START + i, lines[i]);
+    }
+    for (size_t i = 0 ; i < choices.size() ; ++i)
+      SET_CONTROL_LABEL(CONTROL_CHOICES_START + i, choices[i]);
+  }
+  CGUIDialog::Process(currentTime, dirtyregions);
+}
+
+void CGUIDialogBoxBase::OnInitWindow()
+{
+  // set focus to default
+  m_lastControlID = m_defaultControl;
+
+  m_hasTextbox = false;
+  const CGUIControl *control = GetControl(CONTROL_TEXTBOX);
+  if (control && control->GetControlType() == CGUIControl::GUICONTROL_TEXTBOX)
+    m_hasTextbox = true;
+
+  // set initial labels
+  {
+    std::unique_lock<CCriticalSection> lock(m_section);
+    for (int i = 0 ; i < DIALOG_MAX_CHOICES ; ++i)
+    {
+      if (m_strChoices[i].empty())
+        m_strChoices[i] = GetDefaultLabel(CONTROL_CHOICES_START + i);
+    }
+  }
+  CGUIDialog::OnInitWindow();
+}
+
+void CGUIDialogBoxBase::OnDeinitWindow(int nextWindowID)
+{
+  // make sure we set default labels for heading, lines and choices
+  {
+    std::unique_lock<CCriticalSection> lock(m_section);
+    m_strHeading.clear();
+    m_text.clear();
+    for (std::string& choice : m_strChoices)
+      choice.clear();
+  }
+
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+}
+
+std::string CGUIDialogBoxBase::GetLocalized(const CVariant &var) const
+{
+  if (var.isString())
+    return var.asString();
+  else if (var.isInteger() && var.asInteger())
+    return g_localizeStrings.Get((uint32_t)var.asInteger());
+  return "";
+}
+
+std::string CGUIDialogBoxBase::GetDefaultLabel(int controlId) const
+{
+  int labelId = GetDefaultLabelID(controlId);
+  return labelId != -1 ? g_localizeStrings.Get(labelId) : "";
+}
+
+int CGUIDialogBoxBase::GetDefaultLabelID(int controlId) const
+{
+  return -1;
+}
diff --git a/xbmc/dialogs/GUIDialogBoxBase.h b/xbmc/dialogs/GUIDialogBoxBase.h
new file mode 100644
index 0000000..41ab31b
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBoxBase.h
@@ -0,0 +1,61 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+#include "threads/CriticalSection.h"
+
+#include <vector>
+
+#define CONTROL_CHOICES_START  10
+#define CONTROL_NO_BUTTON      CONTROL_CHOICES_START
+#define CONTROL_YES_BUTTON     CONTROL_CHOICES_START + 1
+#define CONTROL_CUSTOM_BUTTON  CONTROL_CHOICES_START + 2
+#define CONTROL_PROGRESS_BAR   20
+
+#define DIALOG_MAX_LINES 3
+#define DIALOG_MAX_CHOICES 3
+
+class CVariant;
+
+class CGUIDialogBoxBase :
+      public CGUIDialog
+{
+public:
+  CGUIDialogBoxBase(int id, const std::string &xmlFile);
+  ~CGUIDialogBoxBase(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool IsConfirmed() const;
+  void SetLine(unsigned int iLine, const CVariant& line);
+  void SetText(const CVariant& text);
+  void SetHeading(const CVariant& heading);
+  void SetChoice(int iButton, const CVariant &choice);
+protected:
+  std::string GetDefaultLabel(int controlId) const;
+  virtual int GetDefaultLabelID(int controlId) const;
+  /*! \brief Get a localized string from a variant
+   If the variant is already a string we return directly, else if it's an integer we return the corresponding
+   localized string.
+   \param var the variant to localize.
+   */
+  std::string GetLocalized(const CVariant &var) const;
+
+  void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+  bool m_bConfirmed;
+  bool m_hasTextbox;
+
+  // actual strings
+  CCriticalSection m_section;
+  std::string m_strHeading;
+  std::string m_text;
+  std::string m_strChoices[DIALOG_MAX_CHOICES];
+};
diff --git a/xbmc/dialogs/GUIDialogBusy.cpp b/xbmc/dialogs/GUIDialogBusy.cpp
new file mode 100644
index 0000000..e53f1fc
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBusy.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 "GUIDialogBusy.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "threads/IRunnable.h"
+#include "threads/Thread.h"
+#include "utils/log.h"
+
+using namespace std::chrono_literals;
+
+class CBusyWaiter : public CThread
+{
+  std::shared_ptr<CEvent> m_done;
+  IRunnable *m_runnable;
+public:
+  explicit CBusyWaiter(IRunnable *runnable) :
+  CThread(runnable, "waiting"), m_done(new CEvent()),  m_runnable(runnable) { }
+
+  ~CBusyWaiter() override { StopThread(); }
+
+  bool Wait(unsigned int displaytime, bool allowCancel)
+  {
+    std::shared_ptr<CEvent> e_done(m_done);
+
+    Create();
+    auto start = std::chrono::steady_clock::now();
+    if (!CGUIDialogBusy::WaitOnEvent(*e_done, displaytime, allowCancel))
+    {
+      m_runnable->Cancel();
+
+      auto end = std::chrono::steady_clock::now();
+      auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+      unsigned int remaining =
+          (duration.count() >= displaytime) ? 0 : displaytime - duration.count();
+      CGUIDialogBusy::WaitOnEvent(*e_done, remaining, false);
+      return false;
+    }
+    return true;
+  }
+
+  // 'this' is actually deleted from the thread where it's on the stack
+  void Process() override
+  {
+    std::shared_ptr<CEvent> e_done(m_done);
+
+    CThread::Process();
+    (*e_done).Set();
+  }
+
+};
+
+bool CGUIDialogBusy::Wait(IRunnable *runnable, unsigned int displaytime, bool allowCancel)
+{
+  if (!runnable)
+    return false;
+  CBusyWaiter waiter(runnable);
+  if (!waiter.Wait(displaytime, allowCancel))
+  {
+    return false;
+  }
+  return true;
+}
+
+bool CGUIDialogBusy::WaitOnEvent(CEvent &event, unsigned int displaytime /* = 100 */, bool allowCancel /* = true */)
+{
+  bool cancelled = false;
+  if (!event.Wait(std::chrono::milliseconds(displaytime)))
+  {
+    // throw up the progress
+    CGUIDialogBusy* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogBusy>(WINDOW_DIALOG_BUSY);
+    if (dialog)
+    {
+      if (dialog->IsDialogRunning())
+      {
+        CLog::Log(LOGFATAL, "Logic error due to two concurrent busydialogs, this is a known issue. "
+                            "The application will exit.");
+        throw std::logic_error("busy dialog already running");
+      }
+
+      dialog->Open();
+
+      while (!event.Wait(1ms))
+      {
+        dialog->ProcessRenderLoop(false);
+        if (allowCancel && dialog->IsCanceled())
+        {
+          cancelled = true;
+          break;
+        }
+      }
+
+      dialog->Close(true);
+    }
+  }
+  return !cancelled;
+}
+
+CGUIDialogBusy::CGUIDialogBusy(void)
+  : CGUIDialog(WINDOW_DIALOG_BUSY, "DialogBusy.xml", DialogModalityType::MODAL)
+{
+  m_loadType = LOAD_ON_GUI_INIT;
+  m_bCanceled = false;
+}
+
+CGUIDialogBusy::~CGUIDialogBusy(void) = default;
+
+void CGUIDialogBusy::Open_Internal(bool bProcessRenderLoop, const std::string& param /* = "" */)
+{
+  m_bCanceled = false;
+  m_bLastVisible = true;
+
+  CGUIDialog::Open_Internal(false, param);
+}
+
+
+void CGUIDialogBusy::DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  bool visible = CServiceBroker::GetGUI()->GetWindowManager().IsModalDialogTopmost(WINDOW_DIALOG_BUSY);
+  if(!visible && m_bLastVisible)
+    dirtyregions.push_back(CDirtyRegion(m_renderRegion));
+  m_bLastVisible = visible;
+
+  CGUIDialog::DoProcess(currentTime, dirtyregions);
+}
+
+void CGUIDialogBusy::Render()
+{
+  if(!m_bLastVisible)
+    return;
+  CGUIDialog::Render();
+}
+
+bool CGUIDialogBusy::OnBack(int actionID)
+{
+  m_bCanceled = true;
+  return true;
+}
diff --git a/xbmc/dialogs/GUIDialogBusy.h b/xbmc/dialogs/GUIDialogBusy.h
new file mode 100644
index 0000000..586d6a3
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBusy.h
@@ -0,0 +1,51 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class IRunnable;
+class CEvent;
+
+class CGUIDialogBusy: public CGUIDialog
+{
+public:
+  CGUIDialogBusy(void);
+  ~CGUIDialogBusy(void) override;
+  bool OnBack(int actionID) override;
+  void DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
+  void Render() override;
+  /*! \brief set the current progress of the busy operation
+   \param progress a percentage of progress
+   */
+  bool IsCanceled() { return m_bCanceled; }
+
+  /*! \brief Wait for a runnable to execute off-thread.
+   Creates a thread to run the given runnable, and while waiting
+   it displays the busy dialog.
+   \param runnable the IRunnable to run.
+   \param displaytime the time in ms to wait prior to showing the busy dialog (defaults to 100ms)
+   \param allowCancel whether the user can cancel the wait, defaults to true.
+   \return true if the runnable completes, false if the user cancels early.
+   */
+  static bool Wait(IRunnable *runnable, unsigned int displaytime, bool allowCancel);
+
+  /*! \brief Wait on an event while displaying the busy dialog.
+   Throws up the busy dialog after the given time.
+   \param event the CEvent to wait on.
+   \param displaytime the time in ms to wait prior to showing the busy dialog (defaults to 100ms)
+   \param allowCancel whether the user can cancel the wait, defaults to true.
+   \return true if the event completed, false if cancelled.
+   */
+  static bool WaitOnEvent(CEvent &event, unsigned int displaytime = 100, bool allowCancel = true);
+protected:
+  void Open_Internal(bool bProcessRenderLoop, const std::string& param = "") override;
+  bool m_bCanceled;
+  bool m_bLastVisible = false;
+};
diff --git a/xbmc/dialogs/GUIDialogBusyNoCancel.cpp b/xbmc/dialogs/GUIDialogBusyNoCancel.cpp
new file mode 100644
index 0000000..2bddd01
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBusyNoCancel.cpp
@@ -0,0 +1,47 @@
+/*
+ *  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 "GUIDialogBusyNoCancel.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "threads/Thread.h"
+
+CGUIDialogBusyNoCancel::CGUIDialogBusyNoCancel(void)
+  : CGUIDialog(WINDOW_DIALOG_BUSY_NOCANCEL, "DialogBusy.xml", DialogModalityType::MODAL)
+{
+  m_loadType = LOAD_ON_GUI_INIT;
+}
+
+CGUIDialogBusyNoCancel::~CGUIDialogBusyNoCancel(void) = default;
+
+void CGUIDialogBusyNoCancel::Open_Internal(bool bProcessRenderLoop,
+                                           const std::string& param /* = "" */)
+{
+  m_bLastVisible = true;
+
+  CGUIDialog::Open_Internal(false, param);
+}
+
+void CGUIDialogBusyNoCancel::DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  bool visible = CServiceBroker::GetGUI()->GetWindowManager().IsModalDialogTopmost(WINDOW_DIALOG_BUSY_NOCANCEL);
+  if (!visible && m_bLastVisible)
+    dirtyregions.push_back(CDirtyRegion(m_renderRegion));
+  m_bLastVisible = visible;
+
+  CGUIDialog::DoProcess(currentTime, dirtyregions);
+}
+
+void CGUIDialogBusyNoCancel::Render()
+{
+  if(!m_bLastVisible)
+    return;
+  CGUIDialog::Render();
+}
diff --git a/xbmc/dialogs/GUIDialogBusyNoCancel.h b/xbmc/dialogs/GUIDialogBusyNoCancel.h
new file mode 100644
index 0000000..b50a080
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogBusyNoCancel.h
@@ -0,0 +1,24 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogBusyNoCancel: public CGUIDialog
+{
+public:
+  CGUIDialogBusyNoCancel(void);
+  ~CGUIDialogBusyNoCancel(void) override;
+  void DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
+  void Render() override;
+
+protected:
+  void Open_Internal(bool bProcessRenderLoop, const std::string& param = "") override;
+  bool m_bLastVisible = false;
+};
diff --git a/xbmc/dialogs/GUIDialogButtonMenu.cpp b/xbmc/dialogs/GUIDialogButtonMenu.cpp
new file mode 100644
index 0000000..04ed916
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogButtonMenu.cpp
@@ -0,0 +1,46 @@
+/*
+ *  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 "GUIDialogButtonMenu.h"
+
+#include "guilib/GUIMessage.h"
+
+#define CONTROL_BUTTON_LABEL  3100
+
+CGUIDialogButtonMenu::CGUIDialogButtonMenu(int id, const std::string &xmlFile)
+: CGUIDialog(id, xmlFile.c_str())
+{
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogButtonMenu::~CGUIDialogButtonMenu(void) = default;
+
+bool CGUIDialogButtonMenu::OnMessage(CGUIMessage &message)
+{
+  bool bRet = CGUIDialog::OnMessage(message);
+  if (message.GetMessage() == GUI_MSG_CLICKED)
+  {
+    // someone has been clicked - deinit...
+    Close();
+    return true;
+  }
+  return bRet;
+}
+
+void CGUIDialogButtonMenu::FrameMove()
+{
+  // get the active control, and put it's label into the label control
+  const CGUIControl *pControl = GetFocusedControl();
+  if (pControl && (pControl->GetControlType() == CGUIControl::GUICONTROL_BUTTON ||
+                   pControl->GetControlType() == CGUIControl::GUICONTROL_TOGGLEBUTTON ||
+                   pControl->GetControlType() == CGUIControl::GUICONTROL_COLORBUTTON))
+  {
+    SET_CONTROL_LABEL(CONTROL_BUTTON_LABEL, pControl->GetDescription());
+  }
+  CGUIDialog::FrameMove();
+}
diff --git a/xbmc/dialogs/GUIDialogButtonMenu.h b/xbmc/dialogs/GUIDialogButtonMenu.h
new file mode 100644
index 0000000..60cb10c
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogButtonMenu.h
@@ -0,0 +1,21 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogButtonMenu :
+      public CGUIDialog
+{
+public:
+  CGUIDialogButtonMenu(int id = WINDOW_DIALOG_BUTTON_MENU, const std::string &xmlFile = "DialogButtonMenu.xml");
+  ~CGUIDialogButtonMenu(void) override;
+  bool OnMessage(CGUIMessage &message) override;
+  void FrameMove() override;
+};
diff --git a/xbmc/dialogs/GUIDialogCache.cpp b/xbmc/dialogs/GUIDialogCache.cpp
new file mode 100644
index 0000000..6ec8b20
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogCache.cpp
@@ -0,0 +1,178 @@
+/*
+ *  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 "GUIDialogCache.h"
+
+#include "ServiceBroker.h"
+#include "dialogs/GUIDialogProgress.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "messaging/ApplicationMessenger.h"
+#include "threads/SystemClock.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+#include <mutex>
+
+using namespace std::chrono_literals;
+
+CGUIDialogCache::CGUIDialogCache(std::chrono::milliseconds delay,
+                                 const std::string& strHeader,
+                                 const std::string& strMsg)
+  : CThread("GUIDialogCache"), m_strHeader(strHeader), m_strLinePrev(strMsg)
+{
+  bSentCancel = false;
+
+  m_pDlg = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
+
+  if (!m_pDlg)
+    return;
+
+  /* if progress dialog is already running, take it over */
+  if( m_pDlg->IsDialogRunning() )
+    delay = 0ms;
+
+  if (delay == 0ms)
+    OpenDialog();
+  else
+    m_endtime.Set(delay);
+
+  Create(true);
+}
+
+void CGUIDialogCache::Close(bool bForceClose)
+{
+  bSentCancel = true;
+
+  // we cannot wait for the app thread to process the close message
+  // as this might happen during player startup which leads to a deadlock
+  if (m_pDlg && m_pDlg->IsDialogRunning())
+    CServiceBroker::GetAppMessenger()->PostMsg(TMSG_GUI_WINDOW_CLOSE, -1, bForceClose ? 1 : 0,
+                                               static_cast<void*>(m_pDlg));
+
+  //Set stop, this will kill this object, when thread stops
+  CThread::m_bStop = true;
+}
+
+CGUIDialogCache::~CGUIDialogCache()
+{
+  if(m_pDlg && m_pDlg->IsDialogRunning())
+    m_pDlg->Close();
+}
+
+void CGUIDialogCache::OpenDialog()
+{
+  if (m_pDlg)
+  {
+    if (m_strHeader.empty())
+      m_pDlg->SetHeading(CVariant{438});
+    else
+      m_pDlg->SetHeading(CVariant{m_strHeader});
+
+    m_pDlg->SetLine(2, CVariant{m_strLinePrev});
+    m_pDlg->Open();
+  }
+  bSentCancel = false;
+}
+
+void CGUIDialogCache::SetHeader(const std::string& strHeader)
+{
+  m_strHeader = strHeader;
+}
+
+void CGUIDialogCache::SetHeader(int nHeader)
+{
+  SetHeader(g_localizeStrings.Get(nHeader));
+}
+
+void CGUIDialogCache::SetMessage(const std::string& strMessage)
+{
+  if (m_pDlg)
+  {
+    m_pDlg->SetLine(0, CVariant{m_strLinePrev2});
+    m_pDlg->SetLine(1, CVariant{m_strLinePrev});
+    m_pDlg->SetLine(2, CVariant{strMessage});
+  }
+  m_strLinePrev2 = m_strLinePrev;
+  m_strLinePrev = strMessage;
+}
+
+bool CGUIDialogCache::OnFileCallback(void* pContext, int ipercent, float avgSpeed)
+{
+  if (m_pDlg)
+  {
+    m_pDlg->ShowProgressBar(true);
+    m_pDlg->SetPercentage(ipercent);
+  }
+
+  if( IsCanceled() )
+    return false;
+  else
+    return true;
+}
+
+void CGUIDialogCache::Process()
+{
+  if (!m_pDlg)
+    return;
+
+  while( true )
+  {
+
+    { //Section to make the lock go out of scope before sleep
+
+      if( CThread::m_bStop ) break;
+
+      try
+      {
+        std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
+        m_pDlg->Progress();
+        if( bSentCancel )
+        {
+          CThread::Sleep(10ms);
+          continue;
+        }
+
+        if(m_pDlg->IsCanceled())
+        {
+          bSentCancel = true;
+        }
+        else if( !m_pDlg->IsDialogRunning() && m_endtime.IsTimePast()
+              && !CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(WINDOW_DIALOG_YES_NO) )
+          OpenDialog();
+      }
+      catch(...)
+      {
+        CLog::Log(LOGERROR, "Exception in CGUIDialogCache::Process()");
+      }
+    }
+
+    CThread::Sleep(10ms);
+  }
+}
+
+void CGUIDialogCache::ShowProgressBar(bool bOnOff)
+{
+  if (m_pDlg)
+    m_pDlg->ShowProgressBar(bOnOff);
+}
+
+void CGUIDialogCache::SetPercentage(int iPercentage)
+{
+  if (m_pDlg)
+    m_pDlg->SetPercentage(iPercentage);
+}
+
+bool CGUIDialogCache::IsCanceled() const
+{
+  if (m_pDlg && m_pDlg->IsDialogRunning())
+    return m_pDlg->IsCanceled();
+  else
+    return false;
+}
diff --git a/xbmc/dialogs/GUIDialogCache.h b/xbmc/dialogs/GUIDialogCache.h
new file mode 100644
index 0000000..3166cbe
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogCache.h
@@ -0,0 +1,48 @@
+/*
+ *  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 "filesystem/IFileTypes.h"
+#include "threads/SystemClock.h"
+#include "threads/Thread.h"
+
+#include <string>
+
+class CGUIDialogProgress;
+
+class CGUIDialogCache : public CThread, public XFILE::IFileCallback
+{
+public:
+  CGUIDialogCache(std::chrono::milliseconds delay = std::chrono::milliseconds(100),
+                  const std::string& strHeader = "",
+                  const std::string& strMsg = "");
+  ~CGUIDialogCache() override;
+  void SetHeader(const std::string& strHeader);
+  void SetHeader(int nHeader);
+  void SetMessage(const std::string& strMessage);
+  bool IsCanceled() const;
+  void ShowProgressBar(bool bOnOff);
+  void SetPercentage(int iPercentage);
+
+  void Close(bool bForceClose = false);
+
+  void Process() override;
+  bool OnFileCallback(void* pContext, int ipercent, float avgSpeed) override;
+
+protected:
+
+  void OpenDialog();
+
+  XbmcThreads::EndTime<> m_endtime;
+  CGUIDialogProgress* m_pDlg;
+  std::string m_strHeader;
+  std::string m_strLinePrev;
+  std::string m_strLinePrev2;
+  bool bSentCancel;
+};
diff --git a/xbmc/dialogs/GUIDialogColorPicker.cpp b/xbmc/dialogs/GUIDialogColorPicker.cpp
new file mode 100644
index 0000000..77cee11
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogColorPicker.cpp
@@ -0,0 +1,260 @@
+/*
+ *  Copyright (C) 2005-2021 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 "GUIDialogColorPicker.h"
+
+#include "FileItem.h"
+#include "filesystem/SpecialProtocol.h"
+#include "guilib/GUIColorManager.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "utils/ColorUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#define CONTROL_HEADING 1
+#define CONTROL_NUMBER_OF_ITEMS 2
+#define CONTROL_ICON_LIST 6
+#define CONTROL_CANCEL_BUTTON 7
+
+CGUIDialogColorPicker::CGUIDialogColorPicker()
+  : CGUIDialogBoxBase(WINDOW_DIALOG_COLOR_PICKER, "DialogColorPicker.xml"),
+    m_vecList(new CFileItemList()),
+    m_focusToButton(false)
+{
+  m_bConfirmed = false;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogColorPicker::~CGUIDialogColorPicker()
+{
+  delete m_vecList;
+}
+
+bool CGUIDialogColorPicker::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      CGUIDialogBoxBase::OnMessage(message);
+      m_selectedColor.clear();
+      for (int i = 0; i < m_vecList->Size(); i++)
+      {
+        CFileItemPtr item = m_vecList->Get(i);
+        if (item->IsSelected())
+        {
+          m_selectedColor = item->GetLabel2();
+          break;
+        }
+      }
+      m_vecList->Clear();
+      return true;
+    }
+    break;
+
+    case GUI_MSG_WINDOW_INIT:
+    {
+      m_bConfirmed = false;
+      CGUIDialogBoxBase::OnMessage(message);
+      return true;
+    }
+    break;
+
+    case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      if (m_viewControl.HasControl(CONTROL_ICON_LIST))
+      {
+        int iAction = message.GetParam1();
+        if (ACTION_SELECT_ITEM == iAction || ACTION_MOUSE_LEFT_CLICK == iAction)
+        {
+          int iSelected = m_viewControl.GetSelectedItem();
+          if (iSelected >= 0 && iSelected < m_vecList->Size())
+          {
+            CFileItemPtr item(m_vecList->Get(iSelected));
+            for (int i = 0; i < m_vecList->Size(); i++)
+              m_vecList->Get(i)->Select(false);
+            item->Select(true);
+            OnSelect(iSelected);
+          }
+        }
+      }
+      if (iControl == CONTROL_CANCEL_BUTTON)
+      {
+        m_selectedColor.clear();
+        m_vecList->Clear();
+        m_bConfirmed = false;
+        Close();
+      }
+    }
+    break;
+
+    case GUI_MSG_SETFOCUS:
+    {
+      if (m_viewControl.HasControl(message.GetControlId()))
+      {
+        if (m_vecList->IsEmpty())
+        {
+          SET_CONTROL_FOCUS(CONTROL_CANCEL_BUTTON, 0);
+          return true;
+        }
+        if (m_viewControl.GetCurrentControl() != message.GetControlId())
+        {
+          m_viewControl.SetFocused();
+          return true;
+        }
+      }
+    }
+    break;
+  }
+
+  return CGUIDialogBoxBase::OnMessage(message);
+}
+
+void CGUIDialogColorPicker::OnSelect(int idx)
+{
+  m_bConfirmed = true;
+  Close();
+}
+
+bool CGUIDialogColorPicker::OnBack(int actionID)
+{
+  m_vecList->Clear();
+  m_bConfirmed = false;
+  return CGUIDialogBoxBase::OnBack(actionID);
+}
+
+void CGUIDialogColorPicker::Reset()
+{
+  m_focusToButton = false;
+  m_selectedColor.clear();
+  m_vecList->Clear();
+}
+
+void CGUIDialogColorPicker::AddItem(const CFileItem& item)
+{
+  m_vecList->Add(CFileItemPtr(new CFileItem(item)));
+}
+
+void CGUIDialogColorPicker::SetItems(const CFileItemList& pList)
+{
+  // need to make internal copy of list to be sure dialog is owner of it
+  m_vecList->Clear();
+  m_vecList->Copy(pList);
+}
+
+void CGUIDialogColorPicker::LoadColors()
+{
+  LoadColors(CSpecialProtocol::TranslatePathConvertCase("special://xbmc/system/dialogcolors.xml"));
+}
+
+void CGUIDialogColorPicker::LoadColors(const std::string& filePath)
+{
+  CGUIColorManager colorManager;
+  std::vector<std::pair<std::string, UTILS::COLOR::ColorInfo>> colors;
+  if (colorManager.LoadColorsListFromXML(filePath, colors, true))
+  {
+    for (auto& color : colors)
+    {
+      CFileItem* item = new CFileItem(color.first);
+      item->SetLabel2(StringUtils::Format("{:08X}", color.second.colorARGB));
+      m_vecList->Add(CFileItemPtr(item));
+    }
+  }
+  else
+    CLog::Log(LOGERROR, "{} - An error occurred when loading colours from the xml file.",
+              __FUNCTION__);
+}
+
+std::string CGUIDialogColorPicker::GetSelectedColor() const
+{
+  return m_selectedColor;
+}
+
+int CGUIDialogColorPicker::GetSelectedItem() const
+{
+  if (m_selectedColor.empty())
+    return -1;
+  for (int index = 0; index < m_vecList->Size(); index++)
+  {
+    if (StringUtils::CompareNoCase(m_selectedColor, m_vecList->Get(index)->GetLabel2()) == 0)
+    {
+      return index;
+    }
+  }
+  return -1;
+}
+
+void CGUIDialogColorPicker::SetSelectedColor(const std::string& colorHex)
+{
+  m_selectedColor = colorHex;
+}
+
+void CGUIDialogColorPicker::SetButtonFocus(bool buttonFocus)
+{
+  m_focusToButton = buttonFocus;
+}
+
+CGUIControl* CGUIDialogColorPicker::GetFirstFocusableControl(int id)
+{
+  if (m_viewControl.HasControl(id))
+    id = m_viewControl.GetCurrentControl();
+  return CGUIDialogBoxBase::GetFirstFocusableControl(id);
+}
+
+void CGUIDialogColorPicker::OnWindowLoaded()
+{
+  CGUIDialogBoxBase::OnWindowLoaded();
+  m_viewControl.Reset();
+  m_viewControl.SetParentWindow(GetID());
+  m_viewControl.AddView(GetControl(CONTROL_ICON_LIST));
+}
+
+void CGUIDialogColorPicker::OnInitWindow()
+{
+  if (!m_vecList || m_vecList->IsEmpty())
+    CLog::Log(LOGERROR, "{} - No colours have been added in the list.", __FUNCTION__);
+
+  m_viewControl.SetItems(*m_vecList);
+  m_viewControl.SetCurrentView(CONTROL_ICON_LIST);
+
+  SET_CONTROL_LABEL(CONTROL_NUMBER_OF_ITEMS,
+                    StringUtils::Format("{} {}", m_vecList->Size(), g_localizeStrings.Get(127)));
+
+  SET_CONTROL_LABEL(CONTROL_CANCEL_BUTTON, g_localizeStrings.Get(222));
+
+  CGUIDialogBoxBase::OnInitWindow();
+
+  // focus one of the buttons if explicitly requested
+  // ATTENTION: this must be done after calling CGUIDialogBoxBase::OnInitWindow()
+  if (m_focusToButton)
+  {
+    SET_CONTROL_FOCUS(CONTROL_CANCEL_BUTTON, 0);
+  }
+
+  // if nothing is selected, select first item
+  m_viewControl.SetSelectedItem(std::max(GetSelectedItem(), 0));
+}
+
+void CGUIDialogColorPicker::OnDeinitWindow(int nextWindowID)
+{
+  m_viewControl.Clear();
+  CGUIDialogBoxBase::OnDeinitWindow(nextWindowID);
+}
+
+void CGUIDialogColorPicker::OnWindowUnload()
+{
+  CGUIDialogBoxBase::OnWindowUnload();
+  m_viewControl.Reset();
+}
diff --git a/xbmc/dialogs/GUIDialogColorPicker.h b/xbmc/dialogs/GUIDialogColorPicker.h
new file mode 100644
index 0000000..1e7c65d
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogColorPicker.h
@@ -0,0 +1,64 @@
+/*
+ *  Copyright (C) 2005-2021 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 "GUIDialogBoxBase.h"
+#include "view/GUIViewControl.h"
+
+#include <string>
+
+class CFileItem;
+class CFileItemList;
+
+class CGUIDialogColorPicker : public CGUIDialogBoxBase
+{
+public:
+  CGUIDialogColorPicker();
+  ~CGUIDialogColorPicker() override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+  void Reset();
+  /*! \brief Add a color item (Label property must be the color name, Label2 property must be the color hex)
+      \param item The CFileItem
+  */
+  void AddItem(const CFileItem& item);
+  /*! \brief Set a list of color items (Label property must be the color name, Label2 property must be the color hex)
+      \param pList The CFileItemList
+  */
+  void SetItems(const CFileItemList& pList);
+  /*! \brief Load a list of colors from the default xml */
+  void LoadColors();
+  /*! \brief Load a list of colors from the specified xml file path
+      \param filePath The xml file path
+  */
+  void LoadColors(const std::string& filePath);
+  /*! \brief Get the hex value of the selected color */
+  std::string GetSelectedColor() const;
+  /*! \brief Set the selected color by hex value */
+  void SetSelectedColor(const std::string& hexColor);
+  /*! \brief Set the focus to the control button */
+  void SetButtonFocus(bool buttonFocus);
+
+protected:
+  CGUIControl* GetFirstFocusableControl(int id) override;
+  void OnWindowLoaded() override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+  void OnWindowUnload() override;
+
+  virtual void OnSelect(int idx);
+
+private:
+  int GetSelectedItem() const;
+
+  CGUIViewControl m_viewControl;
+  CFileItemList* m_vecList;
+  bool m_focusToButton;
+  std::string m_selectedColor;
+};
diff --git a/xbmc/dialogs/GUIDialogContextMenu.cpp b/xbmc/dialogs/GUIDialogContextMenu.cpp
new file mode 100644
index 0000000..dcc9ede
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogContextMenu.cpp
@@ -0,0 +1,705 @@
+/*
+ *  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 "GUIDialogContextMenu.h"
+
+#include "FileItem.h"
+#include "GUIDialogFileBrowser.h"
+#include "GUIDialogMediaSource.h"
+#include "GUIDialogYesNo.h"
+#include "GUIPassword.h"
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "TextureDatabase.h"
+#include "URL.h"
+#include "Util.h"
+#include "addons/Scraper.h"
+#include "favourites/FavouritesService.h"
+#include "guilib/GUIButtonControl.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIControlGroupList.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "media/MediaLockState.h"
+#include "profiles/ProfileManager.h"
+#include "profiles/dialogs/GUIDialogLockSettings.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "storage/MediaManager.h"
+#include "utils/FileUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+
+#define BACKGROUND_IMAGE       999
+#define GROUP_LIST             996
+#define BUTTON_TEMPLATE       1000
+#define BUTTON_START          1001
+#define BUTTON_END            (BUTTON_START + (int)m_buttons.size() - 1)
+
+void CContextButtons::Add(unsigned int button, const std::string &label)
+{
+  for (const auto& i : *this)
+    if (i.first == button)
+      return; // already have this button
+  push_back(std::pair<unsigned int, std::string>(button, label));
+}
+
+void CContextButtons::Add(unsigned int button, int label)
+{
+  for (const auto& i : *this)
+    if (i.first == button)
+      return; // already have added this button
+  push_back(std::pair<unsigned int, std::string>(button, g_localizeStrings.Get(label)));
+}
+
+CGUIDialogContextMenu::CGUIDialogContextMenu(void)
+  : CGUIDialog(WINDOW_DIALOG_CONTEXT_MENU, "DialogContextMenu.xml")
+{
+  m_clickedButton = -1;
+  m_backgroundImageSize = 0;
+  m_loadType = KEEP_IN_MEMORY;
+  m_coordX = 0.0f;
+  m_coordY = 0.0f;
+}
+
+CGUIDialogContextMenu::~CGUIDialogContextMenu(void) = default;
+
+bool CGUIDialogContextMenu::OnMessage(CGUIMessage &message)
+{
+  if (message.GetMessage() == GUI_MSG_CLICKED)
+  { // someone has been clicked - deinit...
+    if (message.GetSenderId() >= BUTTON_START && message.GetSenderId() <= BUTTON_END)
+      m_clickedButton = message.GetSenderId() - BUTTON_START;
+    Close();
+    return true;
+  }
+  else if (message.GetMessage() == GUI_MSG_PLAYBACK_AVSTARTED)
+  {
+    // playback was just started from elsewhere - close the dialog
+    Close();
+    return true;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+bool CGUIDialogContextMenu::OnAction(const CAction& action)
+{
+  if (action.GetID() == ACTION_CONTEXT_MENU ||
+      action.GetID() == ACTION_SWITCH_PLAYER)
+  {
+    Close();
+    return true;
+  }
+
+  return CGUIDialog::OnAction(action);
+}
+
+void CGUIDialogContextMenu::OnInitWindow()
+{
+  m_clickedButton = -1;
+  // set initial control focus
+  m_lastControlID = m_initiallyFocusedButtonIdx + BUTTON_START;
+  CGUIDialog::OnInitWindow();
+}
+
+void CGUIDialogContextMenu::SetupButtons()
+{
+  if (!m_buttons.size())
+    return;
+
+  // disable the template button control
+  CGUIButtonControl *pButtonTemplate = dynamic_cast<CGUIButtonControl *>(GetFirstFocusableControl(BUTTON_TEMPLATE));
+  if (!pButtonTemplate)
+    pButtonTemplate = dynamic_cast<CGUIButtonControl *>(GetControl(BUTTON_TEMPLATE));
+  if (!pButtonTemplate)
+    return;
+  pButtonTemplate->SetVisible(false);
+
+  CGUIControlGroupList* pGroupList = dynamic_cast<CGUIControlGroupList *>(GetControl(GROUP_LIST));
+
+  // add our buttons
+  if (pGroupList)
+  {
+    for (unsigned int i = 0; i < m_buttons.size(); i++)
+    {
+      CGUIButtonControl* pButton = new CGUIButtonControl(*pButtonTemplate);
+      if (pButton)
+      { // set the button's ID and position
+        int id = BUTTON_START + i;
+        pButton->SetID(id);
+        pButton->SetVisible(true);
+        pButton->SetLabel(m_buttons[i].second);
+        pButton->SetPosition(pButtonTemplate->GetXPosition(), pButtonTemplate->GetYPosition());
+        // try inserting context buttons at position specified by template
+        // button, if template button is not in grouplist fallback to adding
+        // new buttons at the end of grouplist
+        if (!pGroupList->InsertControl(pButton, pButtonTemplate))
+          pGroupList->AddControl(pButton);
+      }
+    }
+  }
+
+  // fix up background images placement and size
+  CGUIControl *pControl = GetControl(BACKGROUND_IMAGE);
+  if (pControl)
+  {
+    // first set size of background image
+    if (pGroupList)
+    {
+      if (pGroupList->GetOrientation() == VERTICAL)
+      {
+        // keep gap between bottom edges of grouplist and background image
+        pControl->SetHeight(m_backgroundImageSize - pGroupList->Size() + pGroupList->GetHeight());
+      }
+      else
+      {
+        // keep gap between right edges of grouplist and background image
+        pControl->SetWidth(m_backgroundImageSize - pGroupList->Size() + pGroupList->GetWidth());
+      }
+    }
+  }
+
+  // update our default control
+  if (pGroupList)
+    m_defaultControl = pGroupList->GetID();
+}
+
+void CGUIDialogContextMenu::SetPosition(float posX, float posY)
+{
+  if (posY + GetHeight() > m_coordsRes.iHeight)
+    posY = m_coordsRes.iHeight - GetHeight();
+  if (posY < 0) posY = 0;
+  if (posX + GetWidth() > m_coordsRes.iWidth)
+    posX = m_coordsRes.iWidth - GetWidth();
+  if (posX < 0) posX = 0;
+  CGUIDialog::SetPosition(posX, posY);
+}
+
+float CGUIDialogContextMenu::GetHeight() const
+{
+  if (m_backgroundImage)
+    return m_backgroundImage->GetHeight();
+  else
+    return CGUIDialog::GetHeight();
+}
+
+float CGUIDialogContextMenu::GetWidth() const
+{
+  if (m_backgroundImage)
+    return m_backgroundImage->GetWidth();
+  else
+    return CGUIDialog::GetWidth();
+}
+
+bool CGUIDialogContextMenu::SourcesMenu(const std::string &strType, const CFileItemPtr& item, float posX, float posY)
+{
+  //! @todo This should be callable even if we don't have any valid items
+  if (!item)
+    return false;
+
+  // grab our context menu
+  CContextButtons buttons;
+  GetContextButtons(strType, item, buttons);
+
+  int button = ShowAndGetChoice(buttons);
+  if (button >= 0)
+    return OnContextButton(strType, item, (CONTEXT_BUTTON)button);
+  return false;
+}
+
+void CGUIDialogContextMenu::GetContextButtons(const std::string &type, const CFileItemPtr& item, CContextButtons &buttons)
+{
+  // Add buttons to the ContextMenu that should be visible for both sources and autosourced items
+  // Optical removable drives automatically have the static Eject button added (see CEjectDisk).
+  // Here we only add the eject button to HDD drives
+  if (item && item->IsRemovable() && !item->IsDVD() && !item->IsCDDA())
+  {
+    buttons.Add(CONTEXT_BUTTON_EJECT_DRIVE, 13420); // Remove safely
+  }
+
+  // Next, Add buttons to the ContextMenu that should ONLY be visible for sources and not autosourced items
+  CMediaSource *share = GetShare(type, item.get());
+
+  if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() || g_passwordManager.bMasterUser)
+  {
+    if (share)
+    {
+      // Note. from now on, remove source & disable plugin should mean the same thing
+      //! @todo might be smart to also combine editing source & plugin settings into one concept/dialog
+      // Note. Temporarily disabled ability to remove plugin sources until installer is operational
+
+      CURL url(share->strPath);
+      bool isAddon = ADDON::TranslateContent(url.GetProtocol()) != CONTENT_NONE;
+      if (!share->m_ignore && !isAddon)
+        buttons.Add(CONTEXT_BUTTON_EDIT_SOURCE, 1027); // Edit Source
+      if (type != "video")
+        buttons.Add(CONTEXT_BUTTON_SET_DEFAULT, 13335); // Set as Default
+      if (!share->m_ignore && !isAddon)
+        buttons.Add(CONTEXT_BUTTON_REMOVE_SOURCE, 522); // Remove Source
+
+      buttons.Add(CONTEXT_BUTTON_SET_THUMB, 20019);
+    }
+    if (!GetDefaultShareNameByType(type).empty())
+      buttons.Add(CONTEXT_BUTTON_CLEAR_DEFAULT, 13403); // Clear Default
+  }
+  if (share && LOCK_MODE_EVERYONE != CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetMasterProfile().getLockMode())
+  {
+    if (share->m_iHasLock == LOCK_STATE_NO_LOCK && (CServiceBroker::GetSettingsComponent()
+                                                        ->GetProfileManager()
+                                                        ->GetCurrentProfile()
+                                                        .canWriteSources() ||
+                                                    g_passwordManager.bMasterUser))
+      buttons.Add(CONTEXT_BUTTON_ADD_LOCK, 12332);
+    else if (share->m_iHasLock == LOCK_STATE_LOCK_BUT_UNLOCKED)
+      buttons.Add(CONTEXT_BUTTON_REMOVE_LOCK, 12335);
+    else if (share->m_iHasLock == LOCK_STATE_LOCKED)
+    {
+      buttons.Add(CONTEXT_BUTTON_REMOVE_LOCK, 12335);
+
+      bool maxRetryExceeded = false;
+      if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES) != 0)
+        maxRetryExceeded = (share->m_iBadPwdCount >= CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES));
+
+      if (maxRetryExceeded)
+        buttons.Add(CONTEXT_BUTTON_RESET_LOCK, 12334);
+      else
+        buttons.Add(CONTEXT_BUTTON_CHANGE_LOCK, 12356);
+    }
+  }
+  if (share && !g_passwordManager.bMasterUser && item->m_iHasLock == LOCK_STATE_LOCK_BUT_UNLOCKED)
+    buttons.Add(CONTEXT_BUTTON_REACTIVATE_LOCK, 12353);
+}
+
+bool CGUIDialogContextMenu::OnContextButton(const std::string &type, const CFileItemPtr& item, CONTEXT_BUTTON button)
+{
+  // buttons that are available on both sources and autosourced items
+  if (!item)
+    return false;
+
+  switch (button)
+  {
+    case CONTEXT_BUTTON_EJECT_DRIVE:
+      return CServiceBroker::GetMediaManager().Eject(item->GetPath());
+    default:
+      break;
+  }
+
+  // the rest of the operations require a valid share
+  CMediaSource *share = GetShare(type, item.get());
+  if (!share)
+    return false;
+
+  switch (button)
+  {
+  case CONTEXT_BUTTON_EDIT_SOURCE:
+    if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->IsMasterProfile())
+    {
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+    }
+    else if (!g_passwordManager.IsProfileLockUnlocked())
+      return false;
+
+    return CGUIDialogMediaSource::ShowAndEditMediaSource(type, *share);
+
+  case CONTEXT_BUTTON_REMOVE_SOURCE:
+  {
+    if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->IsMasterProfile())
+    {
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+    }
+    else
+    {
+      if (!CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() && !g_passwordManager.IsMasterLockUnlocked(false))
+        return false;
+      if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() && !g_passwordManager.IsProfileLockUnlocked())
+        return false;
+    }
+    // prompt user if they want to really delete the source
+    if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{751}, CVariant{750}))
+      return false;
+
+    // check default before we delete, as deletion will kill the share object
+    std::string defaultSource(GetDefaultShareNameByType(type));
+    if (!defaultSource.empty())
+    {
+      if (share->strName == defaultSource)
+        ClearDefault(type);
+    }
+    CMediaSourceSettings::GetInstance().DeleteSource(type, share->strName, share->strPath);
+    return true;
+  }
+  case CONTEXT_BUTTON_SET_DEFAULT:
+    if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() && !g_passwordManager.IsProfileLockUnlocked())
+      return false;
+    else if (!g_passwordManager.IsMasterLockUnlocked(true))
+      return false;
+
+    // make share default
+    SetDefault(type, share->strName);
+    return true;
+
+  case CONTEXT_BUTTON_CLEAR_DEFAULT:
+    if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() && !g_passwordManager.IsProfileLockUnlocked())
+      return false;
+    else if (!g_passwordManager.IsMasterLockUnlocked(true))
+      return false;
+    // remove share default
+    ClearDefault(type);
+    return true;
+
+  case CONTEXT_BUTTON_SET_THUMB:
+    {
+      if (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().canWriteSources() && !g_passwordManager.IsProfileLockUnlocked())
+        return false;
+      else if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+
+      // setup our thumb list
+      CFileItemList items;
+
+      // add the current thumb, if available
+      if (!share->m_strThumbnailImage.empty())
+      {
+        CFileItemPtr current(new CFileItem("thumb://Current", false));
+        current->SetArt("thumb", share->m_strThumbnailImage);
+        current->SetLabel(g_localizeStrings.Get(20016));
+        items.Add(current);
+      }
+      else if (item->HasArt("thumb"))
+      { // already have a thumb that the share doesn't know about - must be a local one, so we mayaswell reuse it.
+        CFileItemPtr current(new CFileItem("thumb://Current", false));
+        current->SetArt("thumb", item->GetArt("thumb"));
+        current->SetLabel(g_localizeStrings.Get(20016));
+        items.Add(current);
+      }
+      // see if there's a local thumb for this item
+      std::string folderThumb = item->GetFolderThumb();
+      if (CFileUtils::Exists(folderThumb))
+      {
+        CFileItemPtr local(new CFileItem("thumb://Local", false));
+        local->SetArt("thumb", folderThumb);
+        local->SetLabel(g_localizeStrings.Get(20017));
+        items.Add(local);
+      }
+      // and add a "no thumb" entry as well
+      CFileItemPtr nothumb(new CFileItem("thumb://None", false));
+      nothumb->SetArt("icon", item->GetArt("icon"));
+      nothumb->SetLabel(g_localizeStrings.Get(20018));
+      items.Add(nothumb);
+
+      std::string strThumb;
+      VECSOURCES shares;
+      CServiceBroker::GetMediaManager().GetLocalDrives(shares);
+      if (!CGUIDialogFileBrowser::ShowAndGetImage(items, shares, g_localizeStrings.Get(1030), strThumb))
+        return false;
+
+      if (strThumb == "thumb://Current")
+        return true;
+
+      if (strThumb == "thumb://Local")
+        strThumb = folderThumb;
+
+      if (strThumb == "thumb://None")
+        strThumb = "";
+
+      if (!share->m_ignore)
+      {
+        CMediaSourceSettings::GetInstance().UpdateSource(type,share->strName,"thumbnail",strThumb);
+        CMediaSourceSettings::GetInstance().Save();
+      }
+      else if (!strThumb.empty())
+      { // this is some sort of an auto-share, so store in the texture database
+        CTextureDatabase db;
+        if (db.Open())
+          db.SetTextureForPath(item->GetPath(), "thumb", strThumb);
+      }
+
+      CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+      return true;
+    }
+
+  case CONTEXT_BUTTON_ADD_LOCK:
+    {
+      // prompt user for mastercode when changing lock settings) only for default user
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+
+      std::string strNewPassword = "";
+      if (!CGUIDialogLockSettings::ShowAndGetLock(share->m_iLockMode,strNewPassword))
+        return false;
+      // password entry and re-entry succeeded, write out the lock data
+      share->m_iHasLock = LOCK_STATE_LOCKED;
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockcode", strNewPassword);
+      strNewPassword = std::to_string(share->m_iLockMode);
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockmode", strNewPassword);
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "badpwdcount", "0");
+      CMediaSourceSettings::GetInstance().Save();
+
+      // lock of a mediasource has been added
+      // => refresh favourites due to possible visibility changes
+      CServiceBroker::GetFavouritesService().RefreshFavourites();
+
+      CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+      return true;
+    }
+  case CONTEXT_BUTTON_RESET_LOCK:
+    {
+      // prompt user for profile lock when changing lock settings
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "badpwdcount", "0");
+      CMediaSourceSettings::GetInstance().Save();
+      CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+      return true;
+    }
+  case CONTEXT_BUTTON_REMOVE_LOCK:
+    {
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+
+      // prompt user if they want to really remove the lock
+      if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{12335}, CVariant{750}))
+        return false;
+
+      share->m_iHasLock = LOCK_STATE_NO_LOCK;
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockmode", "0");
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockcode", "0");
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "badpwdcount", "0");
+      CMediaSourceSettings::GetInstance().Save();
+
+      // lock of a mediasource has been removed
+      // => refresh favourites due to possible visibility changes
+      CServiceBroker::GetFavouritesService().RefreshFavourites();
+
+      CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+      return true;
+    }
+  case CONTEXT_BUTTON_REACTIVATE_LOCK:
+    {
+      bool maxRetryExceeded = false;
+      if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES) != 0)
+        maxRetryExceeded = (share->m_iBadPwdCount >= CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MASTERLOCK_MAXRETRIES));
+      if (!maxRetryExceeded)
+      {
+        // don't prompt user for mastercode when reactivating a lock
+        g_passwordManager.LockSource(type, share->strName, true);
+
+        // lock of a mediasource has been reactivated
+        // => refresh favourites due to possible visibility changes
+        CServiceBroker::GetFavouritesService().RefreshFavourites();
+        return true;
+      }
+      return false;
+    }
+  case CONTEXT_BUTTON_CHANGE_LOCK:
+    {
+      if (!g_passwordManager.IsMasterLockUnlocked(true))
+        return false;
+
+      std::string strNewPW;
+      std::string strNewLockMode;
+      if (CGUIDialogLockSettings::ShowAndGetLock(share->m_iLockMode,strNewPW))
+        strNewLockMode = std::to_string(share->m_iLockMode);
+      else
+        return false;
+      // password ReSet and re-entry succeeded, write out the lock data
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockcode", strNewPW);
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "lockmode", strNewLockMode);
+      CMediaSourceSettings::GetInstance().UpdateSource(type, share->strName, "badpwdcount", "0");
+      CMediaSourceSettings::GetInstance().Save();
+
+      // lock of a mediasource has been changed
+      // => refresh favourites due to possible visibility changes
+      CServiceBroker::GetFavouritesService().RefreshFavourites();
+
+      CGUIMessage msg(GUI_MSG_NOTIFY_ALL,0,0,GUI_MSG_UPDATE_SOURCES);
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+      return true;
+    }
+  default:
+    break;
+  }
+  return false;
+}
+
+CMediaSource *CGUIDialogContextMenu::GetShare(const std::string &type, const CFileItem *item)
+{
+  VECSOURCES *shares = CMediaSourceSettings::GetInstance().GetSources(type);
+  if (!shares || !item)
+    return nullptr;
+  for (unsigned int i = 0; i < shares->size(); i++)
+  {
+    CMediaSource &testShare = shares->at(i);
+    if (URIUtils::IsDVD(testShare.strPath))
+    {
+      if (!item->IsDVD())
+        continue;
+    }
+    else
+    {
+      if (!URIUtils::CompareWithoutSlashAtEnd(testShare.strPath, item->GetPath()))
+        continue;
+    }
+    // paths match, what about share name - only match the leftmost
+    // characters as the label may contain other info (status for instance)
+    if (StringUtils::StartsWithNoCase(item->GetLabel(), testShare.strName))
+    {
+      return &testShare;
+    }
+  }
+  return nullptr;
+}
+
+void CGUIDialogContextMenu::OnWindowLoaded()
+{
+  m_coordX = m_posX;
+  m_coordY = m_posY;
+
+  const CGUIControlGroupList* pGroupList = dynamic_cast<const CGUIControlGroupList *>(GetControl(GROUP_LIST));
+  m_backgroundImage = GetControl(BACKGROUND_IMAGE);
+  if (m_backgroundImage && pGroupList)
+  {
+    if (pGroupList->GetOrientation() == VERTICAL)
+      m_backgroundImageSize = m_backgroundImage->GetHeight();
+    else
+      m_backgroundImageSize = m_backgroundImage->GetWidth();
+  }
+
+  CGUIDialog::OnWindowLoaded();
+}
+
+void CGUIDialogContextMenu::OnDeinitWindow(int nextWindowID)
+{
+  //we can't be sure that controls are removed on window unload
+  //we have to remove them to be sure that they won't stay for next use of context menu
+  for (unsigned int i = 0; i < m_buttons.size(); i++)
+  {
+    const CGUIControl *control = GetControl(BUTTON_START + i);
+    if (control)
+    {
+      RemoveControl(control);
+      delete control;
+    }
+  }
+
+  m_buttons.clear();
+  m_initiallyFocusedButtonIdx = 0;
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+}
+
+std::string CGUIDialogContextMenu::GetDefaultShareNameByType(const std::string &strType)
+{
+  VECSOURCES *pShares = CMediaSourceSettings::GetInstance().GetSources(strType);
+  std::string strDefault = CMediaSourceSettings::GetInstance().GetDefaultSource(strType);
+
+  if (!pShares) return "";
+
+  bool bIsSourceName(false);
+  int iIndex = CUtil::GetMatchingSource(strDefault, *pShares, bIsSourceName);
+  if (iIndex < 0 || iIndex >= (int)pShares->size())
+    return "";
+
+  return pShares->at(iIndex).strName;
+}
+
+void CGUIDialogContextMenu::SetDefault(const std::string &strType, const std::string &strDefault)
+{
+  CMediaSourceSettings::GetInstance().SetDefaultSource(strType, strDefault);
+  CMediaSourceSettings::GetInstance().Save();
+}
+
+void CGUIDialogContextMenu::ClearDefault(const std::string &strType)
+{
+  SetDefault(strType, "");
+}
+
+void CGUIDialogContextMenu::SwitchMedia(const std::string& strType, const std::string& strPath)
+{
+  // create menu
+  CContextButtons choices;
+  if (strType != "music")
+    choices.Add(WINDOW_MUSIC_NAV, 2);
+  if (strType != "video")
+    choices.Add(WINDOW_VIDEO_NAV, 3);
+  if (strType != "pictures")
+    choices.Add(WINDOW_PICTURES, 1);
+  if (strType != "files")
+    choices.Add(WINDOW_FILES, 7);
+
+  int window = ShowAndGetChoice(choices);
+  if (window >= 0)
+  {
+    CUtil::DeleteDirectoryCache();
+    CServiceBroker::GetGUI()->GetWindowManager().ChangeActiveWindow(window, strPath);
+  }
+}
+
+int CGUIDialogContextMenu::Show(const CContextButtons& choices, int focusedButtonIdx /* = 0 */)
+{
+  auto dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogContextMenu>(WINDOW_DIALOG_CONTEXT_MENU);
+  if (!dialog)
+    return -1;
+
+  dialog->m_buttons = choices;
+  dialog->Initialize();
+  dialog->SetInitialVisibility();
+  dialog->SetupButtons();
+  dialog->PositionAtCurrentFocus();
+  dialog->m_initiallyFocusedButtonIdx = focusedButtonIdx;
+  dialog->Open();
+  return dialog->m_clickedButton;
+}
+
+int CGUIDialogContextMenu::ShowAndGetChoice(const CContextButtons &choices)
+{
+  if (choices.empty())
+    return -1;
+
+  CGUIDialogContextMenu *pMenu = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogContextMenu>(WINDOW_DIALOG_CONTEXT_MENU);
+  if (pMenu)
+  {
+    pMenu->m_buttons = choices;
+    pMenu->Initialize();
+    pMenu->SetInitialVisibility();
+    pMenu->SetupButtons();
+    pMenu->PositionAtCurrentFocus();
+    pMenu->Open();
+
+    int idx = pMenu->m_clickedButton;
+    if (idx != -1)
+      return choices[idx].first;
+  }
+  return -1;
+}
+
+void CGUIDialogContextMenu::PositionAtCurrentFocus()
+{
+  CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog());
+  if (window)
+  {
+    const CGUIControl *focusedControl = window->GetFocusedControl();
+    if (focusedControl)
+    {
+      CPoint pos = focusedControl->GetRenderPosition() + CPoint(focusedControl->GetWidth() * 0.5f, focusedControl->GetHeight() * 0.5f);
+      SetPosition(m_coordX + pos.x - GetWidth() * 0.5f, m_coordY + pos.y - GetHeight() * 0.5f);
+      return;
+    }
+  }
+  // no control to center at, so just center the window
+  CenterWindow();
+}
diff --git a/xbmc/dialogs/GUIDialogContextMenu.h b/xbmc/dialogs/GUIDialogContextMenu.h
new file mode 100644
index 0000000..420e458
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogContextMenu.h
@@ -0,0 +1,152 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+
+class CMediaSource;
+
+enum CONTEXT_BUTTON { CONTEXT_BUTTON_CANCELLED = 0,
+                      CONTEXT_BUTTON_RENAME,
+                      CONTEXT_BUTTON_DELETE,
+                      CONTEXT_BUTTON_MOVE,
+                      CONTEXT_BUTTON_SETTINGS,
+                      CONTEXT_BUTTON_RIP_CD,
+                      CONTEXT_BUTTON_CANCEL_RIP_CD,
+                      CONTEXT_BUTTON_RIP_TRACK,
+                      CONTEXT_BUTTON_EJECT_DRIVE,
+                      CONTEXT_BUTTON_EDIT_SOURCE,
+                      CONTEXT_BUTTON_REMOVE_SOURCE,
+                      CONTEXT_BUTTON_SET_DEFAULT,
+                      CONTEXT_BUTTON_CLEAR_DEFAULT,
+                      CONTEXT_BUTTON_SET_THUMB,
+                      CONTEXT_BUTTON_ADD_LOCK,
+                      CONTEXT_BUTTON_REMOVE_LOCK,
+                      CONTEXT_BUTTON_CHANGE_LOCK,
+                      CONTEXT_BUTTON_RESET_LOCK,
+                      CONTEXT_BUTTON_REACTIVATE_LOCK,
+                      CONTEXT_BUTTON_VIEW_SLIDESHOW,
+                      CONTEXT_BUTTON_RECURSIVE_SLIDESHOW,
+                      CONTEXT_BUTTON_REFRESH_THUMBS,
+                      CONTEXT_BUTTON_SWITCH_MEDIA,
+                      CONTEXT_BUTTON_MOVE_ITEM,
+                      CONTEXT_BUTTON_MOVE_HERE,
+                      CONTEXT_BUTTON_CANCEL_MOVE,
+                      CONTEXT_BUTTON_MOVE_ITEM_UP,
+                      CONTEXT_BUTTON_MOVE_ITEM_DOWN,
+                      CONTEXT_BUTTON_CLEAR,
+                      CONTEXT_BUTTON_QUEUE_ITEM,
+                      CONTEXT_BUTTON_PLAY_ITEM,
+                      CONTEXT_BUTTON_PLAY_WITH,
+                      CONTEXT_BUTTON_PLAY_PARTYMODE,
+                      CONTEXT_BUTTON_PLAY_PART,
+                      CONTEXT_BUTTON_RESUME_ITEM,
+                      CONTEXT_BUTTON_EDIT,
+                      CONTEXT_BUTTON_EDIT_SMART_PLAYLIST,
+                      CONTEXT_BUTTON_INFO,
+                      CONTEXT_BUTTON_INFO_ALL,
+                      CONTEXT_BUTTON_CDDB,
+                      CONTEXT_BUTTON_SCAN,
+                      CONTEXT_BUTTON_SCAN_TO_LIBRARY,
+                      CONTEXT_BUTTON_SET_ARTIST_THUMB,
+                      CONTEXT_BUTTON_SET_SEASON_ART,
+                      CONTEXT_BUTTON_CANCEL_PARTYMODE,
+                      CONTEXT_BUTTON_MARK_WATCHED,
+                      CONTEXT_BUTTON_MARK_UNWATCHED,
+                      CONTEXT_BUTTON_SET_CONTENT,
+                      CONTEXT_BUTTON_EDIT_PARTYMODE,
+                      CONTEXT_BUTTON_LINK_MOVIE,
+                      CONTEXT_BUTTON_UNLINK_MOVIE,
+                      CONTEXT_BUTTON_GO_TO_ARTIST,
+                      CONTEXT_BUTTON_GO_TO_ALBUM,
+                      CONTEXT_BUTTON_PLAY_OTHER,
+                      CONTEXT_BUTTON_SET_ACTOR_THUMB,
+                      CONTEXT_BUTTON_UNLINK_BOOKMARK,
+                      CONTEXT_BUTTON_ACTIVATE,
+                      CONTEXT_BUTTON_GROUP_MANAGER,
+                      CONTEXT_BUTTON_CHANNEL_MANAGER,
+                      CONTEXT_BUTTON_SET_MOVIESET_ART,
+                      CONTEXT_BUTTON_PLAY_AND_QUEUE,
+                      CONTEXT_BUTTON_PLAY_ONLY_THIS,
+                      CONTEXT_BUTTON_UPDATE_EPG,
+                      CONTEXT_BUTTON_TAGS_ADD_ITEMS,
+                      CONTEXT_BUTTON_TAGS_REMOVE_ITEMS,
+                      CONTEXT_BUTTON_SET_MOVIESET,
+                      CONTEXT_BUTTON_MOVIESET_ADD_REMOVE_ITEMS,
+                      CONTEXT_BUTTON_BROWSE_INTO,
+                      CONTEXT_BUTTON_EDIT_SORTTITLE,
+                      CONTEXT_BUTTON_DELETE_ALL,
+                      CONTEXT_BUTTON_HELP,
+                      CONTEXT_BUTTON_PLAY_NEXT,
+                      CONTEXT_BUTTON_NAVIGATE,
+                    };
+
+class CContextButtons : public std::vector< std::pair<size_t, std::string> >
+{
+public:
+  void Add(unsigned int, const std::string &label);
+  void Add(unsigned int, int label);
+};
+
+class CGUIDialogContextMenu :
+      public CGUIDialog
+{
+public:
+  CGUIDialogContextMenu(void);
+  ~CGUIDialogContextMenu(void) override;
+  bool OnMessage(CGUIMessage &message) override;
+  bool OnAction(const CAction& action) override;
+  void SetPosition(float posX, float posY) override;
+
+  static bool SourcesMenu(const std::string &strType, const CFileItemPtr& item, float posX, float posY);
+  static void SwitchMedia(const std::string& strType, const std::string& strPath);
+
+  static void GetContextButtons(const std::string &type, const CFileItemPtr& item, CContextButtons &buttons);
+  static bool OnContextButton(const std::string &type, const CFileItemPtr& item, CONTEXT_BUTTON button);
+
+  /*! Show the context menu with the given choices and return the index of the selected item,
+    or -1 if cancelled.
+   */
+  static int Show(const CContextButtons& choices, int focusedButton = 0);
+
+  /*! Legacy method that returns the context menu id, or -1 on cancel */
+  static int ShowAndGetChoice(const CContextButtons &choices);
+
+protected:
+  void SetupButtons();
+
+  /*! \brief Position the context menu in the middle of the focused control.
+   If no control is available it is positioned in the middle of the screen.
+   */
+  void PositionAtCurrentFocus();
+
+  float GetWidth() const override;
+  float GetHeight() const override;
+  void OnInitWindow() override;
+  void OnWindowLoaded() override;
+  void OnDeinitWindow(int nextWindowID) override;
+  static std::string GetDefaultShareNameByType(const std::string &strType);
+  static void SetDefault(const std::string &strType, const std::string &strDefault);
+  static void ClearDefault(const std::string &strType);
+  static CMediaSource *GetShare(const std::string &type, const CFileItem *item);
+
+private:
+  float m_coordX, m_coordY;
+  /// \brief Stored size of background image (height or width depending on grouplist orientation)
+  float m_backgroundImageSize;
+  int m_initiallyFocusedButtonIdx = 0;
+  int m_clickedButton;
+  CContextButtons m_buttons;
+  const CGUIControl *m_backgroundImage = nullptr;
+};
diff --git a/xbmc/dialogs/GUIDialogExtendedProgressBar.cpp b/xbmc/dialogs/GUIDialogExtendedProgressBar.cpp
new file mode 100644
index 0000000..9fc1c02
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogExtendedProgressBar.cpp
@@ -0,0 +1,155 @@
+/*
+ *  Copyright (C) 2012-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 "GUIDialogExtendedProgressBar.h"
+
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIProgressControl.h"
+#include "utils/TimeUtils.h"
+
+#include <cmath>
+#include <mutex>
+
+#define CONTROL_LABELHEADER       30
+#define CONTROL_LABELTITLE        31
+#define CONTROL_PROGRESS          32
+
+#define ITEM_SWITCH_TIME_MS       2000
+
+std::string CGUIDialogProgressBarHandle::Text(void) const
+{
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+  std::string retVal(m_strText);
+  return retVal;
+}
+
+void CGUIDialogProgressBarHandle::SetText(const std::string &strText)
+{
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+  m_strText = strText;
+}
+
+void CGUIDialogProgressBarHandle::SetTitle(const std::string &strTitle)
+{
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+  m_strTitle = strTitle;
+}
+
+void CGUIDialogProgressBarHandle::SetProgress(int currentItem, int itemCount)
+{
+  float fPercentage = (currentItem*100.0f)/itemCount;
+  if (!std::isnan(fPercentage))
+    m_fPercentage = std::min(100.0f, fPercentage);
+}
+
+CGUIDialogExtendedProgressBar::CGUIDialogExtendedProgressBar(void)
+  : CGUIDialog(WINDOW_DIALOG_EXT_PROGRESS, "DialogExtendedProgressBar.xml", DialogModalityType::MODELESS)
+{
+  m_loadType        = LOAD_ON_GUI_INIT;
+  m_iLastSwitchTime = 0;
+  m_iCurrentItem    = 0;
+}
+
+CGUIDialogProgressBarHandle *CGUIDialogExtendedProgressBar::GetHandle(const std::string &strTitle)
+{
+  CGUIDialogProgressBarHandle *handle = new CGUIDialogProgressBarHandle(strTitle);
+  {
+    std::unique_lock<CCriticalSection> lock(m_critSection);
+    m_handles.push_back(handle);
+  }
+
+  Open();
+
+  return handle;
+}
+
+bool CGUIDialogExtendedProgressBar::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      m_iLastSwitchTime = CTimeUtils::GetFrameTime();
+      m_iCurrentItem = 0;
+      CGUIDialog::OnMessage(message);
+
+      UpdateState(0);
+      return true;
+    }
+    break;
+  }
+
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogExtendedProgressBar::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  if (m_active)
+    UpdateState(currentTime);
+
+  CGUIDialog::Process(currentTime, dirtyregions);
+}
+
+void CGUIDialogExtendedProgressBar::UpdateState(unsigned int currentTime)
+{
+  std::string strHeader;
+  std::string strTitle;
+  float  fProgress(-1.0f);
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_critSection);
+
+    // delete finished items
+    for (int iPtr = m_handles.size() - 1; iPtr >= 0; iPtr--)
+    {
+      if (m_handles.at(iPtr)->IsFinished())
+      {
+        delete m_handles.at(iPtr);
+        m_handles.erase(m_handles.begin() + iPtr);
+      }
+    }
+
+    if (!m_handles.size())
+    {
+      Close(false, 0, true, false);
+      return;
+    }
+
+    // ensure the current item is in our range
+    if (m_iCurrentItem >= m_handles.size())
+      m_iCurrentItem = m_handles.size() - 1;
+
+    // update the current item ptr
+    if (currentTime > m_iLastSwitchTime &&
+        currentTime - m_iLastSwitchTime >= ITEM_SWITCH_TIME_MS)
+    {
+      m_iLastSwitchTime = currentTime;
+
+      // select next item
+      if (++m_iCurrentItem > m_handles.size() - 1)
+        m_iCurrentItem = 0;
+    }
+
+    CGUIDialogProgressBarHandle *handle = m_handles.at(m_iCurrentItem);
+    if (handle)
+    {
+      strTitle  = handle->Text();
+      strHeader = handle->Title();
+      fProgress = handle->Percentage();
+    }
+  }
+
+  SET_CONTROL_LABEL(CONTROL_LABELHEADER, strHeader);
+  SET_CONTROL_LABEL(CONTROL_LABELTITLE, strTitle);
+
+  if (fProgress > -1.0f)
+  {
+    SET_CONTROL_VISIBLE(CONTROL_PROGRESS);
+    CONTROL_SELECT_ITEM(CONTROL_PROGRESS, (unsigned int)fProgress);
+  }
+}
diff --git a/xbmc/dialogs/GUIDialogExtendedProgressBar.h b/xbmc/dialogs/GUIDialogExtendedProgressBar.h
new file mode 100644
index 0000000..c6a0609
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogExtendedProgressBar.h
@@ -0,0 +1,63 @@
+/*
+ *  Copyright (C) 2012-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 "guilib/GUIDialog.h"
+
+#include <string>
+#include <vector>
+
+class CGUIDialogProgressBarHandle
+{
+public:
+  explicit CGUIDialogProgressBarHandle(const std::string &strTitle) :
+    m_fPercentage(0),
+    m_strTitle(strTitle),
+    m_bFinished(false) {}
+  virtual ~CGUIDialogProgressBarHandle(void) = default;
+
+  const std::string &Title(void) { return m_strTitle; }
+  void SetTitle(const std::string &strTitle);
+
+  std::string Text(void) const;
+  void SetText(const std::string &strText);
+
+  bool IsFinished(void) const { return m_bFinished; }
+  void MarkFinished(void)     { m_bFinished = true; }
+
+  float Percentage(void) const          { return m_fPercentage;}
+  void SetPercentage(float fPercentage) { m_fPercentage = fPercentage; }
+  void SetProgress(int currentItem, int itemCount);
+
+private:
+  mutable CCriticalSection m_critSection;
+  float             m_fPercentage;
+  std::string       m_strTitle;
+  std::string       m_strText;
+  bool              m_bFinished;
+};
+
+class CGUIDialogExtendedProgressBar : public CGUIDialog
+{
+public:
+  CGUIDialogExtendedProgressBar(void);
+  ~CGUIDialogExtendedProgressBar(void) override = default;
+  bool OnMessage(CGUIMessage& message) override;
+  void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
+
+  CGUIDialogProgressBarHandle *GetHandle(const std::string &strTitle);
+
+protected:
+  void UpdateState(unsigned int currentTime);
+
+  CCriticalSection                           m_critSection;
+  unsigned int                               m_iCurrentItem;
+  unsigned int                               m_iLastSwitchTime;
+  std::vector<CGUIDialogProgressBarHandle *> m_handles;
+};
diff --git a/xbmc/dialogs/GUIDialogFileBrowser.cpp b/xbmc/dialogs/GUIDialogFileBrowser.cpp
new file mode 100644
index 0000000..a9f81cb
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogFileBrowser.cpp
@@ -0,0 +1,1020 @@
+/*
+ *  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 "GUIDialogFileBrowser.h"
+
+#include "AutoSwitch.h"
+#include "FileItem.h"
+#include "GUIDialogContextMenu.h"
+#include "GUIDialogMediaSource.h"
+#include "GUIDialogYesNo.h"
+#include "GUIPassword.h"
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "Util.h"
+#include "filesystem/Directory.h"
+#include "filesystem/File.h"
+#include "filesystem/MultiPathDirectory.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "network/GUIDialogNetworkSetup.h"
+#include "network/Network.h"
+#include "profiles/ProfileManager.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/SettingsComponent.h"
+#include "storage/MediaManager.h"
+#include "utils/FileExtensionProvider.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+using namespace KODI::MESSAGING;
+using namespace XFILE;
+
+#define CONTROL_LIST          450
+#define CONTROL_THUMBS        451
+#define CONTROL_HEADING_LABEL 411
+#define CONTROL_LABEL_PATH    412
+#define CONTROL_OK            413
+#define CONTROL_CANCEL        414
+#define CONTROL_NEWFOLDER     415
+#define CONTROL_FLIP          416
+
+CGUIDialogFileBrowser::CGUIDialogFileBrowser()
+    : CGUIDialog(WINDOW_DIALOG_FILE_BROWSER, "FileBrowser.xml")
+{
+  m_Directory = new CFileItem;
+  m_vecItems = new CFileItemList;
+  m_bConfirmed = false;
+  m_Directory->m_bIsFolder = true;
+  m_browsingForFolders = 0;
+  m_browsingForImages = false;
+  m_useFileDirectories = false;
+  m_addNetworkShareEnabled = false;
+  m_singleList = false;
+  m_thumbLoader.SetObserver(this);
+  m_flipEnabled = false;
+  m_bFlip = false;
+  m_multipleSelection = false;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogFileBrowser::~CGUIDialogFileBrowser()
+{
+  delete m_Directory;
+  delete m_vecItems;
+}
+
+bool CGUIDialogFileBrowser::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_PARENT_DIR)
+  {
+    GoParentFolder();
+    return true;
+  }
+  if ((action.GetID() == ACTION_CONTEXT_MENU || action.GetID() == ACTION_MOUSE_RIGHT_CLICK) && m_Directory->GetPath().empty())
+  {
+    int iItem = m_viewControl.GetSelectedItem();
+    if ((!m_addSourceType.empty() && iItem != m_vecItems->Size()-1))
+      return OnPopupMenu(iItem);
+    if (m_addNetworkShareEnabled && CServiceBroker::GetMediaManager().HasLocation(m_selectedPath))
+    {
+      // need to make sure this source is not an auto added location
+      // as users locations might have the same paths
+      CFileItemPtr pItem = (*m_vecItems)[iItem];
+      for (unsigned int i=0;i<m_shares.size();++i)
+      {
+        if (StringUtils::EqualsNoCase(m_shares[i].strName, pItem->GetLabel()) && m_shares[i].m_ignore)
+          return false;
+      }
+
+      return OnPopupMenu(iItem);
+    }
+
+    return false;
+  }
+
+  return CGUIDialog::OnAction(action);
+}
+
+bool CGUIDialogFileBrowser::OnBack(int actionID)
+{
+  if (actionID == ACTION_NAV_BACK && !m_vecItems->IsVirtualDirectoryRoot())
+  {
+    GoParentFolder();
+    return true;
+  }
+  return CGUIDialog::OnBack(actionID);
+}
+
+bool CGUIDialogFileBrowser::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_DEINIT:
+    {
+      if (m_thumbLoader.IsLoading())
+        m_thumbLoader.StopThread();
+      CGUIDialog::OnMessage(message);
+      ClearFileItems();
+      m_addNetworkShareEnabled = false;
+      return true;
+    }
+    break;
+
+  case GUI_MSG_WINDOW_INIT:
+    {
+      m_bConfirmed = false;
+      m_bFlip = false;
+      bool bIsDir = false;
+      // this code allows two different selection modes for directories
+      // end the path with a slash to start inside the directory
+      if (URIUtils::HasSlashAtEnd(m_selectedPath))
+      {
+        bIsDir = true;
+        bool bFool;
+        int iSource = CUtil::GetMatchingSource(m_selectedPath,m_shares,bFool);
+        bFool = true;
+        if (iSource > -1 && iSource < (int)m_shares.size())
+        {
+          if (URIUtils::PathEquals(m_shares[iSource].strPath, m_selectedPath))
+            bFool = false;
+        }
+
+        if (bFool && !CDirectory::Exists(m_selectedPath))
+          m_selectedPath.clear();
+      }
+      else
+      {
+        if (!CFile::Exists(m_selectedPath) && !CDirectory::Exists(m_selectedPath))
+            m_selectedPath.clear();
+      }
+
+      // find the parent folder if we are a file browser (don't do this for folders)
+      m_Directory->SetPath(m_selectedPath);
+      if (!m_browsingForFolders && !bIsDir)
+        m_Directory->SetPath(URIUtils::GetParentPath(m_selectedPath));
+      Update(m_Directory->GetPath());
+      m_viewControl.SetSelectedItem(m_selectedPath);
+      return CGUIDialog::OnMessage(message);
+    }
+    break;
+
+  case GUI_MSG_CLICKED:
+    {
+      if (m_viewControl.HasControl(message.GetSenderId()))  // list control
+      {
+        int iItem = m_viewControl.GetSelectedItem();
+        int iAction = message.GetParam1();
+        if (iItem < 0) break;
+        CFileItemPtr pItem = (*m_vecItems)[iItem];
+        if ((iAction == ACTION_SELECT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK) &&
+           (!m_multipleSelection || pItem->m_bIsShareOrDrive || pItem->m_bIsFolder))
+        {
+          OnClick(iItem);
+          return true;
+        }
+        else if ((iAction == ACTION_HIGHLIGHT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK || iAction == ACTION_SELECT_ITEM) &&
+                (m_multipleSelection && !pItem->m_bIsShareOrDrive && !pItem->m_bIsFolder))
+        {
+          pItem->Select(!pItem->IsSelected());
+          CGUIMessage msg(GUI_MSG_ITEM_SELECT, GetID(), message.GetSenderId(), iItem + 1);
+          OnMessage(msg);
+        }
+      }
+      else if (message.GetSenderId() == CONTROL_OK)
+      {
+        if (m_browsingForFolders == 2)
+        {
+          int iItem = m_viewControl.GetSelectedItem();
+
+          std::string strPath;
+          if (iItem == 0)
+            strPath = m_selectedPath;
+          else
+            strPath = (*m_vecItems)[iItem]->GetPath();
+
+          std::string strTest = URIUtils::AddFileToFolder(strPath, "1");
+          CFile file;
+          if (file.OpenForWrite(strTest,true))
+          {
+            file.Close();
+            CFile::Delete(strTest);
+            m_bConfirmed = true;
+            Close();
+          }
+          else
+            HELPERS::ShowOKDialogText(CVariant{257}, CVariant{20072});
+        }
+        else
+        {
+          if (m_multipleSelection)
+          {
+            for (int iItem = 0; iItem < m_vecItems->Size(); ++iItem)
+            {
+              CFileItemPtr pItem = (*m_vecItems)[iItem];
+              if (pItem->IsSelected())
+                m_markedPath.push_back(pItem->GetPath());
+            }
+          }
+          m_bConfirmed = true;
+          Close();
+        }
+        return true;
+      }
+      else if (message.GetSenderId() == CONTROL_CANCEL)
+      {
+        Close();
+        return true;
+      }
+      else if (message.GetSenderId() == CONTROL_NEWFOLDER)
+      {
+        std::string strInput;
+        if (CGUIKeyboardFactory::ShowAndGetInput(strInput, CVariant{g_localizeStrings.Get(119)}, false))
+        {
+          std::string strPath = URIUtils::AddFileToFolder(m_vecItems->GetPath(), strInput);
+          if (CDirectory::Create(strPath))
+            Update(m_vecItems->GetPath());
+          else
+            HELPERS::ShowOKDialogText(CVariant{20069}, CVariant{20072});
+        }
+      }
+      else if (message.GetSenderId() == CONTROL_FLIP)
+        m_bFlip = !m_bFlip;
+    }
+    break;
+  case GUI_MSG_SETFOCUS:
+    {
+      if (m_viewControl.HasControl(message.GetControlId()) && m_viewControl.GetCurrentControl() != message.GetControlId())
+      {
+        m_viewControl.SetFocused();
+        return true;
+      }
+    }
+    break;
+  case GUI_MSG_NOTIFY_ALL:
+    { // Message is received only if this window is active
+      if (message.GetParam1() == GUI_MSG_REMOVED_MEDIA)
+      {
+        if (m_Directory->IsVirtualDirectoryRoot() && IsActive())
+        {
+          int iItem = m_viewControl.GetSelectedItem();
+          Update(m_Directory->GetPath());
+          m_viewControl.SetSelectedItem(iItem);
+        }
+        else if (m_Directory->IsRemovable())
+        { // check that we have this removable share still
+          if (!m_rootDir.IsInSource(m_Directory->GetPath()))
+          { // don't have this share any more
+            if (IsActive()) Update("");
+            else
+            {
+              m_history.ClearPathHistory();
+              m_Directory->SetPath("");
+            }
+          }
+        }
+        return true;
+      }
+      else if (message.GetParam1()==GUI_MSG_UPDATE_SOURCES)
+      { // State of the sources changed, so update our view
+        if (m_Directory->IsVirtualDirectoryRoot() && IsActive())
+        {
+          int iItem = m_viewControl.GetSelectedItem();
+          Update(m_Directory->GetPath());
+          m_viewControl.SetSelectedItem(iItem);
+        }
+        return true;
+      }
+      else if (message.GetParam1()==GUI_MSG_UPDATE_PATH)
+      {
+        if (IsActive())
+        {
+          if((message.GetStringParam() == m_Directory->GetPath()) ||
+             (m_Directory->IsMultiPath() && XFILE::CMultiPathDirectory::HasPath(m_Directory->GetPath(), message.GetStringParam())))
+          {
+            int iItem = m_viewControl.GetSelectedItem();
+            Update(m_Directory->GetPath());
+            m_viewControl.SetSelectedItem(iItem);
+          }
+        }
+      }
+    }
+    break;
+
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogFileBrowser::ClearFileItems()
+{
+  m_viewControl.Clear();
+  m_vecItems->Clear(); // will clean up everything
+}
+
+void CGUIDialogFileBrowser::OnSort()
+{
+  if (!m_singleList)
+    m_vecItems->Sort(SortByLabel, SortOrderAscending);
+}
+
+void CGUIDialogFileBrowser::Update(const std::string &strDirectory)
+{
+  const CURL pathToUrl(strDirectory);
+
+  if (m_browsingForImages && m_thumbLoader.IsLoading())
+    m_thumbLoader.StopThread();
+  // get selected item
+  int iItem = m_viewControl.GetSelectedItem();
+  std::string strSelectedItem;
+  if (iItem >= 0 && iItem < m_vecItems->Size())
+  {
+    CFileItemPtr pItem = (*m_vecItems)[iItem];
+    if (!pItem->IsParentFolder())
+    {
+      strSelectedItem = pItem->GetPath();
+      URIUtils::RemoveSlashAtEnd(strSelectedItem);
+      m_history.SetSelectedItem(strSelectedItem, m_Directory->GetPath().empty()?"empty":m_Directory->GetPath());
+    }
+  }
+
+  if (!m_singleList)
+  {
+    CFileItemList items;
+    std::string strParentPath;
+
+    if (!m_rootDir.GetDirectory(pathToUrl, items, m_useFileDirectories, false))
+    {
+      CLog::Log(LOGERROR, "CGUIDialogFileBrowser::GetDirectory({}) failed",
+                pathToUrl.GetRedacted());
+
+      // We assume, we can get the parent
+      // directory again
+      std::string strParentPath = m_history.GetParentPath();
+      m_history.RemoveParentPath();
+      Update(strParentPath);
+      return;
+    }
+
+    // check if current directory is a root share
+    if (!m_rootDir.IsSource(strDirectory))
+    {
+      if (URIUtils::GetParentPath(strDirectory, strParentPath))
+      {
+        CFileItemPtr pItem(new CFileItem(".."));
+        pItem->SetPath(strParentPath);
+        pItem->m_bIsFolder = true;
+        pItem->m_bIsShareOrDrive = false;
+        items.AddFront(pItem, 0);
+      }
+    }
+    else
+    {
+      // yes, this is the root of a share
+      // add parent path to the virtual directory
+      CFileItemPtr pItem(new CFileItem(".."));
+      pItem->SetPath("");
+      pItem->m_bIsShareOrDrive = false;
+      pItem->m_bIsFolder = true;
+      items.AddFront(pItem, 0);
+      strParentPath = "";
+    }
+
+    ClearFileItems();
+    m_vecItems->Copy(items);
+    m_Directory->SetPath(strDirectory);
+    m_strParentPath = strParentPath;
+  }
+
+  // if we're getting the root source listing
+  // make sure the path history is clean
+  if (strDirectory.empty())
+    m_history.ClearPathHistory();
+
+  // some evil stuff don't work with the '/' mask, e.g. shoutcast directory - make sure no files are in there
+  if (m_browsingForFolders)
+  {
+    for (int i=0;i<m_vecItems->Size();++i)
+      if (!(*m_vecItems)[i]->m_bIsFolder)
+      {
+        m_vecItems->Remove(i);
+        i--;
+      }
+  }
+
+  // No need to set thumbs
+
+  m_vecItems->FillInDefaultIcons();
+
+  OnSort();
+
+  if (m_Directory->GetPath().empty() && m_addNetworkShareEnabled &&
+     (CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE ||
+      CServiceBroker::GetSettingsComponent()->GetProfileManager()->IsMasterProfile() || g_passwordManager.bMasterUser))
+  { // we are in the virtual directory - add the "Add Network Location" item
+    CFileItemPtr pItem(new CFileItem(g_localizeStrings.Get(1032)));
+    pItem->SetPath("net://");
+    pItem->m_bIsFolder = true;
+    m_vecItems->Add(pItem);
+  }
+  if (m_Directory->GetPath().empty() && !m_addSourceType.empty())
+  {
+    CFileItemPtr pItem(new CFileItem(g_localizeStrings.Get(21359)));
+    pItem->SetPath("source://");
+    pItem->m_bIsFolder = true;
+    m_vecItems->Add(pItem);
+  }
+
+  m_viewControl.SetItems(*m_vecItems);
+  m_viewControl.SetCurrentView((m_browsingForImages && CAutoSwitch::ByFileCount(*m_vecItems)) ? CONTROL_THUMBS : CONTROL_LIST);
+
+  std::string strPath2 = m_Directory->GetPath();
+  URIUtils::RemoveSlashAtEnd(strPath2);
+  strSelectedItem = m_history.GetSelectedItem(strPath2==""?"empty":strPath2);
+
+  bool bSelectedFound = false;
+  for (int i = 0; i < m_vecItems->Size(); ++i)
+  {
+    CFileItemPtr pItem = (*m_vecItems)[i];
+    strPath2 = pItem->GetPath();
+    URIUtils::RemoveSlashAtEnd(strPath2);
+    if (strPath2 == strSelectedItem)
+    {
+      m_viewControl.SetSelectedItem(i);
+      bSelectedFound = true;
+      break;
+    }
+  }
+
+  // if we haven't found the selected item, select the first item
+  if (!bSelectedFound)
+    m_viewControl.SetSelectedItem(0);
+
+  m_history.AddPath(m_Directory->GetPath());
+
+  if (m_browsingForImages)
+    m_thumbLoader.Load(*m_vecItems);
+}
+
+void CGUIDialogFileBrowser::FrameMove()
+{
+  int item = m_viewControl.GetSelectedItem();
+  if (item >= 0)
+  {
+    // if we are browsing for folders, and not in the root directory, then we use the parent path,
+    // else we use the current file's path
+    if (m_browsingForFolders && !m_Directory->IsVirtualDirectoryRoot())
+      m_selectedPath = m_Directory->GetPath();
+    else
+      m_selectedPath = (*m_vecItems)[item]->GetPath();
+    if (m_selectedPath == "net://")
+    {
+      SET_CONTROL_LABEL(CONTROL_LABEL_PATH, g_localizeStrings.Get(1032)); // "Add Network Location..."
+    }
+    else
+    {
+      // Update the current path label
+      CURL url(m_selectedPath);
+      std::string safePath = url.GetWithoutUserDetails();
+      SET_CONTROL_LABEL(CONTROL_LABEL_PATH, safePath);
+    }
+    if ((!m_browsingForFolders && (*m_vecItems)[item]->m_bIsFolder) || ((*m_vecItems)[item]->GetPath() == "image://Browse"))
+    {
+      CONTROL_DISABLE(CONTROL_OK);
+    }
+    else
+    {
+      CONTROL_ENABLE(CONTROL_OK);
+    }
+    if (m_browsingForFolders == 2)
+    {
+      CONTROL_ENABLE(CONTROL_NEWFOLDER);
+    }
+    else
+    {
+      CONTROL_DISABLE(CONTROL_NEWFOLDER);
+    }
+    if (m_flipEnabled)
+    {
+      CONTROL_ENABLE(CONTROL_FLIP);
+    }
+    else
+    {
+      CONTROL_DISABLE(CONTROL_FLIP);
+    }
+  }
+  CGUIDialog::FrameMove();
+}
+
+void CGUIDialogFileBrowser::OnClick(int iItem)
+{
+  if ( iItem < 0 || iItem >= m_vecItems->Size() ) return ;
+  CFileItemPtr pItem = (*m_vecItems)[iItem];
+  std::string strPath = pItem->GetPath();
+
+  if (pItem->m_bIsFolder)
+  {
+    if (pItem->GetPath() == "net://")
+    { // special "Add Network Location" item
+      OnAddNetworkLocation();
+      return;
+    }
+    if (pItem->GetPath() == "source://")
+    { // special "Add Source" item
+      OnAddMediaSource();
+      return;
+    }
+    if (!m_addSourceType.empty())
+    {
+      OnEditMediaSource(pItem.get());
+      return;
+    }
+    if ( pItem->m_bIsShareOrDrive )
+    {
+      if ( !HaveDiscOrConnection( pItem->m_iDriveType ) )
+        return ;
+    }
+    Update(strPath);
+  }
+  else if (!m_browsingForFolders)
+  {
+    m_selectedPath = pItem->GetPath();
+    m_bConfirmed = true;
+    Close();
+  }
+}
+
+bool CGUIDialogFileBrowser::HaveDiscOrConnection( int iDriveType )
+{
+  if ( iDriveType == CMediaSource::SOURCE_TYPE_DVD )
+  {
+    if (!CServiceBroker::GetMediaManager().IsDiscInDrive())
+    {
+      HELPERS::ShowOKDialogText(CVariant{218}, CVariant{219});
+      return false;
+    }
+  }
+  else if ( iDriveType == CMediaSource::SOURCE_TYPE_REMOTE )
+  {
+    //! @todo Handle not connected to a remote share
+    if ( !CServiceBroker::GetNetwork().IsConnected() )
+    {
+      HELPERS::ShowOKDialogText(CVariant{220}, CVariant{221});
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void CGUIDialogFileBrowser::GoParentFolder()
+{
+  std::string strPath(m_strParentPath);
+  if (strPath.size() == 2)
+    if (strPath[1] == ':')
+      URIUtils::AddSlashAtEnd(strPath);
+  Update(strPath);
+}
+
+void CGUIDialogFileBrowser::OnWindowLoaded()
+{
+  CGUIDialog::OnWindowLoaded();
+  m_viewControl.Reset();
+  m_viewControl.SetParentWindow(GetID());
+  m_viewControl.AddView(GetControl(CONTROL_LIST));
+  m_viewControl.AddView(GetControl(CONTROL_THUMBS));
+}
+
+void CGUIDialogFileBrowser::OnWindowUnload()
+{
+  CGUIDialog::OnWindowUnload();
+  m_viewControl.Reset();
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetImage(const CFileItemList &items, const VECSOURCES &shares, const std::string &heading, std::string &result, bool* flip, int label)
+{
+  CGUIDialogFileBrowser *browser = new CGUIDialogFileBrowser();
+  if (!browser)
+    return false;
+  CServiceBroker::GetGUI()->GetWindowManager().AddUniqueInstance(browser);
+
+  browser->m_browsingForImages = true;
+  browser->m_singleList = true;
+  browser->m_vecItems->Clear();
+  browser->m_vecItems->Append(items);
+  if (true)
+  {
+    CFileItemPtr item(new CFileItem("image://Browse", false));
+    item->SetLabel(g_localizeStrings.Get(20153));
+    item->SetArt("icon", "DefaultFolder.png");
+    browser->m_vecItems->Add(item);
+  }
+  browser->SetHeading(heading);
+  browser->m_flipEnabled = flip?true:false;
+  browser->Open();
+  bool confirmed(browser->IsConfirmed());
+  if (confirmed)
+  {
+    result = browser->m_selectedPath;
+    if (result == "image://Browse")
+    { // "Browse for thumb"
+      CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+      delete browser;
+      return ShowAndGetImage(shares, g_localizeStrings.Get(label), result);
+    }
+  }
+
+  if (flip)
+    *flip = browser->m_bFlip != 0;
+
+  CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+  delete browser;
+
+  return confirmed;
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetImage(const VECSOURCES &shares, const std::string &heading, std::string &path)
+{
+  return ShowAndGetFile(shares, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), heading, path, true); // true for use thumbs
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetImageList(const VECSOURCES &shares, const std::string &heading, std::vector<std::string> &path)
+{
+  return ShowAndGetFileList(shares, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), heading, path, true); // true for use thumbs
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetDirectory(const VECSOURCES &shares, const std::string &heading, std::string &path, bool bWriteOnly)
+{
+  // an extension mask of "/" ensures that no files are shown
+  if (bWriteOnly)
+  {
+    VECSOURCES shareWritable;
+    for (unsigned int i=0;i<shares.size();++i)
+    {
+      if (shares[i].IsWritable())
+        shareWritable.push_back(shares[i]);
+    }
+
+    return ShowAndGetFile(shareWritable, "/w", heading, path);
+  }
+
+  return ShowAndGetFile(shares, "/", heading, path);
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetFile(const VECSOURCES &shares, const std::string &mask, const std::string &heading, std::string &path, bool useThumbs /* = false */, bool useFileDirectories /* = false */)
+{
+  CGUIDialogFileBrowser *browser = new CGUIDialogFileBrowser();
+  if (!browser)
+    return false;
+  CServiceBroker::GetGUI()->GetWindowManager().AddUniqueInstance(browser);
+
+  browser->m_useFileDirectories = useFileDirectories;
+
+  browser->m_browsingForImages = useThumbs;
+  browser->SetHeading(heading);
+  browser->SetSources(shares);
+  std::string strMask = mask;
+  if (mask == "/")
+    browser->m_browsingForFolders=1;
+  else
+  if (mask == "/w")
+  {
+    browser->m_browsingForFolders=2;
+    strMask = "/";
+  }
+  else
+    browser->m_browsingForFolders = 0;
+
+  browser->m_rootDir.SetMask(strMask);
+  browser->m_selectedPath = path;
+  browser->m_addNetworkShareEnabled = false;
+  browser->Open();
+  bool confirmed(browser->IsConfirmed());
+  if (confirmed)
+    path = browser->m_selectedPath;
+  CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+  delete browser;
+  return confirmed;
+}
+
+// same as above, starting in a single directory
+bool CGUIDialogFileBrowser::ShowAndGetFile(const std::string &directory, const std::string &mask, const std::string &heading, std::string &path, bool useThumbs /* = false */, bool useFileDirectories /* = false */, bool singleList /* = false */)
+{
+  CGUIDialogFileBrowser *browser = new CGUIDialogFileBrowser();
+  if (!browser)
+    return false;
+  CServiceBroker::GetGUI()->GetWindowManager().AddUniqueInstance(browser);
+
+  browser->m_useFileDirectories = useFileDirectories;
+  browser->m_browsingForImages = useThumbs;
+  browser->SetHeading(heading);
+
+  // add a single share for this directory
+  if (!singleList)
+  {
+    VECSOURCES shares;
+    CMediaSource share;
+    share.strPath = directory;
+    URIUtils::RemoveSlashAtEnd(share.strPath); // this is needed for the dodgy code in WINDOW_INIT
+    shares.push_back(share);
+    browser->SetSources(shares);
+  }
+  else
+  {
+    browser->m_vecItems->Clear();
+    CDirectory::GetDirectory(directory,*browser->m_vecItems, "", DIR_FLAG_DEFAULTS);
+    CFileItemPtr item(new CFileItem("file://Browse", false));
+    item->SetLabel(g_localizeStrings.Get(20153));
+    item->SetArt("icon", "DefaultFolder.png");
+    browser->m_vecItems->Add(item);
+    browser->m_singleList = true;
+  }
+  std::string strMask = mask;
+  if (mask == "/")
+    browser->m_browsingForFolders=1;
+  else
+  if (mask == "/w")
+  {
+    browser->m_browsingForFolders=2;
+    strMask = "/";
+  }
+  else
+    browser->m_browsingForFolders = 0;
+
+  browser->m_rootDir.SetMask(strMask);
+  browser->m_selectedPath = directory;
+  browser->m_addNetworkShareEnabled = false;
+  browser->Open();
+  bool confirmed(browser->IsConfirmed());
+  if (confirmed)
+    path = browser->m_selectedPath;
+  if (path == "file://Browse")
+  { // "Browse for thumb"
+    CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+    delete browser;
+    VECSOURCES shares;
+    CServiceBroker::GetMediaManager().GetLocalDrives(shares);
+
+    return ShowAndGetFile(shares, mask, heading, path, useThumbs,useFileDirectories);
+  }
+  CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+  delete browser;
+  return confirmed;
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetFileList(const VECSOURCES &shares, const std::string &mask, const std::string &heading, std::vector<std::string> &path, bool useThumbs /* = false */, bool useFileDirectories /* = false */)
+{
+  CGUIDialogFileBrowser *browser = new CGUIDialogFileBrowser();
+  if (!browser)
+    return false;
+  CServiceBroker::GetGUI()->GetWindowManager().AddUniqueInstance(browser);
+
+  browser->m_useFileDirectories = useFileDirectories;
+  browser->m_multipleSelection = true;
+  browser->m_browsingForImages = useThumbs;
+  browser->SetHeading(heading);
+  browser->SetSources(shares);
+  browser->m_browsingForFolders = 0;
+  browser->m_rootDir.SetMask(mask);
+  browser->m_addNetworkShareEnabled = false;
+  browser->Open();
+  bool confirmed(browser->IsConfirmed());
+  if (confirmed)
+  {
+    if (browser->m_markedPath.size())
+      path = browser->m_markedPath;
+    else
+      path.push_back(browser->m_selectedPath);
+  }
+  CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+  delete browser;
+  return confirmed;
+}
+
+void CGUIDialogFileBrowser::SetHeading(const std::string &heading)
+{
+  Initialize();
+  SET_CONTROL_LABEL(CONTROL_HEADING_LABEL, heading);
+}
+
+bool CGUIDialogFileBrowser::ShowAndGetSource(std::string &path, bool allowNetworkShares, VECSOURCES* additionalShare /* = NULL */, const std::string& strType /* = "" */)
+{
+  // Technique is
+  // 1.  Show Filebrowser with currently defined local, and optionally the network locations.
+  // 2.  Have the "Add Network Location" option in addition.
+  // 3a. If the "Add Network Location" is pressed, then:
+  //     a) Fire up the network location dialog to grab the new location
+  //     b) Check the location by doing a GetDirectory() - if it fails, prompt the user
+  //        to allow them to add currently disconnected network shares.
+  //     c) Save this location to our xml file (network.xml)
+  //     d) Return to 1.
+  // 3b. If the "Add Source" is pressed, then:
+  //     a) Fire up the media source dialog to add the new location
+  // 4.  Optionally allow user to browse the local and network locations for their share.
+  // 5.  On OK, return.
+
+  // Create a new filebrowser window
+  CGUIDialogFileBrowser *browser = new CGUIDialogFileBrowser();
+  if (!browser) return false;
+
+  // Add it to our window manager
+  CServiceBroker::GetGUI()->GetWindowManager().AddUniqueInstance(browser);
+
+  VECSOURCES shares;
+  if (!strType.empty())
+  {
+    if (additionalShare)
+      shares = *additionalShare;
+    browser->m_addSourceType = strType;
+  }
+  else
+  {
+    browser->SetHeading(g_localizeStrings.Get(1023));
+
+    CServiceBroker::GetMediaManager().GetLocalDrives(shares);
+
+    // Now the additional share if appropriate
+    if (additionalShare)
+    {
+      shares.insert(shares.end(),additionalShare->begin(),additionalShare->end());
+    }
+
+    // Now add the network shares...
+    if (allowNetworkShares)
+    {
+      CServiceBroker::GetMediaManager().GetNetworkLocations(shares);
+    }
+  }
+
+  browser->SetSources(shares);
+  browser->m_rootDir.SetMask("/");
+  browser->m_rootDir.AllowNonLocalSources(false);  // don't allow plug n play shares
+  browser->m_browsingForFolders = 1;
+  browser->m_addNetworkShareEnabled = allowNetworkShares;
+  browser->m_selectedPath = "";
+  browser->Open();
+  bool confirmed = browser->IsConfirmed();
+  if (confirmed)
+    path = browser->m_selectedPath;
+
+  CServiceBroker::GetGUI()->GetWindowManager().Remove(browser->GetID());
+  delete browser;
+  return confirmed;
+}
+
+void CGUIDialogFileBrowser::SetSources(const VECSOURCES &shares)
+{
+  m_shares = shares;
+  if (!m_shares.size() && m_addSourceType.empty())
+    CServiceBroker::GetMediaManager().GetLocalDrives(m_shares);
+  m_rootDir.SetSources(m_shares);
+}
+
+void CGUIDialogFileBrowser::OnAddNetworkLocation()
+{
+  // ok, fire up the network location dialog
+  std::string path;
+  if (CGUIDialogNetworkSetup::ShowAndGetNetworkAddress(path))
+  {
+    // verify the path by doing a GetDirectory.
+    CFileItemList items;
+    if (CDirectory::GetDirectory(path, items, "", DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_ALLOW_PROMPT) || CGUIDialogYesNo::ShowAndGetInput(CVariant{1001}, CVariant{1002}))
+    { // add the network location to the shares list
+      CMediaSource share;
+      share.strPath = path; //setPath(path);
+      CURL url(path);
+      share.strName = url.GetWithoutUserDetails();
+      URIUtils::RemoveSlashAtEnd(share.strName);
+      m_shares.push_back(share);
+      // add to our location manager...
+      CServiceBroker::GetMediaManager().AddNetworkLocation(path);
+    }
+  }
+  m_rootDir.SetSources(m_shares);
+  Update(m_vecItems->GetPath());
+}
+
+void CGUIDialogFileBrowser::OnAddMediaSource()
+{
+  if (CGUIDialogMediaSource::ShowAndAddMediaSource(m_addSourceType))
+  {
+    SetSources(*CMediaSourceSettings::GetInstance().GetSources(m_addSourceType));
+    Update("");
+  }
+}
+
+void CGUIDialogFileBrowser::OnEditMediaSource(CFileItem* pItem)
+{
+  if (CGUIDialogMediaSource::ShowAndEditMediaSource(m_addSourceType,pItem->GetLabel()))
+  {
+    SetSources(*CMediaSourceSettings::GetInstance().GetSources(m_addSourceType));
+    Update("");
+  }
+}
+
+bool CGUIDialogFileBrowser::OnPopupMenu(int iItem)
+{
+  CContextButtons choices;
+  choices.Add(1, m_addSourceType.empty() ? 20133 : 21364);
+  choices.Add(2, m_addSourceType.empty() ? 20134 : 21365);
+
+  int btnid = CGUIDialogContextMenu::ShowAndGetChoice(choices);
+  if (btnid == 1)
+  {
+    if (m_addNetworkShareEnabled)
+    {
+      std::string strOldPath=m_selectedPath,newPath=m_selectedPath;
+      VECSOURCES shares=m_shares;
+      if (CGUIDialogNetworkSetup::ShowAndGetNetworkAddress(newPath))
+      {
+        CServiceBroker::GetMediaManager().SetLocationPath(strOldPath, newPath);
+        CURL url(newPath);
+        for (unsigned int i=0;i<shares.size();++i)
+        {
+          if (URIUtils::CompareWithoutSlashAtEnd(shares[i].strPath, strOldPath))//getPath().Equals(strOldPath))
+          {
+            shares[i].strName = url.GetWithoutUserDetails();
+            shares[i].strPath = newPath;
+            URIUtils::RemoveSlashAtEnd(shares[i].strName);
+            break;
+          }
+        }
+        // refresh dialog content
+        SetSources(shares);
+        m_rootDir.SetMask("/");
+        m_browsingForFolders = 1;
+        m_addNetworkShareEnabled = true;
+        m_selectedPath = url.GetWithoutUserDetails();
+        Update(m_Directory->GetPath());
+        m_viewControl.SetSelectedItem(iItem);
+      }
+    }
+    else
+    {
+      CFileItemPtr item = m_vecItems->Get(iItem);
+      OnEditMediaSource(item.get());
+    }
+  }
+  if (btnid == 2)
+  {
+    if (m_addNetworkShareEnabled)
+    {
+      CServiceBroker::GetMediaManager().RemoveLocation(m_selectedPath);
+
+      for (unsigned int i=0;i<m_shares.size();++i)
+      {
+        if (URIUtils::CompareWithoutSlashAtEnd(m_shares[i].strPath, m_selectedPath) && !m_shares[i].m_ignore) // getPath().Equals(m_selectedPath))
+        {
+          m_shares.erase(m_shares.begin()+i);
+          break;
+        }
+      }
+      m_rootDir.SetSources(m_shares);
+      m_rootDir.SetMask("/");
+
+      m_browsingForFolders = 1;
+      m_addNetworkShareEnabled = true;
+      m_selectedPath = "";
+
+      Update(m_Directory->GetPath());
+    }
+    else
+    {
+      CMediaSourceSettings::GetInstance().DeleteSource(m_addSourceType,(*m_vecItems)[iItem]->GetLabel(),(*m_vecItems)[iItem]->GetPath());
+      SetSources(*CMediaSourceSettings::GetInstance().GetSources(m_addSourceType));
+      Update("");
+    }
+  }
+
+  return true;
+}
+
+CFileItemPtr CGUIDialogFileBrowser::GetCurrentListItem(int offset)
+{
+  int item = m_viewControl.GetSelectedItem();
+  if (item < 0 || !m_vecItems->Size()) return CFileItemPtr();
+
+  item = (item + offset) % m_vecItems->Size();
+  if (item < 0) item += m_vecItems->Size();
+  return (*m_vecItems)[item];
+}
+
+CGUIControl *CGUIDialogFileBrowser::GetFirstFocusableControl(int id)
+{
+  if (m_viewControl.HasControl(id))
+    id = m_viewControl.GetCurrentControl();
+  return CGUIWindow::GetFirstFocusableControl(id);
+}
+
+
diff --git a/xbmc/dialogs/GUIDialogFileBrowser.h b/xbmc/dialogs/GUIDialogFileBrowser.h
new file mode 100644
index 0000000..8cafaba
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogFileBrowser.h
@@ -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.
+ */
+
+#pragma once
+
+#include "filesystem/DirectoryHistory.h"
+#include "filesystem/VirtualDirectory.h"
+#include "guilib/GUIDialog.h"
+#include "pictures/PictureThumbLoader.h"
+#include "view/GUIViewControl.h"
+
+#include <string>
+#include <vector>
+
+class CFileItem;
+class CFileItemList;
+
+class CGUIDialogFileBrowser : public CGUIDialog, public IBackgroundLoaderObserver
+{
+public:
+  CGUIDialogFileBrowser(void);
+  ~CGUIDialogFileBrowser(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnAction(const CAction &action) override;
+  bool OnBack(int actionID) override;
+  void FrameMove() override;
+  void OnWindowLoaded() override;
+  void OnWindowUnload() override;
+  bool IsConfirmed() { return m_bConfirmed; }
+  void SetHeading(const std::string &heading);
+
+  static bool ShowAndGetDirectory(const VECSOURCES &shares, const std::string &heading, std::string &path, bool bWriteOnly=false);
+  static bool ShowAndGetFile(const VECSOURCES &shares, const std::string &mask, const std::string &heading, std::string &path, bool useThumbs = false, bool useFileDirectories = false);
+  static bool ShowAndGetFile(const std::string &directory, const std::string &mask, const std::string &heading, std::string &path, bool useThumbs = false, bool useFileDirectories = false, bool singleList = false);
+  static bool ShowAndGetSource(std::string &path, bool allowNetworkShares, VECSOURCES* additionalShare = NULL, const std::string& strType="");
+  static bool ShowAndGetFileList(const VECSOURCES &shares, const std::string &mask, const std::string &heading, std::vector<std::string> &path, bool useThumbs = false, bool useFileDirectories = false);
+  static bool ShowAndGetImage(const VECSOURCES &shares, const std::string &heading, std::string &path);
+  static bool ShowAndGetImage(const CFileItemList &items, const VECSOURCES &shares, const std::string &heading, std::string &path, bool* flip=NULL, int label=21371);
+  static bool ShowAndGetImageList(const VECSOURCES &shares, const std::string &heading, std::vector<std::string> &path);
+
+  void SetSources(const VECSOURCES &shares);
+
+  void OnItemLoaded(CFileItem *item) override {};
+
+  bool HasListItems() const override { return true; }
+  CFileItemPtr GetCurrentListItem(int offset = 0) override;
+  int GetViewContainerID() const override { return m_viewControl.GetCurrentControl(); }
+
+protected:
+  void GoParentFolder();
+  void OnClick(int iItem);
+  void OnSort();
+  void ClearFileItems();
+  void Update(const std::string &strDirectory);
+  bool HaveDiscOrConnection( int iDriveType );
+  bool OnPopupMenu(int iItem);
+  void OnAddNetworkLocation();
+  void OnAddMediaSource();
+  void OnEditMediaSource(CFileItem* pItem);
+  CGUIControl *GetFirstFocusableControl(int id) override;
+
+  VECSOURCES m_shares;
+  XFILE::CVirtualDirectory m_rootDir;
+  CFileItemList* m_vecItems;
+  CFileItem* m_Directory;
+  std::string m_strParentPath;
+  std::string m_selectedPath;
+  CDirectoryHistory m_history;
+  int m_browsingForFolders; // 0 - no, 1 - yes, 2 - yes, only writable
+  bool m_bConfirmed;
+  int m_bFlip;
+  bool m_addNetworkShareEnabled;
+  bool m_flipEnabled;
+  std::string m_addSourceType;
+  bool m_browsingForImages;
+  bool m_useFileDirectories;
+  bool m_singleList;              // if true, we have no shares or anything
+  bool m_multipleSelection;
+  std::vector<std::string> m_markedPath;
+
+  CPictureThumbLoader m_thumbLoader;
+  CGUIViewControl m_viewControl;
+};
diff --git a/xbmc/dialogs/GUIDialogGamepad.cpp b/xbmc/dialogs/GUIDialogGamepad.cpp
new file mode 100644
index 0000000..07f5809
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogGamepad.cpp
@@ -0,0 +1,326 @@
+/*
+ *  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 "GUIDialogGamepad.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIAudioManager.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/Digest.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+
+#include <utility>
+
+using namespace KODI::MESSAGING;
+using KODI::UTILITY::CDigest;
+
+CGUIDialogGamepad::CGUIDialogGamepad(void)
+    : CGUIDialogBoxBase(WINDOW_DIALOG_GAMEPAD, "DialogConfirm.xml")
+{
+  m_bCanceled = false;
+  m_iRetries = 0;
+  m_bUserInputCleanup = true;
+  m_bHideInputChars = true;
+  m_cHideInputChar = '*';
+}
+
+CGUIDialogGamepad::~CGUIDialogGamepad(void) = default;
+
+void CGUIDialogGamepad::OnInitWindow()
+{
+  // hide all controls
+  for (int i = 0; i < DIALOG_MAX_CHOICES; ++i)
+    SET_CONTROL_HIDDEN(CONTROL_CHOICES_START + i);
+  SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR);
+
+  CGUIDialogBoxBase::OnInitWindow();
+}
+
+bool CGUIDialogGamepad::OnAction(const CAction &action)
+{
+  if ((action.GetButtonCode() >= KEY_BUTTON_A &&
+       action.GetButtonCode() <= KEY_BUTTON_RIGHT_TRIGGER) ||
+      (action.GetButtonCode() >= KEY_BUTTON_DPAD_UP &&
+       action.GetButtonCode() <= KEY_BUTTON_DPAD_RIGHT) ||
+      (action.GetID() >= ACTION_MOVE_LEFT &&
+       action.GetID() <= ACTION_MOVE_DOWN) ||
+      action.GetID() == ACTION_PLAYER_PLAY
+     )
+  {
+    switch (action.GetButtonCode())
+    {
+    case KEY_BUTTON_A : m_strUserInput += "A"; break;
+    case KEY_BUTTON_B : m_strUserInput += "B"; break;
+    case KEY_BUTTON_X : m_strUserInput += "X"; break;
+    case KEY_BUTTON_Y : m_strUserInput += "Y"; break;
+    case KEY_BUTTON_BLACK : m_strUserInput += "K"; break;
+    case KEY_BUTTON_WHITE : m_strUserInput += "W"; break;
+    case KEY_BUTTON_LEFT_TRIGGER : m_strUserInput += "("; break;
+    case KEY_BUTTON_RIGHT_TRIGGER : m_strUserInput += ")"; break;
+    case KEY_BUTTON_DPAD_UP : m_strUserInput += "U"; break;
+    case KEY_BUTTON_DPAD_DOWN : m_strUserInput += "D"; break;
+    case KEY_BUTTON_DPAD_LEFT : m_strUserInput += "L"; break;
+    case KEY_BUTTON_DPAD_RIGHT : m_strUserInput += "R"; break;
+    default:
+      switch (action.GetID())
+      {
+        case ACTION_MOVE_LEFT:   m_strUserInput += "L"; break;
+        case ACTION_MOVE_RIGHT:  m_strUserInput += "R"; break;
+        case ACTION_MOVE_UP:     m_strUserInput += "U"; break;
+        case ACTION_MOVE_DOWN:   m_strUserInput += "D"; break;
+        case ACTION_PLAYER_PLAY: m_strUserInput += "P"; break;
+        default:
+          return true;
+      }
+      break;
+    }
+
+    std::string strHiddenInput(m_strUserInput);
+    for (int i = 0; i < (int)strHiddenInput.size(); i++)
+    {
+      strHiddenInput[i] = m_cHideInputChar;
+    }
+    SetLine(2, CVariant{std::move(strHiddenInput)});
+    return true;
+  }
+  else if (action.GetButtonCode() == KEY_BUTTON_BACK || action.GetID() == ACTION_PREVIOUS_MENU || action.GetID() == ACTION_NAV_BACK)
+  {
+    m_bConfirmed = false;
+    m_bCanceled = true;
+    m_strUserInput = "";
+    m_bHideInputChars = true;
+    Close();
+    return true;
+  }
+  else if (action.GetButtonCode() == KEY_BUTTON_START || action.GetID() == ACTION_SELECT_ITEM)
+  {
+    m_bConfirmed = false;
+    m_bCanceled = false;
+
+    std::string md5pword2 = CDigest::Calculate(CDigest::Type::MD5, m_strUserInput);
+
+    if (!StringUtils::EqualsNoCase(m_strPassword, md5pword2))
+    {
+      // incorrect password entered
+      m_iRetries--;
+
+      // don't clean up if the calling code wants the bad user input
+      if (m_bUserInputCleanup)
+        m_strUserInput = "";
+      else
+        m_bUserInputCleanup = true;
+
+      m_bHideInputChars = true;
+      Close();
+      return true;
+    }
+
+    // correct password entered
+    m_bConfirmed = true;
+    m_iRetries = 0;
+    m_strUserInput = "";
+    m_bHideInputChars = true;
+    Close();
+    return true;
+  }
+  else if (action.GetID() >= REMOTE_0 && action.GetID() <= REMOTE_9)
+  {
+    return true; // unhandled
+  }
+  else
+  {
+    return CGUIDialog::OnAction(action);
+  }
+}
+
+bool CGUIDialogGamepad::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      m_bConfirmed = false;
+      m_bCanceled = false;
+      m_cHideInputChar = g_localizeStrings.Get(12322).c_str()[0];
+      CGUIDialog::OnMessage(message);
+      return true;
+    }
+    break;
+
+  case GUI_MSG_CLICKED:
+    {
+      m_bConfirmed = false;
+      m_bCanceled = false;
+    }
+    break;
+  }
+  return CGUIDialogBoxBase::OnMessage(message);
+}
+
+// \brief Show gamepad keypad and replace aTextString with user input.
+// \param aTextString String to preload into the keyboard accumulator. Overwritten with user input if return=true.
+// \param dlgHeading String shown on dialog title. Converts to localized string if contains a positive integer.
+// \param bHideUserInput Masks user input as asterisks if set as true.  Currently not yet implemented.
+// \return true if successful display and user input. false if unsuccessful display, no user input, or canceled editing.
+bool CGUIDialogGamepad::ShowAndGetInput(std::string& aTextString, const std::string &dlgHeading, bool bHideUserInput)
+{
+  // Prompt user for input
+  std::string strUserInput;
+  if (ShowAndVerifyInput(strUserInput, dlgHeading, aTextString, "", "", true, bHideUserInput))
+  {
+    // user entry was blank
+    return false;
+  }
+
+  if (strUserInput.empty())
+    // user canceled out
+    return false;
+
+
+  // We should have a string to return
+  aTextString = strUserInput;
+  return true;
+}
+
+// \brief Show gamepad keypad twice to get and confirm a user-entered password string.
+// \param strNewPassword String to preload into the keyboard accumulator. Overwritten with user input if return=true.
+// \return true if successful display and user input entry/re-entry. false if unsuccessful display, no user input, or canceled editing.
+bool CGUIDialogGamepad::ShowAndVerifyNewPassword(std::string& strNewPassword)
+{
+  // Prompt user for password input
+  std::string strUserInput;
+  if (ShowAndVerifyInput(strUserInput, "12340", "12330", "12331", "", true, true))
+  {
+    //! @todo Show error to user saying the password entry was blank
+    HELPERS::ShowOKDialogText(CVariant{12357}, CVariant{12358}); // Password is empty/blank
+    return false;
+  }
+
+  if (strUserInput.empty())
+    // user canceled out
+    return false;
+
+  // Prompt again for password input, this time sending previous input as the password to verify
+  if (!ShowAndVerifyInput(strUserInput, "12341", "12330", "12331", "", false, true))
+  {
+    //! @todo Show error to user saying the password re-entry failed
+    HELPERS::ShowOKDialogText(CVariant{12357}, CVariant{12344}); // Password do not match
+    return false;
+  }
+
+  // password entry and re-entry succeeded
+  strNewPassword = strUserInput;
+  return true;
+}
+
+// \brief Show gamepad keypad and verify user input against strPassword.
+// \param strPassword Value to compare against user input.
+// \param dlgHeading String shown on dialog title. Converts to localized string if contains a positive integer.
+// \param iRetries If greater than 0, shows "Incorrect password, %d retries left" on dialog line 2, else line 2 is blank.
+// \return 0 if successful display and user input. 1 if unsuccessful input. -1 if no user input or canceled editing.
+int CGUIDialogGamepad::ShowAndVerifyPassword(std::string& strPassword, const std::string& dlgHeading, int iRetries)
+{
+  std::string strLine2;
+  if (0 < iRetries)
+  {
+    // Show a string telling user they have iRetries retries left
+    strLine2 = StringUtils::Format("{} {} {}", g_localizeStrings.Get(12342), iRetries,
+                                   g_localizeStrings.Get(12343));
+  }
+
+  // make a copy of strPassword to prevent from overwriting it later
+  std::string strPassTemp = strPassword;
+  if (ShowAndVerifyInput(strPassTemp, dlgHeading, g_localizeStrings.Get(12330), g_localizeStrings.Get(12331), strLine2, true, true))
+  {
+    // user entered correct password
+    return 0;
+  }
+
+  if (strPassTemp.empty())
+    // user canceled out
+    return -1;
+
+  // user must have entered an incorrect password
+  return 1;
+}
+
+// \brief Show gamepad keypad and verify user input against strToVerify.
+// \param strToVerify Value to compare against user input.
+// \param dlgHeading String shown on dialog title. Converts to localized string if contains a positive integer.
+// \param dlgLine0 String shown on dialog line 0. Converts to localized string if contains a positive integer.
+// \param dlgLine1 String shown on dialog line 1. Converts to localized string if contains a positive integer.
+// \param dlgLine2 String shown on dialog line 2. Converts to localized string if contains a positive integer.
+// \param bGetUserInput If set as true and return=true, strToVerify is overwritten with user input string.
+// \param bHideInputChars Masks user input as asterisks if set as true.  Currently not yet implemented.
+// \return true if successful display and user input. false if unsuccessful display, no user input, or canceled editing.
+bool CGUIDialogGamepad::ShowAndVerifyInput(std::string& strToVerify, const std::string& dlgHeading,
+    const std::string& dlgLine0, const std::string& dlgLine1,
+    const std::string& dlgLine2, bool bGetUserInput, bool bHideInputChars)
+{
+  // Prompt user for password input
+  CGUIDialogGamepad *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogGamepad>(WINDOW_DIALOG_GAMEPAD);
+  pDialog->m_strPassword = strToVerify;
+  pDialog->m_bUserInputCleanup = !bGetUserInput;
+  pDialog->m_bHideInputChars = bHideInputChars;
+
+  // HACK: This won't work if the label specified is actually a positive numeric value, but that's very unlikely
+  if (!StringUtils::IsNaturalNumber(dlgHeading))
+    pDialog->SetHeading(CVariant{dlgHeading});
+  else
+    pDialog->SetHeading(CVariant{atoi(dlgHeading.c_str())});
+
+  if (!StringUtils::IsNaturalNumber(dlgLine0))
+    pDialog->SetLine(0, CVariant{dlgLine0});
+  else
+    pDialog->SetLine(0, CVariant{atoi(dlgLine0.c_str())});
+
+  if (!StringUtils::IsNaturalNumber(dlgLine1))
+    pDialog->SetLine(1, CVariant{dlgLine1});
+  else
+    pDialog->SetLine(1, CVariant{atoi(dlgLine1.c_str())});
+
+  if (!StringUtils::IsNaturalNumber(dlgLine2))
+    pDialog->SetLine(2, CVariant{dlgLine2});
+  else
+    pDialog->SetLine(2, CVariant{atoi(dlgLine2.c_str())});
+
+  CGUIComponent* gui = CServiceBroker::GetGUI();
+  if (gui)
+    gui->GetAudioManager().Enable(false); // don't do sounds during pwd input
+
+  pDialog->Open();
+
+  if (gui)
+    gui->GetAudioManager().Enable(true);
+
+  if (bGetUserInput && !pDialog->IsCanceled())
+  {
+    strToVerify = CDigest::Calculate(CDigest::Type::MD5, pDialog->m_strUserInput);
+    pDialog->m_strUserInput = "";
+  }
+
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+  {
+    // user canceled out or entered an incorrect password
+    return false;
+  }
+
+  // user entered correct password
+  return true;
+}
+
+bool CGUIDialogGamepad::IsCanceled() const
+{
+  return m_bCanceled;
+}
+
diff --git a/xbmc/dialogs/GUIDialogGamepad.h b/xbmc/dialogs/GUIDialogGamepad.h
new file mode 100644
index 0000000..db520ac
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogGamepad.h
@@ -0,0 +1,35 @@
+/*
+ *  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 "GUIDialogBoxBase.h"
+
+class CGUIDialogGamepad :
+      public CGUIDialogBoxBase
+{
+public:
+  CGUIDialogGamepad(void);
+  ~CGUIDialogGamepad(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool IsCanceled() const;
+  std::string m_strUserInput;
+  std::string m_strPassword;
+  int m_iRetries;
+  bool m_bUserInputCleanup;
+  bool m_bHideInputChars;
+  static bool ShowAndGetInput(std::string& aTextString, const std::string& dlgHeading, bool bHideUserInput);
+  static bool ShowAndVerifyNewPassword(std::string& strNewPassword);
+  static int ShowAndVerifyPassword(std::string& strPassword, const std::string& dlgHeading, int iRetries);
+  static bool ShowAndVerifyInput(std::string& strPassword, const std::string& dlgHeading, const std::string& dlgLine0, const std::string& dlgLine1, const std::string& dlgLine2, bool bGetUserInput, bool bHideInputChars);
+protected:
+  bool OnAction(const CAction &action) override;
+  void OnInitWindow() override;
+  bool m_bCanceled;
+  char m_cHideInputChar;
+};
diff --git a/xbmc/dialogs/GUIDialogKaiToast.cpp b/xbmc/dialogs/GUIDialogKaiToast.cpp
new file mode 100644
index 0000000..2f8ca00
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKaiToast.cpp
@@ -0,0 +1,186 @@
+/*
+ *  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 "GUIDialogKaiToast.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIFadeLabelControl.h"
+#include "guilib/GUIMessage.h"
+#include "peripherals/Peripherals.h"
+#include "utils/TimeUtils.h"
+
+#include <mutex>
+
+#define POPUP_ICON                400
+#define POPUP_CAPTION_TEXT        401
+#define POPUP_NOTIFICATION_BUTTON 402
+
+CGUIDialogKaiToast::TOASTQUEUE CGUIDialogKaiToast::m_notifications;
+CCriticalSection CGUIDialogKaiToast::m_critical;
+
+CGUIDialogKaiToast::CGUIDialogKaiToast(void)
+  : CGUIDialog(WINDOW_DIALOG_KAI_TOAST, "DialogNotification.xml", DialogModalityType::MODELESS)
+{
+  m_loadType = LOAD_ON_GUI_INIT;
+  m_timer = 0;
+  m_toastDisplayTime = 0;
+  m_toastMessageTime = 0;
+}
+
+CGUIDialogKaiToast::~CGUIDialogKaiToast(void) = default;
+
+bool CGUIDialogKaiToast::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      CGUIDialog::OnMessage(message);
+      ResetTimer();
+      return true;
+    }
+    break;
+
+  case GUI_MSG_WINDOW_DEINIT:
+    {
+    }
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogKaiToast::QueueNotification(eMessageType eType, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime /*= TOAST_DISPLAY_TIME*/, bool withSound /*= true*/, unsigned int messageTime /*= TOAST_MESSAGE_TIME*/)
+{
+  AddToQueue("", eType, aCaption, aDescription, displayTime, withSound, messageTime);
+}
+
+void CGUIDialogKaiToast::QueueNotification(const std::string& aCaption, const std::string& aDescription)
+{
+  QueueNotification("", aCaption, aDescription);
+}
+
+void CGUIDialogKaiToast::QueueNotification(const std::string& aImageFile, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime /*= TOAST_DISPLAY_TIME*/, bool withSound /*= true*/, unsigned int messageTime /*= TOAST_MESSAGE_TIME*/)
+{
+  AddToQueue(aImageFile, Default, aCaption, aDescription, displayTime, withSound, messageTime);
+}
+
+void CGUIDialogKaiToast::AddToQueue(const std::string& aImageFile, const eMessageType eType, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime /*= TOAST_DISPLAY_TIME*/, bool withSound /*= true*/, unsigned int messageTime /*= TOAST_MESSAGE_TIME*/)
+{
+  std::unique_lock<CCriticalSection> lock(m_critical);
+
+  if (!m_notifications.empty())
+  {
+    const auto& last = m_notifications.back();
+    if (last.eType == eType && last.imagefile == aImageFile && last.caption == aCaption &&
+        last.description == aDescription)
+      return; // avoid duplicates in a row.
+  }
+
+  Notification toast;
+  toast.eType = eType;
+  toast.imagefile = aImageFile;
+  toast.caption = aCaption;
+  toast.description = aDescription;
+  toast.displayTime = displayTime > TOAST_MESSAGE_TIME + 500 ? displayTime : TOAST_MESSAGE_TIME + 500;
+  toast.messageTime = messageTime;
+  toast.withSound = withSound;
+
+  m_notifications.push(toast);
+}
+
+bool CGUIDialogKaiToast::DoWork()
+{
+  std::unique_lock<CCriticalSection> lock(m_critical);
+
+  if (!m_notifications.empty() &&
+      CTimeUtils::GetFrameTime() - m_timer > m_toastMessageTime)
+  {
+    // if we have a fade label control for the text to display, ensure the whole text was shown
+    // (scrolled to the end) before we move on to the next message
+    const CGUIFadeLabelControl* notificationText =
+        dynamic_cast<const CGUIFadeLabelControl*>(GetControl(POPUP_NOTIFICATION_BUTTON));
+    if (notificationText && !notificationText->AllLabelsShown())
+      return false;
+
+    Notification toast = m_notifications.front();
+    m_notifications.pop();
+    lock.unlock();
+
+    m_toastDisplayTime = toast.displayTime;
+    m_toastMessageTime = toast.messageTime;
+
+    std::unique_lock<CCriticalSection> lock2(CServiceBroker::GetWinSystem()->GetGfxContext());
+
+    if(!Initialize())
+      return false;
+
+    SET_CONTROL_LABEL(POPUP_CAPTION_TEXT, toast.caption);
+
+    SET_CONTROL_LABEL(POPUP_NOTIFICATION_BUTTON, toast.description);
+
+    // set the appropriate icon
+    {
+      std::string icon = toast.imagefile;
+      if (icon.empty())
+      {
+        if (toast.eType == Warning)
+          icon = "DefaultIconWarning.png";
+        else if (toast.eType == Error)
+          icon = "DefaultIconError.png";
+        else
+          icon = "DefaultIconInfo.png";
+      }
+      SET_CONTROL_FILENAME(POPUP_ICON, icon);
+    }
+
+    //  Play the window specific init sound for each notification queued
+    SetSound(toast.withSound);
+
+    // Activate haptics for this notification
+    CServiceBroker::GetPeripherals().OnUserNotification();
+
+    ResetTimer();
+    return true;
+  }
+
+  return false;
+}
+
+
+void CGUIDialogKaiToast::ResetTimer()
+{
+  m_timer = CTimeUtils::GetFrameTime();
+}
+
+void CGUIDialogKaiToast::FrameMove()
+{
+  //  Fading does not count as display time
+  if (IsAnimating(ANIM_TYPE_WINDOW_OPEN))
+    ResetTimer();
+
+  // now check if we should exit
+  if (CTimeUtils::GetFrameTime() - m_timer > m_toastDisplayTime)
+  {
+    bool bClose = true;
+
+    // if we have a fade label control for the text to display, ensure the whole text was shown
+    // (scrolled to the end) before we're closing the toast dialog
+    const CGUIFadeLabelControl* notificationText =
+        dynamic_cast<const CGUIFadeLabelControl*>(GetControl(POPUP_NOTIFICATION_BUTTON));
+    if (notificationText)
+    {
+      std::unique_lock<CCriticalSection> lock(m_critical);
+      bClose = notificationText->AllLabelsShown() && m_notifications.empty();
+    }
+
+    if (bClose)
+      Close();
+  }
+
+  CGUIDialog::FrameMove();
+}
diff --git a/xbmc/dialogs/GUIDialogKaiToast.h b/xbmc/dialogs/GUIDialogKaiToast.h
new file mode 100644
index 0000000..78f2919
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKaiToast.h
@@ -0,0 +1,58 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+#include <queue>
+
+#define TOAST_DISPLAY_TIME   5000L  // default 5 seconds
+#define TOAST_MESSAGE_TIME   1000L  // minimal message time 1 second
+
+class CGUIDialogKaiToast: public CGUIDialog
+{
+public:
+  CGUIDialogKaiToast(void);
+  ~CGUIDialogKaiToast(void) override;
+
+  enum eMessageType { Default = 0, Info, Warning, Error };
+
+  struct Notification
+  {
+    std::string caption;
+    std::string description;
+    std::string imagefile;
+    eMessageType eType;
+    unsigned int displayTime;
+    unsigned int messageTime;
+    bool withSound;
+  };
+
+  typedef std::queue<Notification> TOASTQUEUE;
+
+  static void QueueNotification(eMessageType eType, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime = TOAST_DISPLAY_TIME, bool withSound = true, unsigned int messageTime = TOAST_MESSAGE_TIME);
+  static void QueueNotification(const std::string& aCaption, const std::string& aDescription);
+  static void QueueNotification(const std::string& aImageFile, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime = TOAST_DISPLAY_TIME, bool withSound = true, unsigned int messageTime = TOAST_MESSAGE_TIME);
+  bool DoWork();
+
+  bool OnMessage(CGUIMessage& message) override;
+  void FrameMove() override;
+  void ResetTimer();
+
+protected:
+  static void AddToQueue(const std::string& aImageFile, const eMessageType eType, const std::string& aCaption, const std::string& aDescription, unsigned int displayTime, bool withSound, unsigned int messageTime);
+
+  unsigned int m_timer;
+
+  unsigned int m_toastDisplayTime;
+  unsigned int m_toastMessageTime;
+
+  static TOASTQUEUE m_notifications;
+  static CCriticalSection m_critical;
+};
diff --git a/xbmc/dialogs/GUIDialogKeyboardGeneric.cpp b/xbmc/dialogs/GUIDialogKeyboardGeneric.cpp
new file mode 100644
index 0000000..5eeed8f
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKeyboardGeneric.cpp
@@ -0,0 +1,843 @@
+/*
+ *  Copyright (C) 2012-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 "GUIDialogKeyboardGeneric.h"
+
+#include "GUIDialogNumeric.h"
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "dialogs/GUIDialogKaiToast.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIEditControl.h"
+#include "guilib/GUILabelControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/InputCodingTable.h"
+#include "input/Key.h"
+#include "input/KeyboardLayoutManager.h"
+#include "input/XBMC_vkeys.h"
+#include "interfaces/AnnouncementManager.h"
+#include "messaging/ApplicationMessenger.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "speech/ISpeechRecognition.h"
+#include "speech/ISpeechRecognitionListener.h"
+#include "speech/SpeechRecognitionErrors.h"
+#include "utils/CharsetConverter.h"
+#include "utils/RegExp.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+#include "windowing/WinSystem.h"
+
+#include <mutex>
+
+using namespace KODI::MESSAGING;
+
+#define BUTTON_ID_OFFSET      100
+#define BUTTONS_PER_ROW        20
+#define BUTTONS_MAX_ROWS        4
+
+#define CTL_BUTTON_DONE       300
+#define CTL_BUTTON_CANCEL     301
+#define CTL_BUTTON_SHIFT      302
+#define CTL_BUTTON_CAPS       303
+#define CTL_BUTTON_SYMBOLS    304
+#define CTL_BUTTON_LEFT       305
+#define CTL_BUTTON_RIGHT      306
+#define CTL_BUTTON_IP_ADDRESS 307
+#define CTL_BUTTON_CLEAR      308
+#define CTL_BUTTON_LAYOUT     309
+#define CTL_BUTTON_REVEAL     310
+#define CTL_LABEL_HEADING     311
+#define CTL_EDIT              312
+#define CTL_LABEL_HZCODE      313
+#define CTL_LABEL_HZLIST      314
+
+#define CTL_BUTTON_BACKSPACE    8
+#define CTL_BUTTON_SPACE       32
+
+#define SEARCH_DELAY         1000
+
+class CSpeechRecognitionListener : public speech::ISpeechRecognitionListener
+{
+public:
+  CSpeechRecognitionListener(int dialogId) : m_dialogId(dialogId) {}
+
+  void OnReadyForSpeech() override
+  {
+    CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info,
+                                          g_localizeStrings.Get(39177), // Speech to text
+                                          g_localizeStrings.Get(39179)); // Listening...
+  }
+
+  void OnError(int recognitionError) override
+  {
+    uint32_t msgId = 0;
+    switch (recognitionError)
+    {
+      case speech::RecognitionError::SERVICE_NOT_AVAILABLE:
+        msgId = 39178; // Speech recognition service not available
+        break;
+      case speech::RecognitionError::NO_MATCH:
+        msgId = 39180; // No recognition result matched
+        break;
+      case speech::RecognitionError::INSUFFICIENT_PERMISSIONS:
+        msgId = 39185; // Insufficient permissions for speech recognition
+        break;
+      default:
+        msgId = 39181; // Speech recognition error
+        break;
+    }
+
+    CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error,
+                                          g_localizeStrings.Get(39177), // Speech to text
+                                          g_localizeStrings.Get(msgId));
+  }
+
+  void OnResults(const std::vector<std::string>& results) override
+  {
+    if (!results.empty())
+    {
+      CGUIMessage msg(GUI_MSG_SET_TEXT, m_dialogId, CTL_EDIT);
+      msg.SetLabel(results.front());
+
+      // dispatch to GUI thread
+      CServiceBroker::GetAppMessenger()->SendGUIMessage(msg, m_dialogId);
+    }
+  }
+
+private:
+  const int m_dialogId{0};
+};
+
+CGUIDialogKeyboardGeneric::CGUIDialogKeyboardGeneric()
+: CGUIDialog(WINDOW_DIALOG_KEYBOARD, "DialogKeyboard.xml")
+, CGUIKeyboard()
+, m_pCharCallback(NULL)
+{
+  m_bIsConfirmed = false;
+  m_bShift = false;
+  m_hiddenInput = false;
+  m_keyType = LOWER;
+  m_currentLayout = 0;
+  m_loadType = KEEP_IN_MEMORY;
+  m_isKeyboardNavigationMode = false;
+  m_previouslyFocusedButton = 0;
+  m_pos = 0;
+  m_listwidth = 600;
+}
+
+void CGUIDialogKeyboardGeneric::OnWindowLoaded()
+{
+  CGUIEditControl *edit = static_cast<CGUIEditControl*>(GetControl(CTL_EDIT));
+  if (edit)
+  {
+    // add control CTL_LABEL_HZCODE and CTL_LABEL_HZLIST if not exist
+    CGUIControlGroup *ParentControl = static_cast<CGUIControlGroup*>(edit->GetParentControl());
+    CLabelInfo labelInfo = edit->GetLabelInfo();
+    float px = edit->GetXPosition();
+    float py = edit->GetYPosition();
+    float pw = edit->GetWidth();
+    float ph = edit->GetHeight();
+
+    CGUILabelControl* control = static_cast<CGUILabelControl*>(GetControl(CTL_LABEL_HZCODE));
+    if (!control)
+    {
+      control = new CGUILabelControl(GetID(), CTL_LABEL_HZCODE, px, py + ph, 90, 30, labelInfo, false, false);
+      ParentControl->AddControl(control);
+    }
+
+    control = static_cast<CGUILabelControl*>(GetControl(CTL_LABEL_HZLIST));
+    if (!control)
+    {
+      labelInfo.align = XBFONT_CENTER_Y;
+      control = new CGUILabelControl(GetID(), CTL_LABEL_HZLIST, px + 95, py + ph, pw - 95, 30, labelInfo, false, false);
+      ParentControl->AddControl(control);
+    }
+  }
+
+  CGUIDialog::OnWindowLoaded();
+}
+
+void CGUIDialogKeyboardGeneric::OnInitWindow()
+{
+  CGUIDialog::OnInitWindow();
+
+  m_bIsConfirmed = false;
+  m_isKeyboardNavigationMode = false;
+
+  // fill in the keyboard layouts
+  m_currentLayout = 0;
+  m_layouts.clear();
+  const KeyboardLayouts& keyboardLayouts = CServiceBroker::GetKeyboardLayoutManager()->GetLayouts();
+  const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
+  std::vector<CVariant> layoutNames = settings->GetList(CSettings::SETTING_LOCALE_KEYBOARDLAYOUTS);
+  std::string activeLayout = settings->GetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT);
+
+  for (const auto& layoutName : layoutNames)
+  {
+    const auto keyboardLayout = keyboardLayouts.find(layoutName.asString());
+    if (keyboardLayout != keyboardLayouts.end())
+    {
+      m_layouts.emplace_back(keyboardLayout->second);
+      if (layoutName.asString() == activeLayout)
+        m_currentLayout = m_layouts.size() - 1;
+    }
+  }
+
+  // set alphabetic (capitals)
+  UpdateButtons();
+
+  // set heading
+  if (!m_strHeading.empty())
+  {
+    SET_CONTROL_LABEL(CTL_LABEL_HEADING, m_strHeading);
+    SET_CONTROL_VISIBLE(CTL_LABEL_HEADING);
+  }
+  else
+  {
+    SET_CONTROL_HIDDEN(CTL_LABEL_HEADING);
+  }
+  // set type
+  {
+    CGUIMessage msg(GUI_MSG_SET_TYPE, GetID(), CTL_EDIT, m_hiddenInput ? CGUIEditControl::INPUT_TYPE_PASSWORD : CGUIEditControl::INPUT_TYPE_TEXT);
+    OnMessage(msg);
+  }
+  if (m_hiddenInput)
+  {
+    SET_CONTROL_VISIBLE(CTL_BUTTON_REVEAL);
+    SET_CONTROL_LABEL(CTL_BUTTON_REVEAL, g_localizeStrings.Get(12308));
+  }
+  else
+    SET_CONTROL_HIDDEN(CTL_BUTTON_REVEAL);
+
+  SetEditText(m_text);
+
+  // get HZLIST label options
+  CGUILabelControl* pEdit = static_cast<CGUILabelControl*>(GetControl(CTL_LABEL_HZLIST));
+  CLabelInfo labelInfo = pEdit->GetLabelInfo();
+  m_listfont = labelInfo.font;
+  m_listwidth = pEdit->GetWidth();
+  m_hzcode.clear();
+  m_words.clear();
+  SET_CONTROL_LABEL(CTL_LABEL_HZCODE, "");
+  SET_CONTROL_LABEL(CTL_LABEL_HZLIST, "");
+
+  CVariant data;
+  data["title"] = m_strHeading;
+  data["type"] = !m_hiddenInput ? "keyboard" : "password";
+  data["value"] = GetText();
+  CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Input, "OnInputRequested", data);
+}
+
+bool CGUIDialogKeyboardGeneric::OnAction(const CAction &action)
+{
+  int actionId = action.GetID();
+  bool handled = true;
+  if (actionId == (KEY_VKEY | XBMCVK_BACK))
+    Backspace();
+  else if (actionId == ACTION_ENTER ||
+           (actionId == ACTION_SELECT_ITEM && (m_isKeyboardNavigationMode || GetFocusedControlID() == CTL_EDIT)))
+    OnOK();
+  else if (actionId == ACTION_SHIFT)
+    OnShift();
+  else if (actionId == ACTION_SYMBOLS)
+    OnSymbols();
+  // don't handle move left/right and select in the edit control
+  else if (!m_isKeyboardNavigationMode &&
+           (actionId == ACTION_MOVE_LEFT ||
+           actionId == ACTION_MOVE_RIGHT ||
+           actionId == ACTION_SELECT_ITEM))
+    handled = false;
+  else if (actionId == ACTION_VOICE_RECOGNIZE)
+    OnVoiceRecognition();
+  else
+  {
+    std::wstring wch = L"";
+    wch.insert(wch.begin(), action.GetUnicode());
+    std::string ch;
+    g_charsetConverter.wToUTF8(wch, ch);
+    handled = CodingCharacter(ch);
+    if (!handled)
+    {
+      // send action to edit control
+      CGUIControl *edit = GetControl(CTL_EDIT);
+      if (edit)
+        handled = edit->OnAction(action);
+      if (!handled && actionId >= KEY_VKEY && actionId < KEY_UNICODE)
+      {
+        unsigned char b = actionId & 0xFF;
+        if (b == XBMCVK_TAB)
+        {
+          // Toggle left/right key mode
+          m_isKeyboardNavigationMode = !m_isKeyboardNavigationMode;
+          if (m_isKeyboardNavigationMode)
+          {
+            m_previouslyFocusedButton = GetFocusedControlID();
+            SET_CONTROL_FOCUS(edit->GetID(), 0);
+          }
+          else
+            SET_CONTROL_FOCUS(m_previouslyFocusedButton, 0);
+          handled = true;
+        }
+      }
+    }
+  }
+
+  if (!handled) // unhandled by us - let's see if the baseclass wants it
+    handled = CGUIDialog::OnAction(action);
+
+  return handled;
+}
+
+bool CGUIDialogKeyboardGeneric::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+
+      switch (iControl)
+      {
+      case CTL_BUTTON_DONE:
+        OnOK();
+        break;
+      case CTL_BUTTON_CANCEL:
+        Close();
+        break;
+      case CTL_BUTTON_SHIFT:
+        OnShift();
+        break;
+      case CTL_BUTTON_CAPS:
+        if (m_keyType == LOWER)
+          m_keyType = CAPS;
+        else if (m_keyType == CAPS)
+          m_keyType = LOWER;
+        UpdateButtons();
+        break;
+      case CTL_BUTTON_LAYOUT:
+        OnLayout();
+        break;
+      case CTL_BUTTON_REVEAL:
+        OnReveal();
+        break;
+      case CTL_BUTTON_SYMBOLS:
+        OnSymbols();
+        break;
+      case CTL_BUTTON_LEFT:
+        MoveCursor( -1);
+        break;
+      case CTL_BUTTON_RIGHT:
+        MoveCursor(1);
+        break;
+      case CTL_BUTTON_IP_ADDRESS:
+        OnIPAddress();
+        break;
+      case CTL_BUTTON_CLEAR:
+        SetEditText("");
+        break;
+      case CTL_EDIT:
+      {
+        CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CTL_EDIT);
+        OnMessage(msg);
+        // update callback I guess?
+        if (m_pCharCallback)
+        { // we did _something_, so make sure our search message filter is reset
+          m_pCharCallback(this, msg.GetLabel());
+        }
+        m_text = msg.GetLabel();
+        return true;
+      }
+      default:
+        OnClickButton(iControl);
+        break;
+      }
+    }
+    break;
+
+  case GUI_MSG_SET_TEXT:
+    {
+      // the edit control only handles these messages if it is either focused
+      // or its specific control ID is set in the message. As neither is the
+      // case here (focus is on one of the keyboard buttons) we have to force
+      // the control ID of the message to the control ID of the edit control
+      // (unfortunately we have to create a whole copy of the message object for that)
+      CGUIMessage messageCopy(message.GetMessage(), message.GetSenderId(), CTL_EDIT, message.GetParam1(), message.GetParam2(), message.GetItem());
+      messageCopy.SetLabel(message.GetLabel());
+
+      // ensure this goes to the edit control
+      CGUIControl *edit = GetControl(CTL_EDIT);
+      if (edit)
+        edit->OnMessage(messageCopy);
+
+      // close the dialog if requested
+      if (message.GetMessage() == GUI_MSG_SET_TEXT && message.GetParam1() > 0)
+        OnOK();
+      return true;
+    }
+  case GUI_MSG_CODINGTABLE_LOOKUP_COMPLETED:
+    {
+      const std::string& code = message.GetStringParam();
+      if (code == m_hzcode)
+      {
+        int response = message.GetParam1();
+        auto words = m_codingtable->GetResponse(response);
+        m_words.insert(m_words.end(), words.begin(), words.end());
+        ShowWordList(0);
+      }
+    }
+  }
+
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogKeyboardGeneric::SetEditText(const std::string &text)
+{
+  CGUIMessage msg(GUI_MSG_SET_TEXT, GetID(), CTL_EDIT);
+  msg.SetLabel(text);
+  OnMessage(msg);
+}
+
+void CGUIDialogKeyboardGeneric::SetText(const std::string& text)
+{
+  m_text = text;
+}
+
+const std::string &CGUIDialogKeyboardGeneric::GetText() const
+{
+  return m_text;
+}
+
+void CGUIDialogKeyboardGeneric::Character(const std::string &ch)
+{
+  if (ch.empty()) return;
+  if (!CodingCharacter(ch))
+    NormalCharacter(ch);
+}
+
+void CGUIDialogKeyboardGeneric::NormalCharacter(const std::string &ch)
+{
+  // send text to edit control
+  CGUIControl *edit = GetControl(CTL_EDIT);
+  if (edit)
+  {
+    CAction action(ACTION_INPUT_TEXT);
+    action.SetText(ch);
+    edit->OnAction(action);
+  }
+}
+
+void CGUIDialogKeyboardGeneric::Backspace()
+{
+  if (m_codingtable && m_hzcode.length() > 0)
+  {
+    std::wstring tmp;
+    g_charsetConverter.utf8ToW(m_hzcode, tmp);
+    tmp.erase(tmp.length() - 1, 1);
+    g_charsetConverter.wToUTF8(tmp, m_hzcode);
+
+    switch (m_codingtable->GetType())
+    {
+    case IInputCodingTable::TYPE_WORD_LIST:
+      SetControlLabel(CTL_LABEL_HZCODE, m_hzcode);
+      ChangeWordList(0);
+      break;
+
+    case IInputCodingTable::TYPE_CONVERT_STRING:
+      SetEditText(m_codingtable->ConvertString(m_hzcode));
+      break;
+    }
+  }
+  else
+  {
+    // send action to edit control
+    CGUIControl *edit = GetControl(CTL_EDIT);
+    if (edit)
+      edit->OnAction(CAction(ACTION_BACKSPACE));
+
+    if (m_codingtable && m_codingtable->GetType() == IInputCodingTable::TYPE_CONVERT_STRING)
+      m_codingtable->SetTextPrev(GetText());
+  }
+}
+
+void CGUIDialogKeyboardGeneric::OnClickButton(int iButtonControl)
+{
+  if (iButtonControl == CTL_BUTTON_BACKSPACE)
+  {
+    Backspace();
+  }
+  else if (iButtonControl == CTL_BUTTON_SPACE)
+  {
+    Character(" ");
+  }
+  else
+  {
+    const CGUIControl* pButton = GetControl(iButtonControl);
+    // Do not register input for buttons with id >= 500
+    if (pButton && iButtonControl < 500)
+    {
+      Character(pButton->GetDescription());
+      // reset the shift keys
+      if (m_bShift) OnShift();
+    }
+  }
+}
+
+void CGUIDialogKeyboardGeneric::UpdateButtons()
+{
+  SET_CONTROL_SELECTED(GetID(), CTL_BUTTON_SHIFT, m_bShift);
+  SET_CONTROL_SELECTED(GetID(), CTL_BUTTON_CAPS, m_keyType == CAPS);
+  SET_CONTROL_SELECTED(GetID(), CTL_BUTTON_SYMBOLS, m_keyType == SYMBOLS);
+
+  if (m_currentLayout >= m_layouts.size())
+    m_currentLayout = 0;
+  CKeyboardLayout layout = m_layouts.empty() ? CKeyboardLayout() : m_layouts[m_currentLayout];
+  m_codingtable = layout.GetCodingTable();
+  if (m_codingtable && !m_codingtable->IsInitialized())
+    m_codingtable->Initialize();
+
+  bool bShowWordList = false;
+  if (m_codingtable)
+  {
+    switch (m_codingtable->GetType())
+    {
+    case IInputCodingTable::TYPE_WORD_LIST:
+      bShowWordList = true;
+      break;
+
+    case IInputCodingTable::TYPE_CONVERT_STRING:
+      m_codingtable->SetTextPrev(GetText());
+      m_hzcode.clear();
+      break;
+    }
+  }
+
+  if (bShowWordList)
+  {
+    SET_CONTROL_VISIBLE(CTL_LABEL_HZCODE);
+    SET_CONTROL_VISIBLE(CTL_LABEL_HZLIST);
+  }
+  else
+  {
+    SET_CONTROL_HIDDEN(CTL_LABEL_HZCODE);
+    SET_CONTROL_HIDDEN(CTL_LABEL_HZLIST);
+  }
+  SET_CONTROL_LABEL(CTL_BUTTON_LAYOUT, layout.GetName());
+
+  unsigned int modifiers = CKeyboardLayout::ModifierKeyNone;
+  if ((m_keyType == CAPS && !m_bShift) || (m_keyType == LOWER && m_bShift))
+    modifiers |= CKeyboardLayout::ModifierKeyShift;
+  if (m_keyType == SYMBOLS)
+  {
+    modifiers |= CKeyboardLayout::ModifierKeySymbol;
+    if (m_bShift)
+      modifiers |= CKeyboardLayout::ModifierKeyShift;
+  }
+
+  for (unsigned int row = 0; row < BUTTONS_MAX_ROWS; row++)
+  {
+    for (unsigned int column = 0; column < BUTTONS_PER_ROW; column++)
+    {
+      int buttonID = (row * BUTTONS_PER_ROW) + column + BUTTON_ID_OFFSET;
+      std::string label = layout.GetCharAt(row, column, modifiers);
+      SetControlLabel(buttonID, label);
+      if (!label.empty())
+        SET_CONTROL_VISIBLE(buttonID);
+      else
+        SET_CONTROL_HIDDEN(buttonID);
+    }
+  }
+}
+
+void CGUIDialogKeyboardGeneric::OnDeinitWindow(int nextWindowID)
+{
+  for (auto& layout : m_layouts)
+  {
+    auto codingTable = layout.GetCodingTable();
+    if (codingTable && codingTable->IsInitialized())
+      codingTable->Deinitialize();
+  }
+  // call base class
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+  // reset the heading (we don't always have this)
+  m_strHeading = "";
+
+  CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Input, "OnInputFinished");
+}
+
+void CGUIDialogKeyboardGeneric::MoveCursor(int iAmount)
+{
+  if (m_codingtable && m_words.size())
+    ChangeWordList(iAmount);
+  else
+  {
+    CGUIControl *edit = GetControl(CTL_EDIT);
+    if (edit)
+      edit->OnAction(CAction(iAmount < 0 ? ACTION_CURSOR_LEFT : ACTION_CURSOR_RIGHT));
+  }
+}
+
+void CGUIDialogKeyboardGeneric::OnLayout()
+{
+  m_currentLayout++;
+  if (m_currentLayout >= m_layouts.size())
+    m_currentLayout = 0;
+  CKeyboardLayout layout = m_layouts.empty() ? CKeyboardLayout() : m_layouts[m_currentLayout];
+  CServiceBroker::GetSettingsComponent()->GetSettings()->SetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT, layout.GetName());
+  UpdateButtons();
+}
+
+void CGUIDialogKeyboardGeneric::OnSymbols()
+{
+  if (m_keyType == SYMBOLS)
+    m_keyType = LOWER;
+  else
+    m_keyType = SYMBOLS;
+  UpdateButtons();
+}
+
+void CGUIDialogKeyboardGeneric::OnReveal()
+{
+  m_hiddenInput = !m_hiddenInput;
+  SET_CONTROL_LABEL(CTL_BUTTON_REVEAL, g_localizeStrings.Get(m_hiddenInput ? 12308 : 12309));
+  CGUIMessage msg(GUI_MSG_SET_TYPE, GetID(), CTL_EDIT,
+                  m_hiddenInput ? CGUIEditControl::INPUT_TYPE_PASSWORD
+                                : CGUIEditControl::INPUT_TYPE_TEXT);
+  OnMessage(msg);
+}
+
+void CGUIDialogKeyboardGeneric::OnShift()
+{
+  m_bShift = !m_bShift;
+  UpdateButtons();
+}
+
+void CGUIDialogKeyboardGeneric::OnIPAddress()
+{
+  // find any IP address in the current string if there is any
+  // We match to #.#.#.#
+  std::string text = GetText();
+  std::string ip;
+  CRegExp reg;
+  reg.RegComp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
+  int start = reg.RegFind(text.c_str());
+  int length = 0;
+  if (start > -1)
+  {
+    length = reg.GetSubLength(0);
+    ip = text.substr(start, length);
+  }
+  else
+    start = text.size();
+  if (CGUIDialogNumeric::ShowAndGetIPAddress(ip, g_localizeStrings.Get(14068)))
+    SetEditText(text.substr(0, start) + ip.c_str() + text.substr(start + length));
+}
+
+void CGUIDialogKeyboardGeneric::OnVoiceRecognition()
+{
+  const auto speechRecognition = CServiceBroker::GetSpeechRecognition();
+  if (speechRecognition)
+  {
+    if (!m_speechRecognitionListener)
+      m_speechRecognitionListener = std::make_shared<CSpeechRecognitionListener>(GetID());
+
+    speechRecognition->StartSpeechRecognition(m_speechRecognitionListener);
+  }
+  else
+  {
+    CLog::LogF(LOGWARNING, "No voice recognition implementation available.");
+  }
+}
+
+void CGUIDialogKeyboardGeneric::SetControlLabel(int id, const std::string &label)
+{ // find all controls with this id, and set all their labels
+  CGUIMessage message(GUI_MSG_LABEL_SET, GetID(), id);
+  message.SetLabel(label);
+  for (unsigned int i = 0; i < m_children.size(); i++)
+  {
+    if (m_children[i]->GetID() == id || m_children[i]->IsGroup())
+      m_children[i]->OnMessage(message);
+  }
+}
+
+void CGUIDialogKeyboardGeneric::OnOK()
+{
+  m_bIsConfirmed = true;
+  Close();
+}
+
+void CGUIDialogKeyboardGeneric::SetHeading(const std::string &heading)
+{
+  m_strHeading = heading;
+}
+
+int CGUIDialogKeyboardGeneric::GetWindowId() const
+{
+  return GetID();
+}
+
+void CGUIDialogKeyboardGeneric::Cancel()
+{
+  m_bIsConfirmed = false;
+  Close();
+}
+
+bool CGUIDialogKeyboardGeneric::ShowAndGetInput(char_callback_t pCallback, const std::string &initialString, std::string &typedString, const std::string &heading, bool bHiddenInput)
+{
+  CGUIDialogKeyboardGeneric *pKeyboard = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogKeyboardGeneric>(WINDOW_DIALOG_KEYBOARD);
+
+  if (!pKeyboard)
+    return false;
+
+  m_pCharCallback = pCallback;
+  // setup keyboard
+  pKeyboard->Initialize();
+  pKeyboard->SetHeading(heading);
+  pKeyboard->SetHiddenInput(bHiddenInput);
+  pKeyboard->SetText(initialString);
+  pKeyboard->Open();
+  pKeyboard->Close();
+
+  // If have text - update this.
+  if (pKeyboard->IsConfirmed())
+  {
+    typedString = pKeyboard->GetText();
+    return true;
+  }
+  else return false;
+}
+
+float CGUIDialogKeyboardGeneric::GetStringWidth(const std::wstring & utf16)
+{
+  vecText utf32;
+
+  utf32.resize(utf16.size());
+  for (unsigned int i = 0; i < utf16.size(); i++)
+    utf32[i] = utf16[i];
+
+  return m_listfont->GetTextWidth(utf32);
+}
+
+void CGUIDialogKeyboardGeneric::ChangeWordList(int direct)
+{
+  if (direct == 0)
+  {
+    m_pos = 0;
+    m_words.clear();
+    m_codingtable->GetWordListPage(m_hzcode, true);
+  }
+  else
+  {
+    ShowWordList(direct);
+    if (direct > 0 && m_pos + m_num == static_cast<int>(m_words.size()))
+      m_codingtable->GetWordListPage(m_hzcode, false);
+  }
+}
+
+void CGUIDialogKeyboardGeneric::ShowWordList(int direct)
+{
+  std::unique_lock<CCriticalSection> lock(m_CS);
+  std::wstring hzlist = L"";
+  CServiceBroker::GetWinSystem()->GetGfxContext().SetScalingResolution(m_coordsRes, true);
+  float width = m_listfont->GetCharWidth(L'<') + m_listfont->GetCharWidth(L'>');
+  float spacewidth = m_listfont->GetCharWidth(L' ');
+  float numwidth = m_listfont->GetCharWidth(L'1') + m_listfont->GetCharWidth(L'.');
+  int i;
+
+  if (direct >= 0)
+  {
+    if (direct > 0)
+      m_pos += m_num;
+    if (m_pos > static_cast<int>(m_words.size()) - 1)
+      m_pos = 0;
+    for (i = 0; m_pos + i < static_cast<int>(m_words.size()); i++)
+    {
+      if ((i > 0 && width + GetStringWidth(m_words[m_pos + i]) + numwidth > m_listwidth) || i > 9)
+        break;
+      hzlist.insert(hzlist.length(), 1, (wchar_t)(i + 48));
+      hzlist.insert(hzlist.length(), 1, L'.');
+      hzlist.append(m_words[m_pos + i]);
+      hzlist.insert(hzlist.length(), 1, L' ');
+      width += GetStringWidth(m_words[m_pos + i]) + numwidth + spacewidth;
+    }
+    m_num = i;
+  }
+  else
+  {
+    if (m_pos == 0)
+      return;
+    for (i = 1; i <= 10; i++)
+    {
+      if (m_pos - i < 0 || (i > 1 && width + GetStringWidth(m_words[m_pos - i]) + numwidth > m_listwidth))
+        break;
+      width += GetStringWidth(m_words[m_pos - i]) + numwidth + spacewidth;
+    }
+    m_num = --i;
+    m_pos -= m_num;
+    for (i = 0; i < m_num; i++)
+    {
+      hzlist.insert(hzlist.length(), 1, (wchar_t)(i + 48));
+      hzlist.insert(hzlist.length(), 1, L'.');
+      hzlist.append(m_words[m_pos + i]);
+      hzlist.insert(hzlist.length(), 1, L' ');
+    }
+  }
+  hzlist.erase(hzlist.find_last_not_of(L' ') + 1);
+  if (m_pos > 0)
+    hzlist.insert(0, 1, L'<');
+  if (m_pos + m_num < static_cast<int>(m_words.size()))
+    hzlist.insert(hzlist.length(), 1, L'>');
+  std::string utf8String;
+  g_charsetConverter.wToUTF8(hzlist, utf8String);
+  SET_CONTROL_LABEL(CTL_LABEL_HZLIST, utf8String);
+}
+
+bool CGUIDialogKeyboardGeneric::CodingCharacter(const std::string &ch)
+{
+  if (!m_codingtable)
+    return false;
+
+  switch (m_codingtable->GetType())
+  {
+  case IInputCodingTable::TYPE_CONVERT_STRING:
+    if (!ch.empty() && ch[0] != 0)
+    {
+      m_hzcode += ch;
+      SetEditText(m_codingtable->ConvertString(m_hzcode));
+      return true;
+    }
+    break;
+
+  case IInputCodingTable::TYPE_WORD_LIST:
+    if (m_codingtable->GetCodeChars().find(ch) != std::string::npos)
+    {
+      m_hzcode += ch;
+      SetControlLabel(CTL_LABEL_HZCODE, m_hzcode);
+      ChangeWordList(0);
+      return true;
+    }
+    if (ch[0] >= '0' && ch[0] <= '9')
+    {
+      int i = m_pos + (int)ch[0] - 48;
+      if (i < (m_pos + m_num))
+      {
+        m_hzcode = "";
+        SetControlLabel(CTL_LABEL_HZCODE, m_hzcode);
+        std::string utf8String;
+        g_charsetConverter.wToUTF8(m_words[i], utf8String);
+        NormalCharacter(utf8String);
+      }
+      return true;
+    }
+    break;
+  }
+
+  return false;
+}
diff --git a/xbmc/dialogs/GUIDialogKeyboardGeneric.h b/xbmc/dialogs/GUIDialogKeyboardGeneric.h
new file mode 100644
index 0000000..c88d056
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKeyboardGeneric.h
@@ -0,0 +1,95 @@
+/*
+ *  Copyright (C) 2012-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 "guilib/GUIDialog.h"
+#include "guilib/GUIKeyboard.h"
+#include "input/KeyboardLayout.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class CGUIFont;
+
+class CSpeechRecognitionListener;
+
+enum KEYBOARD {CAPS, LOWER, SYMBOLS};
+
+class CGUIDialogKeyboardGeneric : public CGUIDialog, public CGUIKeyboard
+{
+  public:
+    CGUIDialogKeyboardGeneric();
+
+    //CGUIKeyboard Interface
+    bool ShowAndGetInput(char_callback_t pCallback, const std::string &initialString, std::string &typedString, const std::string &heading, bool bHiddenInput) override;
+    void Cancel() override;
+    int GetWindowId() const override;
+
+    void SetHeading(const std::string& heading);
+    void SetText(const std::string& text);
+    const std::string &GetText() const;
+    bool IsConfirmed() { return m_bIsConfirmed; }
+    void SetHiddenInput(bool hiddenInput) { m_hiddenInput = hiddenInput; }
+    bool IsInputHidden() const { return m_hiddenInput; }
+
+  protected:
+    void OnWindowLoaded() override;
+    void OnInitWindow() override;
+    bool OnAction(const CAction &action) override;
+    bool OnMessage(CGUIMessage& message) override;
+    void OnDeinitWindow(int nextWindowID) override;
+    void SetControlLabel(int id, const std::string &label);
+    void OnShift();
+    void MoveCursor(int iAmount);
+    void OnLayout();
+    void OnReveal();
+    void OnSymbols();
+    void OnIPAddress();
+    void OnVoiceRecognition();
+    void OnOK();
+
+  private:
+    void OnClickButton(int iButtonControl);
+    void UpdateButtons();
+    void Character(const std::string &ch);
+    void Backspace();
+    void SetEditText(const std::string& text);
+    float GetStringWidth(const std::wstring& utf16);
+    void ChangeWordList(int direct);  // direct: 0 - first page, 1 - next page, -1 - prev page
+    void ShowWordList(int which); // which: 0 - current page, 1 - next page, -1 -prev page
+    bool CodingCharacter(const std::string &ch);
+    void NormalCharacter(const std::string &ch);
+
+    bool m_bIsConfirmed;
+    KEYBOARD m_keyType;
+    bool m_bShift;
+    bool m_hiddenInput;
+    bool m_isKeyboardNavigationMode;
+    int m_previouslyFocusedButton;
+
+    std::vector<CKeyboardLayout> m_layouts;
+    unsigned int                 m_currentLayout;
+
+    std::string m_strHeading;
+    std::string m_text;       ///< current text
+
+    IInputCodingTablePtr m_codingtable;
+    std::vector<std::wstring> m_words;
+    std::string m_hzcode;
+    int         m_pos;
+    int         m_num = 0;
+    float       m_listwidth;
+    CGUIFont   *m_listfont = nullptr;
+    CCriticalSection  m_CS;
+
+    char_callback_t m_pCharCallback;
+
+    std::shared_ptr<CSpeechRecognitionListener> m_speechRecognitionListener;
+};
diff --git a/xbmc/dialogs/GUIDialogKeyboardTouch.cpp b/xbmc/dialogs/GUIDialogKeyboardTouch.cpp
new file mode 100644
index 0000000..e9511ce
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKeyboardTouch.cpp
@@ -0,0 +1,86 @@
+/*
+ *  Copyright (C) 2012-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 "GUIDialogKeyboardTouch.h"
+#if defined(TARGET_DARWIN_EMBEDDED)
+#include "platform/darwin/ios-common/DarwinEmbedKeyboard.h"
+#endif
+
+CGUIDialogKeyboardTouch::CGUIDialogKeyboardTouch()
+: CGUIDialog(WINDOW_DIALOG_KEYBOARD_TOUCH, "")
+, CGUIKeyboard()
+, CThread("keyboard")
+, m_pCharCallback(NULL)
+{
+}
+
+bool CGUIDialogKeyboardTouch::ShowAndGetInput(char_callback_t pCallback, const std::string &initialString, std::string &typedString, const std::string &heading, bool bHiddenInput)
+{
+#if defined(TARGET_DARWIN_EMBEDDED)
+  m_keyboard.reset(new CDarwinEmbedKeyboard());
+#endif
+
+  if (!m_keyboard)
+    return false;
+
+  m_pCharCallback = pCallback;
+  m_initialString = initialString;
+  m_typedString = typedString;
+  m_heading = heading;
+  m_bHiddenInput = bHiddenInput;
+
+  m_confirmed = false;
+  Initialize();
+  Open();
+
+  m_keyboard.reset();
+
+  if (m_confirmed)
+  {
+    typedString = m_typedString;
+    return true;
+  }
+
+  return false;
+}
+
+bool CGUIDialogKeyboardTouch::SetTextToKeyboard(const std::string &text, bool closeKeyboard)
+{
+  if (m_keyboard)
+    return m_keyboard->SetTextToKeyboard(text, closeKeyboard);
+
+  return false;
+}
+
+void CGUIDialogKeyboardTouch::Cancel()
+{
+  if (m_keyboard)
+    m_keyboard->Cancel();
+}
+
+int CGUIDialogKeyboardTouch::GetWindowId() const
+{
+  return GetID();
+}
+
+void CGUIDialogKeyboardTouch::OnInitWindow()
+{
+  CGUIDialog::OnInitWindow();
+  m_windowLoaded = true;
+  m_active = true;
+  Create();
+}
+
+void CGUIDialogKeyboardTouch::Process()
+{
+  if (m_keyboard)
+  {
+    m_confirmed = m_keyboard->ShowAndGetInput(m_pCharCallback, m_initialString, m_typedString, m_heading, m_bHiddenInput);
+  }
+  Close();
+}
\ No newline at end of file
diff --git a/xbmc/dialogs/GUIDialogKeyboardTouch.h b/xbmc/dialogs/GUIDialogKeyboardTouch.h
new file mode 100644
index 0000000..e7ad433
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogKeyboardTouch.h
@@ -0,0 +1,40 @@
+/*
+ *  Copyright (C) 2012-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 "guilib/GUIDialog.h"
+#include "guilib/GUIKeyboard.h"
+
+#include <atomic>
+#include <memory>
+
+class CGUIDialogKeyboardTouch : public CGUIDialog, public CGUIKeyboard, public CThread
+{
+public:
+  CGUIDialogKeyboardTouch();
+  bool ShowAndGetInput(char_callback_t pCallback, const std::string &initialString, std::string &typedString, const std::string &heading, bool bHiddenInput) override;
+  bool SetTextToKeyboard(const std::string &text, bool closeKeyboard = false) override;
+  void Cancel() override;
+  int GetWindowId() const override;
+
+protected:
+  void OnInitWindow() override;
+  using CGUIControlGroup::Process;
+  void Process() override;
+
+  char_callback_t m_pCharCallback;
+  std::string m_initialString;
+  std::string m_typedString;
+  std::string m_heading;
+  bool m_bHiddenInput;
+
+  std::unique_ptr<CGUIKeyboard> m_keyboard;
+  std::atomic_bool m_active;
+  bool m_confirmed;
+};
diff --git a/xbmc/dialogs/GUIDialogMediaFilter.cpp b/xbmc/dialogs/GUIDialogMediaFilter.cpp
new file mode 100644
index 0000000..4985627
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogMediaFilter.cpp
@@ -0,0 +1,937 @@
+/*
+ *  Copyright (C) 2012-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 "GUIDialogMediaFilter.h"
+
+#include "DbUrl.h"
+#include "FileItem.h"
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "XBDateTime.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "music/MusicDatabase.h"
+#include "music/MusicDbUrl.h"
+#include "playlists/SmartPlayList.h"
+#include "settings/SettingUtils.h"
+#include "settings/lib/Setting.h"
+#include "settings/lib/SettingDefinitions.h"
+#include "settings/windows/GUIControlSettings.h"
+#include "utils/SortUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+#include "video/VideoDatabase.h"
+#include "video/VideoDbUrl.h"
+
+#define CONTROL_HEADING             2
+
+#define CONTROL_OKAY_BUTTON        28
+#define CONTROL_CANCEL_BUTTON      29
+#define CONTROL_CLEAR_BUTTON       30
+
+#define CHECK_ALL                  -1
+#define CHECK_NO                    0
+#define CHECK_YES                   1
+#define CHECK_LABEL_ALL           593
+#define CHECK_LABEL_NO            106
+#define CHECK_LABEL_YES           107
+
+static const CGUIDialogMediaFilter::Filter filterList[] = {
+  { "movies",       FieldTitle,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "movies",       FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "movies",       FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  //{ "movies",       FieldTime,          180,    SettingType::Integer, "range",  "time",     CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "movies",       FieldInProgress,    575,    SettingType::Integer, "toggle", "",         CDatabaseQueryRule::OPERATOR_FALSE },
+  { "movies",       FieldYear,          562,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "movies",       FieldTag,           20459,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "movies",       FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "movies",       FieldActor,         20337,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "movies",       FieldDirector,      20339,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "movies",       FieldStudio,        572,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+
+  { "tvshows",      FieldTitle,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  //{ "tvshows",      FieldTvShowStatus,  126,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "tvshows",      FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "tvshows",      FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "tvshows",      FieldInProgress,    575,    SettingType::Integer, "toggle", "",         CDatabaseQueryRule::OPERATOR_FALSE },
+  { "tvshows",      FieldYear,          562,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "tvshows",      FieldTag,           20459,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "tvshows",      FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "tvshows",      FieldActor,         20337,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "tvshows",      FieldDirector,      20339,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "tvshows",      FieldStudio,        572,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+
+  { "episodes",     FieldTitle,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "episodes",     FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "episodes",     FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "episodes",     FieldAirDate,       20416,  SettingType::Integer, "range",  "date",     CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "episodes",     FieldInProgress,    575,    SettingType::Integer, "toggle", "",         CDatabaseQueryRule::OPERATOR_FALSE },
+  { "episodes",     FieldActor,         20337,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "episodes",     FieldDirector,      20339,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+
+  { "musicvideos",  FieldTitle,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "musicvideos",  FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "musicvideos",  FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "musicvideos",  FieldArtist,        557,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "musicvideos",  FieldAlbum,         558,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  //{ "musicvideos",  FieldTime,          180,    SettingType::Integer, "range",  "time",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "musicvideos",  FieldYear,          562,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "musicvideos",  FieldTag,           20459,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "musicvideos",  FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "musicvideos",  FieldDirector,      20339,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "musicvideos",  FieldStudio,        572,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+
+  { "artists",      FieldArtist,        557,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldSource,      39030,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "artists",      FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "artists",      FieldMoods,         175,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldStyles,        176,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldInstruments, 21892,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldArtistType,    564,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "artists",      FieldGender,      39025,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "artists",      FieldDisambiguation, 39026, SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldBiography,   21887,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldBorn,        21893,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldBandFormed,  21894,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldDisbanded,   21896,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "artists",      FieldDied,        21897,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+
+  { "albums",       FieldAlbum,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+//  { "albums",       FieldArtist,        557,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldDiscTitle,     38076,  SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "albums",       FieldAlbumArtist,   566,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldSource,      39030,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "albums",       FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "albums",       FieldAlbumType,     564,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldYear,          562,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "albums",       FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldMusicLabel,    21899,  SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "albums",       FieldCompilation,   204,    SettingType::Boolean, "toggle", "",         CDatabaseQueryRule::OPERATOR_FALSE },
+  { "albums",       FieldIsBoxset,      38074,  SettingType::Boolean, "toggle", "",         CDatabaseQueryRule::OPERATOR_FALSE },
+  { "albums",       FieldOrigYear,      38078,  SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+
+  { "songs",        FieldTitle,         556,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "songs",        FieldAlbum,         558,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "songs",        FieldDiscTitle,   38076,    SettingType::String,  "edit",   "string",   CDatabaseQueryRule::OPERATOR_CONTAINS },
+  { "songs",        FieldArtist,        557,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "songs",        FieldTime,          180,    SettingType::Integer, "range",  "time",     CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "songs",        FieldRating,        563,    SettingType::Number,  "range",  "number",   CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "songs",        FieldUserRating,    38018,  SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "songs",        FieldYear,          562,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "songs",        FieldGenre,         515,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS },
+  { "songs",        FieldPlaycount,     567,    SettingType::Integer, "range",  "integer",  CDatabaseQueryRule::OPERATOR_BETWEEN },
+  { "songs",        FieldSource,      39030,    SettingType::List,    "list",   "string",   CDatabaseQueryRule::OPERATOR_EQUALS }
+};
+
+CGUIDialogMediaFilter::CGUIDialogMediaFilter()
+  : CGUIDialogSettingsManualBase(WINDOW_DIALOG_MEDIA_FILTER, "DialogSettings.xml"),
+    m_dbUrl(NULL),
+    m_filter(NULL)
+{ }
+
+CGUIDialogMediaFilter::~CGUIDialogMediaFilter()
+{
+  Reset();
+}
+
+bool CGUIDialogMediaFilter::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_CLICKED:
+    {
+      if (message.GetSenderId()== CONTROL_CLEAR_BUTTON)
+      {
+        m_filter->Reset();
+        m_filter->SetType(m_mediaType);
+
+        for (auto& filter : m_filters)
+        {
+          filter.second.rule = nullptr;
+          filter.second.setting->Reset();
+        }
+
+        TriggerFilter();
+        return true;
+      }
+      break;
+    }
+
+    case GUI_MSG_REFRESH_LIST:
+    {
+      TriggerFilter();
+      UpdateControls();
+      break;
+    }
+
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      Reset();
+      break;
+    }
+
+    default:
+      break;
+  }
+
+  return CGUIDialogSettingsManualBase::OnMessage(message);
+}
+
+void CGUIDialogMediaFilter::ShowAndEditMediaFilter(const std::string &path, CSmartPlaylist &filter)
+{
+  CGUIDialogMediaFilter *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogMediaFilter>(WINDOW_DIALOG_MEDIA_FILTER);
+  if (dialog == NULL)
+    return;
+
+  // initialize and show the dialog
+  dialog->Initialize();
+  dialog->m_filter = &filter;
+
+  // must be called after setting the filter/smartplaylist
+  if (!dialog->SetPath(path))
+    return;
+
+  dialog->Open();
+}
+
+void CGUIDialogMediaFilter::OnWindowLoaded()
+{
+  CGUIDialogSettingsManualBase::OnWindowLoaded();
+
+  // we don't need the cancel button so let's hide it
+  SET_CONTROL_HIDDEN(CONTROL_CANCEL_BUTTON);
+}
+
+void CGUIDialogMediaFilter::OnInitWindow()
+{
+  CGUIDialogSettingsManualBase::OnInitWindow();
+
+  UpdateControls();
+}
+
+void CGUIDialogMediaFilter::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
+{
+  CGUIDialogSettingsManualBase::OnSettingChanged(setting);
+
+  std::map<std::string, Filter>::iterator it = m_filters.find(setting->GetId());
+  if (it == m_filters.end())
+    return;
+
+  bool remove = false;
+  Filter& filter = it->second;
+
+  if (filter.controlType == "edit")
+  {
+    std::string value = setting->ToString();
+    if (!value.empty())
+    {
+      if (filter.rule == NULL)
+        filter.rule = AddRule(filter.field, filter.ruleOperator);
+      filter.rule->m_parameter.clear();
+      filter.rule->m_parameter.push_back(value);
+    }
+    else
+      remove = true;
+  }
+  else if (filter.controlType == "toggle")
+  {
+    int choice = std::static_pointer_cast<const CSettingInt>(setting)->GetValue();
+    if (choice > CHECK_ALL)
+    {
+      CDatabaseQueryRule::SEARCH_OPERATOR ruleOperator = choice == CHECK_YES ? CDatabaseQueryRule::OPERATOR_TRUE : CDatabaseQueryRule::OPERATOR_FALSE;
+      if (filter.rule == NULL)
+        filter.rule = AddRule(filter.field, ruleOperator);
+      else
+        filter.rule->m_operator = ruleOperator;
+    }
+    else
+      remove = true;
+  }
+  else if (filter.controlType == "list")
+  {
+    std::vector<CVariant> values = CSettingUtils::GetList(std::static_pointer_cast<const CSettingList>(setting));
+    if (!values.empty())
+    {
+      if (filter.rule == NULL)
+        filter.rule = AddRule(filter.field, filter.ruleOperator);
+
+      filter.rule->m_parameter.clear();
+      for (const auto& itValue : values)
+        filter.rule->m_parameter.push_back(itValue.asString());
+    }
+    else
+      remove = true;
+  }
+  else if (filter.controlType == "range")
+  {
+    const std::shared_ptr<const CSettingList> settingList = std::static_pointer_cast<const CSettingList>(setting);
+    std::vector<CVariant> values = CSettingUtils::GetList(settingList);
+    if (values.size() != 2)
+      return;
+
+    std::string strValueLower, strValueUpper;
+
+    SettingConstPtr definition = settingList->GetDefinition();
+    if (definition->GetType() == SettingType::Integer)
+    {
+      const std::shared_ptr<const CSettingInt> definitionInt = std::static_pointer_cast<const CSettingInt>(definition);
+      int valueLower = static_cast<int>(values.at(0).asInteger());
+      int valueUpper = static_cast<int>(values.at(1).asInteger());
+
+      if (valueLower > definitionInt->GetMinimum() ||
+          valueUpper < definitionInt->GetMaximum())
+      {
+        if (filter.controlFormat == "date")
+        {
+          strValueLower = CDateTime(static_cast<time_t>(valueLower)).GetAsDBDate();
+          strValueUpper = CDateTime(static_cast<time_t>(valueUpper)).GetAsDBDate();
+        }
+        else
+        {
+          strValueLower = values.at(0).asString();
+          strValueUpper = values.at(1).asString();
+        }
+      }
+    }
+    else if (definition->GetType() == SettingType::Number)
+    {
+      const std::shared_ptr<const CSettingNumber> definitionNumber = std::static_pointer_cast<const CSettingNumber>(definition);
+      float valueLower = values.at(0).asFloat();
+      float valueUpper = values.at(1).asFloat();
+
+      if (static_cast<double>(valueLower) > definitionNumber->GetMinimum() ||
+          static_cast<double>(valueUpper) < definitionNumber->GetMaximum())
+      {
+        strValueLower = values.at(0).asString();
+        strValueUpper = values.at(1).asString();
+      }
+    }
+    else
+      return;
+
+    if (!strValueLower.empty() && !strValueUpper.empty())
+    {
+      // prepare the filter rule
+      if (filter.rule == NULL)
+        filter.rule = AddRule(filter.field, filter.ruleOperator);
+      filter.rule->m_parameter.clear();
+
+      filter.rule->m_parameter.push_back(strValueLower);
+      filter.rule->m_parameter.push_back(strValueUpper);
+    }
+    else
+      remove = true;
+  }
+  else
+    return;
+
+  // we need to remove the existing rule for the title
+  if (remove && filter.rule != NULL)
+  {
+    DeleteRule(filter.field);
+    filter.rule = NULL;
+  }
+
+  CGUIMessage msg(GUI_MSG_REFRESH_LIST, GetID(), 0);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, WINDOW_DIALOG_MEDIA_FILTER);
+}
+
+void CGUIDialogMediaFilter::SetupView()
+{
+  CGUIDialogSettingsManualBase::SetupView();
+
+  // set the heading label based on the media type
+  uint32_t localizedMediaId = 0;
+  if (m_mediaType == "movies")
+    localizedMediaId = 20342;
+  else if (m_mediaType == "tvshows")
+    localizedMediaId = 20343;
+  else if (m_mediaType == "episodes")
+    localizedMediaId = 20360;
+  else if (m_mediaType == "musicvideos")
+    localizedMediaId = 20389;
+  else if (m_mediaType == "artists")
+    localizedMediaId = 133;
+  else if (m_mediaType == "albums")
+    localizedMediaId = 132;
+  else if (m_mediaType == "songs")
+    localizedMediaId = 134;
+
+  // set the heading
+  SET_CONTROL_LABEL(CONTROL_HEADING, StringUtils::Format(g_localizeStrings.Get(1275),
+                                                         g_localizeStrings.Get(localizedMediaId)));
+
+  SET_CONTROL_LABEL(CONTROL_OKAY_BUTTON, 186);
+  SET_CONTROL_LABEL(CONTROL_CLEAR_BUTTON, 192);
+}
+
+void CGUIDialogMediaFilter::InitializeSettings()
+{
+  CGUIDialogSettingsManualBase::InitializeSettings();
+
+  if (m_filter == NULL)
+    return;
+
+  Reset(true);
+
+  int handledRules = 0;
+
+  const std::shared_ptr<CSettingCategory> category = AddCategory("filter", -1);
+  if (category == NULL)
+  {
+    CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
+    return;
+  }
+
+  const std::shared_ptr<CSettingGroup> group = AddGroup(category);
+  if (group == NULL)
+  {
+    CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
+    return;
+  }
+
+  for (const Filter& f : filterList)
+  {
+    if (f.mediaType != m_mediaType)
+      continue;
+
+    Filter filter = f;
+
+    // check the smartplaylist if it contains a matching rule
+    for (auto& rule : m_filter->m_ruleCombination.m_rules)
+    {
+      if (rule->m_field == filter.field)
+      {
+        filter.rule = static_cast<CSmartPlaylistRule*>(rule.get());
+        handledRules++;
+        break;
+      }
+    }
+
+    std::string settingId = StringUtils::Format("filter.{}.{}", filter.mediaType, filter.field);
+    if (filter.controlType == "edit")
+    {
+      CVariant data;
+      if (filter.rule != NULL && filter.rule->m_parameter.size() == 1)
+        data = filter.rule->m_parameter.at(0);
+
+      if (filter.settingType == SettingType::String)
+        filter.setting = AddEdit(group, settingId, filter.label, SettingLevel::Basic, data.asString(), true, false, filter.label, true);
+      else if (filter.settingType == SettingType::Integer)
+        filter.setting = AddEdit(group, settingId, filter.label, SettingLevel::Basic, static_cast<int>(data.asInteger()), 0, 1, 0, false,  static_cast<int>(filter.label), true);
+      else if (filter.settingType == SettingType::Number)
+        filter.setting = AddEdit(group, settingId, filter.label, SettingLevel::Basic, data.asFloat(), 0.0f, 1.0f, 0.0f, false, filter.label, true);
+    }
+    else if (filter.controlType == "toggle")
+    {
+      int value = CHECK_ALL;
+      if (filter.rule != NULL)
+        value = filter.rule->m_operator == CDatabaseQueryRule::OPERATOR_TRUE ? CHECK_YES : CHECK_NO;
+
+      TranslatableIntegerSettingOptions entries;
+      entries.push_back(TranslatableIntegerSettingOption(CHECK_LABEL_ALL, CHECK_ALL));
+      entries.push_back(TranslatableIntegerSettingOption(CHECK_LABEL_NO, CHECK_NO));
+      entries.push_back(TranslatableIntegerSettingOption(CHECK_LABEL_YES, CHECK_YES));
+
+      filter.setting = AddSpinner(group, settingId, filter.label, SettingLevel::Basic, value, entries, true);
+    }
+    else if (filter.controlType == "list")
+    {
+      std::vector<std::string> values;
+      if (filter.rule != NULL && !filter.rule->m_parameter.empty())
+      {
+        values = StringUtils::Split(filter.rule->GetParameter(), DATABASEQUERY_RULE_VALUE_SEPARATOR);
+        if (values.size() == 1 && values.at(0).empty())
+          values.erase(values.begin());
+      }
+
+      filter.setting = AddList(group, settingId, filter.label, SettingLevel::Basic, values, GetStringListOptions, filter.label);
+    }
+    else if (filter.controlType == "range")
+    {
+      CVariant valueLower, valueUpper;
+      if (filter.rule != NULL)
+      {
+        if (filter.rule->m_parameter.size() == 2)
+        {
+          valueLower = filter.rule->m_parameter.at(0);
+          valueUpper = filter.rule->m_parameter.at(1);
+        }
+        else
+        {
+          DeleteRule(filter.field);
+          filter.rule = NULL;
+        }
+      }
+
+      if (filter.settingType == SettingType::Integer)
+      {
+        int min = 0;
+        int interval = 0;
+        int max = 0;
+        GetRange(filter, min, interval, max);
+
+        // don't create the filter if there's no real range
+        if (min == max)
+          continue;
+
+        int iValueLower = valueLower.isNull() ? min : static_cast<int>(valueLower.asInteger());
+        int iValueUpper = valueUpper.isNull() ? max : static_cast<int>(valueUpper.asInteger());
+
+        if (filter.controlFormat == "integer")
+          filter.setting = AddRange(group, settingId, filter.label, SettingLevel::Basic, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
+        else if (filter.controlFormat == "percentage")
+          filter.setting = AddPercentageRange(group, settingId, filter.label, SettingLevel::Basic, iValueLower, iValueUpper, -1, 1, 21469, true);
+        else if (filter.controlFormat == "date")
+          filter.setting = AddDateRange(group, settingId, filter.label, SettingLevel::Basic, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
+        else if (filter.controlFormat == "time")
+          filter.setting = AddTimeRange(group, settingId, filter.label, SettingLevel::Basic, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
+      }
+      else if (filter.settingType == SettingType::Number)
+      {
+        float min = 0;
+        float interval = 0;
+        float max = 0;
+        GetRange(filter, min, interval, max);
+
+        // don't create the filter if there's no real range
+        if (min == max)
+          continue;
+
+        float fValueLower = valueLower.isNull() ? min : valueLower.asFloat();
+        float fValueUpper = valueUpper.isNull() ? max : valueUpper.asFloat();
+
+        filter.setting = AddRange(group, settingId, filter.label, SettingLevel::Basic, fValueLower, fValueUpper, min, interval, max, -1, 21469, true);
+      }
+    }
+    else
+    {
+      if (filter.rule != NULL)
+        handledRules--;
+
+      CLog::Log(LOGWARNING,
+                "CGUIDialogMediaFilter: filter {} of media type {} with unknown control type '{}'",
+                filter.field, filter.mediaType, filter.controlType);
+      continue;
+    }
+
+    if (filter.setting == NULL)
+    {
+      if (filter.rule != NULL)
+        handledRules--;
+
+      CLog::Log(LOGWARNING,
+                "CGUIDialogMediaFilter: failed to create filter {} of media type {} with control "
+                "type '{}'",
+                filter.field, filter.mediaType, filter.controlType);
+      continue;
+    }
+
+    m_filters.insert(make_pair(settingId, filter));
+  }
+
+  // make sure that no change in capacity size is needed when adding new rules
+  // which would copy around the rules and our pointers in the Filter struct
+  // wouldn't work anymore
+  m_filter->m_ruleCombination.m_rules.reserve(m_filters.size() + (m_filter->m_ruleCombination.m_rules.size() - handledRules));
+}
+
+bool CGUIDialogMediaFilter::SetPath(const std::string &path)
+{
+  if (path.empty() || m_filter == NULL)
+  {
+    CLog::Log(LOGWARNING, "CGUIDialogMediaFilter::SetPath({}): invalid path or filter", path);
+    return false;
+  }
+
+  delete m_dbUrl;
+  bool video = false;
+  if (path.find("videodb://") == 0)
+  {
+    m_dbUrl = new CVideoDbUrl();
+    video = true;
+  }
+  else if (path.find("musicdb://") == 0)
+    m_dbUrl = new CMusicDbUrl();
+  else
+  {
+    CLog::Log(
+        LOGWARNING,
+        "CGUIDialogMediaFilter::SetPath({}): invalid path (neither videodb:// nor musicdb://)",
+        path);
+    return false;
+  }
+
+  if (!m_dbUrl->FromString(path) ||
+     (video && m_dbUrl->GetType() != "movies" && m_dbUrl->GetType() != "tvshows" && m_dbUrl->GetType() != "episodes" && m_dbUrl->GetType() != "musicvideos") ||
+     (!video && m_dbUrl->GetType() != "artists" && m_dbUrl->GetType() != "albums" && m_dbUrl->GetType() != "songs"))
+  {
+    CLog::Log(LOGWARNING, "CGUIDialogMediaFilter::SetPath({}): invalid media type", path);
+    return false;
+  }
+
+  // remove "filter" option
+  if (m_dbUrl->HasOption("filter"))
+    m_dbUrl->RemoveOption("filter");
+
+  if (video)
+    m_mediaType = ((CVideoDbUrl*)m_dbUrl)->GetItemType();
+  else
+    m_mediaType = m_dbUrl->GetType();
+
+  m_filter->SetType(m_mediaType);
+  return true;
+}
+
+void CGUIDialogMediaFilter::UpdateControls()
+{
+  for (const auto& itFilter : m_filters)
+  {
+    if (itFilter.second.controlType != "list")
+      continue;
+
+    std::vector<std::string> items;
+    int size = GetItems(itFilter.second, items, true);
+
+    std::string label = g_localizeStrings.Get(itFilter.second.label);
+    BaseSettingControlPtr control = GetSettingControl(itFilter.second.setting->GetId());
+    if (control == NULL)
+      continue;
+
+    if (size <= 0 ||
+        (size == 1 && itFilter.second.field != FieldSet && itFilter.second.field != FieldTag))
+      CONTROL_DISABLE(control->GetID());
+    else
+    {
+      CONTROL_ENABLE(control->GetID());
+      label = StringUtils::Format(g_localizeStrings.Get(21470), label, size);
+    }
+    SET_CONTROL_LABEL(control->GetID(), label);
+  }
+}
+
+void CGUIDialogMediaFilter::TriggerFilter() const
+{
+  if (m_filter == NULL)
+    return;
+
+  CGUIMessage message(GUI_MSG_NOTIFY_ALL, GetID(), 0, GUI_MSG_FILTER_ITEMS, 10); // 10 for advanced
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message);
+}
+
+void CGUIDialogMediaFilter::Reset(bool filtersOnly /* = false */)
+{
+  if (!filtersOnly)
+  {
+    delete m_dbUrl;
+    m_dbUrl = NULL;
+  }
+
+  m_filters.clear();
+}
+
+int CGUIDialogMediaFilter::GetItems(const Filter &filter, std::vector<std::string> &items, bool countOnly /* = false */)
+{
+  CFileItemList selectItems;
+
+  // remove the rule for the field of the filter we want to retrieve items for
+  CSmartPlaylist tmpFilter = *m_filter;
+  for (CDatabaseQueryRules::iterator rule = tmpFilter.m_ruleCombination.m_rules.begin();
+       rule != tmpFilter.m_ruleCombination.m_rules.end(); ++rule)
+  {
+    if ((*rule)->m_field == filter.field)
+    {
+      tmpFilter.m_ruleCombination.m_rules.erase(rule);
+      break;
+    }
+  }
+
+  if (m_mediaType == "movies" || m_mediaType == "tvshows" || m_mediaType == "episodes" || m_mediaType == "musicvideos")
+  {
+    CVideoDatabase videodb;
+    if (!videodb.Open())
+      return -1;
+
+    std::set<std::string> playlists;
+    CDatabase::Filter dbfilter;
+    dbfilter.where = tmpFilter.GetWhereClause(videodb, playlists);
+
+    VideoDbContentType type = VideoDbContentType::MOVIES;
+    if (m_mediaType == "tvshows")
+      type = VideoDbContentType::TVSHOWS;
+    else if (m_mediaType == "episodes")
+      type = VideoDbContentType::EPISODES;
+    else if (m_mediaType == "musicvideos")
+      type = VideoDbContentType::MUSICVIDEOS;
+
+    if (filter.field == FieldGenre)
+      videodb.GetGenresNav(m_dbUrl->ToString(), selectItems, type, dbfilter, countOnly);
+    else if (filter.field == FieldActor || filter.field == FieldArtist)
+      videodb.GetActorsNav(m_dbUrl->ToString(), selectItems, type, dbfilter, countOnly);
+    else if (filter.field == FieldDirector)
+      videodb.GetDirectorsNav(m_dbUrl->ToString(), selectItems, type, dbfilter, countOnly);
+    else if (filter.field == FieldStudio)
+      videodb.GetStudiosNav(m_dbUrl->ToString(), selectItems, type, dbfilter, countOnly);
+    else if (filter.field == FieldAlbum)
+      videodb.GetMusicVideoAlbumsNav(m_dbUrl->ToString(), selectItems, -1, dbfilter, countOnly);
+    else if (filter.field == FieldTag)
+      videodb.GetTagsNav(m_dbUrl->ToString(), selectItems, type, dbfilter, countOnly);
+  }
+  else if (m_mediaType == "artists" || m_mediaType == "albums" || m_mediaType == "songs")
+  {
+    CMusicDatabase musicdb;
+    if (!musicdb.Open())
+      return -1;
+
+    std::set<std::string> playlists;
+    CDatabase::Filter dbfilter;
+    dbfilter.where = tmpFilter.GetWhereClause(musicdb, playlists);
+
+    if (filter.field == FieldGenre)
+      musicdb.GetGenresNav(m_dbUrl->ToString(), selectItems, dbfilter, countOnly);
+    else if (filter.field == FieldArtist || filter.field == FieldAlbumArtist)
+      musicdb.GetArtistsNav(m_dbUrl->ToString(), selectItems, m_mediaType == "albums", -1, -1, -1, dbfilter, SortDescription(), countOnly);
+    else if (filter.field == FieldAlbum)
+      musicdb.GetAlbumsNav(m_dbUrl->ToString(), selectItems, -1, -1, dbfilter, SortDescription(), countOnly);
+    else if (filter.field == FieldAlbumType)
+      musicdb.GetAlbumTypesNav(m_dbUrl->ToString(), selectItems, dbfilter, countOnly);
+    else if (filter.field == FieldMusicLabel)
+      musicdb.GetMusicLabelsNav(m_dbUrl->ToString(), selectItems, dbfilter, countOnly);
+    if (filter.field == FieldSource)
+      musicdb.GetSourcesNav(m_dbUrl->ToString(), selectItems, dbfilter, countOnly);
+  }
+
+  int size = selectItems.Size();
+  if (size <= 0)
+    return 0;
+
+  if (countOnly)
+  {
+    if (size == 1 && selectItems.Get(0)->HasProperty("total"))
+      return (int)selectItems.Get(0)->GetProperty("total").asInteger();
+    return 0;
+  }
+
+  // sort the items
+  selectItems.Sort(SortByLabel, SortOrderAscending);
+
+  for (int index = 0; index < size; ++index)
+    items.push_back(selectItems.Get(index)->GetLabel());
+
+  return items.size();
+}
+
+CSmartPlaylistRule* CGUIDialogMediaFilter::AddRule(Field field, CDatabaseQueryRule::SEARCH_OPERATOR ruleOperator /* = CDatabaseQueryRule::OPERATOR_CONTAINS */)
+{
+  CSmartPlaylistRule rule;
+  rule.m_field = field;
+  rule.m_operator = ruleOperator;
+
+  m_filter->m_ruleCombination.AddRule(rule);
+  return (CSmartPlaylistRule *)m_filter->m_ruleCombination.m_rules.back().get();
+}
+
+void CGUIDialogMediaFilter::DeleteRule(Field field)
+{
+  for (CDatabaseQueryRules::iterator rule = m_filter->m_ruleCombination.m_rules.begin();
+       rule != m_filter->m_ruleCombination.m_rules.end(); ++rule)
+  {
+    if ((*rule)->m_field == field)
+    {
+      m_filter->m_ruleCombination.m_rules.erase(rule);
+      break;
+    }
+  }
+}
+
+void CGUIDialogMediaFilter::GetStringListOptions(const SettingConstPtr& setting,
+                                                 std::vector<StringSettingOption>& list,
+                                                 std::string& current,
+                                                 void* data)
+{
+  if (setting == NULL || data == NULL)
+    return;
+
+  CGUIDialogMediaFilter *mediaFilter = static_cast<CGUIDialogMediaFilter*>(data);
+
+  std::map<std::string, Filter>::const_iterator itFilter = mediaFilter->m_filters.find(setting->GetId());
+  if (itFilter == mediaFilter->m_filters.end())
+    return;
+
+  std::vector<std::string> items;
+  if (mediaFilter->GetItems(itFilter->second, items, false) <= 0)
+    return;
+
+  for (const auto& item : items)
+    list.emplace_back(item, item);
+}
+
+void CGUIDialogMediaFilter::GetRange(const Filter &filter, int &min, int &interval, int &max)
+{
+  if (filter.field == FieldUserRating &&
+     (m_mediaType == "movies" || m_mediaType == "tvshows" || m_mediaType == "episodes"|| m_mediaType == "musicvideos" || m_mediaType == "albums" || m_mediaType == "songs"))
+  {
+    min = 0;
+    interval = 1;
+    max = 10;
+  }
+  else if (filter.field == FieldYear)
+  {
+    min = 0;
+    interval = 1;
+    max = 0;
+
+    if (m_mediaType == "movies" || m_mediaType == "tvshows" || m_mediaType == "musicvideos")
+    {
+      std::string table;
+      std::string year;
+      if (m_mediaType == "movies")
+      {
+        table = "movie_view";
+        year = DatabaseUtils::GetField(FieldYear, MediaTypeMovie, DatabaseQueryPartWhere);
+      }
+      else if (m_mediaType == "tvshows")
+      {
+        table = "tvshow_view";
+        year = StringUtils::Format(
+            "strftime(\"%%Y\", {})",
+            DatabaseUtils::GetField(FieldYear, MediaTypeTvShow, DatabaseQueryPartWhere));
+      }
+      else if (m_mediaType == "musicvideos")
+      {
+        table = "musicvideo_view";
+        year = DatabaseUtils::GetField(FieldYear, MediaTypeMusicVideo, DatabaseQueryPartWhere);
+      }
+
+      CDatabase::Filter filter;
+      filter.where = year + " > 0";
+      GetMinMax(table, year, min, max, filter);
+    }
+    else if (m_mediaType == "albums" || m_mediaType == "songs")
+    {
+      std::string table;
+      if (m_mediaType == "albums")
+        table = "albumview";
+      else if (m_mediaType == "songs")
+        table = "songview";
+      else
+        return;
+
+      CDatabase::Filter filter;
+      filter.where = DatabaseUtils::GetField(FieldYear, CMediaTypes::FromString(m_mediaType), DatabaseQueryPartWhere) + " > 0";
+      GetMinMax(table, DatabaseUtils::GetField(FieldYear, CMediaTypes::FromString(m_mediaType), DatabaseQueryPartSelect), min, max, filter);
+    }
+  }
+  else if (filter.field == FieldAirDate)
+  {
+    min = 0;
+    interval = 1;
+    max = 0;
+
+    if (m_mediaType == "episodes")
+    {
+      std::string field = StringUtils::Format("CAST(strftime(\"%%s\", c{:02}) AS INTEGER)",
+                                              VIDEODB_ID_EPISODE_AIRED);
+
+      GetMinMax("episode_view", field, min, max);
+      interval = 60 * 60 * 24 * 7; // 1 week
+    }
+  }
+  else if (filter.field == FieldTime)
+  {
+    min = 0;
+    interval = 10;
+    max = 0;
+
+    if (m_mediaType == "songs")
+      GetMinMax("songview", "iDuration", min, max);
+  }
+  else if (filter.field == FieldPlaycount)
+  {
+    min = 0;
+    interval = 1;
+    max = 0;
+
+    if (m_mediaType == "songs")
+      GetMinMax("songview", "iTimesPlayed", min, max);
+  }
+}
+
+void CGUIDialogMediaFilter::GetRange(const Filter &filter, float &min, float &interval, float &max)
+{
+  if (filter.field == FieldRating &&
+     (m_mediaType == "movies" || m_mediaType == "tvshows" || m_mediaType == "episodes" || m_mediaType == "musicvideos" || m_mediaType == "albums" || m_mediaType == "songs"))
+  {
+    min = 0.0f;
+    interval = 0.1f;
+    max = 10.0f;
+  }
+}
+
+bool CGUIDialogMediaFilter::GetMinMax(const std::string &table, const std::string &field, int &min, int &max, const CDatabase::Filter &filter /* = CDatabase::Filter() */)
+{
+  if (table.empty() || field.empty())
+    return false;
+
+  CDatabase *db = NULL;
+  CDbUrl *dbUrl = NULL;
+  if (m_mediaType == "movies" || m_mediaType == "tvshows" || m_mediaType == "episodes" || m_mediaType == "musicvideos")
+  {
+    CVideoDatabase *videodb = new CVideoDatabase();
+    if (!videodb->Open())
+    {
+      delete videodb;
+      return false;
+    }
+
+    db = videodb;
+    dbUrl = new CVideoDbUrl();
+  }
+  else if (m_mediaType == "artists" || m_mediaType == "albums" || m_mediaType == "songs")
+  {
+    CMusicDatabase *musicdb = new CMusicDatabase();
+    if (!musicdb->Open())
+    {
+      delete musicdb;
+      return false;
+    }
+
+    db = musicdb;
+    dbUrl = new CMusicDbUrl();
+  }
+
+  if (db == NULL || !db->IsOpen() || dbUrl == NULL)
+  {
+    delete db;
+    delete dbUrl;
+    return false;
+  }
+
+  CDatabase::Filter extFilter = filter;
+  std::string strSQLExtra;
+  if (!db->BuildSQL(m_dbUrl->ToString(), strSQLExtra, extFilter, strSQLExtra, *dbUrl))
+  {
+    delete db;
+    delete dbUrl;
+    return false;
+  }
+
+  std::string strSQL = "SELECT %s FROM %s ";
+
+  min = static_cast<int>(strtol(db->GetSingleValue(db->PrepareSQL(strSQL, ("MIN(" + field + ")").c_str(), table.c_str()) + strSQLExtra).c_str(), NULL, 0));
+  max = static_cast<int>(strtol(db->GetSingleValue(db->PrepareSQL(strSQL, ("MAX(" + field + ")").c_str(), table.c_str()) + strSQLExtra).c_str(), NULL, 0));
+
+  db->Close();
+  delete db;
+  delete dbUrl;
+
+  return true;
+}
diff --git a/xbmc/dialogs/GUIDialogMediaFilter.h b/xbmc/dialogs/GUIDialogMediaFilter.h
new file mode 100644
index 0000000..893f1c2
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogMediaFilter.h
@@ -0,0 +1,92 @@
+/*
+ *  Copyright (C) 2012-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 "dbwrappers/Database.h"
+#include "dbwrappers/DatabaseQuery.h"
+#include "settings/dialogs/GUIDialogSettingsManualBase.h"
+#include "settings/lib/SettingType.h"
+#include "utils/DatabaseUtils.h"
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+class CDbUrl;
+class CSetting;
+class CSmartPlaylist;
+class CSmartPlaylistRule;
+struct StringSettingOption;
+
+class CGUIDialogMediaFilter : public CGUIDialogSettingsManualBase
+{
+public:
+  CGUIDialogMediaFilter();
+  ~CGUIDialogMediaFilter() override;
+
+  // specializations of CGUIControl
+  bool OnMessage(CGUIMessage &message) override;
+
+  static void ShowAndEditMediaFilter(const std::string &path, CSmartPlaylist &filter);
+
+  struct Filter
+  {
+    std::string mediaType;
+    Field field;
+    uint32_t label;
+    SettingType settingType;
+    std::string controlType;
+    std::string controlFormat;
+    CDatabaseQueryRule::SEARCH_OPERATOR ruleOperator;
+    std::shared_ptr<CSetting> setting = nullptr;
+    CSmartPlaylistRule* rule = nullptr;
+    void* data = nullptr;
+  };
+
+protected:
+  // specializations of CGUIWindow
+  void OnWindowLoaded() override;
+  void OnInitWindow() override;
+
+  // implementations of ISettingCallback
+  void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override;
+
+  // specialization of CGUIDialogSettingsBase
+  bool AllowResettingSettings() const override { return false; }
+  bool Save() override { return true; }
+  std::chrono::milliseconds GetDelayMs() const override { return std::chrono::milliseconds(500); }
+
+  // specialization of CGUIDialogSettingsManualBase
+  void SetupView() override;
+  void InitializeSettings() override;
+
+  bool SetPath(const std::string &path);
+  void UpdateControls();
+  void TriggerFilter() const;
+  void Reset(bool filtersOnly = false);
+
+  int GetItems(const Filter &filter, std::vector<std::string> &items, bool countOnly = false);
+  void GetRange(const Filter &filter, int &min, int &interval, int &max);
+  void GetRange(const Filter &filter, float &min, float &interval, float &max);
+  bool GetMinMax(const std::string &table, const std::string &field, int &min, int &max, const CDatabase::Filter &filter = CDatabase::Filter());
+
+  CSmartPlaylistRule* AddRule(Field field, CDatabaseQueryRule::SEARCH_OPERATOR ruleOperator = CDatabaseQueryRule::OPERATOR_CONTAINS);
+  void DeleteRule(Field field);
+
+  static void GetStringListOptions(const std::shared_ptr<const CSetting>& setting,
+                                   std::vector<StringSettingOption>& list,
+                                   std::string& current,
+                                   void* data);
+
+  CDbUrl* m_dbUrl;
+  std::string m_mediaType;
+  CSmartPlaylist *m_filter;
+  std::map<std::string, Filter> m_filters;
+};
diff --git a/xbmc/dialogs/GUIDialogMediaSource.cpp b/xbmc/dialogs/GUIDialogMediaSource.cpp
new file mode 100644
index 0000000..13b13e5
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogMediaSource.cpp
@@ -0,0 +1,620 @@
+/*
+ *  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 "GUIDialogMediaSource.h"
+#include "ServiceBroker.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "GUIDialogFileBrowser.h"
+#include "video/windows/GUIWindowVideoBase.h"
+#include "music/windows/GUIWindowMusicBase.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/Key.h"
+#include "Util.h"
+#include "utils/URIUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "filesystem/Directory.h"
+#include "filesystem/PVRDirectory.h"
+#include "GUIDialogYesNo.h"
+#include "FileItem.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "guilib/LocalizeStrings.h"
+#include "PasswordManager.h"
+#include "URL.h"
+#include "pvr/recordings/PVRRecordingsPath.h"
+
+#if defined(TARGET_ANDROID)
+#include "utils/FileUtils.h"
+
+#include "platform/android/activity/XBMCApp.h"
+#endif
+
+#ifdef TARGET_WINDOWS_STORE
+#include "platform/win10/filesystem/WinLibraryDirectory.h"
+#endif
+
+using namespace XFILE;
+
+#define CONTROL_HEADING          2
+#define CONTROL_PATH            10
+#define CONTROL_PATH_BROWSE     11
+#define CONTROL_NAME            12
+#define CONTROL_PATH_ADD        13
+#define CONTROL_PATH_REMOVE     14
+#define CONTROL_OK              18
+#define CONTROL_CANCEL          19
+#define CONTROL_CONTENT         20
+
+CGUIDialogMediaSource::CGUIDialogMediaSource(void)
+    : CGUIDialog(WINDOW_DIALOG_MEDIA_SOURCE, "DialogMediaSource.xml")
+{
+  m_paths = new CFileItemList;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogMediaSource::~CGUIDialogMediaSource()
+{
+  delete m_paths;
+}
+
+bool CGUIDialogMediaSource::OnBack(int actionID)
+{
+  m_confirmed = false;
+  return CGUIDialog::OnBack(actionID);
+}
+
+bool CGUIDialogMediaSource::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+  case GUI_MSG_CLICKED:
+  {
+    int iControl = message.GetSenderId();
+    int iAction = message.GetParam1();
+    if (iControl == CONTROL_PATH && (iAction == ACTION_SELECT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK))
+      OnPath(GetSelectedItem());
+    else if (iControl == CONTROL_PATH_BROWSE)
+      OnPathBrowse(GetSelectedItem());
+    else if (iControl == CONTROL_PATH_ADD)
+      OnPathAdd();
+    else if (iControl == CONTROL_PATH_REMOVE)
+      OnPathRemove(GetSelectedItem());
+    else if (iControl == CONTROL_NAME)
+    {
+      OnEditChanged(iControl, m_name);
+      UpdateButtons();
+    }
+    else if (iControl == CONTROL_OK)
+      OnOK();
+    else if (iControl == CONTROL_CANCEL)
+      OnCancel();
+    else
+      break;
+    return true;
+  }
+  break;
+  case GUI_MSG_WINDOW_INIT:
+  {
+    UpdateButtons();
+  }
+  break;
+  case GUI_MSG_SETFOCUS:
+    if (message.GetControlId() == CONTROL_PATH_BROWSE ||
+      message.GetControlId() == CONTROL_PATH_ADD ||
+      message.GetControlId() == CONTROL_PATH_REMOVE)
+    {
+      HighlightItem(GetSelectedItem());
+    }
+    else
+      HighlightItem(-1);
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+// \brief Show CGUIDialogMediaSource dialog and prompt for a new media source.
+// \return True if the media source is added, false otherwise.
+bool CGUIDialogMediaSource::ShowAndAddMediaSource(const std::string &type)
+{
+  CGUIDialogMediaSource *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogMediaSource>(WINDOW_DIALOG_MEDIA_SOURCE);
+  if (!dialog) return false;
+  dialog->Initialize();
+  dialog->SetShare(CMediaSource());
+  dialog->SetTypeOfMedia(type);
+  dialog->Open();
+  bool confirmed(dialog->IsConfirmed());
+  if (confirmed)
+  {
+    // Add this media source
+    // Get unique source name
+    std::string strName = dialog->GetUniqueMediaSourceName();
+
+    CMediaSource share;
+    share.FromNameAndPaths(type, strName, dialog->GetPaths());
+    if (dialog->m_paths->Size() > 0)
+      share.m_strThumbnailImage = dialog->m_paths->Get(0)->GetArt("thumb");
+    CMediaSourceSettings::GetInstance().AddShare(type, share);
+    OnMediaSourceChanged(type, "", share);
+  }
+  dialog->m_paths->Clear();
+  return confirmed;
+}
+
+bool CGUIDialogMediaSource::ShowAndEditMediaSource(const std::string &type, const std::string&share)
+{
+  VECSOURCES* pShares = CMediaSourceSettings::GetInstance().GetSources(type);
+  if (pShares)
+  {
+    for (unsigned int i = 0;i<pShares->size();++i)
+    {
+      if (StringUtils::EqualsNoCase((*pShares)[i].strName, share))
+        return ShowAndEditMediaSource(type, (*pShares)[i]);
+    }
+  }
+  return false;
+}
+
+bool CGUIDialogMediaSource::ShowAndEditMediaSource(const std::string &type, const CMediaSource &share)
+{
+  std::string strOldName = share.strName;
+  CGUIDialogMediaSource *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogMediaSource>(WINDOW_DIALOG_MEDIA_SOURCE);
+  if (!dialog) return false;
+  dialog->Initialize();
+  dialog->SetShare(share);
+  dialog->SetTypeOfMedia(type, true);
+  dialog->Open();
+  bool confirmed(dialog->IsConfirmed());
+  if (confirmed)
+  {
+    // Update media source
+    // Get unique new source name when changed
+    std::string strName(dialog->m_name);
+    if (!StringUtils::EqualsNoCase(dialog->m_name, strOldName))
+      strName = dialog->GetUniqueMediaSourceName();
+
+    CMediaSource newShare;
+    newShare.FromNameAndPaths(type, strName, dialog->GetPaths());
+    CMediaSourceSettings::GetInstance().UpdateShare(type, strOldName, newShare);
+
+    OnMediaSourceChanged(type, strOldName, newShare);
+  }
+  dialog->m_paths->Clear();
+  return confirmed;
+}
+
+std::string CGUIDialogMediaSource::GetUniqueMediaSourceName()
+{
+  // Get unique source name for this media type
+  unsigned int i, j = 2;
+  bool bConfirmed = false;
+  VECSOURCES* pShares = CMediaSourceSettings::GetInstance().GetSources(m_type);
+  std::string strName = m_name;
+  while (!bConfirmed)
+  {
+    for (i = 0; i<pShares->size(); ++i)
+    {
+      if (StringUtils::EqualsNoCase((*pShares)[i].strName, strName))
+        break;
+    }
+    if (i < pShares->size())
+      // found a match -  try next
+      strName = StringUtils::Format("{} ({})", m_name, j++);
+    else
+      bConfirmed = true;
+  }
+  return strName;
+}
+
+void CGUIDialogMediaSource::OnMediaSourceChanged(const std::string& type, const std::string& oldName, const CMediaSource& share)
+{
+  // Processing once media source added/edited - library scraping and scanning
+  if (!StringUtils::StartsWithNoCase(share.strPath, "rss://") &&
+    !StringUtils::StartsWithNoCase(share.strPath, "rsss://") &&
+    !StringUtils::StartsWithNoCase(share.strPath, "upnp://"))
+  {
+    if (type == "video" && !URIUtils::IsLiveTV(share.strPath))
+      // Assign content to a path, refresh scraper information optionally start a scan
+      CGUIWindowVideoBase::OnAssignContent(share.strPath);
+    else if (type == "music")
+      CGUIWindowMusicBase::OnAssignContent(oldName, share);
+  }
+}
+
+void CGUIDialogMediaSource::OnPathBrowse(int item)
+{
+  if (item < 0 || item >= m_paths->Size()) return;
+  // Browse is called.  Open the filebrowser dialog.
+  // Ignore current path is best at this stage??
+  std::string path = m_paths->Get(item)->GetPath();
+  bool allowNetworkShares(m_type != "programs");
+  VECSOURCES extraShares;
+
+  if (m_name != CUtil::GetTitleFromPath(path))
+    m_bNameChanged = true;
+  path.clear();
+
+  if (m_type == "music")
+  {
+    CMediaSource share1;
+#if defined(TARGET_ANDROID)
+    // add the default android music directory
+    std::string path;
+    if (CXBMCApp::GetExternalStorage(path, "music") && !path.empty() && CDirectory::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20240);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+
+#if defined(TARGET_WINDOWS_STORE)
+    // add the default UWP music directory
+    std::string path;
+    if (XFILE::CWinLibraryDirectory::GetStoragePath(m_type, path) && !path.empty() && CDirectory::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20245);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+
+    // add the music playlist location
+    share1.strPath = "special://musicplaylists/";
+    share1.strName = g_localizeStrings.Get(20011);
+    share1.m_ignore = true;
+    extraShares.push_back(share1);
+
+    // add the recordings dir as needed
+    if (CPVRDirectory::HasRadioRecordings())
+    {
+      share1.strPath = PVR::CPVRRecordingsPath::PATH_ACTIVE_RADIO_RECORDINGS;
+      share1.strName = g_localizeStrings.Get(19017); // Recordings
+      extraShares.push_back(share1);
+    }
+    if (CPVRDirectory::HasDeletedRadioRecordings())
+    {
+      share1.strPath = PVR::CPVRRecordingsPath::PATH_DELETED_RADIO_RECORDINGS;
+      share1.strName = g_localizeStrings.Get(19184); // Deleted recordings
+      extraShares.push_back(share1);
+    }
+
+    if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_AUDIOCDS_RECORDINGPATH) != "")
+    {
+      share1.strPath = "special://recordings/";
+      share1.strName = g_localizeStrings.Get(21883);
+      extraShares.push_back(share1);
+    }
+  }
+  else if (m_type == "video")
+  {
+    CMediaSource share1;
+#if defined(TARGET_ANDROID)
+    // add the default android video directory
+    std::string path;
+    if (CXBMCApp::GetExternalStorage(path, "videos") && !path.empty() && CFileUtils::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20241);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+#if defined(TARGET_WINDOWS_STORE)
+    // add the default UWP music directory
+    std::string path;
+    if (XFILE::CWinLibraryDirectory::GetStoragePath(m_type, path) && !path.empty() && CDirectory::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20246);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+
+    // add the video playlist location
+    share1.m_ignore = true;
+    share1.strPath = "special://videoplaylists/";
+    share1.strName = g_localizeStrings.Get(20012);
+    extraShares.push_back(share1);
+
+    // add the recordings dir as needed
+    if (CPVRDirectory::HasTVRecordings())
+    {
+      share1.strPath = PVR::CPVRRecordingsPath::PATH_ACTIVE_TV_RECORDINGS;
+      share1.strName = g_localizeStrings.Get(19017); // Recordings
+      extraShares.push_back(share1);
+    }
+    if (CPVRDirectory::HasDeletedTVRecordings())
+    {
+      share1.strPath = PVR::CPVRRecordingsPath::PATH_DELETED_TV_RECORDINGS;
+      share1.strName = g_localizeStrings.Get(19184); // Deleted recordings
+      extraShares.push_back(share1);
+    }
+  }
+  else if (m_type == "pictures")
+  {
+    CMediaSource share1;
+#if defined(TARGET_ANDROID)
+    // add the default android music directory
+    std::string path;
+    if (CXBMCApp::GetExternalStorage(path, "pictures") && !path.empty() && CFileUtils::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20242);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+
+    path.clear();
+    if (CXBMCApp::GetExternalStorage(path, "photos") && !path.empty() && CFileUtils::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20243);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+#if defined(TARGET_WINDOWS_STORE)
+    // add the default UWP music directory
+    std::string path;
+    if (XFILE::CWinLibraryDirectory::GetStoragePath(m_type, path) && !path.empty() && CDirectory::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20247);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+    path.clear();
+    if (XFILE::CWinLibraryDirectory::GetStoragePath("photos", path) && !path.empty() && CDirectory::Exists(path))
+    {
+      share1.strPath = path;
+      share1.strName = g_localizeStrings.Get(20248);
+      share1.m_ignore = true;
+      extraShares.push_back(share1);
+    }
+#endif
+
+    share1.m_ignore = true;
+    if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_DEBUG_SCREENSHOTPATH) != "")
+    {
+      share1.strPath = "special://screenshots/";
+      share1.strName = g_localizeStrings.Get(20008);
+      extraShares.push_back(share1);
+    }
+  }
+  else if (m_type == "games")
+  {
+    // nothing to add
+  }
+  else if (m_type == "programs")
+  {
+    // nothing to add
+  }
+  if (CGUIDialogFileBrowser::ShowAndGetSource(path, allowNetworkShares, extraShares.size() == 0 ? NULL : &extraShares))
+  {
+    if (item < m_paths->Size()) // if the skin does funky things, m_paths may have been cleared
+      m_paths->Get(item)->SetPath(path);
+    if (!m_bNameChanged || m_name.empty())
+    {
+      CURL url(path);
+      m_name = url.GetWithoutUserDetails();
+      URIUtils::RemoveSlashAtEnd(m_name);
+      m_name = CUtil::GetTitleFromPath(m_name);
+    }
+    UpdateButtons();
+  }
+}
+
+void CGUIDialogMediaSource::OnPath(int item)
+{
+  if (item < 0 || item >= m_paths->Size()) return;
+
+  std::string path(m_paths->Get(item)->GetPath());
+  if (m_name != CUtil::GetTitleFromPath(path))
+    m_bNameChanged = true;
+
+  CGUIKeyboardFactory::ShowAndGetInput(path, CVariant{ g_localizeStrings.Get(1021) }, false);
+  m_paths->Get(item)->SetPath(path);
+
+  if (!m_bNameChanged || m_name.empty())
+  {
+    CURL url(m_paths->Get(item)->GetPath());
+    m_name = url.GetWithoutUserDetails();
+    URIUtils::RemoveSlashAtEnd(m_name);
+    m_name = CUtil::GetTitleFromPath(m_name);
+  }
+  UpdateButtons();
+}
+
+void CGUIDialogMediaSource::OnOK()
+{
+  // Verify the paths by doing a GetDirectory.
+  CFileItemList items;
+
+  // Create temp media source to encode path urls as multipath
+  // Name of actual source may need to be made unique when saved in sources
+  CMediaSource share;
+  share.FromNameAndPaths(m_type, m_name, GetPaths());
+
+  if (StringUtils::StartsWithNoCase(share.strPath, "plugin://") ||
+    CDirectory::GetDirectory(share.strPath, items, "", DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_ALLOW_PROMPT) ||
+    CGUIDialogYesNo::ShowAndGetInput(CVariant{ 1001 }, CVariant{ 1025 }))
+  {
+    m_confirmed = true;
+    Close();
+  }
+}
+
+void CGUIDialogMediaSource::OnCancel()
+{
+  m_confirmed = false;
+  Close();
+}
+
+void CGUIDialogMediaSource::UpdateButtons()
+{
+  if (!m_paths->Size()) // sanity
+    return;
+
+  CONTROL_ENABLE_ON_CONDITION(CONTROL_OK, !m_paths->Get(0)->GetPath().empty() && !m_name.empty());
+  CONTROL_ENABLE_ON_CONDITION(CONTROL_PATH_ADD, !m_paths->Get(0)->GetPath().empty());
+  CONTROL_ENABLE_ON_CONDITION(CONTROL_PATH_REMOVE, m_paths->Size() > 1);
+  // name
+  SET_CONTROL_LABEL2(CONTROL_NAME, m_name);
+  SendMessage(GUI_MSG_SET_TYPE, CONTROL_NAME, 0, 1022);
+
+  int currentItem = GetSelectedItem();
+  SendMessage(GUI_MSG_LABEL_RESET, CONTROL_PATH);
+  for (int i = 0; i < m_paths->Size(); i++)
+  {
+    CFileItemPtr item = m_paths->Get(i);
+    std::string path;
+    CURL url(item->GetPath());
+    path = url.GetWithoutUserDetails();
+    if (path.empty()) path = "<" + g_localizeStrings.Get(231) + ">"; // <None>
+    item->SetLabel(path);
+  }
+  CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), CONTROL_PATH, 0, 0, m_paths);
+  OnMessage(msg);
+  SendMessage(GUI_MSG_ITEM_SELECT, CONTROL_PATH, currentItem);
+
+  SET_CONTROL_HIDDEN(CONTROL_CONTENT);
+}
+
+void CGUIDialogMediaSource::SetShare(const CMediaSource &share)
+{
+  m_paths->Clear();
+  for (unsigned int i = 0; i < share.vecPaths.size(); i++)
+  {
+    CFileItemPtr item(new CFileItem(share.vecPaths[i], true));
+    m_paths->Add(item);
+  }
+  if (0 == share.vecPaths.size())
+  {
+    CFileItemPtr item(new CFileItem("", true));
+    m_paths->Add(item);
+  }
+  m_name = share.strName;
+  UpdateButtons();
+}
+
+void CGUIDialogMediaSource::SetTypeOfMedia(const std::string &type, bool editNotAdd)
+{
+  m_type = type;
+  std::string heading;
+  if (editNotAdd)
+  {
+    if (type == "video")
+      heading = g_localizeStrings.Get(10053);
+    else if (type == "music")
+      heading = g_localizeStrings.Get(10054);
+    else if (type == "pictures")
+      heading = g_localizeStrings.Get(10055);
+    else if (type == "games")
+      heading = g_localizeStrings.Get(35252); // "Edit game source"
+    else if (type == "programs")
+      heading = g_localizeStrings.Get(10056);
+    else
+      heading = g_localizeStrings.Get(10057);
+  }
+  else
+  {
+    if (type == "video")
+      heading = g_localizeStrings.Get(10048);
+    else if (type == "music")
+      heading = g_localizeStrings.Get(10049);
+    else if (type == "pictures")
+      heading = g_localizeStrings.Get(13006);
+    else if (type == "games")
+      heading = g_localizeStrings.Get(35251); // "Add game source"
+    else if (type == "programs")
+      heading = g_localizeStrings.Get(10051);
+    else
+      heading = g_localizeStrings.Get(10052);
+  }
+  SET_CONTROL_LABEL(CONTROL_HEADING, heading);
+}
+
+int CGUIDialogMediaSource::GetSelectedItem()
+{
+  CGUIMessage message(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_PATH);
+  OnMessage(message);
+  int value = message.GetParam1();
+  if (value < 0 || value >= m_paths->Size()) return 0;
+  return value;
+}
+
+void CGUIDialogMediaSource::HighlightItem(int item)
+{
+  for (int i = 0; i < m_paths->Size(); i++)
+    m_paths->Get(i)->Select(false);
+  if (item >= 0 && item < m_paths->Size())
+    m_paths->Get(item)->Select(true);
+  CGUIMessage msg(GUI_MSG_ITEM_SELECT, GetID(), CONTROL_PATH, item);
+  OnMessage(msg);
+}
+
+void CGUIDialogMediaSource::OnPathRemove(int item)
+{
+  m_paths->Remove(item);
+  UpdateButtons();
+  if (item >= m_paths->Size())
+    HighlightItem(m_paths->Size() - 1);
+  else
+    HighlightItem(item);
+  if (m_paths->Size() <= 1)
+  {
+    SET_CONTROL_FOCUS(CONTROL_PATH_ADD, 0);
+  }
+}
+
+void CGUIDialogMediaSource::OnPathAdd()
+{
+  // add a new item and select it as well
+  CFileItemPtr item(new CFileItem("", true));
+  m_paths->Add(item);
+  UpdateButtons();
+  HighlightItem(m_paths->Size() - 1);
+}
+
+std::vector<std::string> CGUIDialogMediaSource::GetPaths() const
+{
+  std::vector<std::string> paths;
+  for (int i = 0; i < m_paths->Size(); i++)
+  {
+    if (!m_paths->Get(i)->GetPath().empty())
+    { // strip off the user and password for supported paths (anything that the password manager can auth)
+      // and add the user/pass to the password manager - note, we haven't confirmed that it works
+      // at this point, but if it doesn't, the user will get prompted anyway in implementation.
+      CURL url(m_paths->Get(i)->GetPath());
+      if (CPasswordManager::GetInstance().IsURLSupported(url) && !url.GetUserName().empty())
+      {
+        CPasswordManager::GetInstance().SaveAuthenticatedURL(url);
+        url.SetPassword("");
+        url.SetUserName("");
+        url.SetDomain("");
+      }
+      paths.push_back(url.Get());
+    }
+  }
+  return paths;
+}
+
+void CGUIDialogMediaSource::OnDeinitWindow(int nextWindowID)
+{
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  // clear paths container
+  CGUIMessage msg(GUI_MSG_LABEL_RESET, GetID(), CONTROL_PATH, 0);
+  OnMessage(msg);
+}
diff --git a/xbmc/dialogs/GUIDialogMediaSource.h b/xbmc/dialogs/GUIDialogMediaSource.h
new file mode 100644
index 0000000..e858e13
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogMediaSource.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 "guilib/GUIDialog.h"
+
+#include <string>
+#include <vector>
+
+class CFileItemList;
+class CMediaSource;
+
+class CGUIDialogMediaSource :
+      public CGUIDialog
+{
+public:
+  CGUIDialogMediaSource(void);
+  ~CGUIDialogMediaSource(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  void OnDeinitWindow(int nextWindowID) override;
+  bool OnBack(int actionID) override;
+  static bool ShowAndAddMediaSource(const std::string &type);
+  static bool ShowAndEditMediaSource(const std::string &type, const CMediaSource &share);
+  static bool ShowAndEditMediaSource(const std::string &type, const std::string &share);
+
+  bool IsConfirmed() const { return m_confirmed; }
+
+  void SetShare(const CMediaSource &share);
+  void SetTypeOfMedia(const std::string &type, bool editNotAdd = false);
+protected:
+  void OnPathBrowse(int item);
+  void OnPath(int item);
+  void OnPathAdd();
+  void OnPathRemove(int item);
+  void OnOK();
+  void OnCancel();
+  void UpdateButtons();
+  int GetSelectedItem();
+  void HighlightItem(int item);
+  std::string GetUniqueMediaSourceName();
+  static void OnMediaSourceChanged(const std::string& type, const std::string& oldName, const CMediaSource& share);
+
+  std::vector<std::string> GetPaths() const;
+
+  std::string m_type;
+  std::string m_name;
+  CFileItemList* m_paths;
+  bool m_confirmed = false;
+  bool m_bNameChanged = false;
+};
diff --git a/xbmc/dialogs/GUIDialogNumeric.cpp b/xbmc/dialogs/GUIDialogNumeric.cpp
new file mode 100644
index 0000000..182cf6a
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogNumeric.cpp
@@ -0,0 +1,916 @@
+/*
+ *  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 "GUIDialogNumeric.h"
+
+#include "ServiceBroker.h"
+#include "XBDateTime.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUILabelControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "input/XBMC_vkeys.h"
+#include "interfaces/AnnouncementManager.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/Digest.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+
+#include <cassert>
+
+#define CONTROL_HEADING_LABEL  1
+#define CONTROL_INPUT_LABEL    4
+#define CONTROL_NUM0          10
+#define CONTROL_NUM9          19
+#define CONTROL_PREVIOUS      20
+#define CONTROL_ENTER         21
+#define CONTROL_NEXT          22
+#define CONTROL_BACKSPACE     23
+
+using namespace KODI::MESSAGING;
+using KODI::UTILITY::CDigest;
+
+CGUIDialogNumeric::CGUIDialogNumeric(void)
+  : CGUIDialog(WINDOW_DIALOG_NUMERIC, "DialogNumeric.xml"),
+    m_bConfirmed{false},
+    m_bCanceled{false},
+    m_mode{INPUT_PASSWORD},
+    m_block{},
+    m_lastblock{},
+    m_dirty{false}
+{
+  memset(&m_datetime, 0, sizeof(KODI::TIME::SystemTime));
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogNumeric::~CGUIDialogNumeric(void) = default;
+
+void CGUIDialogNumeric::OnInitWindow()
+{
+  CGUIDialog::OnInitWindow();
+
+  CVariant data;
+  switch (m_mode)
+  {
+  case INPUT_TIME:
+    data["type"] = "time";
+    break;
+  case INPUT_DATE:
+    data["type"] = "date";
+    break;
+  case INPUT_IP_ADDRESS:
+    data["type"] = "ip";
+    break;
+  case INPUT_PASSWORD:
+    data["type"] = "numericpassword";
+    break;
+  case INPUT_NUMBER:
+    data["type"] = "number";
+    break;
+  case INPUT_TIME_SECONDS:
+    data["type"] = "seconds";
+    break;
+  default:
+    data["type"] = "keyboard";
+    break;
+  }
+
+  const CGUIControl *control = GetControl(CONTROL_HEADING_LABEL);
+  if (control != nullptr)
+    data["title"] = control->GetDescription();
+
+  data["value"] = GetOutputString();
+
+  CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Input, "OnInputRequested", data);
+}
+
+void CGUIDialogNumeric::OnDeinitWindow(int nextWindowID)
+{
+  // call base class
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Input, "OnInputFinished");
+}
+
+bool CGUIDialogNumeric::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_NEXT_ITEM)
+    OnNext();
+  else if (action.GetID() == ACTION_PREV_ITEM)
+    OnPrevious();
+  else if (action.GetID() == ACTION_BACKSPACE)
+    OnBackSpace();
+  else if (action.GetID() == ACTION_ENTER)
+    OnOK();
+  else if (action.GetID() >= REMOTE_0 && action.GetID() <= REMOTE_9)
+    OnNumber(action.GetID() - REMOTE_0);
+  else if (action.GetID() >= KEY_VKEY && action.GetID() < KEY_UNICODE)
+  {
+    // input from the keyboard (vkey, not ascii)
+    uint8_t b = action.GetID() & 0xFF;
+    if (b == XBMCVK_LEFT)
+      OnPrevious();
+    else if (b == XBMCVK_RIGHT)
+      OnNext();
+    else if (b == XBMCVK_RETURN || b == XBMCVK_NUMPADENTER)
+      OnOK();
+    else if (b == XBMCVK_BACK)
+      OnBackSpace();
+    else if (b == XBMCVK_ESCAPE)
+      OnCancel();
+  }
+  else if (action.GetID() == KEY_UNICODE)
+  { // input from the keyboard
+    if (action.GetUnicode() == 10 || action.GetUnicode() == 13)
+      OnOK(); // enter
+    else if (action.GetUnicode() == 8)
+      OnBackSpace(); // backspace
+    else if (action.GetUnicode() == 27)
+      OnCancel(); // escape
+    else if (action.GetUnicode() == 46)
+      OnNext(); // '.'
+    else if (action.GetUnicode() >= 48 && action.GetUnicode() < 58)  // number
+      OnNumber(action.GetUnicode() - 48);
+  }
+  else
+    return CGUIDialog::OnAction(action);
+
+  return true;
+}
+
+bool CGUIDialogNumeric::OnBack(int actionID)
+{
+  OnCancel();
+  return true;
+}
+
+bool CGUIDialogNumeric::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      m_bConfirmed = false;
+      m_bCanceled = false;
+      m_dirty = false;
+      return CGUIDialog::OnMessage(message);
+    }
+    break;
+
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      m_bConfirmed = false;
+      m_bCanceled = false;
+      if (CONTROL_NUM0 <= iControl && iControl <= CONTROL_NUM9)  // User numeric entry via dialog button UI
+      {
+        OnNumber(iControl - 10);
+        return true;
+      }
+      else if (iControl == CONTROL_PREVIOUS)
+      {
+        OnPrevious();
+        return true;
+      }
+      else if (iControl == CONTROL_NEXT)
+      {
+        OnNext();
+        return true;
+      }
+      else if (iControl == CONTROL_BACKSPACE)
+      {
+        OnBackSpace();
+        return true;
+      }
+      else if (iControl == CONTROL_ENTER)
+      {
+        OnOK();
+        return true;
+      }
+    }
+    break;
+
+  case GUI_MSG_SET_TEXT:
+    SetMode(m_mode, message.GetLabel());
+
+    // close the dialog if requested
+    if (message.GetParam1() > 0)
+      OnOK();
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogNumeric::OnBackSpace()
+{
+  if (!m_dirty && m_block)
+  {
+    --m_block;
+    return;
+  }
+  if (m_mode == INPUT_NUMBER || m_mode == INPUT_PASSWORD)
+  { // just go back one character
+    if (!m_number.empty())
+      m_number.erase(m_number.length() - 1);
+  }
+  else if (m_mode == INPUT_IP_ADDRESS)
+  {
+    if (m_ip[m_block])
+      m_ip[m_block] /= 10;
+    else if (m_block)
+    {
+      --m_block;
+      m_dirty = false;
+    }
+  }
+  else if (m_mode == INPUT_TIME)
+  {
+    if (m_block == 0)
+      m_datetime.hour /= 10;
+    else if (m_datetime.minute)
+      m_datetime.minute /= 10;
+    else
+    {
+      m_block = 0;
+      m_dirty = false;
+    }
+  }
+  else if (m_mode == INPUT_TIME_SECONDS)
+  {
+    if (m_block == 0)
+      m_datetime.hour /= 10;
+    else if (m_block == 1)
+    {
+      if (m_datetime.minute)
+        m_datetime.minute /= 10;
+      else
+      {
+        m_block = 0;
+        m_dirty = false;
+      }
+    }
+    else if (m_datetime.second)
+      m_datetime.minute /= 10;
+    else
+    {
+      m_block = 0;
+      m_dirty = false;
+    }
+  }
+  else if (m_mode == INPUT_DATE)
+  {
+    if (m_block == 0)
+      m_datetime.day /= 10;
+    else if (m_block == 1)
+    {
+      if (m_datetime.month)
+        m_datetime.month /= 10;
+      else
+      {
+        m_block = 0;
+        m_dirty = false;
+      }
+    }
+    else if (m_datetime.year) // m_block == 2
+      m_datetime.year /= 10;
+    else
+    {
+      m_block = 1;
+      m_dirty = false;
+    }
+  }
+}
+
+void CGUIDialogNumeric::OnPrevious()
+{
+  if (m_block)
+    m_block--;
+  m_dirty = false;
+}
+
+void CGUIDialogNumeric::OnNext()
+{
+  if (m_mode == INPUT_IP_ADDRESS && m_block==0 && m_ip[0]==0)
+    return;
+
+  if (m_block < m_lastblock)
+    m_block++;
+  m_dirty = false;
+  if (m_mode == INPUT_DATE)
+    VerifyDate(m_block == 2);
+}
+
+void CGUIDialogNumeric::FrameMove()
+{
+  std::string strLabel;
+  unsigned int start = 0;
+  unsigned int end = 0;
+  if (m_mode == INPUT_PASSWORD)
+    strLabel.assign(m_number.length(), '*');
+  else if (m_mode == INPUT_NUMBER)
+    strLabel = m_number;
+  else if (m_mode == INPUT_TIME)
+  { // format up the time
+    strLabel = StringUtils::Format("{:2}:{:02}", m_datetime.hour, m_datetime.minute);
+    start = m_block * 3;
+    end = m_block * 3 + 2;
+  }
+  else if (m_mode == INPUT_TIME_SECONDS)
+  { // format up the time
+    strLabel = StringUtils::Format("{:2}:{:02}:{:02}", m_datetime.hour, m_datetime.minute,
+                                   m_datetime.second);
+    start = m_block * 3;
+    end = m_block * 3 + 2;
+  }
+  else if (m_mode == INPUT_DATE)
+  { // format up the date
+    strLabel =
+        StringUtils::Format("{:2}/{:2}/{:4}", m_datetime.day, m_datetime.month, m_datetime.year);
+    start = m_block * 3;
+    end = m_block * 3 + 2;
+    if (m_block == 2)
+      end = m_block * 3 + 4;
+  }
+  else if (m_mode == INPUT_IP_ADDRESS)
+  { // format up the date
+    strLabel = StringUtils::Format("{:3}.{:3}.{:3}.{:3}", m_ip[0], m_ip[1], m_ip[2], m_ip[3]);
+    start = m_block * 4;
+    end = m_block * 4 + 3;
+  }
+  CGUILabelControl *pLabel = dynamic_cast<CGUILabelControl *>(GetControl(CONTROL_INPUT_LABEL));
+  if (pLabel)
+  {
+    pLabel->SetLabel(strLabel);
+    pLabel->SetHighlight(start, end);
+  }
+  CGUIDialog::FrameMove();
+}
+
+void CGUIDialogNumeric::OnNumber(uint32_t num)
+{
+  ResetAutoClose();
+
+  switch (m_mode)
+  {
+  case INPUT_NUMBER:
+  case INPUT_PASSWORD:
+    m_number += num + '0';
+    break;
+  case INPUT_TIME:
+    HandleInputTime(num);
+    break;
+  case INPUT_TIME_SECONDS:
+    HandleInputSeconds(num);
+    break;
+  case INPUT_DATE:
+    HandleInputDate(num);
+    break;
+  case INPUT_IP_ADDRESS:
+    HandleInputIP(num);
+    break;
+  }
+}
+
+void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const KODI::TIME::SystemTime& initial)
+{
+  m_mode = mode;
+  m_block = 0;
+  m_lastblock = 0;
+  if (m_mode == INPUT_TIME || m_mode == INPUT_TIME_SECONDS || m_mode == INPUT_DATE)
+  {
+    m_datetime = initial;
+    m_lastblock = (m_mode != INPUT_TIME) ? 2 : 1;
+  }
+}
+
+void CGUIDialogNumeric::SetMode(INPUT_MODE mode, const std::string &initial)
+{
+  m_mode = mode;
+  m_block = 0;
+  m_lastblock = 0;
+  if (m_mode == INPUT_TIME || m_mode == INPUT_TIME_SECONDS || m_mode == INPUT_DATE)
+  {
+    CDateTime dateTime;
+    if (m_mode == INPUT_TIME || m_mode == INPUT_TIME_SECONDS)
+    {
+      // check if we have a pure number
+      if (initial.find_first_not_of("0123456789") == std::string::npos)
+      {
+        long seconds = strtol(initial.c_str(), nullptr, 10);
+        dateTime = seconds;
+      }
+      else
+      {
+        std::string tmp = initial;
+        // if we are handling seconds and if the string only contains
+        // "mm:ss" we need to add dummy "hh:" to get "hh:mm:ss"
+        if (m_mode == INPUT_TIME_SECONDS && tmp.length() <= 5)
+          tmp = "00:" + tmp;
+        dateTime.SetFromDBTime(tmp);
+      }
+    }
+    else if (m_mode == INPUT_DATE)
+    {
+      std::string tmp = initial;
+      StringUtils::Replace(tmp, '/', '.');
+      dateTime.SetFromDBDate(tmp);
+    }
+
+    if (!dateTime.IsValid())
+      return;
+
+    dateTime.GetAsSystemTime(m_datetime);
+    m_lastblock = (m_mode == INPUT_DATE) ? 2 : 1;
+  }
+  else if (m_mode == INPUT_IP_ADDRESS)
+  {
+    m_lastblock = 3;
+    auto blocks = StringUtils::Split(initial, '.');
+    if (blocks.size() != 4)
+      return;
+
+    for (size_t i = 0; i < blocks.size(); ++i)
+    {
+      if (blocks[i].length() > 3)
+        return;
+
+      m_ip[i] = static_cast<uint8_t>(atoi(blocks[i].c_str()));
+    }
+  }
+  else if (m_mode == INPUT_NUMBER || m_mode == INPUT_PASSWORD)
+    m_number = initial;
+}
+
+KODI::TIME::SystemTime CGUIDialogNumeric::GetOutput() const
+{
+  assert(m_mode == INPUT_TIME || m_mode == INPUT_TIME_SECONDS || m_mode == INPUT_DATE);
+  return m_datetime;
+}
+
+std::string CGUIDialogNumeric::GetOutputString() const
+{
+  switch (m_mode)
+  {
+  case INPUT_DATE:
+    return StringUtils::Format("{:02}/{:02}/{:04}", m_datetime.day, m_datetime.month,
+                               m_datetime.year);
+  case INPUT_TIME:
+    return StringUtils::Format("{}:{:02}", m_datetime.hour, m_datetime.minute);
+  case INPUT_TIME_SECONDS:
+    return StringUtils::Format("{}:{:02}:{:02}", m_datetime.hour, m_datetime.minute,
+                               m_datetime.second);
+  case INPUT_IP_ADDRESS:
+    return StringUtils::Format("{}.{}.{}.{}", m_ip[0], m_ip[1], m_ip[2], m_ip[3]);
+  case INPUT_NUMBER:
+  case INPUT_PASSWORD:
+    return m_number;
+  }
+
+  //should never get here
+  return std::string();
+}
+
+bool CGUIDialogNumeric::ShowAndGetSeconds(std::string &timeString, const std::string &heading)
+{
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  if (!pDialog) return false;
+  int seconds = StringUtils::TimeStringToSeconds(timeString);
+  KODI::TIME::SystemTime time = {};
+  time.hour = seconds / 3600;
+  time.minute = (seconds - time.hour * 3600) / 60;
+  time.second = seconds - time.hour * 3600 - time.minute * 60;
+  pDialog->SetMode(INPUT_TIME_SECONDS, time);
+  pDialog->SetHeading(heading);
+  pDialog->Open();
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+    return false;
+  time = pDialog->GetOutput();
+  seconds = time.hour * 3600 + time.minute * 60 + time.second;
+  timeString = StringUtils::SecondsToTimeString(seconds);
+  return true;
+}
+
+bool CGUIDialogNumeric::ShowAndGetTime(KODI::TIME::SystemTime& time, const std::string& heading)
+{
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  if (!pDialog) return false;
+  pDialog->SetMode(INPUT_TIME, time);
+  pDialog->SetHeading(heading);
+  pDialog->Open();
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+    return false;
+  time = pDialog->GetOutput();
+  return true;
+}
+
+bool CGUIDialogNumeric::ShowAndGetDate(KODI::TIME::SystemTime& date, const std::string& heading)
+{
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  if (!pDialog) return false;
+  pDialog->SetMode(INPUT_DATE, date);
+  pDialog->SetHeading(heading);
+  pDialog->Open();
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+    return false;
+  date = pDialog->GetOutput();
+  return true;
+}
+
+bool CGUIDialogNumeric::ShowAndGetIPAddress(std::string &IPAddress, const std::string &heading)
+{
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  if (!pDialog) return false;
+  pDialog->SetMode(INPUT_IP_ADDRESS, IPAddress);
+  pDialog->SetHeading(heading);
+  pDialog->Open();
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+    return false;
+  IPAddress = pDialog->GetOutputString();
+  return true;
+}
+
+bool CGUIDialogNumeric::ShowAndGetNumber(std::string& strInput, const std::string &strHeading, unsigned int iAutoCloseTimeoutMs /* = 0 */, bool bSetHidden /* = false */)
+{
+  // Prompt user for password input
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  pDialog->SetHeading( strHeading );
+
+  if (bSetHidden)
+    pDialog->SetMode(INPUT_PASSWORD, strInput);
+  else
+    pDialog->SetMode(INPUT_NUMBER, strInput);
+  if (iAutoCloseTimeoutMs)
+    pDialog->SetAutoClose(iAutoCloseTimeoutMs);
+
+  pDialog->Open();
+
+  if (!pDialog->IsAutoClosed() && (!pDialog->IsConfirmed() || pDialog->IsCanceled()))
+    return false;
+  strInput = pDialog->GetOutputString();
+  return true;
+}
+
+// \brief Show numeric keypad twice to get and confirm a user-entered password string.
+// \param strNewPassword String to preload into the keyboard accumulator. Overwritten with user input if return=true.
+// \return true if successful display and user input entry/re-entry. false if unsuccessful display, no user input, or canceled editing.
+bool CGUIDialogNumeric::ShowAndVerifyNewPassword(std::string& strNewPassword)
+{
+  // Prompt user for password input
+  std::string strUserInput;
+  InputVerificationResult ret = ShowAndVerifyInput(strUserInput, g_localizeStrings.Get(12340), false);
+  if (ret != InputVerificationResult::SUCCESS)
+  {
+    if (ret == InputVerificationResult::FAILED)
+    {
+      // Show error to user saying the password entry was blank
+      HELPERS::ShowOKDialogText(CVariant{12357}, CVariant{12358}); // Password is empty/blank
+    }
+    return false;
+  }
+
+  if (strUserInput.empty())
+    // user canceled out
+    return false;
+
+  // Prompt again for password input, this time sending previous input as the password to verify
+  ret = ShowAndVerifyInput(strUserInput, g_localizeStrings.Get(12341), true);
+  if (ret != InputVerificationResult::SUCCESS)
+  {
+    if (ret == InputVerificationResult::FAILED)
+    {
+      // Show error to user saying the password re-entry failed
+      HELPERS::ShowOKDialogText(CVariant{12357}, CVariant{12344}); // Password do not match
+    }
+    return false;
+  }
+
+  // password entry and re-entry succeeded
+  strNewPassword = strUserInput;
+  return true;
+}
+
+// \brief Show numeric keypad and verify user input against strPassword.
+// \param strPassword Value to compare against user input.
+// \param strHeading String shown on dialog title. Converts to localized string if contains a positive integer.
+// \param iRetries If greater than 0, shows "Incorrect password, %d retries left" on dialog line 2, else line 2 is blank.
+// \return 0 if successful display and user input. 1 if unsuccessful input. -1 if no user input or canceled editing.
+int CGUIDialogNumeric::ShowAndVerifyPassword(std::string& strPassword, const std::string& strHeading, int iRetries)
+{
+  std::string strTempHeading = strHeading;
+  if (iRetries > 0)
+  {
+    // Show a string telling user they have iRetries retries left
+    strTempHeading = StringUtils::Format("{}. {} {} {}", strHeading, g_localizeStrings.Get(12342),
+                                         iRetries, g_localizeStrings.Get(12343));
+  }
+
+  // make a copy of strPassword to prevent from overwriting it later
+  std::string strPassTemp = strPassword;
+  InputVerificationResult ret = ShowAndVerifyInput(strPassTemp, strTempHeading, true);
+  if (ret == InputVerificationResult::SUCCESS)
+    return 0;   // user entered correct password
+
+  if (ret == InputVerificationResult::CANCELED)
+    return -1;   // user canceled out
+
+  return 1; // user must have entered an incorrect password
+}
+
+// \brief Show numeric keypad and verify user input against strToVerify.
+// \param strToVerify Value to compare against user input.
+// \param dlgHeading String shown on dialog title.
+// \param bVerifyInput If set as true we verify the users input versus strToVerify.
+// \return the result of the check (success, failed, or canceled by user).
+InputVerificationResult CGUIDialogNumeric::ShowAndVerifyInput(std::string& strToVerify, const std::string& dlgHeading, bool bVerifyInput)
+{
+  // Prompt user for password input
+  CGUIDialogNumeric *pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogNumeric>(WINDOW_DIALOG_NUMERIC);
+  pDialog->SetHeading(dlgHeading);
+
+  std::string strInput;
+  if (!bVerifyInput)
+    strInput = strToVerify;
+
+  pDialog->SetMode(INPUT_PASSWORD, strInput);
+  pDialog->Open();
+
+  strInput = pDialog->GetOutputString();
+
+  if (!pDialog->IsConfirmed() || pDialog->IsCanceled())
+  {
+    // user canceled out
+    strToVerify = "";
+    return InputVerificationResult::CANCELED;
+  }
+
+  const std::string md5pword2 = CDigest::Calculate(CDigest::Type::MD5, strInput);
+
+  if (!bVerifyInput)
+  {
+    strToVerify = md5pword2;
+    return InputVerificationResult::SUCCESS;
+  }
+
+  return StringUtils::EqualsNoCase(strToVerify, md5pword2) ? InputVerificationResult::SUCCESS : InputVerificationResult::FAILED;
+}
+
+bool CGUIDialogNumeric::IsConfirmed() const
+{
+  return m_bConfirmed;
+}
+
+bool CGUIDialogNumeric::IsCanceled() const
+{
+  return m_bCanceled;
+}
+
+void CGUIDialogNumeric::SetHeading(const std::string& strHeading)
+{
+  Initialize();
+  CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), CONTROL_HEADING_LABEL);
+  msg.SetLabel(strHeading);
+  OnMessage(msg);
+}
+
+void CGUIDialogNumeric::VerifyDate(bool checkYear)
+{
+  if (m_datetime.day == 0)
+    m_datetime.day = 1;
+  if (m_datetime.month == 0)
+    m_datetime.month = 1;
+  // check for number of days in the month
+  if (m_datetime.day == 31)
+  {
+    if (m_datetime.month == 4 || m_datetime.month == 6 || m_datetime.month == 9 ||
+        m_datetime.month == 11)
+      m_datetime.day = 30;
+  }
+  if (m_datetime.month == 2 && m_datetime.day > 28)
+  {
+    m_datetime.day = 29; // max in february.
+    if (checkYear)
+    {
+      // leap years occur when the year is divisible by 4 but not by 100, or the year is divisible by 400
+      // thus they don't occur, if the year has a remainder when divided by 4, or when the year is divisible by 100 but not by 400
+      if ((m_datetime.year % 4) || (!(m_datetime.year % 100) && (m_datetime.year % 400)))
+        m_datetime.day = 28;
+    }
+  }
+}
+
+void CGUIDialogNumeric::OnOK()
+{
+  m_bConfirmed = true;
+  m_bCanceled = false;
+  Close();
+}
+
+void CGUIDialogNumeric::OnCancel()
+{
+  m_bConfirmed = false;
+  m_bCanceled = true;
+  Close();
+}
+
+void CGUIDialogNumeric::HandleInputIP(uint32_t num)
+{
+  if (m_dirty && ((m_ip[m_block] < 25) || (m_ip[m_block] == 25 && num < 6) || !(m_block == 0 && num == 0)))
+  {
+    m_ip[m_block] *= 10;
+    m_ip[m_block] += num;
+  }
+  else
+    m_ip[m_block] = num;
+
+  if (m_ip[m_block] > 25 || (m_ip[m_block] == 0 && num == 0))
+  {
+    ++m_block;
+    if (m_block > 3)
+      m_block = 0;
+    m_dirty = false;
+  }
+  else
+    m_dirty = true;
+}
+
+void CGUIDialogNumeric::HandleInputDate(uint32_t num)
+{
+  if (m_block == 0) // day of month
+  {
+    if (m_dirty && (m_datetime.day < 3 || num < 2))
+    {
+      m_datetime.day *= 10;
+      m_datetime.day += num;
+    }
+    else
+      m_datetime.day = num;
+
+    if (m_datetime.day > 3)
+    {
+      m_block = 1;             // move to months
+      m_dirty = false;
+    }
+    else
+      m_dirty = true;
+  }
+  else if (m_block == 1)  // months
+  {
+    if (m_dirty && num < 3)
+    {
+      m_datetime.month *= 10;
+      m_datetime.month += num;
+    }
+    else
+      m_datetime.month = num;
+
+    if (m_datetime.month > 1)
+    {
+      VerifyDate(false);
+      m_block = 2;             // move to year
+      m_dirty = false;
+    }
+    else
+      m_dirty = true;
+  }
+  else // year
+  {
+    if (m_dirty && m_datetime.year < 1000) // have taken input
+    {
+      m_datetime.year *= 10;
+      m_datetime.year += num;
+    }
+    else
+      m_datetime.year = num;
+
+    if (m_datetime.year > 1000)
+    {
+      VerifyDate(true);
+      m_block = 0;        // move to day of month
+      m_dirty = false;
+    }
+    else
+      m_dirty = true;
+  }
+}
+
+void CGUIDialogNumeric::HandleInputSeconds(uint32_t num)
+{
+  if (m_block == 0) // hour
+  {
+    if (m_dirty) // have input the first digit
+    {
+      m_datetime.hour *= 10;
+      m_datetime.hour += num;
+      m_block = 1;             // move to minutes - allows up to 99 hours
+      m_dirty = false;
+    }
+    else  // this is the first digit
+    {
+      m_datetime.hour = num;
+      m_dirty = true;
+    }
+  }
+  else if (m_block == 1) // minute
+  {
+    if (m_dirty) // have input the first digit
+    {
+      m_datetime.minute *= 10;
+      m_datetime.minute += num;
+      m_block = 2;             // move to seconds - allows up to 99 minutes
+      m_dirty = false;
+    }
+    else  // this is the first digit
+    {
+      m_datetime.minute = num;
+      if (num > 5)
+      {
+        m_block = 2;           // move to seconds
+        m_dirty = false;
+      }
+      else
+        m_dirty = true;
+    }
+  }
+  else  // seconds
+  {
+    if (m_dirty) // have input the first digit
+    {
+      m_datetime.second *= 10;
+      m_datetime.second += num;
+      m_block = 0;             // move to hours
+      m_dirty = false;
+    }
+    else  // this is the first digit
+    {
+      m_datetime.second = num;
+      if (num > 5)
+      {
+        m_block = 0;           // move to hours
+        m_dirty = false;
+      }
+      else
+        m_dirty = true;
+    }
+  }
+}
+
+void CGUIDialogNumeric::HandleInputTime(uint32_t num)
+{
+  if (m_block == 0) // hour
+  {
+    if (m_dirty) // have input the first digit
+    {
+      if (m_datetime.hour < 2 || num < 4)
+      {
+        m_datetime.hour *= 10;
+        m_datetime.hour += num;
+      }
+      else
+        m_datetime.hour = num;
+
+      m_block = 1;             // move to minutes
+      m_dirty = false;
+    }
+    else  // this is the first digit
+    {
+      m_datetime.hour = num;
+
+      if (num > 2)
+      {
+        m_block = 1;             // move to minutes
+        m_dirty = false;
+      }
+      else
+        m_dirty = true;
+    }
+  }
+  else  // minute
+  {
+    if (m_dirty) // have input the first digit
+    {
+      m_datetime.minute *= 10;
+      m_datetime.minute += num;
+      m_block = 0;             // move to hours
+      m_dirty = false;
+    }
+    else  // this is the first digit
+    {
+      m_datetime.minute = num;
+
+      if (num > 5)
+      {
+        m_block = 0;           // move to hours
+        m_dirty = false;
+      }
+      else
+        m_dirty = true;
+    }
+  }
+}
+
diff --git a/xbmc/dialogs/GUIDialogNumeric.h b/xbmc/dialogs/GUIDialogNumeric.h
new file mode 100644
index 0000000..2932053
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogNumeric.h
@@ -0,0 +1,82 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+#include "utils/XTimeUtils.h"
+
+#include <cstdint>
+
+enum class InputVerificationResult
+{
+  CANCELED,
+  FAILED,
+  SUCCESS
+};
+
+class CGUIDialogNumeric :
+      public CGUIDialog
+{
+public:
+  enum INPUT_MODE { INPUT_TIME = 1, INPUT_DATE, INPUT_IP_ADDRESS, INPUT_PASSWORD, INPUT_NUMBER, INPUT_TIME_SECONDS };
+  CGUIDialogNumeric(void);
+  ~CGUIDialogNumeric(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnAction(const CAction &action) override;
+  bool OnBack(int actionID) override;
+  void FrameMove() override;
+
+  bool IsConfirmed() const;
+  bool IsCanceled() const;
+  bool IsInputHidden() const { return m_mode == INPUT_PASSWORD; }
+
+  static bool ShowAndVerifyNewPassword(std::string& strNewPassword);
+  static int ShowAndVerifyPassword(std::string& strPassword, const std::string& strHeading, int iRetries);
+  static InputVerificationResult ShowAndVerifyInput(std::string& strPassword, const std::string& strHeading, bool bGetUserInput);
+
+  void SetHeading(const std::string &strHeading);
+  void SetMode(INPUT_MODE mode, const KODI::TIME::SystemTime& initial);
+  void SetMode(INPUT_MODE mode, const std::string &initial);
+  KODI::TIME::SystemTime GetOutput() const;
+  std::string GetOutputString() const;
+
+  static bool ShowAndGetTime(KODI::TIME::SystemTime& time, const std::string& heading);
+  static bool ShowAndGetDate(KODI::TIME::SystemTime& date, const std::string& heading);
+  static bool ShowAndGetIPAddress(std::string &IPAddress, const std::string &heading);
+  static bool ShowAndGetNumber(std::string& strInput, const std::string &strHeading, unsigned int iAutoCloseTimeoutMs = 0, bool bSetHidden = false);
+  static bool ShowAndGetSeconds(std::string& timeString, const std::string &heading);
+
+protected:
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+  void OnNumber(uint32_t num);
+  void VerifyDate(bool checkYear);
+  void OnNext();
+  void OnPrevious();
+  void OnBackSpace();
+  void OnOK();
+  void OnCancel();
+
+  void HandleInputIP(uint32_t num);
+  void HandleInputDate(uint32_t num);
+  void HandleInputSeconds(uint32_t num);
+  void HandleInputTime(uint32_t num);
+
+  bool m_bConfirmed;
+  bool m_bCanceled;
+
+  INPUT_MODE m_mode;                // the current input mode
+  KODI::TIME::SystemTime m_datetime; // for time and date modes
+  uint8_t m_ip[4];                  // for ip address mode
+  uint32_t m_block;             // for time, date, and IP methods.
+  uint32_t m_lastblock;
+  bool m_dirty;                     // true if the current block has been changed.
+  std::string m_number;              ///< for number or password input
+};
diff --git a/xbmc/dialogs/GUIDialogOK.cpp b/xbmc/dialogs/GUIDialogOK.cpp
new file mode 100644
index 0000000..af626dc
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogOK.cpp
@@ -0,0 +1,99 @@
+/*
+ *  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 "GUIDialogOK.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/Variant.h"
+
+CGUIDialogOK::CGUIDialogOK(void)
+    : CGUIDialogBoxBase(WINDOW_DIALOG_OK, "DialogConfirm.xml")
+{
+}
+
+CGUIDialogOK::~CGUIDialogOK(void) = default;
+
+bool CGUIDialogOK::OnMessage(CGUIMessage& message)
+{
+  if (message.GetMessage() == GUI_MSG_CLICKED)
+  {
+    int iControl = message.GetSenderId();
+    if (iControl == CONTROL_YES_BUTTON)
+    {
+      m_bConfirmed = true;
+      Close();
+      return true;
+    }
+  }
+  return CGUIDialogBoxBase::OnMessage(message);
+}
+
+// \brief Show CGUIDialogOK dialog, then wait for user to dismiss it.
+bool CGUIDialogOK::ShowAndGetInput(const CVariant& heading, const CVariant& text)
+{
+  CGUIDialogOK *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogOK>(WINDOW_DIALOG_OK);
+  if (!dialog)
+    return false;
+  dialog->SetHeading(heading);
+  dialog->SetText(text);
+  dialog->Open();
+  return dialog->IsConfirmed();
+}
+
+// \brief Show CGUIDialogOK dialog, then wait for user to dismiss it.
+bool CGUIDialogOK::ShowAndGetInput(const CVariant& heading,
+                                   const CVariant& line0,
+                                   const CVariant& line1,
+                                   const CVariant& line2)
+{
+  CGUIDialogOK *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogOK>(WINDOW_DIALOG_OK);
+  if (!dialog)
+    return false;
+  dialog->SetHeading(heading);
+  dialog->SetLine(0, line0);
+  dialog->SetLine(1, line1);
+  dialog->SetLine(2, line2);
+  dialog->Open();
+  return dialog->IsConfirmed();
+}
+
+bool CGUIDialogOK::ShowAndGetInput(const HELPERS::DialogOKMessage & options)
+{
+  if (!options.heading.isNull())
+    SetHeading(options.heading);
+  if (!options.text.isNull())
+    SetText(options.text);
+
+  for (size_t i = 0; i < 3; ++i)
+  {
+    if (!options.lines[i].isNull())
+      SetLine(i, options.lines[i]);
+  }
+  Open();
+  return IsConfirmed();
+}
+
+void CGUIDialogOK::OnInitWindow()
+{
+  SET_CONTROL_HIDDEN(CONTROL_NO_BUTTON);
+  SET_CONTROL_HIDDEN(CONTROL_CUSTOM_BUTTON);
+  SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR);
+  SET_CONTROL_FOCUS(CONTROL_YES_BUTTON, 0);
+
+  CGUIDialogBoxBase::OnInitWindow();
+}
+
+int CGUIDialogOK::GetDefaultLabelID(int controlId) const
+{
+  if (controlId == CONTROL_YES_BUTTON)
+    return 186;
+  return CGUIDialogBoxBase::GetDefaultLabelID(controlId);
+}
diff --git a/xbmc/dialogs/GUIDialogOK.h b/xbmc/dialogs/GUIDialogOK.h
new file mode 100644
index 0000000..94678e3
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogOK.h
@@ -0,0 +1,43 @@
+/*
+ *  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 "GUIDialogBoxBase.h"
+#include "messaging/helpers/DialogOKHelper.h"
+
+class CGUIMessage;
+class CVariant;
+
+using namespace KODI::MESSAGING;
+
+class CGUIDialogOK :
+      public CGUIDialogBoxBase
+{
+public:
+  CGUIDialogOK(void);
+  ~CGUIDialogOK(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  static bool ShowAndGetInput(const CVariant& heading, const CVariant& text);
+  static bool ShowAndGetInput(const CVariant& heading,
+                              const CVariant& line0,
+                              const CVariant& line1,
+                              const CVariant& line2);
+  /*!
+  \brief Open a OK dialog and wait for input
+
+  \param[in] options  a struct of type DialogOKMessage containing
+  the options to set for this dialog.
+
+  \sa KODI::MESSAGING::HELPERS::DialogOKMessage
+  */
+  bool ShowAndGetInput(const HELPERS::DialogOKMessage& options);
+protected:
+  void OnInitWindow() override;
+  int GetDefaultLabelID(int controlId) const override;
+};
diff --git a/xbmc/dialogs/GUIDialogPlayEject.cpp b/xbmc/dialogs/GUIDialogPlayEject.cpp
new file mode 100644
index 0000000..14ee2bc
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayEject.cpp
@@ -0,0 +1,101 @@
+/*
+ *  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 "GUIDialogPlayEject.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "storage/MediaManager.h"
+#include "utils/Variant.h"
+
+#include <utility>
+
+#define ID_BUTTON_PLAY      11
+#define ID_BUTTON_EJECT     10
+
+CGUIDialogPlayEject::CGUIDialogPlayEject()
+    : CGUIDialogYesNo(WINDOW_DIALOG_PLAY_EJECT)
+{
+}
+
+CGUIDialogPlayEject::~CGUIDialogPlayEject() = default;
+
+bool CGUIDialogPlayEject::OnMessage(CGUIMessage& message)
+{
+  if (message.GetMessage() == GUI_MSG_CLICKED)
+  {
+    int iControl = message.GetSenderId();
+    if (iControl == ID_BUTTON_PLAY)
+    {
+      if (CServiceBroker::GetMediaManager().IsDiscInDrive())
+      {
+        m_bConfirmed = true;
+        Close();
+      }
+
+      return true;
+    }
+    if (iControl == ID_BUTTON_EJECT)
+    {
+      CServiceBroker::GetMediaManager().ToggleTray();
+      return true;
+    }
+  }
+
+  return CGUIDialogYesNo::OnMessage(message);
+}
+
+void CGUIDialogPlayEject::FrameMove()
+{
+  CONTROL_ENABLE_ON_CONDITION(ID_BUTTON_PLAY, CServiceBroker::GetMediaManager().IsDiscInDrive());
+
+  CGUIDialogYesNo::FrameMove();
+}
+
+void CGUIDialogPlayEject::OnInitWindow()
+{
+  if (CServiceBroker::GetMediaManager().IsDiscInDrive())
+  {
+    m_defaultControl = ID_BUTTON_PLAY;
+  }
+  else
+  {
+    CONTROL_DISABLE(ID_BUTTON_PLAY);
+    m_defaultControl = ID_BUTTON_EJECT;
+  }
+
+  CGUIDialogYesNo::OnInitWindow();
+}
+
+bool CGUIDialogPlayEject::ShowAndGetInput(const std::string& strLine1,
+                                          const std::string& strLine2,
+                                          unsigned int uiAutoCloseTime /* = 0 */)
+{
+
+  // Create the dialog
+  CGUIDialogPlayEject * pDialog = (CGUIDialogPlayEject *)CServiceBroker::GetGUI()->GetWindowManager().
+    GetWindow(WINDOW_DIALOG_PLAY_EJECT);
+  if (!pDialog)
+    return false;
+
+  // Setup dialog parameters
+  pDialog->SetHeading(CVariant{219});
+  pDialog->SetLine(0, CVariant{429});
+  pDialog->SetLine(1, CVariant{strLine1});
+  pDialog->SetLine(2, CVariant{strLine2});
+  pDialog->SetChoice(ID_BUTTON_PLAY - 10, 208);
+  pDialog->SetChoice(ID_BUTTON_EJECT - 10, 13391);
+  if (uiAutoCloseTime)
+    pDialog->SetAutoClose(uiAutoCloseTime);
+
+  // Display the dialog
+  pDialog->Open();
+
+  return pDialog->IsConfirmed();
+}
diff --git a/xbmc/dialogs/GUIDialogPlayEject.h b/xbmc/dialogs/GUIDialogPlayEject.h
new file mode 100644
index 0000000..8354b53
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayEject.h
@@ -0,0 +1,27 @@
+/*
+ *  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 "GUIDialogYesNo.h"
+
+class CGUIDialogPlayEject : public CGUIDialogYesNo
+{
+public:
+  CGUIDialogPlayEject();
+  ~CGUIDialogPlayEject() override;
+  bool OnMessage(CGUIMessage& message) override;
+  void FrameMove() override;
+
+  static bool ShowAndGetInput(const std::string& strLine1,
+                              const std::string& strLine2,
+                              unsigned int uiAutoCloseTime = 0);
+
+protected:
+  void OnInitWindow() override;
+};
diff --git a/xbmc/dialogs/GUIDialogPlayerControls.cpp b/xbmc/dialogs/GUIDialogPlayerControls.cpp
new file mode 100644
index 0000000..e137eb1
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayerControls.cpp
@@ -0,0 +1,19 @@
+/*
+ *  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 "GUIDialogPlayerControls.h"
+
+
+CGUIDialogPlayerControls::CGUIDialogPlayerControls(void)
+    : CGUIDialog(WINDOW_DIALOG_PLAYER_CONTROLS, "PlayerControls.xml")
+{
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogPlayerControls::~CGUIDialogPlayerControls(void) = default;
+
diff --git a/xbmc/dialogs/GUIDialogPlayerControls.h b/xbmc/dialogs/GUIDialogPlayerControls.h
new file mode 100644
index 0000000..e2bb1a4
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayerControls.h
@@ -0,0 +1,19 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogPlayerControls :
+      public CGUIDialog
+{
+public:
+  CGUIDialogPlayerControls(void);
+  ~CGUIDialogPlayerControls(void) override;
+};
diff --git a/xbmc/dialogs/GUIDialogPlayerProcessInfo.cpp b/xbmc/dialogs/GUIDialogPlayerProcessInfo.cpp
new file mode 100644
index 0000000..8276311
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayerProcessInfo.cpp
@@ -0,0 +1,29 @@
+/*
+ *  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 "GUIDialogPlayerProcessInfo.h"
+
+#include "input/Key.h"
+
+CGUIDialogPlayerProcessInfo::CGUIDialogPlayerProcessInfo(void)
+    : CGUIDialog(WINDOW_DIALOG_PLAYER_PROCESS_INFO, "DialogPlayerProcessInfo.xml")
+{
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogPlayerProcessInfo::~CGUIDialogPlayerProcessInfo(void) = default;
+
+bool CGUIDialogPlayerProcessInfo::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_PLAYER_PROCESS_INFO)
+  {
+    Close();
+    return true;
+  }
+  return CGUIDialog::OnAction(action);
+}
diff --git a/xbmc/dialogs/GUIDialogPlayerProcessInfo.h b/xbmc/dialogs/GUIDialogPlayerProcessInfo.h
new file mode 100644
index 0000000..7413770
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogPlayerProcessInfo.h
@@ -0,0 +1,20 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogPlayerProcessInfo : public CGUIDialog
+{
+public:
+  CGUIDialogPlayerProcessInfo(void);
+  ~CGUIDialogPlayerProcessInfo(void) override;
+
+  bool OnAction(const CAction &action) override;
+};
diff --git a/xbmc/dialogs/GUIDialogProgress.cpp b/xbmc/dialogs/GUIDialogProgress.cpp
new file mode 100644
index 0000000..21acb0a
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogProgress.cpp
@@ -0,0 +1,292 @@
+/*
+ *  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 "GUIDialogProgress.h"
+
+#include "guilib/GUIProgressControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/guiinfo/GUIInfoLabels.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+#include <mutex>
+
+using namespace std::chrono_literals;
+
+CGUIDialogProgress::CGUIDialogProgress(void)
+    : CGUIDialogBoxBase(WINDOW_DIALOG_PROGRESS, "DialogConfirm.xml")
+{
+  Reset();
+}
+
+CGUIDialogProgress::~CGUIDialogProgress(void) = default;
+
+void CGUIDialogProgress::Reset()
+{
+  std::unique_lock<CCriticalSection> lock(m_section);
+  m_iCurrent = 0;
+  m_iMax = 0;
+  m_percentage = 0;
+  m_showProgress = true;
+  m_bCanCancel = true;
+  m_iChoice = CHOICE_NONE;
+  m_supportedChoices = {};
+
+  SetInvalid();
+}
+
+void CGUIDialogProgress::SetCanCancel(bool bCanCancel)
+{
+  std::unique_lock<CCriticalSection> lock(m_section);
+  m_bCanCancel = bCanCancel;
+  SetInvalid();
+}
+
+void CGUIDialogProgress::ShowChoice(int iChoice, const CVariant& label)
+{
+  if (iChoice >= 0 && iChoice < DIALOG_MAX_CHOICES)
+  {
+    m_supportedChoices[iChoice] = true;
+    SetChoice(iChoice, label);
+    SetInvalid();
+  }
+}
+
+int CGUIDialogProgress::GetChoice() const
+{
+  return m_iChoice;
+}
+
+void CGUIDialogProgress::Open(const std::string &param /* = "" */)
+{
+  CLog::Log(LOGDEBUG, "DialogProgress::Open called {}", m_active ? "(already running)!" : "");
+
+  {
+    std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
+    ShowProgressBar(true);
+  }
+
+  CGUIDialog::Open(false, param);
+
+  while (m_active && IsAnimating(ANIM_TYPE_WINDOW_OPEN))
+  {
+    Progress();
+    // we should have rendered at least once by now - if we haven't, then
+    // we must be running from fullscreen video or similar where the
+    // calling thread handles rendering (ie not main app thread) but
+    // is waiting on this routine before rendering begins
+    if (!HasProcessed())
+      break;
+  }
+}
+
+void CGUIDialogProgress::Progress()
+{
+  if (m_active)
+  {
+    ProcessRenderLoop();
+  }
+}
+
+bool CGUIDialogProgress::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+
+  case GUI_MSG_WINDOW_DEINIT:
+    Reset();
+    break;
+
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      if (iControl >= CONTROL_CHOICES_START && iControl < (CONTROL_CHOICES_START + DIALOG_MAX_CHOICES))
+      {
+        // special handling for choice 0 mapped to cancel button
+        if (m_bCanCancel && !m_supportedChoices[0] && (iControl == CONTROL_CHOICES_START))
+        {
+          if (m_iChoice != CHOICE_CANCELED)
+          {
+            std::string strHeading = m_strHeading;
+            strHeading.append(" : ");
+            strHeading.append(g_localizeStrings.Get(16024));
+            CGUIDialogBoxBase::SetHeading(CVariant{strHeading});
+            m_iChoice = CHOICE_CANCELED;
+          }
+        }
+        else
+        {
+          m_iChoice = iControl - CONTROL_CHOICES_START;
+        }
+        return true;
+      }
+    }
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+bool CGUIDialogProgress::OnBack(int actionID)
+{
+  if (m_bCanCancel)
+    m_iChoice = CHOICE_CANCELED;
+  else
+    m_iChoice = CHOICE_NONE;
+
+  return true;
+}
+
+void CGUIDialogProgress::OnWindowLoaded()
+{
+  CGUIDialog::OnWindowLoaded();
+  CGUIControl *control = GetControl(CONTROL_PROGRESS_BAR);
+  if (control && control->GetControlType() == CGUIControl::GUICONTROL_PROGRESS)
+  {
+    // make sure we have the appropriate info set
+    CGUIProgressControl *progress = static_cast<CGUIProgressControl*>(control);
+    if (!progress->GetInfo())
+      progress->SetInfo(SYSTEM_PROGRESS_BAR);
+  }
+}
+
+void CGUIDialogProgress::SetPercentage(int iPercentage)
+{
+  if (iPercentage < 0) iPercentage = 0;
+  if (iPercentage > 100) iPercentage = 100;
+
+  if (iPercentage != m_percentage)
+    MarkDirtyRegion();
+
+  m_percentage = iPercentage;
+}
+
+void CGUIDialogProgress::SetProgressMax(int iMax)
+{
+  m_iMax=iMax;
+  m_iCurrent=0;
+}
+
+void CGUIDialogProgress::SetProgressAdvance(int nSteps/*=1*/)
+{
+  m_iCurrent+=nSteps;
+
+  if (m_iCurrent>m_iMax)
+    m_iCurrent=0;
+
+  if (m_iMax > 0)
+    SetPercentage((m_iCurrent*100)/m_iMax);
+}
+
+bool CGUIDialogProgress::Abort()
+{
+  return m_active ? IsCanceled() : false;
+}
+
+void CGUIDialogProgress::ShowProgressBar(bool bOnOff)
+{
+  std::unique_lock<CCriticalSection> lock(m_section);
+  m_showProgress = bOnOff;
+  SetInvalid();
+}
+
+bool CGUIDialogProgress::Wait(int progresstime /*= 10*/)
+{
+  CEvent m_done;
+  while (!m_done.Wait(std::chrono::milliseconds(progresstime)) && m_active && !IsCanceled())
+    Progress();
+
+  return !IsCanceled();
+}
+
+bool CGUIDialogProgress::WaitOnEvent(CEvent& event)
+{
+  while (!event.Wait(1ms))
+  {
+    if (IsCanceled())
+      return false;
+
+    Progress();
+  }
+
+  return !IsCanceled();
+}
+
+void CGUIDialogProgress::UpdateControls()
+{
+  // take a copy to save holding the lock for too long
+  bool bShowProgress;
+  bool bShowCancel;
+  std::array<bool, DIALOG_MAX_CHOICES> choices;
+  {
+    std::unique_lock<CCriticalSection> lock(m_section);
+    bShowProgress = m_showProgress;
+    bShowCancel = m_bCanCancel;
+    choices = m_supportedChoices;
+  }
+
+  if (bShowProgress)
+    SET_CONTROL_VISIBLE(CONTROL_PROGRESS_BAR);
+  else
+    SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR);
+
+  bool bAllHidden = true;
+  for (int i = 0; i < DIALOG_MAX_CHOICES; ++i)
+  {
+    if (choices[i])
+    {
+      bAllHidden = false;
+      SET_CONTROL_VISIBLE(CONTROL_CHOICES_START + i);
+    }
+    else
+      SET_CONTROL_HIDDEN(CONTROL_CHOICES_START + i);
+  }
+
+  // special handling for choice 0 mapped to cancel button
+  if (bShowCancel && bAllHidden)
+    SET_CONTROL_VISIBLE(CONTROL_CHOICES_START);
+}
+
+void CGUIDialogProgress::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  if (m_bInvalidated)
+    UpdateControls();
+
+  CGUIDialogBoxBase::Process(currentTime, dirtyregions);
+}
+
+void CGUIDialogProgress::OnInitWindow()
+{
+  UpdateControls();
+
+  bool bNoFocus = true;
+  for (int i = 0; i < DIALOG_MAX_CHOICES; ++i)
+  {
+    if (m_supportedChoices[i])
+    {
+      bNoFocus = false;
+      SET_CONTROL_FOCUS(CONTROL_CHOICES_START + i, 0);
+      break;
+    }
+  }
+
+  // special handling for choice 0 mapped to cancel button
+  if (m_bCanCancel && bNoFocus)
+    SET_CONTROL_FOCUS(CONTROL_CHOICES_START,0 );
+
+  CGUIDialogBoxBase::OnInitWindow();
+}
+
+int CGUIDialogProgress::GetDefaultLabelID(int controlId) const
+{
+  // special handling for choice 0 mapped to cancel button
+  if (m_bCanCancel && !m_supportedChoices[0] && (controlId == CONTROL_CHOICES_START))
+    return 222; // Cancel
+
+  return CGUIDialogBoxBase::GetDefaultLabelID(controlId);
+}
diff --git a/xbmc/dialogs/GUIDialogProgress.h b/xbmc/dialogs/GUIDialogProgress.h
new file mode 100644
index 0000000..ba84269
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogProgress.h
@@ -0,0 +1,80 @@
+/*
+ *  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 "GUIDialogBoxBase.h"
+#include "IProgressCallback.h"
+
+#include <array>
+
+class CGUIDialogProgress :
+      public CGUIDialogBoxBase, public IProgressCallback
+{
+public:
+  CGUIDialogProgress(void);
+  ~CGUIDialogProgress(void) override;
+
+  void Reset();
+  void Open(const std::string &param = "");
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+  void OnWindowLoaded() override;
+  void Progress();
+  bool IsCanceled() const { return m_iChoice == CHOICE_CANCELED; }
+  void SetPercentage(int iPercentage);
+  int GetPercentage() const { return m_percentage; }
+  void ShowProgressBar(bool bOnOff);
+
+  void ShowChoice(int iChoice, const CVariant& label);
+
+  static constexpr int CHOICE_NONE = -2;
+  static constexpr int CHOICE_CANCELED = -1;
+  int GetChoice() const;
+
+  /*! \brief Wait for the progress dialog to be closed or canceled, while regularly
+   rendering to allow for pointer movement or progress to be shown. Used when showing
+   the progress of a process that is taking place on a separate thread and may be
+   reporting progress infrequently.
+   \param progresstime the time in ms to wait between rendering the dialog (defaults to 10ms)
+   \return true if the dialog is closed, false if the user cancels early.
+   */
+  bool Wait(int progresstime = 10);
+
+  /*! \brief Wait on an event or for the progress dialog to be canceled, while
+  regularly rendering to allow for pointer movement or progress to be shown.
+  \param event the CEvent to wait on.
+  \return true if the event completed, false if cancelled.
+  */
+  bool WaitOnEvent(CEvent& event);
+
+  // Implements IProgressCallback
+  void SetProgressMax(int iMax) override;
+  void SetProgressAdvance(int nSteps=1) override;
+  bool Abort() override;
+
+  void SetCanCancel(bool bCanCancel);
+
+protected:
+  void OnInitWindow() override;
+  int GetDefaultLabelID(int controlId) const override;
+  void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
+
+  bool m_bCanCancel;
+
+  int  m_iCurrent;
+  int  m_iMax;
+  int m_percentage;
+  bool m_showProgress;
+
+  std::array<bool, DIALOG_MAX_CHOICES> m_supportedChoices = {};
+  int m_iChoice = CHOICE_NONE;
+
+private:
+  void UpdateControls();
+};
diff --git a/xbmc/dialogs/GUIDialogSeekBar.cpp b/xbmc/dialogs/GUIDialogSeekBar.cpp
new file mode 100644
index 0000000..d2f462d
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSeekBar.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 "GUIDialogSeekBar.h"
+
+#include "GUIInfoManager.h"
+#include "SeekHandler.h"
+#include "application/ApplicationComponents.h"
+#include "application/ApplicationPlayer.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/guiinfo/GUIInfoLabels.h"
+
+#include <cmath>
+
+#define POPUP_SEEK_PROGRESS           401
+#define POPUP_SEEK_EPG_EVENT_PROGRESS 402
+#define POPUP_SEEK_TIMESHIFT_PROGRESS 403
+
+CGUIDialogSeekBar::CGUIDialogSeekBar(void)
+  : CGUIDialog(WINDOW_DIALOG_SEEK_BAR, "DialogSeekBar.xml", DialogModalityType::MODELESS)
+{
+  m_loadType = LOAD_ON_GUI_INIT;    // the application class handles our resources
+}
+
+CGUIDialogSeekBar::~CGUIDialogSeekBar(void) = default;
+
+bool CGUIDialogSeekBar::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+  case GUI_MSG_WINDOW_INIT:
+  case GUI_MSG_WINDOW_DEINIT:
+    return CGUIDialog::OnMessage(message);
+  case GUI_MSG_ITEM_SELECT:
+    if (message.GetSenderId() == GetID() &&
+        (message.GetControlId() == POPUP_SEEK_PROGRESS ||
+         message.GetControlId() == POPUP_SEEK_EPG_EVENT_PROGRESS ||
+         message.GetControlId() == POPUP_SEEK_TIMESHIFT_PROGRESS))
+      return CGUIDialog::OnMessage(message);
+    break;
+  case GUI_MSG_REFRESH_TIMER:
+    return CGUIDialog::OnMessage(message);
+  }
+  return false; // don't process anything other than what we need!
+}
+
+void CGUIDialogSeekBar::FrameMove()
+{
+  const auto& components = CServiceBroker::GetAppComponents();
+  const auto appPlayer = components.GetComponent<CApplicationPlayer>();
+  if (!appPlayer->HasPlayer())
+  {
+    Close(true);
+    return;
+  }
+
+  int progress = GetProgress();
+  if (progress != m_lastProgress)
+    CONTROL_SELECT_ITEM(POPUP_SEEK_PROGRESS, m_lastProgress = progress);
+
+  int epgEventProgress = GetEpgEventProgress();
+  if (epgEventProgress != m_lastEpgEventProgress)
+    CONTROL_SELECT_ITEM(POPUP_SEEK_EPG_EVENT_PROGRESS, m_lastEpgEventProgress = epgEventProgress);
+
+  int timeshiftProgress = GetTimeshiftProgress();
+  if (timeshiftProgress != m_lastTimeshiftProgress)
+    CONTROL_SELECT_ITEM(POPUP_SEEK_TIMESHIFT_PROGRESS, m_lastTimeshiftProgress = timeshiftProgress);
+
+  CGUIDialog::FrameMove();
+}
+
+int CGUIDialogSeekBar::GetProgress() const
+{
+  const CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager();
+
+  int progress = 0;
+
+  const auto& components = CServiceBroker::GetAppComponents();
+  const auto appPlayer = components.GetComponent<CApplicationPlayer>();
+  if (appPlayer->GetSeekHandler().GetSeekSize() != 0)
+    infoMgr.GetInt(progress, PLAYER_SEEKBAR, INFO::DEFAULT_CONTEXT);
+  else
+    infoMgr.GetInt(progress, PLAYER_PROGRESS, INFO::DEFAULT_CONTEXT);
+
+  return progress;
+}
+
+int CGUIDialogSeekBar::GetEpgEventProgress() const
+{
+  CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager();
+
+  int progress = 0;
+  infoMgr.GetInt(progress, PVR_EPG_EVENT_PROGRESS, INFO::DEFAULT_CONTEXT);
+
+  const auto& components = CServiceBroker::GetAppComponents();
+  const auto appPlayer = components.GetComponent<CApplicationPlayer>();
+  int seekSize = appPlayer->GetSeekHandler().GetSeekSize();
+  if (seekSize != 0)
+  {
+    int total = 0;
+    infoMgr.GetInt(total, PVR_EPG_EVENT_DURATION, INFO::DEFAULT_CONTEXT);
+
+    float totalTime = static_cast<float>(total);
+    if (totalTime == 0.0f)
+      return 0;
+
+    float percentPerSecond = 100.0f / totalTime;
+    float percent = progress + percentPerSecond * seekSize;
+    percent = std::max(0.0f, std::min(percent, 100.0f));
+    return std::lrintf(percent);
+  }
+
+  return progress;
+}
+
+int CGUIDialogSeekBar::GetTimeshiftProgress() const
+{
+  const CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager();
+
+  int progress = 0;
+  infoMgr.GetInt(progress, PVR_TIMESHIFT_SEEKBAR, INFO::DEFAULT_CONTEXT);
+
+  return progress;
+}
diff --git a/xbmc/dialogs/GUIDialogSeekBar.h b/xbmc/dialogs/GUIDialogSeekBar.h
new file mode 100644
index 0000000..314bf27
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSeekBar.h
@@ -0,0 +1,28 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogSeekBar : public CGUIDialog
+{
+public:
+  CGUIDialogSeekBar(void);
+  ~CGUIDialogSeekBar(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  void FrameMove() override;
+private:
+  int GetProgress() const;
+  int GetEpgEventProgress() const;
+  int GetTimeshiftProgress() const;
+
+  int m_lastProgress = 0;
+  int m_lastEpgEventProgress = 0;
+  int m_lastTimeshiftProgress = 0;
+};
diff --git a/xbmc/dialogs/GUIDialogSelect.cpp b/xbmc/dialogs/GUIDialogSelect.cpp
new file mode 100644
index 0000000..0f125b2
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSelect.cpp
@@ -0,0 +1,405 @@
+/*
+ *  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 "GUIDialogSelect.h"
+
+#include "FileItem.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "utils/StringUtils.h"
+
+#define CONTROL_HEADING         1
+#define CONTROL_NUMBER_OF_ITEMS 2
+#define CONTROL_SIMPLE_LIST     3
+#define CONTROL_DETAILED_LIST   6
+#define CONTROL_EXTRA_BUTTON    5
+#define CONTROL_EXTRA_BUTTON2 8
+#define CONTROL_CANCEL_BUTTON   7
+
+CGUIDialogSelect::CGUIDialogSelect() : CGUIDialogSelect(WINDOW_DIALOG_SELECT) {}
+
+CGUIDialogSelect::CGUIDialogSelect(int windowId)
+  : CGUIDialogBoxBase(windowId, "DialogSelect.xml"),
+    m_vecList(std::make_unique<CFileItemList>()),
+    m_bButtonEnabled(false),
+    m_bButton2Enabled(false),
+    m_bButtonPressed(false),
+    m_bButton2Pressed(false),
+    m_useDetails(false),
+    m_multiSelection(false)
+{
+  m_bConfirmed = false;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogSelect::~CGUIDialogSelect(void) = default;
+
+bool CGUIDialogSelect::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+  case GUI_MSG_WINDOW_DEINIT:
+    {
+      CGUIDialogBoxBase::OnMessage(message);
+
+      m_bButtonEnabled = false;
+      m_bButton2Enabled = false;
+      m_useDetails = false;
+      m_multiSelection = false;
+
+      // construct selected items list
+      m_selectedItems.clear();
+      m_selectedItem = nullptr;
+      for (int i = 0 ; i < m_vecList->Size() ; i++)
+      {
+        CFileItemPtr item = m_vecList->Get(i);
+        if (item->IsSelected())
+        {
+          m_selectedItems.push_back(i);
+          if (!m_selectedItem)
+            m_selectedItem = item;
+        }
+      }
+      m_vecList->Clear();
+      return true;
+    }
+    break;
+
+  case GUI_MSG_WINDOW_INIT:
+    {
+      m_bButtonPressed = false;
+      m_bButton2Pressed = false;
+      m_bConfirmed = false;
+      CGUIDialogBoxBase::OnMessage(message);
+      return true;
+    }
+    break;
+
+
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      if (m_viewControl.HasControl(CONTROL_SIMPLE_LIST))
+      {
+        int iAction = message.GetParam1();
+        if (ACTION_SELECT_ITEM == iAction || ACTION_MOUSE_LEFT_CLICK == iAction)
+        {
+          int iSelected = m_viewControl.GetSelectedItem();
+          if (iSelected >= 0 && iSelected < m_vecList->Size())
+          {
+            CFileItemPtr item(m_vecList->Get(iSelected));
+            if (m_multiSelection)
+              item->Select(!item->IsSelected());
+            else
+            {
+              for (int i = 0 ; i < m_vecList->Size() ; i++)
+                m_vecList->Get(i)->Select(false);
+              item->Select(true);
+              OnSelect(iSelected);
+            }
+          }
+        }
+      }
+      if (iControl == CONTROL_EXTRA_BUTTON2)
+      {
+        m_bButton2Pressed = true;
+        if (m_multiSelection)
+          m_bConfirmed = true;
+        Close();
+      }
+      if (iControl == CONTROL_EXTRA_BUTTON)
+      {
+        m_selectedItem = nullptr;
+        m_bButtonPressed = true;
+        if (m_multiSelection)
+          m_bConfirmed = true;
+        Close();
+      }
+      else if (iControl == CONTROL_CANCEL_BUTTON)
+      {
+        m_selectedItem = nullptr;
+        m_vecList->Clear();
+        m_selectedItems.clear();
+        m_bConfirmed = false;
+        Close();
+      }
+    }
+    break;
+  case GUI_MSG_SETFOCUS:
+    {
+      if (m_viewControl.HasControl(message.GetControlId()))
+      {
+        if (m_vecList->IsEmpty())
+        {
+          if (m_bButtonEnabled)
+            SET_CONTROL_FOCUS(CONTROL_EXTRA_BUTTON, 0);
+          else
+            SET_CONTROL_FOCUS(CONTROL_CANCEL_BUTTON, 0);
+          return true;
+        }
+        if (m_viewControl.GetCurrentControl() != message.GetControlId())
+        {
+          m_viewControl.SetFocused();
+          return true;
+        }
+      }
+    }
+    break;
+  }
+
+  return CGUIDialogBoxBase::OnMessage(message);
+}
+
+void CGUIDialogSelect::OnSelect(int idx)
+{
+  m_bConfirmed = true;
+  Close();
+}
+
+bool CGUIDialogSelect::OnBack(int actionID)
+{
+  m_selectedItem = nullptr;
+  m_vecList->Clear();
+  m_selectedItems.clear();
+  m_bConfirmed = false;
+  return CGUIDialogBoxBase::OnBack(actionID);
+}
+
+void CGUIDialogSelect::Reset()
+{
+  m_bButtonEnabled = false;
+  m_bButtonPressed = false;
+  m_bButton2Enabled = false;
+  m_bButton2Pressed = false;
+
+  m_useDetails = false;
+  m_multiSelection = false;
+  m_focusToButton = false;
+  m_selectedItem = nullptr;
+  m_vecList->Clear();
+  m_selectedItems.clear();
+}
+
+int CGUIDialogSelect::Add(const std::string& strLabel)
+{
+  CFileItemPtr pItem(new CFileItem(strLabel));
+  m_vecList->Add(pItem);
+  return m_vecList->Size() - 1;
+}
+
+int CGUIDialogSelect::Add(const CFileItem& item)
+{
+  m_vecList->Add(CFileItemPtr(new CFileItem(item)));
+  return m_vecList->Size() - 1;
+}
+
+void CGUIDialogSelect::SetItems(const CFileItemList& pList)
+{
+  // need to make internal copy of list to be sure dialog is owner of it
+  m_vecList->Clear();
+  m_vecList->Copy(pList);
+
+  m_viewControl.SetItems(*m_vecList);
+}
+
+int CGUIDialogSelect::GetSelectedItem() const
+{
+  return m_selectedItems.size() > 0 ? m_selectedItems[0] : -1;
+}
+
+const CFileItemPtr CGUIDialogSelect::GetSelectedFileItem() const
+{
+  if (m_selectedItem)
+    return m_selectedItem;
+  return CFileItemPtr(new CFileItem);
+}
+
+const std::vector<int>& CGUIDialogSelect::GetSelectedItems() const
+{
+  return m_selectedItems;
+}
+
+void CGUIDialogSelect::EnableButton(bool enable, int label)
+{
+  m_bButtonEnabled = enable;
+  m_buttonLabel = g_localizeStrings.Get(label);
+}
+
+void CGUIDialogSelect::EnableButton(bool enable, const std::string& label)
+{
+  m_bButtonEnabled = enable;
+  m_buttonLabel = label;
+}
+
+void CGUIDialogSelect::EnableButton2(bool enable, int label)
+{
+  m_bButton2Enabled = enable;
+  m_button2Label = g_localizeStrings.Get(label);
+}
+
+void CGUIDialogSelect::EnableButton2(bool enable, const std::string& label)
+{
+  m_bButton2Enabled = enable;
+  m_button2Label = label;
+}
+
+bool CGUIDialogSelect::IsButtonPressed()
+{
+  return m_bButtonPressed;
+}
+
+bool CGUIDialogSelect::IsButton2Pressed()
+{
+  return m_bButton2Pressed;
+}
+
+void CGUIDialogSelect::Sort(bool bSortOrder /*=true*/)
+{
+  m_vecList->Sort(SortByLabel, bSortOrder ? SortOrderAscending : SortOrderDescending);
+}
+
+void CGUIDialogSelect::SetSelected(int iSelected)
+{
+  if (iSelected < 0 || iSelected >= m_vecList->Size() ||
+      m_vecList->Get(iSelected).get() == NULL)
+    return;
+
+  // only set m_iSelected if there is no multi-select
+  // or if it doesn't have a valid value yet
+  // or if the current value is bigger than the new one
+  // so that we always focus the item nearest to the beginning of the list
+  if (!m_multiSelection || !m_selectedItem ||
+      (!m_selectedItems.empty() && m_selectedItems.back() > iSelected))
+    m_selectedItem = m_vecList->Get(iSelected);
+  m_vecList->Get(iSelected)->Select(true);
+  m_selectedItems.push_back(iSelected);
+}
+
+void CGUIDialogSelect::SetSelected(const std::string &strSelectedLabel)
+{
+  for (int index = 0; index < m_vecList->Size(); index++)
+  {
+    if (strSelectedLabel == m_vecList->Get(index)->GetLabel())
+    {
+      SetSelected(index);
+      return;
+    }
+  }
+}
+
+void CGUIDialogSelect::SetSelected(const std::vector<int>& selectedIndexes)
+{
+  for (auto i : selectedIndexes)
+    SetSelected(i);
+}
+
+void CGUIDialogSelect::SetSelected(const std::vector<std::string> &selectedLabels)
+{
+  for (const auto& label : selectedLabels)
+    SetSelected(label);
+}
+
+void CGUIDialogSelect::SetUseDetails(bool useDetails)
+{
+  m_useDetails = useDetails;
+}
+
+void CGUIDialogSelect::SetMultiSelection(bool multiSelection)
+{
+  m_multiSelection = multiSelection;
+}
+
+void CGUIDialogSelect::SetButtonFocus(bool buttonFocus)
+{
+  m_focusToButton = buttonFocus;
+}
+
+CGUIControl *CGUIDialogSelect::GetFirstFocusableControl(int id)
+{
+  if (m_viewControl.HasControl(id))
+    id = m_viewControl.GetCurrentControl();
+  return CGUIDialogBoxBase::GetFirstFocusableControl(id);
+}
+
+void CGUIDialogSelect::OnWindowLoaded()
+{
+  CGUIDialogBoxBase::OnWindowLoaded();
+  m_viewControl.Reset();
+  m_viewControl.SetParentWindow(GetID());
+  m_viewControl.AddView(GetControl(CONTROL_SIMPLE_LIST));
+  m_viewControl.AddView(GetControl(CONTROL_DETAILED_LIST));
+}
+
+void CGUIDialogSelect::OnInitWindow()
+{
+  m_viewControl.SetItems(*m_vecList);
+  m_selectedItems.clear();
+  for(int i = 0 ; i < m_vecList->Size(); i++)
+  {
+    auto item = m_vecList->Get(i);
+    if (item->IsSelected())
+    {
+      m_selectedItems.push_back(i);
+      if (m_selectedItem == nullptr)
+        m_selectedItem = item;
+    }
+  }
+  m_viewControl.SetCurrentView(m_useDetails ? CONTROL_DETAILED_LIST : CONTROL_SIMPLE_LIST);
+
+  SET_CONTROL_LABEL(CONTROL_NUMBER_OF_ITEMS,
+                    StringUtils::Format("{} {}", m_vecList->Size(), g_localizeStrings.Get(127)));
+
+  if (m_multiSelection)
+    EnableButton(true, 186);
+
+  if (m_bButtonEnabled)
+  {
+    SET_CONTROL_LABEL(CONTROL_EXTRA_BUTTON, m_buttonLabel);
+    SET_CONTROL_VISIBLE(CONTROL_EXTRA_BUTTON);
+  }
+  else
+    SET_CONTROL_HIDDEN(CONTROL_EXTRA_BUTTON);
+
+  if (m_bButton2Enabled)
+  {
+    SET_CONTROL_LABEL(CONTROL_EXTRA_BUTTON2, m_button2Label);
+    SET_CONTROL_VISIBLE(CONTROL_EXTRA_BUTTON2);
+  }
+  else
+    SET_CONTROL_HIDDEN(CONTROL_EXTRA_BUTTON2);
+
+  SET_CONTROL_LABEL(CONTROL_CANCEL_BUTTON, g_localizeStrings.Get(222));
+
+  CGUIDialogBoxBase::OnInitWindow();
+
+  // focus one of the buttons if explicitly requested
+  // ATTENTION: this must be done after calling CGUIDialogBoxBase::OnInitWindow()
+  if (m_focusToButton)
+  {
+    if (m_bButtonEnabled)
+      SET_CONTROL_FOCUS(CONTROL_EXTRA_BUTTON, 0);
+    else
+      SET_CONTROL_FOCUS(CONTROL_CANCEL_BUTTON, 0);
+  }
+
+  // if nothing is selected, select first item
+  m_viewControl.SetSelectedItem(std::max(GetSelectedItem(), 0));
+}
+
+void CGUIDialogSelect::OnDeinitWindow(int nextWindowID)
+{
+  m_viewControl.Clear();
+  CGUIDialogBoxBase::OnDeinitWindow(nextWindowID);
+}
+
+void CGUIDialogSelect::OnWindowUnload()
+{
+  CGUIDialogBoxBase::OnWindowUnload();
+  m_viewControl.Reset();
+}
diff --git a/xbmc/dialogs/GUIDialogSelect.h b/xbmc/dialogs/GUIDialogSelect.h
new file mode 100644
index 0000000..7edb493
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSelect.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 "GUIDialogBoxBase.h"
+#include "view/GUIViewControl.h"
+
+#include <string>
+#include <vector>
+
+class CFileItem;
+class CFileItemList;
+
+class CGUIDialogSelect : public CGUIDialogBoxBase
+{
+public:
+  CGUIDialogSelect();
+  ~CGUIDialogSelect(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+
+  void Reset();
+  int  Add(const std::string& strLabel);
+  int  Add(const CFileItem& item);
+  void SetItems(const CFileItemList& items);
+  const CFileItemPtr GetSelectedFileItem() const;
+  int GetSelectedItem() const;
+  const std::vector<int>& GetSelectedItems() const;
+  void EnableButton(bool enable, int label);
+  void EnableButton(bool enable, const std::string& label);
+  void EnableButton2(bool enable, int label);
+  void EnableButton2(bool enable, const std::string& label);
+  bool IsButtonPressed();
+  bool IsButton2Pressed();
+  void Sort(bool bSortOrder = true);
+  void SetSelected(int iSelected);
+  void SetSelected(const std::string &strSelectedLabel);
+  void SetSelected(const std::vector<int>& selectedIndexes);
+  void SetSelected(const std::vector<std::string> &selectedLabels);
+  void SetUseDetails(bool useDetails);
+  void SetMultiSelection(bool multiSelection);
+  void SetButtonFocus(bool buttonFocus);
+
+protected:
+  explicit CGUIDialogSelect(int windowid);
+  CGUIControl *GetFirstFocusableControl(int id) override;
+  void OnWindowLoaded() override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+  void OnWindowUnload() override;
+
+  virtual void OnSelect(int idx);
+
+  CFileItemPtr m_selectedItem;
+  std::unique_ptr<CFileItemList> m_vecList;
+  CGUIViewControl m_viewControl;
+
+private:
+  bool m_bButtonEnabled;
+  bool m_bButton2Enabled;
+  bool m_bButtonPressed;
+  bool m_bButton2Pressed;
+  std::string m_buttonLabel;
+  std::string m_button2Label;
+  bool m_useDetails;
+  bool m_multiSelection;
+  bool m_focusToButton{};
+
+  std::vector<int> m_selectedItems;
+};
diff --git a/xbmc/dialogs/GUIDialogSimpleMenu.cpp b/xbmc/dialogs/GUIDialogSimpleMenu.cpp
new file mode 100644
index 0000000..0d4d11a
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSimpleMenu.cpp
@@ -0,0 +1,154 @@
+/*
+ *  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 "GUIDialogSimpleMenu.h"
+
+#include "FileItem.h"
+#include "GUIDialogSelect.h"
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "dialogs/GUIDialogBusy.h"
+#include "filesystem/Directory.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "settings/DiscSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "threads/IRunnable.h"
+#include "utils/FileUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+#include "video/VideoInfoTag.h"
+
+namespace
+{
+class CGetDirectoryItems : public IRunnable
+{
+public:
+  CGetDirectoryItems(const std::string &path, CFileItemList &items, const XFILE::CDirectory::CHints &hints)
+  : m_path(path), m_items(items), m_hints(hints)
+  {
+  }
+  void Run() override
+  {
+    m_result = XFILE::CDirectory::GetDirectory(m_path, m_items, m_hints);
+  }
+  bool m_result;
+protected:
+  std::string m_path;
+  CFileItemList &m_items;
+  XFILE::CDirectory::CHints m_hints;
+};
+}
+
+
+bool CGUIDialogSimpleMenu::ShowPlaySelection(CFileItem& item)
+{
+  if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_DISC_PLAYBACK) != BD_PLAYBACK_SIMPLE_MENU)
+    return true;
+
+  if (item.IsBDFile())
+  {
+    std::string root = URIUtils::GetParentPath(item.GetDynPath());
+    URIUtils::RemoveSlashAtEnd(root);
+    if (URIUtils::GetFileName(root) == "BDMV")
+    {
+      CURL url("bluray://");
+      url.SetHostName(URIUtils::GetParentPath(root));
+      url.SetFileName("root");
+      return ShowPlaySelection(item, url.Get());
+    }
+  }
+
+  if (item.IsDiscImage())
+  {
+    CURL url2("udf://");
+    url2.SetHostName(item.GetDynPath());
+    url2.SetFileName("BDMV/index.bdmv");
+    if (CFileUtils::Exists(url2.Get()))
+    {
+      url2.SetFileName("");
+
+      CURL url("bluray://");
+      url.SetHostName(url2.Get());
+      url.SetFileName("root");
+      return ShowPlaySelection(item, url.Get());
+    }
+  }
+  return true;
+}
+
+bool CGUIDialogSimpleMenu::ShowPlaySelection(CFileItem& item, const std::string& directory)
+{
+
+  CFileItemList items;
+
+  if (!GetDirectoryItems(directory, items, XFILE::CDirectory::CHints()))
+  {
+    CLog::Log(LOGERROR,
+              "CGUIWindowVideoBase::ShowPlaySelection - Failed to get play directory for {}",
+              directory);
+    return true;
+  }
+
+  if (items.IsEmpty())
+  {
+    CLog::Log(LOGERROR, "CGUIWindowVideoBase::ShowPlaySelection - Failed to get any items {}",
+              directory);
+    return true;
+  }
+
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  while (true)
+  {
+    dialog->Reset();
+    dialog->SetHeading(CVariant{25006}); // Select playback item
+    dialog->SetItems(items);
+    dialog->SetUseDetails(true);
+    dialog->Open();
+
+    CFileItemPtr item_new = dialog->GetSelectedFileItem();
+    if (!item_new || dialog->GetSelectedItem() < 0)
+    {
+      CLog::Log(LOGDEBUG, "CGUIWindowVideoBase::ShowPlaySelection - User aborted {}", directory);
+      break;
+    }
+
+    if (item_new->m_bIsFolder == false)
+    {
+      std::string original_path = item.GetDynPath();
+      item.SetDynPath(item_new->GetDynPath());
+      item.SetProperty("get_stream_details_from_player", true);
+      item.SetProperty("original_listitem_url", original_path);
+      return true;
+    }
+
+    items.Clear();
+    if (!GetDirectoryItems(item_new->GetDynPath(), items, XFILE::CDirectory::CHints()) || items.IsEmpty())
+    {
+      CLog::Log(LOGERROR, "CGUIWindowVideoBase::ShowPlaySelection - Failed to get any items {}",
+                item_new->GetPath());
+      break;
+    }
+  }
+
+  return false;
+}
+
+bool CGUIDialogSimpleMenu::GetDirectoryItems(const std::string &path, CFileItemList &items,
+                                             const XFILE::CDirectory::CHints &hints)
+{
+  CGetDirectoryItems getItems(path, items, hints);
+  if (!CGUIDialogBusy::Wait(&getItems, 100, true))
+  {
+    return false;
+  }
+  return getItems.m_result;
+}
diff --git a/xbmc/dialogs/GUIDialogSimpleMenu.h b/xbmc/dialogs/GUIDialogSimpleMenu.h
new file mode 100644
index 0000000..ed476a4
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSimpleMenu.h
@@ -0,0 +1,28 @@
+/*
+ *  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 "filesystem/Directory.h"
+
+#include <string>
+
+class CFileItem;
+class CFileItemList;
+
+class CGUIDialogSimpleMenu
+{
+public:
+
+  /*! \brief Show dialog allowing selection of wanted playback item */
+  static bool ShowPlaySelection(CFileItem& item);
+  static bool ShowPlaySelection(CFileItem& item, const std::string& directory);
+
+protected:
+  static bool GetDirectoryItems(const std::string &path, CFileItemList &items, const XFILE::CDirectory::CHints &hints);
+};
diff --git a/xbmc/dialogs/GUIDialogSlider.cpp b/xbmc/dialogs/GUIDialogSlider.cpp
new file mode 100644
index 0000000..5d9fb1d
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSlider.cpp
@@ -0,0 +1,125 @@
+/*
+ *  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 "GUIDialogSlider.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUISliderControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+
+#define CONTROL_HEADING 10
+#define CONTROL_SLIDER  11
+#define CONTROL_LABEL   12
+
+CGUIDialogSlider::CGUIDialogSlider(void)
+    : CGUIDialog(WINDOW_DIALOG_SLIDER, "DialogSlider.xml")
+{
+  m_callback = NULL;
+  m_callbackData = NULL;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogSlider::~CGUIDialogSlider(void) = default;
+
+bool CGUIDialogSlider::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_SELECT_ITEM)
+  {
+    Close();
+    return true;
+  }
+  return CGUIDialog::OnAction(action);
+}
+
+bool CGUIDialogSlider::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_CLICKED:
+    if (message.GetSenderId() == CONTROL_SLIDER)
+    {
+      CGUISliderControl *slider = dynamic_cast<CGUISliderControl *>(GetControl(CONTROL_SLIDER));
+      if (slider && m_callback)
+      {
+        m_callback->OnSliderChange(m_callbackData, slider);
+        SET_CONTROL_LABEL(CONTROL_LABEL, slider->GetDescription());
+      }
+    }
+    break;
+  case GUI_MSG_WINDOW_DEINIT:
+    m_callback = NULL;
+    m_callbackData = NULL;
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogSlider::SetSlider(const std::string &label, float value, float min, float delta, float max, ISliderCallback *callback, void *callbackData)
+{
+  SET_CONTROL_LABEL(CONTROL_HEADING, label);
+  CGUISliderControl *slider = dynamic_cast<CGUISliderControl *>(GetControl(CONTROL_SLIDER));
+  m_callback = callback;
+  m_callbackData = callbackData;
+  if (slider)
+  {
+    slider->SetType(SLIDER_CONTROL_TYPE_FLOAT);
+    slider->SetFloatRange(min, max);
+    slider->SetFloatInterval(delta);
+    slider->SetFloatValue(value);
+    if (m_callback)
+    {
+      m_callback->OnSliderChange(m_callbackData, slider);
+      SET_CONTROL_LABEL(CONTROL_LABEL, slider->GetDescription());
+    }
+  }
+}
+
+void CGUIDialogSlider::OnWindowLoaded()
+{
+  // ensure our callbacks are NULL, incase we were loaded via some non-standard means
+  m_callback = NULL;
+  m_callbackData = NULL;
+  CGUIDialog::OnWindowLoaded();
+}
+
+void CGUIDialogSlider::SetModalityType(DialogModalityType type)
+{
+  m_modalityType = type;
+}
+
+void CGUIDialogSlider::ShowAndGetInput(const std::string &label, float value, float min, float delta, float max, ISliderCallback *callback, void *callbackData)
+{
+  // grab the slider dialog
+  CGUIDialogSlider *slider = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSlider>(WINDOW_DIALOG_SLIDER);
+  if (!slider)
+    return;
+
+  // set the label and value
+  slider->Initialize();
+  slider->SetSlider(label, value, min, delta, max, callback, callbackData);
+  slider->SetModalityType(DialogModalityType::MODAL);
+  slider->Open();
+}
+
+void CGUIDialogSlider::Display(int label, float value, float min, float delta, float max, ISliderCallback *callback)
+{
+  // grab the slider dialog
+  CGUIDialogSlider *slider = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSlider>(WINDOW_DIALOG_SLIDER);
+  if (!slider)
+    return;
+
+  // set the label and value
+  slider->Initialize();
+  slider->SetAutoClose(1000);
+  slider->SetSlider(g_localizeStrings.Get(label), value, min, delta, max, callback, NULL);
+  slider->SetModalityType(DialogModalityType::MODELESS);
+  slider->Open();
+}
diff --git a/xbmc/dialogs/GUIDialogSlider.h b/xbmc/dialogs/GUIDialogSlider.h
new file mode 100644
index 0000000..5d09a90
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSlider.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 "guilib/GUIDialog.h"
+#include "guilib/ISliderCallback.h"
+
+class CGUIDialogSlider : public CGUIDialog
+{
+public:
+  CGUIDialogSlider();
+  ~CGUIDialogSlider(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnAction(const CAction &action) override;
+
+  void SetModalityType(DialogModalityType type);
+
+  /*! \brief Show the slider dialog and wait for the user to change the value
+   Shows the slider until the user is happy with the adjusted value.  Calls back with each change to the callback function
+   allowing changes to take place immediately.
+   \param label description of what is being changed by the slider
+   \param value start value of the slider
+   \param min minimal value the slider may take
+   \param delta amount the slider advances for a single click
+   \param max maximal value the slider may take
+   \param callback callback class that implements ISliderCallback::OnSliderChange
+   \param callbackData pointer to callback-specific data (defaults to NULL)
+   \sa ISliderCallback, Display
+   */
+  static void ShowAndGetInput(const std::string &label, float value, float min, float delta, float max, ISliderCallback *callback, void *callbackData = NULL);
+
+  /*! \brief Show the slider dialog as a response to user input
+   Shows the slider with the given values for a short period of time, used for UI feedback of a set user action.
+   This function is asynchronous.
+   \param label id of the description label for the slider
+   \param value start value of the slider
+   \param min minimal value the slider may take
+   \param delta amount the slider advances for a single click
+   \param max maximal value the slider may take
+   \param callback callback class that implements ISliderCallback::OnSliderChange
+   \sa ISliderCallback, ShowAndGetInput
+   */
+  static void Display(int label, float value, float min, float delta, float max, ISliderCallback *callback);
+protected:
+  void SetSlider(const std::string &label, float value, float min, float delta, float max, ISliderCallback *callback, void *callbackData);
+  void OnWindowLoaded() override;
+
+  ISliderCallback *m_callback;
+  void *m_callbackData;
+};
+
diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp
new file mode 100644
index 0000000..49d6398
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp
@@ -0,0 +1,648 @@
+/*
+ *  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 "GUIDialogSmartPlaylistEditor.h"
+
+#include "FileItem.h"
+#include "GUIDialogContextMenu.h"
+#include "GUIDialogSelect.h"
+#include "GUIDialogSmartPlaylistRule.h"
+#include "ServiceBroker.h"
+#include "Util.h"
+#include "filesystem/File.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/Key.h"
+#include "profiles/ProfileManager.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "utils/SortUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/Variant.h"
+
+#include <utility>
+
+#define CONTROL_HEADING         2
+#define CONTROL_RULE_LIST       10
+#define CONTROL_NAME            12
+#define CONTROL_RULE_ADD        13
+#define CONTROL_RULE_REMOVE     14
+#define CONTROL_RULE_EDIT       15
+#define CONTROL_MATCH           16
+#define CONTROL_LIMIT           17
+#define CONTROL_ORDER_FIELD     18
+#define CONTROL_ORDER_DIRECTION 19
+#define CONTROL_GROUP_BY        23
+#define CONTROL_GROUP_MIXED     24
+
+#define CONTROL_OK              20
+#define CONTROL_CANCEL          21
+#define CONTROL_TYPE            22
+
+typedef struct
+{
+  CGUIDialogSmartPlaylistEditor::PLAYLIST_TYPE type;
+  char string[13];
+  int localizedString;
+} translateType;
+
+static const translateType types[] = { { CGUIDialogSmartPlaylistEditor::TYPE_SONGS, "songs", 134 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_ALBUMS, "albums", 132 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_ARTISTS, "artists", 133 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_MIXED, "mixed", 20395 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_MUSICVIDEOS, "musicvideos", 20389 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_MOVIES, "movies", 20342 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_TVSHOWS, "tvshows", 20343 },
+                                       { CGUIDialogSmartPlaylistEditor::TYPE_EPISODES, "episodes", 20360 }
+                                     };
+
+CGUIDialogSmartPlaylistEditor::CGUIDialogSmartPlaylistEditor(void)
+    : CGUIDialog(WINDOW_DIALOG_SMART_PLAYLIST_EDITOR, "SmartPlaylistEditor.xml")
+{
+  m_cancelled = false;
+  m_ruleLabels = new CFileItemList;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogSmartPlaylistEditor::~CGUIDialogSmartPlaylistEditor()
+{
+  delete m_ruleLabels;
+}
+
+bool CGUIDialogSmartPlaylistEditor::OnBack(int actionID)
+{
+  m_cancelled = true;
+  return CGUIDialog::OnBack(actionID);
+}
+
+bool CGUIDialogSmartPlaylistEditor::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      int iAction = message.GetParam1();
+      if (iControl == CONTROL_RULE_LIST && (iAction == ACTION_SELECT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK))
+        OnRuleList(GetSelectedItem());
+      else if (iControl == CONTROL_RULE_ADD)
+        OnRuleAdd();
+      else if (iControl == CONTROL_RULE_EDIT)
+        OnRuleList(GetSelectedItem());
+      else if (iControl == CONTROL_RULE_REMOVE)
+        OnRuleRemove(GetSelectedItem());
+      else if (iControl == CONTROL_NAME)
+        OnName();
+      else if (iControl == CONTROL_OK)
+        OnOK();
+      else if (iControl == CONTROL_CANCEL)
+        OnCancel();
+      else if (iControl == CONTROL_MATCH)
+        OnMatch();
+      else if (iControl == CONTROL_LIMIT)
+        OnLimit();
+      else if (iControl == CONTROL_ORDER_FIELD)
+        OnOrder();
+      else if (iControl == CONTROL_ORDER_DIRECTION)
+        OnOrderDirection();
+      else if (iControl == CONTROL_TYPE)
+        OnType();
+      else if (iControl == CONTROL_GROUP_BY)
+        OnGroupBy();
+      else if (iControl == CONTROL_GROUP_MIXED)
+        OnGroupMixed();
+      else if (iControl == CONTROL_RULE_LIST && (iAction == ACTION_CONTEXT_MENU || iAction == ACTION_MOUSE_RIGHT_CLICK))
+        OnPopupMenu(GetSelectedItem());
+      else
+        return CGUIDialog::OnMessage(message);
+      return true;
+    }
+    break;
+  case GUI_MSG_FOCUSED:
+    if (message.GetControlId() == CONTROL_RULE_REMOVE ||
+        message.GetControlId() == CONTROL_RULE_EDIT)
+      HighlightItem(GetSelectedItem());
+    else
+    {
+      if (message.GetControlId() == CONTROL_RULE_LIST)
+        UpdateRuleControlButtons();
+
+      HighlightItem(-1);
+    }
+    break;
+  case GUI_MSG_WINDOW_INIT:
+    {
+      const std::string& startupList = message.GetStringParam(0);
+      if (!startupList.empty())
+      {
+        int party = 0;
+        if (URIUtils::PathEquals(startupList, CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetUserDataItem("PartyMode.xsp")))
+          party = 1;
+        else if (URIUtils::PathEquals(startupList, CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetUserDataItem("PartyMode-Video.xsp")))
+          party = 2;
+
+        if ((party && !XFILE::CFile::Exists(startupList)) ||
+             m_playlist.Load(startupList))
+        {
+          m_path = startupList;
+
+          if (party == 1)
+            m_mode = "partymusic";
+          else if (party == 2)
+            m_mode = "partyvideo";
+          else
+          {
+            PLAYLIST_TYPE type = ConvertType(m_playlist.GetType());
+            if (type == TYPE_SONGS || type == TYPE_ALBUMS || type == TYPE_ARTISTS)
+              m_mode = "music";
+            else
+              m_mode = "video";
+          }
+        }
+        else
+          return false;
+      }
+    }
+    break;
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      m_playlist.Reset();
+    }
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogSmartPlaylistEditor::OnPopupMenu(int item)
+{
+  if (item < 0 || static_cast<size_t>(item) >= m_playlist.m_ruleCombination.m_rules.size())
+    return;
+  // highlight the item
+  m_ruleLabels->Get(item)->Select(true);
+
+  CContextButtons choices;
+  choices.Add(1, 15015);
+
+  int button = CGUIDialogContextMenu::ShowAndGetChoice(choices);
+
+  // unhighlight the item
+  m_ruleLabels->Get(item)->Select(false);
+
+  if (button == 1)
+    OnRuleRemove(item);
+}
+
+void CGUIDialogSmartPlaylistEditor::OnRuleList(int item)
+{
+  if (item < 0 || item > static_cast<int>(m_playlist.m_ruleCombination.m_rules.size()))
+    return;
+  if (item == static_cast<int>(m_playlist.m_ruleCombination.m_rules.size()))
+    OnRuleAdd();
+  else
+  {
+    CSmartPlaylistRule rule = *std::static_pointer_cast<CSmartPlaylistRule>(m_playlist.m_ruleCombination.m_rules[item]);
+    if (CGUIDialogSmartPlaylistRule::EditRule(rule, m_playlist.GetType()))
+      *m_playlist.m_ruleCombination.m_rules[item] = rule;
+  }
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnOK()
+{
+  std::string systemPlaylistsPath = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_SYSTEM_PLAYLISTSPATH);
+  // save our playlist
+  if (m_path.empty())
+  {
+    std::string filename(CUtil::MakeLegalFileName(m_playlist.m_playlistName));
+    std::string path;
+    if (CGUIKeyboardFactory::ShowAndGetInput(filename, CVariant{g_localizeStrings.Get(16013)}, false))
+    {
+      path = URIUtils::AddFileToFolder(systemPlaylistsPath, m_playlist.GetSaveLocation(),
+                                        CUtil::MakeLegalFileName(filename));
+    }
+    else
+      return;
+    if (!URIUtils::HasExtension(path, ".xsp"))
+      path += ".xsp";
+
+    // should we check whether we should overwrite?
+    m_path = path;
+  }
+  else
+  {
+    // check if we need to actually change the save location for this playlist
+    // this occurs if the user switches from music video <> songs <> mixed
+    if (StringUtils::StartsWith(m_path, systemPlaylistsPath))
+    {
+      std::string filename = URIUtils::GetFileName(m_path);
+      std::string strFolder = m_path.substr(systemPlaylistsPath.size(), m_path.size() - filename.size() - systemPlaylistsPath.size() - 1);
+      if (strFolder != m_playlist.GetSaveLocation())
+      { // move to the correct folder
+        XFILE::CFile::Delete(m_path);
+        m_path = URIUtils::AddFileToFolder(systemPlaylistsPath, m_playlist.GetSaveLocation(), filename);
+      }
+    }
+  }
+
+  m_playlist.Save(m_path);
+
+  m_cancelled = false;
+  Close();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnCancel()
+{
+  m_cancelled = true;
+  Close();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnMatch()
+{
+  // toggle between AND and OR setting
+  if (m_playlist.m_ruleCombination.GetType() == CSmartPlaylistRuleCombination::CombinationOr)
+    m_playlist.m_ruleCombination.SetType(CSmartPlaylistRuleCombination::CombinationAnd);
+  else
+    m_playlist.m_ruleCombination.SetType(CSmartPlaylistRuleCombination::CombinationOr);
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnName()
+{
+  std::string name = m_playlist.m_playlistName;
+  if (CGUIKeyboardFactory::ShowAndGetInput(name, CVariant{16012}, false))
+  {
+    m_playlist.m_playlistName = name;
+    UpdateButtons();
+  }
+}
+
+void CGUIDialogSmartPlaylistEditor::OnLimit()
+{
+  std::vector<int> limits = {0, 10, 25, 50, 100, 250, 500, 1000};
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  int selected = -1;
+  for (auto limit = limits.begin(); limit != limits.end(); limit++)
+  {
+    if (*limit == static_cast<int>(m_playlist.m_limit))
+      selected = std::distance(limits.begin(), limit);
+    if (*limit == 0)
+      dialog->Add(g_localizeStrings.Get(21428));
+    else
+      dialog->Add(StringUtils::Format(g_localizeStrings.Get(21436), *limit));
+  }
+  dialog->SetHeading(CVariant{ 21427 });
+  dialog->SetSelected(selected);
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+  if (!dialog->IsConfirmed() || newSelected < 0 || limits[newSelected] == static_cast<int>(m_playlist.m_limit))
+    return;
+  m_playlist.m_limit = limits[newSelected];
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnType()
+{
+  std::vector<PLAYLIST_TYPE> allowedTypes = GetAllowedTypes(m_mode);
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  for (auto allowedType: allowedTypes)
+    dialog->Add(GetLocalizedType(allowedType));
+  dialog->SetHeading(CVariant{ 564 });
+  dialog->SetSelected(GetLocalizedType(ConvertType(m_playlist.GetType())));
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+  if (!dialog->IsConfirmed() || newSelected < 0 || allowedTypes[newSelected] == ConvertType(m_playlist.GetType()))
+    return;
+
+  m_playlist.SetType(ConvertType(allowedTypes[newSelected]));
+  
+  // Remove any invalid grouping left over when changing the type
+  Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup().c_str());
+  if (currentGroup != FieldNone && currentGroup != FieldUnknown)
+  {
+    std::vector<Field> groups = CSmartPlaylistRule::GetGroups(m_playlist.GetType());
+    if (std::find(groups.begin(), groups.end(), currentGroup) == groups.end())
+      m_playlist.SetGroup(CSmartPlaylistRule::TranslateGroup(FieldUnknown));
+  }
+
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnOrder()
+{
+  std::vector<SortBy> orders = CSmartPlaylistRule::GetOrders(m_playlist.GetType());
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  for (auto order: orders)
+    dialog->Add(g_localizeStrings.Get(SortUtils::GetSortLabel(order)));
+  dialog->SetHeading(CVariant{ 21429 });
+  dialog->SetSelected(g_localizeStrings.Get(SortUtils::GetSortLabel(m_playlist.m_orderField)));
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+  if (!dialog->IsConfirmed() || newSelected < 0 || orders[newSelected] == m_playlist.m_orderField)
+    return;
+  m_playlist.m_orderField = orders[newSelected];
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnOrderDirection()
+{
+  if (m_playlist.m_orderDirection == SortOrderDescending)
+    m_playlist.m_orderDirection = SortOrderAscending;
+  else
+    m_playlist.m_orderDirection = SortOrderDescending;
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnGroupBy()
+{
+  std::vector<Field> groups = CSmartPlaylistRule::GetGroups(m_playlist.GetType());
+  Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup().c_str());
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  for (auto group : groups)
+    dialog->Add(CSmartPlaylistRule::GetLocalizedGroup(group));
+  dialog->SetHeading(CVariant{ 21458 });
+  dialog->SetSelected(CSmartPlaylistRule::GetLocalizedGroup(currentGroup));
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+   // check if selection has changed
+  if (!dialog->IsConfirmed() || newSelected < 0 || groups[newSelected] == currentGroup)
+    return;
+  m_playlist.SetGroup(CSmartPlaylistRule::TranslateGroup(groups[newSelected]));
+
+  if (m_playlist.IsGroupMixed() && !CSmartPlaylistRule::CanGroupMix(currentGroup))
+    m_playlist.SetGroupMixed(false);
+
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnGroupMixed()
+{
+  m_playlist.SetGroupMixed(!m_playlist.IsGroupMixed());
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistEditor::UpdateButtons()
+{
+  CONTROL_ENABLE(CONTROL_OK); // always enabled since we can have no rules -> match everything (as we do with default partymode playlists)
+
+  if (m_mode == "partyvideo" || m_mode == "partymusic")
+  {
+    SET_CONTROL_LABEL2(CONTROL_NAME, g_localizeStrings.Get(16035));
+    CONTROL_DISABLE(CONTROL_NAME);
+  }
+  else
+    SET_CONTROL_LABEL2(CONTROL_NAME, m_playlist.m_playlistName);
+
+  UpdateRuleControlButtons();
+
+  if (m_playlist.m_ruleCombination.GetType() == CSmartPlaylistRuleCombination::CombinationOr)
+    SET_CONTROL_LABEL2(CONTROL_MATCH, g_localizeStrings.Get(21426)); // one or more of the rules
+  else
+    SET_CONTROL_LABEL2(CONTROL_MATCH, g_localizeStrings.Get(21425)); // all of the rules
+  CONTROL_ENABLE_ON_CONDITION(CONTROL_MATCH, m_playlist.m_ruleCombination.m_rules.size() > 1);
+  if (m_playlist.m_limit == 0)
+    SET_CONTROL_LABEL2(CONTROL_LIMIT, g_localizeStrings.Get(21428)); // no limit
+  else
+    SET_CONTROL_LABEL2(CONTROL_LIMIT,
+                       StringUtils::Format(g_localizeStrings.Get(21436), m_playlist.m_limit));
+  int currentItem = GetSelectedItem();
+  CGUIMessage msgReset(GUI_MSG_LABEL_RESET, GetID(), CONTROL_RULE_LIST);
+  OnMessage(msgReset);
+  m_ruleLabels->Clear();
+  for (const auto& rule: m_playlist.m_ruleCombination.m_rules)
+  {
+    CFileItemPtr item(new CFileItem("", false));
+    item->SetLabel(std::static_pointer_cast<CSmartPlaylistRule>(rule)->GetLocalizedRule());
+    m_ruleLabels->Add(item);
+  }
+  CFileItemPtr item(new CFileItem("", false));
+  item->SetLabel(g_localizeStrings.Get(21423));
+  m_ruleLabels->Add(item);
+  CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), CONTROL_RULE_LIST, 0, 0, m_ruleLabels);
+  OnMessage(msg);
+  SendMessage(GUI_MSG_ITEM_SELECT, GetID(), CONTROL_RULE_LIST, currentItem);
+
+  if (m_playlist.m_orderDirection != SortOrderDescending)
+  {
+    SET_CONTROL_LABEL2(CONTROL_ORDER_DIRECTION, g_localizeStrings.Get(21430));
+  }
+  else
+  {
+    SET_CONTROL_LABEL2(CONTROL_ORDER_DIRECTION, g_localizeStrings.Get(21431));
+  }
+
+  SET_CONTROL_LABEL2(CONTROL_ORDER_FIELD, g_localizeStrings.Get(SortUtils::GetSortLabel(m_playlist.m_orderField)));
+  SET_CONTROL_LABEL2(CONTROL_TYPE, GetLocalizedType(ConvertType(m_playlist.GetType())));
+
+  // setup groups
+  std::vector<Field> groups = CSmartPlaylistRule::GetGroups(m_playlist.GetType());
+  Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup().c_str());
+  SET_CONTROL_LABEL2(CONTROL_GROUP_BY, CSmartPlaylistRule::GetLocalizedGroup(currentGroup));
+  if (m_playlist.IsGroupMixed())
+    CONTROL_SELECT(CONTROL_GROUP_MIXED);
+  else
+    CONTROL_DESELECT(CONTROL_GROUP_MIXED);
+
+  // disable the group controls if there's no group
+  // or only one group which can't be mixed
+  if (groups.empty() ||
+     (groups.size() == 1 && !CSmartPlaylistRule::CanGroupMix(groups[0])))
+  {
+    CONTROL_DISABLE(CONTROL_GROUP_BY);
+    CONTROL_DISABLE(CONTROL_GROUP_MIXED);
+  }
+  else
+  {
+    CONTROL_ENABLE(CONTROL_GROUP_BY);
+    CONTROL_ENABLE_ON_CONDITION(CONTROL_GROUP_MIXED, CSmartPlaylistRule::CanGroupMix(currentGroup));
+  }
+}
+
+void CGUIDialogSmartPlaylistEditor::UpdateRuleControlButtons()
+{
+  int iSize = m_playlist.m_ruleCombination.m_rules.size();
+  int iItem = GetSelectedItem();
+  // only enable the remove control if ...
+  CONTROL_ENABLE_ON_CONDITION(CONTROL_RULE_REMOVE,
+                              iSize > 0 && // there is at least one item
+                              iItem >= 0 && iItem < iSize && // and a valid item is selected
+                              m_playlist.m_ruleCombination.m_rules[iItem]->m_field != FieldNone); // and it is not be empty
+}
+
+void CGUIDialogSmartPlaylistEditor::OnInitWindow()
+{
+  m_cancelled = false;
+
+  std::vector<PLAYLIST_TYPE> allowedTypes = GetAllowedTypes(m_mode);
+  // check if our playlist type is allowed
+  PLAYLIST_TYPE type = ConvertType(m_playlist.GetType());
+  bool allowed = false;
+  for (auto allowedType: allowedTypes)
+  {
+    if (type == allowedType)
+      allowed = true;
+  }
+  if (!allowed && allowedTypes.size())
+    m_playlist.SetType(ConvertType(allowedTypes[0]));
+
+  UpdateButtons();
+
+  SET_CONTROL_LABEL(CONTROL_HEADING, 21432);
+
+  CGUIDialog::OnInitWindow();
+}
+
+void CGUIDialogSmartPlaylistEditor::OnDeinitWindow(int nextWindowID)
+{
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+  SendMessage(GUI_MSG_LABEL_RESET, CONTROL_RULE_LIST);
+  SendMessage(GUI_MSG_LABEL_RESET, CONTROL_TYPE);
+  m_ruleLabels->Clear();
+}
+
+CGUIDialogSmartPlaylistEditor::PLAYLIST_TYPE CGUIDialogSmartPlaylistEditor::ConvertType(const std::string &type)
+{
+  for (const translateType& t : types)
+    if (type == t.string)
+      return t.type;
+  assert(false);
+  return TYPE_SONGS;
+}
+
+std::string CGUIDialogSmartPlaylistEditor::GetLocalizedType(PLAYLIST_TYPE type)
+{
+  for (const translateType& t : types)
+    if (t.type == type)
+      return g_localizeStrings.Get(t.localizedString);
+  assert(false);
+  return "";
+}
+
+std::string CGUIDialogSmartPlaylistEditor::ConvertType(PLAYLIST_TYPE type)
+{
+  for (const translateType& t : types)
+    if (t.type == type)
+      return t.string;
+  assert(false);
+  return "songs";
+}
+
+int CGUIDialogSmartPlaylistEditor::GetSelectedItem()
+{
+  CGUIMessage message(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_RULE_LIST);
+  OnMessage(message);
+  return message.GetParam1();
+}
+
+void CGUIDialogSmartPlaylistEditor::HighlightItem(int item)
+{
+  for (int i = 0; i < m_ruleLabels->Size(); i++)
+    (*m_ruleLabels)[i]->Select(false);
+  if (item >= 0 && item < m_ruleLabels->Size())
+    (*m_ruleLabels)[item]->Select(true);
+  CGUIMessage msg(GUI_MSG_ITEM_SELECT, GetID(), CONTROL_RULE_LIST, item);
+  OnMessage(msg);
+}
+
+std::vector<CGUIDialogSmartPlaylistEditor::PLAYLIST_TYPE> CGUIDialogSmartPlaylistEditor::GetAllowedTypes(const std::string& mode)
+{
+  std::vector<PLAYLIST_TYPE> allowedTypes;
+  if (mode == "partymusic")
+  {
+    allowedTypes.push_back(TYPE_SONGS);
+    allowedTypes.push_back(TYPE_MIXED);
+  }
+  else if (mode == "partyvideo")
+  {
+    allowedTypes.push_back(TYPE_MUSICVIDEOS);
+    allowedTypes.push_back(TYPE_MIXED);
+  }
+  else if (mode == "music")
+  { // music types + mixed
+    allowedTypes.push_back(TYPE_SONGS);
+    allowedTypes.push_back(TYPE_ALBUMS);
+    allowedTypes.push_back(TYPE_ARTISTS);
+    allowedTypes.push_back(TYPE_MIXED);
+  }
+  else if (mode == "video")
+  { // general category for videos
+    allowedTypes.push_back(TYPE_MOVIES);
+    allowedTypes.push_back(TYPE_TVSHOWS);
+    allowedTypes.push_back(TYPE_EPISODES);
+    allowedTypes.push_back(TYPE_MUSICVIDEOS);
+    allowedTypes.push_back(TYPE_MIXED);
+  }
+  return allowedTypes;
+}
+
+void CGUIDialogSmartPlaylistEditor::OnRuleRemove(int item)
+{
+  if (item < 0 || item >= (int)m_playlist.m_ruleCombination.m_rules.size()) return;
+  m_playlist.m_ruleCombination.m_rules.erase(m_playlist.m_ruleCombination.m_rules.begin() + item);
+
+  UpdateButtons();
+  if (item >= m_ruleLabels->Size())
+    HighlightItem(m_ruleLabels->Size() - 1);
+  else
+    HighlightItem(item);
+}
+
+void CGUIDialogSmartPlaylistEditor::OnRuleAdd()
+{
+  CSmartPlaylistRule rule;
+  if (CGUIDialogSmartPlaylistRule::EditRule(rule,m_playlist.GetType()))
+    m_playlist.m_ruleCombination.AddRule(rule);
+  UpdateButtons();
+}
+
+bool CGUIDialogSmartPlaylistEditor::NewPlaylist(const std::string &type)
+{
+  CGUIDialogSmartPlaylistEditor *editor = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSmartPlaylistEditor>(WINDOW_DIALOG_SMART_PLAYLIST_EDITOR);
+  if (!editor) return false;
+
+  editor->m_path = "";
+  editor->m_playlist = CSmartPlaylist();
+  editor->m_mode = type;
+  editor->Initialize();
+  editor->Open();
+  return !editor->m_cancelled;
+}
+
+bool CGUIDialogSmartPlaylistEditor::EditPlaylist(const std::string &path, const std::string &type)
+{
+  CGUIDialogSmartPlaylistEditor *editor = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSmartPlaylistEditor>(WINDOW_DIALOG_SMART_PLAYLIST_EDITOR);
+  if (!editor) return false;
+
+  editor->m_mode = type;
+  if (URIUtils::PathEquals(path, CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetUserDataItem("PartyMode.xsp")))
+    editor->m_mode = "partymusic";
+  if (URIUtils::PathEquals(path, CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetUserDataItem("PartyMode-Video.xsp")))
+    editor->m_mode = "partyvideo";
+
+  CSmartPlaylist playlist;
+  bool loaded(playlist.Load(path));
+  if (!loaded)
+  { // failed to load
+    if (!StringUtils::StartsWithNoCase(editor->m_mode, "party"))
+      return false; // only edit normal playlists that exist
+    // party mode playlists can be edited even if they don't exist
+    playlist.SetType(editor->m_mode == "partymusic" ? "songs" : "musicvideos");
+  }
+
+  editor->m_playlist = playlist;
+  editor->m_path = path;
+  editor->Initialize();
+  editor->Open();
+  return !editor->m_cancelled;
+}
diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistEditor.h b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.h
new file mode 100644
index 0000000..c754f91
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.h
@@ -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.
+ */
+
+#pragma once
+
+#include "guilib/GUIDialog.h"
+#include "playlists/SmartPlayList.h"
+
+class CFileItemList;
+
+class CGUIDialogSmartPlaylistEditor :
+      public CGUIDialog
+{
+public:
+  enum PLAYLIST_TYPE { TYPE_SONGS = 1, TYPE_ALBUMS, TYPE_ARTISTS, TYPE_MIXED, TYPE_MUSICVIDEOS, TYPE_MOVIES, TYPE_TVSHOWS, TYPE_EPISODES };
+
+  CGUIDialogSmartPlaylistEditor(void);
+  ~CGUIDialogSmartPlaylistEditor(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+  static bool EditPlaylist(const std::string &path, const std::string &type = "");
+  static bool NewPlaylist(const std::string &type);
+
+protected:
+  void OnRuleList(int item);
+  void OnRuleAdd();
+  void OnRuleRemove(int item);
+  void OnMatch();
+  void OnLimit();
+  void OnName();
+  void OnType();
+  void OnOrder();
+  void OnOrderDirection();
+  void OnGroupBy();
+  void OnGroupMixed();
+  void OnOK();
+  void OnCancel();
+  void OnPopupMenu(int item);
+  void UpdateButtons();
+  void UpdateRuleControlButtons();
+  int GetSelectedItem();
+  void HighlightItem(int item);
+  std::vector<PLAYLIST_TYPE> GetAllowedTypes(const std::string& mode);
+  PLAYLIST_TYPE ConvertType(const std::string &type);
+  std::string ConvertType(PLAYLIST_TYPE type);
+  std::string GetLocalizedType(PLAYLIST_TYPE type);
+
+  CSmartPlaylist m_playlist;
+
+  // our list of rules for display purposes
+  CFileItemList* m_ruleLabels;
+
+  std::string m_path;
+  bool m_cancelled;
+  std::string m_mode;  // mode we're in (partymode etc.)
+};
diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp b/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp
new file mode 100644
index 0000000..671219b
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp
@@ -0,0 +1,575 @@
+/*
+ *  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 "GUIDialogSmartPlaylistRule.h"
+
+#include "FileItem.h"
+#include "GUIDialogFileBrowser.h"
+#include "GUIDialogSelect.h"
+#include "ServiceBroker.h"
+#include "filesystem/Directory.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIEditControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "music/MusicDatabase.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "storage/MediaManager.h"
+#include "utils/LabelFormatter.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "video/VideoDatabase.h"
+
+#include <utility>
+
+#define CONTROL_FIELD           15
+#define CONTROL_OPERATOR        16
+#define CONTROL_VALUE           17
+#define CONTROL_OK              18
+#define CONTROL_CANCEL          19
+#define CONTROL_BROWSE          20
+
+CGUIDialogSmartPlaylistRule::CGUIDialogSmartPlaylistRule(void)
+    : CGUIDialog(WINDOW_DIALOG_SMART_PLAYLIST_RULE, "SmartPlaylistRule.xml")
+{
+  m_cancelled = false;
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogSmartPlaylistRule::~CGUIDialogSmartPlaylistRule() = default;
+
+bool CGUIDialogSmartPlaylistRule::OnBack(int actionID)
+{
+  m_cancelled = true;
+  return CGUIDialog::OnBack(actionID);
+}
+
+bool CGUIDialogSmartPlaylistRule::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      if (iControl == CONTROL_OK)
+        OnOK();
+      else if (iControl == CONTROL_CANCEL)
+        OnCancel();
+      else if (iControl == CONTROL_VALUE)
+      {
+        std::string parameter;
+        OnEditChanged(iControl, parameter);
+        m_rule.SetParameter(parameter);
+      }
+      else if (iControl == CONTROL_OPERATOR)
+        OnOperator();
+      else if (iControl == CONTROL_FIELD)
+        OnField();
+      else if (iControl == CONTROL_BROWSE)
+        OnBrowse();
+      return true;
+    }
+    break;
+
+  case GUI_MSG_VALIDITY_CHANGED:
+    CONTROL_ENABLE_ON_CONDITION(CONTROL_OK, message.GetParam1());
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogSmartPlaylistRule::OnOK()
+{
+  m_cancelled = false;
+  Close();
+}
+
+void CGUIDialogSmartPlaylistRule::OnBrowse()
+{
+  CFileItemList items;
+  CMusicDatabase database;
+  database.Open();
+  CVideoDatabase videodatabase;
+  videodatabase.Open();
+
+  std::string basePath;
+  if (CSmartPlaylist::IsMusicType(m_type))
+    basePath = "musicdb://";
+  else
+    basePath = "videodb://";
+
+  VideoDbContentType type = VideoDbContentType::MOVIES;
+  if (m_type == "movies")
+    basePath += "movies/";
+  else if (m_type == "tvshows")
+  {
+    type = VideoDbContentType::TVSHOWS;
+    basePath += "tvshows/";
+  }
+  else if (m_type == "musicvideos")
+  {
+    type = VideoDbContentType::MUSICVIDEOS;
+    basePath += "musicvideos/";
+  }
+  else if (m_type == "episodes")
+  {
+    if (m_rule.m_field == FieldGenre || m_rule.m_field == FieldYear ||
+        m_rule.m_field == FieldStudio)
+      type = VideoDbContentType::TVSHOWS;
+    else
+      type = VideoDbContentType::EPISODES;
+    basePath += "tvshows/";
+  }
+
+  int iLabel = 0;
+  if (m_rule.m_field == FieldGenre)
+  {
+    if (m_type == "tvshows" ||
+        m_type == "episodes" ||
+        m_type == "movies")
+      videodatabase.GetGenresNav(basePath + "genres/", items, type);
+    else if (m_type == "songs" ||
+             m_type == "albums" ||
+             m_type == "artists" ||
+             m_type == "mixed")
+      database.GetGenresNav("musicdb://genres/",items);
+    if (m_type == "musicvideos" ||
+        m_type == "mixed")
+    {
+      CFileItemList items2;
+      videodatabase.GetGenresNav("videodb://musicvideos/genres/", items2,
+                                 VideoDbContentType::MUSICVIDEOS);
+      items.Append(items2);
+    }
+    iLabel = 515;
+  }
+  else if (m_rule.m_field == FieldSource)
+  {
+    if (m_type == "songs" ||
+      m_type == "albums" ||
+      m_type == "artists" ||
+      m_type == "mixed")
+    {
+      database.GetSourcesNav("musicdb://sources/", items);
+      iLabel = 39030;
+    }
+  }
+  else if (m_rule.m_field == FieldRole)
+  {
+    if (m_type == "artists" || m_type == "mixed")
+    {
+      database.GetRolesNav("musicdb://songs/", items);
+      iLabel = 38033;
+    }
+  }
+  else if (m_rule.m_field == FieldCountry)
+  {
+    videodatabase.GetCountriesNav(basePath, items, type);
+    iLabel = 574;
+  }
+  else if (m_rule.m_field == FieldArtist || m_rule.m_field == FieldAlbumArtist)
+  {
+    if (CSmartPlaylist::IsMusicType(m_type))
+      database.GetArtistsNav("musicdb://artists/", items, m_rule.m_field == FieldAlbumArtist, -1);
+    if (m_type == "musicvideos" ||
+        m_type == "mixed")
+    {
+      CFileItemList items2;
+      videodatabase.GetMusicVideoArtistsByName("", items2);
+      items.Append(items2);
+    }
+    iLabel = 557;
+  }
+  else if (m_rule.m_field == FieldAlbum)
+  {
+    if (CSmartPlaylist::IsMusicType(m_type))
+      database.GetAlbumsNav("musicdb://albums/", items);
+    if (m_type == "musicvideos" ||
+        m_type == "mixed")
+    {
+      CFileItemList items2;
+      videodatabase.GetMusicVideoAlbumsByName("", items2);
+      items.Append(items2);
+    }
+    iLabel = 558;
+  }
+  else if (m_rule.m_field == FieldActor)
+  {
+    videodatabase.GetActorsNav(basePath + "actors/",items,type);
+    iLabel = 20337;
+  }
+  else if (m_rule.m_field == FieldYear)
+  {
+    if (CSmartPlaylist::IsMusicType(m_type))
+      database.GetYearsNav("musicdb://years/", items);
+    if (CSmartPlaylist::IsVideoType(m_type))
+    {
+      CFileItemList items2;
+      videodatabase.GetYearsNav(basePath + "years/", items2, type);
+      items.Append(items2);
+    }
+    iLabel = 562;
+  }
+  else if (m_rule.m_field == FieldOrigYear)
+  {
+    database.GetYearsNav("musicdb://originalyears/", items);
+    iLabel = 38078;
+  }
+  else if (m_rule.m_field == FieldDirector)
+  {
+    videodatabase.GetDirectorsNav(basePath + "directors/", items, type);
+    iLabel = 20339;
+  }
+  else if (m_rule.m_field == FieldStudio)
+  {
+    videodatabase.GetStudiosNav(basePath + "studios/", items, type);
+    iLabel = 572;
+  }
+  else if (m_rule.m_field == FieldWriter)
+  {
+    videodatabase.GetWritersNav(basePath, items, type);
+    iLabel = 20417;
+  }
+  else if (m_rule.m_field == FieldTvShowTitle ||
+          (m_type == "tvshows" && m_rule.m_field == FieldTitle))
+  {
+    videodatabase.GetTvShowsNav(basePath + "titles/", items);
+    iLabel = 20343;
+  }
+  else if (m_rule.m_field == FieldTitle)
+  {
+    if (m_type == "songs" || m_type == "mixed")
+    {
+      database.GetSongsNav("musicdb://songs/", items, -1, -1, -1);
+      iLabel = 134;
+    }
+    if (m_type == "movies")
+    {
+      videodatabase.GetMoviesNav(basePath + "titles/", items);
+      iLabel = 20342;
+    }
+    if (m_type == "episodes")
+    {
+      videodatabase.GetEpisodesNav(basePath + "titles/-1/-1/", items);
+      // we need to replace the db label (<season>x<episode> <title>) with the title only
+      CLabelFormatter format("%T", "");
+      for (int i = 0; i < items.Size(); i++)
+        format.FormatLabel(items[i].get());
+      iLabel = 20360;
+    }
+    if (m_type == "musicvideos" || m_type == "mixed")
+    {
+      videodatabase.GetMusicVideosNav(basePath + "titles/", items);
+      iLabel = 20389;
+    }
+  }
+  else if (m_rule.m_field == FieldPlaylist || m_rule.m_field == FieldVirtualFolder)
+  {
+    // use filebrowser to grab another smart playlist
+
+    // Note: This can cause infinite loops (playlist that refers to the same playlist) but I don't
+    //       think there's any decent way to deal with this, as the infinite loop may be an arbitrary
+    //       number of playlists deep, eg playlist1 -> playlist2 -> playlist3 ... -> playlistn -> playlist1
+    if (CSmartPlaylist::IsVideoType(m_type))
+      XFILE::CDirectory::GetDirectory("special://videoplaylists/", items, ".xsp", XFILE::DIR_FLAG_NO_FILE_DIRS);
+    if (CSmartPlaylist::IsMusicType(m_type))
+    {
+      CFileItemList items2;
+      XFILE::CDirectory::GetDirectory("special://musicplaylists/", items2, ".xsp", XFILE::DIR_FLAG_NO_FILE_DIRS);
+      items.Append(items2);
+    }
+
+    for (int i = 0; i < items.Size(); i++)
+    {
+      CFileItemPtr item = items[i];
+      CSmartPlaylist playlist;
+      // don't list unloadable smartplaylists or any referenceable smartplaylists
+      // which do not match the type of the current smartplaylist
+      if (!playlist.Load(item->GetPath()) ||
+         (m_rule.m_field == FieldPlaylist &&
+         (!CSmartPlaylist::CheckTypeCompatibility(m_type, playlist.GetType()) ||
+         (!playlist.GetGroup().empty() || playlist.IsGroupMixed()))))
+      {
+        items.Remove(i);
+        i -= 1;
+        continue;
+      }
+
+      if (!playlist.GetName().empty())
+        item->SetLabel(playlist.GetName());
+    }
+    iLabel = 559;
+  }
+  else if (m_rule.m_field == FieldPath)
+  {
+    VECSOURCES sources;
+    if (m_type == "songs" || m_type == "mixed")
+      sources = *CMediaSourceSettings::GetInstance().GetSources("music");
+    if (CSmartPlaylist::IsVideoType(m_type))
+    {
+      VECSOURCES sources2 = *CMediaSourceSettings::GetInstance().GetSources("video");
+      sources.insert(sources.end(),sources2.begin(),sources2.end());
+    }
+    CServiceBroker::GetMediaManager().GetLocalDrives(sources);
+
+    std::string path = m_rule.GetParameter();
+    CGUIDialogFileBrowser::ShowAndGetDirectory(sources, g_localizeStrings.Get(657), path, false);
+    if (!m_rule.m_parameter.empty())
+      m_rule.m_parameter.clear();
+    if (!path.empty())
+      m_rule.m_parameter.emplace_back(std::move(path));
+
+    UpdateButtons();
+    return;
+  }
+  else if (m_rule.m_field == FieldSet)
+  {
+    videodatabase.GetSetsNav("videodb://movies/sets/", items, VideoDbContentType::MOVIES);
+    iLabel = 20434;
+  }
+  else if (m_rule.m_field == FieldTag)
+  {
+    VideoDbContentType type = VideoDbContentType::MOVIES;
+    if (m_type == "tvshows" ||
+        m_type == "episodes")
+      type = VideoDbContentType::TVSHOWS;
+    else if (m_type == "musicvideos")
+      type = VideoDbContentType::MUSICVIDEOS;
+    else if (m_type != "movies")
+      return;
+
+    videodatabase.GetTagsNav(basePath + "tags/", items, type);
+    iLabel = 20459;
+  }
+  else
+  { //! @todo Add browseability in here.
+    assert(false);
+  }
+
+  // sort the items
+  items.Sort(SortByLabel, SortOrderAscending, CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_FILELISTS_IGNORETHEWHENSORTING) ? SortAttributeIgnoreArticle : SortAttributeNone);
+
+  CGUIDialogSelect* pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  pDialog->Reset();
+  pDialog->SetItems(items);
+  std::string strHeading =
+      StringUtils::Format(g_localizeStrings.Get(13401), g_localizeStrings.Get(iLabel));
+  pDialog->SetHeading(CVariant{std::move(strHeading)});
+  pDialog->SetMultiSelection(m_rule.m_field != FieldPlaylist && m_rule.m_field != FieldVirtualFolder);
+
+  if (!m_rule.m_parameter.empty())
+    pDialog->SetSelected(m_rule.m_parameter);
+
+  pDialog->Open();
+  if (pDialog->IsConfirmed())
+  {
+    m_rule.m_parameter.clear();
+    for (int i : pDialog->GetSelectedItems())
+      m_rule.m_parameter.push_back(items.Get(i)->GetLabel());
+
+    UpdateButtons();
+  }
+  pDialog->Reset();
+}
+
+std::pair<std::string, int> OperatorLabel(CDatabaseQueryRule::SEARCH_OPERATOR op)
+{
+  return std::make_pair(CSmartPlaylistRule::GetLocalizedOperator(op), op);
+}
+
+std::vector<std::pair<std::string, int>> CGUIDialogSmartPlaylistRule::GetValidOperators(const CSmartPlaylistRule& rule)
+{
+  std::vector< std::pair<std::string, int> > labels;
+  switch (rule.GetFieldType(rule.m_field))
+  {
+  case CDatabaseQueryRule::TEXT_FIELD:
+    // text fields - add the usual comparisons
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_EQUALS));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_DOES_NOT_EQUAL));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_CONTAINS));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_DOES_NOT_CONTAIN));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_STARTS_WITH));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_ENDS_WITH));
+    break;
+
+  case CDatabaseQueryRule::REAL_FIELD:
+  case CDatabaseQueryRule::NUMERIC_FIELD:
+  case CDatabaseQueryRule::SECONDS_FIELD:
+    // numerical fields - less than greater than
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_EQUALS));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_DOES_NOT_EQUAL));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_GREATER_THAN));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_LESS_THAN));
+    break;
+
+  case CDatabaseQueryRule::DATE_FIELD:
+    // date field
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_AFTER));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_BEFORE));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_IN_THE_LAST));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_NOT_IN_THE_LAST));
+    break;
+
+  case CDatabaseQueryRule::PLAYLIST_FIELD:
+    CONTROL_ENABLE(CONTROL_BROWSE);
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_EQUALS));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_DOES_NOT_EQUAL));
+    break;
+
+  case CDatabaseQueryRule::BOOLEAN_FIELD:
+    CONTROL_DISABLE(CONTROL_VALUE);
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_TRUE));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_FALSE));
+    break;
+
+  case CDatabaseQueryRule::TEXTIN_FIELD:
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_EQUALS));
+    labels.push_back(OperatorLabel(CDatabaseQueryRule::OPERATOR_DOES_NOT_EQUAL));
+    break;
+  }
+  return labels;
+}
+
+void CGUIDialogSmartPlaylistRule::OnCancel()
+{
+  m_cancelled = true;
+  Close();
+}
+
+void CGUIDialogSmartPlaylistRule::OnField()
+{
+  const auto fields = CSmartPlaylistRule::GetFields(m_type);
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  dialog->SetHeading(CVariant{20427});
+  int selected = -1;
+  for (auto field = fields.begin(); field != fields.end(); field++)
+  {
+    dialog->Add(CSmartPlaylistRule::GetLocalizedField(*field));
+    if (*field == m_rule.m_field)
+      selected = std::distance(fields.begin(), field);
+  }
+  if (selected > -1)
+    dialog->SetSelected(selected);
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+  // check if selection has changed
+  if (!dialog->IsConfirmed() || newSelected < 0 || newSelected == selected)
+    return;
+
+  m_rule.m_field = fields[newSelected];
+  // check if operator is still valid. if not, reset to first valid one
+  std::vector< std::pair<std::string, int> > validOperators = GetValidOperators(m_rule);
+  bool isValid = false;
+  for (auto op : validOperators)
+    if (std::get<0>(op) == std::get<0>(OperatorLabel(m_rule.m_operator)))
+      isValid = true;
+  if (!isValid)
+    m_rule.m_operator = (CDatabaseQueryRule::SEARCH_OPERATOR)std::get<1>(validOperators[0]);
+
+  m_rule.SetParameter("");
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistRule::OnOperator()
+{
+  const auto labels = GetValidOperators(m_rule);
+  CGUIDialogSelect* dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  dialog->Reset();
+  dialog->SetHeading(CVariant{ 16023 });
+  for (auto label : labels)
+    dialog->Add(std::get<0>(label));
+  dialog->SetSelected(CSmartPlaylistRule::GetLocalizedOperator(m_rule.m_operator));
+  dialog->Open();
+  int newSelected = dialog->GetSelectedItem();
+  // check if selection has changed
+  if (!dialog->IsConfirmed() || newSelected < 0)
+    return;
+
+  m_rule.m_operator = (CDatabaseQueryRule::SEARCH_OPERATOR)std::get<1>(labels[newSelected]);
+  UpdateButtons();
+}
+
+void CGUIDialogSmartPlaylistRule::UpdateButtons()
+{
+  if (m_rule.m_field == 0)
+    m_rule.m_field = CSmartPlaylistRule::GetFields(m_type)[0];
+  SET_CONTROL_LABEL(CONTROL_FIELD, CSmartPlaylistRule::GetLocalizedField(m_rule.m_field));
+
+  CONTROL_ENABLE(CONTROL_VALUE);
+  if (CSmartPlaylistRule::IsFieldBrowseable(m_rule.m_field))
+    CONTROL_ENABLE(CONTROL_BROWSE);
+  else
+    CONTROL_DISABLE(CONTROL_BROWSE);
+  SET_CONTROL_LABEL(CONTROL_OPERATOR, std::get<0>(OperatorLabel(m_rule.m_operator)));
+
+  // update label2 appropriately
+  SET_CONTROL_LABEL2(CONTROL_VALUE, m_rule.GetParameter());
+  CGUIEditControl::INPUT_TYPE type = CGUIEditControl::INPUT_TYPE_TEXT;
+  CDatabaseQueryRule::FIELD_TYPE fieldType = m_rule.GetFieldType(m_rule.m_field);
+  switch (fieldType)
+  {
+  case CDatabaseQueryRule::TEXT_FIELD:
+  case CDatabaseQueryRule::PLAYLIST_FIELD:
+  case CDatabaseQueryRule::TEXTIN_FIELD:
+  case CDatabaseQueryRule::REAL_FIELD:
+  case CDatabaseQueryRule::NUMERIC_FIELD:
+    type = CGUIEditControl::INPUT_TYPE_TEXT;
+    break;
+  case CDatabaseQueryRule::DATE_FIELD:
+    if (m_rule.m_operator == CDatabaseQueryRule::OPERATOR_IN_THE_LAST ||
+        m_rule.m_operator == CDatabaseQueryRule::OPERATOR_NOT_IN_THE_LAST)
+      type = CGUIEditControl::INPUT_TYPE_TEXT;
+    else
+      type = CGUIEditControl::INPUT_TYPE_DATE;
+    break;
+  case CDatabaseQueryRule::SECONDS_FIELD:
+    type = CGUIEditControl::INPUT_TYPE_SECONDS;
+    break;
+  case CDatabaseQueryRule::BOOLEAN_FIELD:
+    type = CGUIEditControl::INPUT_TYPE_NUMBER;
+    break;
+  }
+  SendMessage(GUI_MSG_SET_TYPE, CONTROL_VALUE, type, 21420);
+}
+
+void CGUIDialogSmartPlaylistRule::OnInitWindow()
+{
+  CGUIDialog::OnInitWindow();
+
+  UpdateButtons();
+
+  CGUIEditControl *editControl = dynamic_cast<CGUIEditControl*>(GetControl(CONTROL_VALUE));
+  if (editControl != NULL)
+    editControl->SetInputValidation(CSmartPlaylistRule::Validate, &m_rule);
+}
+
+void CGUIDialogSmartPlaylistRule::OnDeinitWindow(int nextWindowID)
+{
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  // reset field spincontrolex
+  SendMessage(GUI_MSG_LABEL_RESET, CONTROL_FIELD);
+  // reset operator spincontrolex
+  SendMessage(GUI_MSG_LABEL_RESET, CONTROL_OPERATOR);
+}
+
+bool CGUIDialogSmartPlaylistRule::EditRule(CSmartPlaylistRule &rule, const std::string& type)
+{
+  CGUIDialogSmartPlaylistRule *editor = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSmartPlaylistRule>(WINDOW_DIALOG_SMART_PLAYLIST_RULE);
+  if (!editor) return false;
+
+  editor->m_rule = rule;
+  editor->m_type = type;
+  editor->Open();
+  rule = editor->m_rule;
+  return !editor->m_cancelled;
+}
+
diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistRule.h b/xbmc/dialogs/GUIDialogSmartPlaylistRule.h
new file mode 100644
index 0000000..23ca11d
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistRule.h
@@ -0,0 +1,38 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+#include "playlists/SmartPlayList.h"
+
+class CGUIDialogSmartPlaylistRule :
+      public CGUIDialog
+{
+public:
+  CGUIDialogSmartPlaylistRule(void);
+  ~CGUIDialogSmartPlaylistRule(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+  static bool EditRule(CSmartPlaylistRule &rule, const std::string& type="songs");
+
+protected:
+  void OnField();
+  void OnOperator();
+  void OnOK();
+  void OnCancel();
+  void UpdateButtons();
+  void OnBrowse();
+  std::vector< std::pair<std::string, int> > GetValidOperators(const CSmartPlaylistRule& rule);
+  CSmartPlaylistRule m_rule;
+  bool m_cancelled;
+  std::string m_type;
+};
diff --git a/xbmc/dialogs/GUIDialogSubMenu.cpp b/xbmc/dialogs/GUIDialogSubMenu.cpp
new file mode 100644
index 0000000..ab1cdb2
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSubMenu.cpp
@@ -0,0 +1,30 @@
+/*
+ *  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 "GUIDialogSubMenu.h"
+
+#include "guilib/GUIMessage.h"
+
+CGUIDialogSubMenu::CGUIDialogSubMenu(int id, const std::string &xmlFile)
+    : CGUIDialog(id, xmlFile.c_str())
+{
+}
+
+CGUIDialogSubMenu::~CGUIDialogSubMenu(void) = default;
+
+bool CGUIDialogSubMenu::OnMessage(CGUIMessage &message)
+{
+  if (message.GetMessage() == GUI_MSG_CLICKED)
+  {
+    // someone has been clicked - deinit...
+    CGUIDialog::OnMessage(message);
+    Close();
+    return true;
+  }
+  return CGUIDialog::OnMessage(message);
+}
diff --git a/xbmc/dialogs/GUIDialogSubMenu.h b/xbmc/dialogs/GUIDialogSubMenu.h
new file mode 100644
index 0000000..eaf77d2
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogSubMenu.h
@@ -0,0 +1,20 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogSubMenu :
+      public CGUIDialog
+{
+public:
+  CGUIDialogSubMenu(int id = WINDOW_DIALOG_SUB_MENU, const std::string &xmlFile = "DialogSubMenu.xml");
+  ~CGUIDialogSubMenu(void) override;
+  bool OnMessage(CGUIMessage &message) override;
+};
diff --git a/xbmc/dialogs/GUIDialogTextViewer.cpp b/xbmc/dialogs/GUIDialogTextViewer.cpp
new file mode 100644
index 0000000..363f102
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogTextViewer.cpp
@@ -0,0 +1,132 @@
+/*
+ *  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 "GUIDialogTextViewer.h"
+
+#include "GUIUserMessages.h"
+#include "ServiceBroker.h"
+#include "filesystem/File.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+using namespace XFILE;
+
+#define CONTROL_HEADING  1
+#define CONTROL_TEXTAREA 5
+
+CGUIDialogTextViewer::CGUIDialogTextViewer(void)
+    : CGUIDialog(WINDOW_DIALOG_TEXT_VIEWER, "DialogTextViewer.xml")
+{
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIDialogTextViewer::~CGUIDialogTextViewer(void) = default;
+
+bool CGUIDialogTextViewer::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_TOGGLE_FONT)
+  {
+    UseMonoFont(!m_mono);
+    return true;
+  }
+
+  return CGUIDialog::OnAction(action);
+}
+
+bool CGUIDialogTextViewer::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_WINDOW_INIT:
+    {
+      CGUIDialog::OnMessage(message);
+      SetHeading();
+      SetText();
+      UseMonoFont(m_mono);
+      return true;
+    }
+    break;
+  case GUI_MSG_NOTIFY_ALL:
+    {
+      if (message.GetParam1() == GUI_MSG_UPDATE)
+      {
+        SetText();
+        SetHeading();
+        return true;
+      }
+    }
+    break;
+  default:
+    break;
+  }
+  return CGUIDialog::OnMessage(message);
+}
+
+void CGUIDialogTextViewer::SetText()
+{
+  CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), CONTROL_TEXTAREA);
+  msg.SetLabel(m_strText);
+  OnMessage(msg);
+}
+
+void CGUIDialogTextViewer::SetHeading()
+{
+  CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), CONTROL_HEADING);
+  msg.SetLabel(m_strHeading);
+  OnMessage(msg);
+}
+
+void CGUIDialogTextViewer::UseMonoFont(bool use)
+{
+  m_mono = use;
+  CGUIMessage msg(GUI_MSG_SET_TYPE, GetID(), CONTROL_TEXTAREA, use ? 1 : 0);
+  OnMessage(msg);
+}
+
+void CGUIDialogTextViewer::OnDeinitWindow(int nextWindowID)
+{
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  // reset text area
+  CGUIMessage msgReset(GUI_MSG_LABEL_RESET, GetID(), CONTROL_TEXTAREA);
+  OnMessage(msgReset);
+
+  // reset heading
+  SET_CONTROL_LABEL(CONTROL_HEADING, "");
+}
+
+void CGUIDialogTextViewer::ShowForFile(const std::string& path, bool useMonoFont)
+{
+  CFile file;
+  if (file.Open(path))
+  {
+    std::string data;
+    try
+    {
+      data.resize(file.GetLength()+1);
+      file.Read(&data[0], file.GetLength());
+      CGUIDialogTextViewer* pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogTextViewer>(WINDOW_DIALOG_TEXT_VIEWER);
+      pDialog->SetHeading(URIUtils::GetFileName(path));
+      pDialog->SetText(data);
+      pDialog->UseMonoFont(useMonoFont);
+      pDialog->Open();
+    }
+    catch(const std::bad_alloc&)
+    {
+      CLog::Log(LOGERROR, "Not enough memory to load text file {}", path);
+    }
+    catch(...)
+    {
+      CLog::Log(LOGERROR, "Exception while trying to view text file {}", path);
+    }
+  }
+}
diff --git a/xbmc/dialogs/GUIDialogTextViewer.h b/xbmc/dialogs/GUIDialogTextViewer.h
new file mode 100644
index 0000000..1e7bacd
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogTextViewer.h
@@ -0,0 +1,39 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+class CGUIDialogTextViewer :
+      public CGUIDialog
+{
+public:
+  CGUIDialogTextViewer(void);
+  ~CGUIDialogTextViewer(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  void SetText(const std::string& strText) { m_strText = strText; }
+  void SetHeading(const std::string& strHeading) { m_strHeading = strHeading; }
+  void UseMonoFont(bool use);
+
+  //! \brief Load a file into memory and show in dialog.
+  //! \param path Path to file
+  //! \param useMonoFont True to use monospace font
+  static void ShowForFile(const std::string& path, bool useMonoFont);
+protected:
+  void OnDeinitWindow(int nextWindowID) override;
+  bool OnAction(const CAction &action) override;
+
+  std::string m_strText;
+  std::string m_strHeading;
+  bool m_mono = false;
+
+  void SetText();
+  void SetHeading();
+};
+
diff --git a/xbmc/dialogs/GUIDialogVolumeBar.cpp b/xbmc/dialogs/GUIDialogVolumeBar.cpp
new file mode 100644
index 0000000..a4d903f
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogVolumeBar.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 "GUIDialogVolumeBar.h"
+
+#include "IGUIVolumeBarCallback.h"
+#include "application/ApplicationComponents.h"
+#include "application/ApplicationVolumeHandling.h"
+#include "guilib/GUIMessage.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+
+#include <mutex>
+
+#define VOLUME_BAR_DISPLAY_TIME 1000L
+
+CGUIDialogVolumeBar::CGUIDialogVolumeBar(void)
+  : CGUIDialog(WINDOW_DIALOG_VOLUME_BAR, "DialogVolumeBar.xml", DialogModalityType::MODELESS)
+{
+  m_loadType = LOAD_ON_GUI_INIT;
+}
+
+CGUIDialogVolumeBar::~CGUIDialogVolumeBar(void) = default;
+
+bool CGUIDialogVolumeBar::OnAction(const CAction &action)
+{
+  if (action.GetID() == ACTION_VOLUME_UP || action.GetID() == ACTION_VOLUME_DOWN || action.GetID() == ACTION_VOLUME_SET || action.GetID() == ACTION_MUTE)
+  {
+    const auto& components = CServiceBroker::GetAppComponents();
+    const auto appVolume = components.GetComponent<CApplicationVolumeHandling>();
+    if (appVolume->IsMuted() ||
+        appVolume->GetVolumeRatio() <= CApplicationVolumeHandling::VOLUME_MINIMUM)
+    { // cancel the timer, dialog needs to stay visible
+      CancelAutoClose();
+    }
+    else
+    { // reset the timer, as we've changed the volume level
+      SetAutoClose(VOLUME_BAR_DISPLAY_TIME);
+    }
+    MarkDirtyRegion();
+    return true;
+  }
+  return CGUIDialog::OnAction(action);
+}
+
+bool CGUIDialogVolumeBar::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+  case GUI_MSG_WINDOW_INIT:
+  case GUI_MSG_WINDOW_DEINIT:
+    return CGUIDialog::OnMessage(message);
+  }
+  return false; // don't process anything other than what we need!
+}
+
+void CGUIDialogVolumeBar::RegisterCallback(IGUIVolumeBarCallback *callback)
+{
+  std::unique_lock<CCriticalSection> lock(m_callbackMutex);
+
+  m_callbacks.insert(callback);
+}
+
+void CGUIDialogVolumeBar::UnregisterCallback(IGUIVolumeBarCallback *callback)
+{
+  std::unique_lock<CCriticalSection> lock(m_callbackMutex);
+
+  m_callbacks.erase(callback);
+}
+
+bool CGUIDialogVolumeBar::IsVolumeBarEnabled() const
+{
+  std::unique_lock<CCriticalSection> lock(m_callbackMutex);
+
+  // Hide volume bar if any callbacks are shown
+  for (const auto &callback : m_callbacks)
+  {
+    if (callback->IsShown())
+      return false;
+  }
+
+  return true;
+}
diff --git a/xbmc/dialogs/GUIDialogVolumeBar.h b/xbmc/dialogs/GUIDialogVolumeBar.h
new file mode 100644
index 0000000..e8413d0
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogVolumeBar.h
@@ -0,0 +1,34 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+#include "threads/CriticalSection.h"
+
+#include <set>
+
+class IGUIVolumeBarCallback;
+
+class CGUIDialogVolumeBar : public CGUIDialog
+{
+public:
+  CGUIDialogVolumeBar(void);
+  ~CGUIDialogVolumeBar(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnAction(const CAction &action) override;
+
+  // Volume bar interface
+  void RegisterCallback(IGUIVolumeBarCallback *callback);
+  void UnregisterCallback(IGUIVolumeBarCallback *callback);
+  bool IsVolumeBarEnabled() const;
+
+private:
+  std::set<IGUIVolumeBarCallback*> m_callbacks;
+  mutable CCriticalSection m_callbackMutex;
+};
diff --git a/xbmc/dialogs/GUIDialogYesNo.cpp b/xbmc/dialogs/GUIDialogYesNo.cpp
new file mode 100644
index 0000000..56709c3
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogYesNo.cpp
@@ -0,0 +1,243 @@
+/*
+ *  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 "GUIDialogYesNo.h"
+
+#include "ServiceBroker.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/Key.h"
+#include "messaging/helpers/DialogHelper.h"
+
+CGUIDialogYesNo::CGUIDialogYesNo(int overrideId /* = -1 */)
+    : CGUIDialogBoxBase(overrideId == -1 ? WINDOW_DIALOG_YES_NO : overrideId, "DialogConfirm.xml")
+{
+  Reset();
+}
+
+CGUIDialogYesNo::~CGUIDialogYesNo() = default;
+
+bool CGUIDialogYesNo::OnMessage(CGUIMessage& message)
+{
+  switch ( message.GetMessage() )
+  {
+  case GUI_MSG_CLICKED:
+    {
+      int iControl = message.GetSenderId();
+      int iAction = message.GetParam1();
+      if (true || ACTION_SELECT_ITEM == iAction)
+      {
+        if (iControl == CONTROL_NO_BUTTON)
+        {
+          m_bConfirmed = false;
+          Close();
+          return true;
+        }
+        if (iControl == CONTROL_YES_BUTTON)
+        {
+          m_bConfirmed = true;
+          Close();
+          return true;
+        }
+        if (iControl == CONTROL_CUSTOM_BUTTON)
+        {
+          m_bConfirmed = false;
+          m_bCustom = true;
+          Close();
+          return true;
+        }
+      }
+    }
+    break;
+  }
+  return CGUIDialogBoxBase::OnMessage(message);
+}
+
+bool CGUIDialogYesNo::OnBack(int actionID)
+{
+  m_bCanceled = true;
+  m_bConfirmed = false;
+  m_bCustom = false;
+  return CGUIDialogBoxBase::OnBack(actionID);
+}
+
+void CGUIDialogYesNo::OnInitWindow()
+{
+  if (!m_strChoices[2].empty())
+    SET_CONTROL_VISIBLE(CONTROL_CUSTOM_BUTTON);
+  else
+    SET_CONTROL_HIDDEN(CONTROL_CUSTOM_BUTTON);
+  SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR);
+  SET_CONTROL_FOCUS(m_defaultButtonId, 0);
+
+  CGUIDialogBoxBase::OnInitWindow();
+}
+
+bool CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading,
+                                      const CVariant& line0,
+                                      const CVariant& line1,
+                                      const CVariant& line2,
+                                      bool& bCanceled)
+{
+  return ShowAndGetInput(heading, line0, line1, line2, bCanceled, "", "", NO_TIMEOUT);
+}
+
+bool CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading,
+                                      const CVariant& line0,
+                                      const CVariant& line1,
+                                      const CVariant& line2,
+                                      const CVariant& noLabel /* = "" */,
+                                      const CVariant& yesLabel /* = "" */)
+{
+  bool bDummy(false);
+  return ShowAndGetInput(heading, line0, line1, line2, bDummy, noLabel, yesLabel, NO_TIMEOUT);
+}
+
+bool CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading,
+                                      const CVariant& line0,
+                                      const CVariant& line1,
+                                      const CVariant& line2,
+                                      bool& bCanceled,
+                                      const CVariant& noLabel,
+                                      const CVariant& yesLabel,
+                                      unsigned int autoCloseTime)
+{
+  CGUIDialogYesNo *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
+  if (!dialog)
+    return false;
+
+  dialog->SetHeading(heading);
+  dialog->SetLine(0, line0);
+  dialog->SetLine(1, line1);
+  dialog->SetLine(2, line2);
+  if (autoCloseTime)
+    dialog->SetAutoClose(autoCloseTime);
+  dialog->SetChoice(0, !noLabel.empty() ? noLabel : 106);
+  dialog->SetChoice(1, !yesLabel.empty() ? yesLabel : 107);
+  dialog->SetChoice(2, "");
+  dialog->m_bCanceled = false;
+  dialog->m_defaultButtonId = CONTROL_NO_BUTTON;
+  dialog->Open();
+
+  bCanceled = dialog->m_bCanceled;
+  return (dialog->IsConfirmed()) ? true : false;
+}
+
+bool CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading, const CVariant& text)
+{
+  bool bDummy(false);
+  return ShowAndGetInput(heading, text, "", "", bDummy);
+}
+
+bool CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading,
+                                      const CVariant& text,
+                                      bool& bCanceled,
+                                      const CVariant& noLabel /* = "" */,
+                                      const CVariant& yesLabel /* = "" */,
+                                      unsigned int autoCloseTime,
+                                      int defaultButtonId /* = CONTROL_NO_BUTTON */)
+{
+  int result =
+      ShowAndGetInput(heading, text, noLabel, yesLabel, "", autoCloseTime, defaultButtonId);
+
+  bCanceled = result == -1;
+  return result == 1;
+}
+
+void CGUIDialogYesNo::Reset()
+{
+  m_bConfirmed = false;
+  m_bCanceled = false;
+  m_bCustom = false;
+  m_bAutoClosed = false;
+  m_defaultButtonId = CONTROL_NO_BUTTON;
+}
+
+int CGUIDialogYesNo::GetResult() const
+{
+  if (m_bCanceled)
+    return -1;
+  else if (m_bCustom)
+    return 2;
+  else if (IsConfirmed())
+    return 1;
+  else
+    return 0;
+}
+
+int CGUIDialogYesNo::ShowAndGetInput(const CVariant& heading,
+                                     const CVariant& text,
+                                     const CVariant& noLabel,
+                                     const CVariant& yesLabel,
+                                     const CVariant& customLabel,
+                                     unsigned int autoCloseTime,
+                                     int defaultButtonId /* = CONTROL_NO_BUTTON */)
+{
+  CGUIDialogYesNo *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
+  if (!dialog)
+    return false;
+
+  dialog->SetHeading(heading);
+  dialog->SetText(text);
+  if (autoCloseTime > 0)
+    dialog->SetAutoClose(autoCloseTime);
+  dialog->m_bCanceled = false;
+  dialog->m_bCustom = false;
+  dialog->m_defaultButtonId = defaultButtonId;
+  dialog->SetChoice(0, !noLabel.empty() ? noLabel : 106);
+  dialog->SetChoice(1, !yesLabel.empty() ? yesLabel : 107);
+  dialog->SetChoice(2, customLabel);  // Button only visible when label is not empty
+  dialog->Open();
+
+  return dialog->GetResult();
+}
+
+int CGUIDialogYesNo::ShowAndGetInput(const KODI::MESSAGING::HELPERS::DialogYesNoMessage& options)
+{
+  //Set default yes/no labels, these might be overwritten further down if specified
+  //by the caller
+  SetChoice(0, 106);
+  SetChoice(1, 107);
+  SetChoice(2, "");
+  if (!options.heading.isNull())
+    SetHeading(options.heading);
+  if (!options.text.isNull())
+    SetText(options.text);
+  if (!options.noLabel.isNull())
+    SetChoice(0, options.noLabel);
+  if (!options.yesLabel.isNull())
+    SetChoice(1, options.yesLabel);
+  if (!options.customLabel.isNull())
+    SetChoice(2, options.customLabel);
+  if (options.autoclose > 0)
+    SetAutoClose(options.autoclose);
+  m_bCanceled = false;
+  m_bCustom = false;
+  m_defaultButtonId = CONTROL_NO_BUTTON;
+
+  for (size_t i = 0; i < 3; ++i)
+  {
+    if (!options.lines[i].isNull())
+      SetLine(i, options.lines[i]);
+  }
+
+  Open();
+
+  return GetResult();
+}
+
+int CGUIDialogYesNo::GetDefaultLabelID(int controlId) const
+{
+  if (controlId == CONTROL_NO_BUTTON)
+    return 106;
+  else if (controlId == CONTROL_YES_BUTTON)
+    return 107;
+  else if (controlId == CONTROL_CUSTOM_BUTTON)
+    return -1;
+  return CGUIDialogBoxBase::GetDefaultLabelID(controlId);
+}
diff --git a/xbmc/dialogs/GUIDialogYesNo.h b/xbmc/dialogs/GUIDialogYesNo.h
new file mode 100644
index 0000000..e8baac2
--- /dev/null
+++ b/xbmc/dialogs/GUIDialogYesNo.h
@@ -0,0 +1,153 @@
+/*
+ *  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 "GUIDialogBoxBase.h"
+#include "utils/Variant.h"
+
+namespace KODI
+{
+  namespace MESSAGING
+  {
+    namespace HELPERS
+    {
+      struct DialogYesNoMessage;
+    }
+  }
+}
+
+class CGUIDialogYesNo :
+      public CGUIDialogBoxBase
+{
+public:
+  explicit CGUIDialogYesNo(int overrideId = -1);
+  ~CGUIDialogYesNo(void) override;
+  bool OnMessage(CGUIMessage& message) override;
+  bool OnBack(int actionID) override;
+
+  void Reset();
+  int GetResult() const;
+
+  enum TimeOut
+  {
+    NO_TIMEOUT = 0
+  };
+
+  /*! \brief Show a yes-no dialog, then wait for user to dismiss it.
+   \param heading Localized label id or string for the heading of the dialog
+   \param line0 Localized label id or string for line 1 of the dialog message
+   \param line1 Localized label id or string for line 2 of the dialog message
+   \param line2 Localized label id or string for line 3 of the dialog message
+   \param bCanceled Holds true if the dialog was canceled otherwise false
+   \return true if user selects Yes, otherwise false if user selects No.
+   */
+  static bool ShowAndGetInput(const CVariant& heading,
+                              const CVariant& line0,
+                              const CVariant& line1,
+                              const CVariant& line2,
+                              bool& bCanceled);
+
+  /*! \brief Show a yes-no dialog, then wait for user to dismiss it.
+   \param heading Localized label id or string for the heading of the dialog
+   \param line0 Localized label id or string for line 1 of the dialog message
+   \param line1 Localized label id or string for line 2 of the dialog message
+   \param line2 Localized label id or string for line 3 of the dialog message
+   \param iNoLabel Localized label id or string for the no button
+   \param iYesLabel Localized label id or string for the yes button
+   \return true if user selects Yes, otherwise false if user selects No.
+   */
+  static bool ShowAndGetInput(const CVariant& heading,
+                              const CVariant& line0,
+                              const CVariant& line1,
+                              const CVariant& line2,
+                              const CVariant& noLabel = "",
+                              const CVariant& yesLabel = "");
+
+  /*! \brief Show a yes-no dialog, then wait for user to dismiss it.
+   \param heading Localized label id or string for the heading of the dialog
+   \param line0 Localized label id or string for line 1 of the dialog message
+   \param line1 Localized label id or string for line 2 of the dialog message
+   \param line2 Localized label id or string for line 3 of the dialog message
+   \param bCanceled Holds true if the dialog was canceled otherwise false
+   \param iNoLabel Localized label id or string for the no button
+   \param iYesLabel Localized label id or string for the yes button
+   \param autoCloseTime Time in ms before the dialog becomes automatically closed
+   \return true if user selects Yes, otherwise false if user selects No.
+   */
+  static bool ShowAndGetInput(const CVariant& heading,
+                              const CVariant& line0,
+                              const CVariant& line1,
+                              const CVariant& line2,
+                              bool& bCanceled,
+                              const CVariant& noLabel,
+                              const CVariant& yesLabel,
+                              unsigned int autoCloseTime);
+
+  /*! \brief Show a yes-no dialog, then wait for user to dismiss it.
+   \param heading Localized label id or string for the heading of the dialog
+   \param text Localized label id or string for the dialog message
+   \return true if user selects Yes, otherwise false if user selects No.
+   */
+  static bool ShowAndGetInput(const CVariant& heading, const CVariant& text);
+
+  /*! \brief Show a yes-no dialog, then wait for user to dismiss it.
+   \param heading Localized label id or string for the heading of the dialog
+   \param text Localized label id or string for the dialog message
+   \param bCanceled Holds true if the dialog was canceled otherwise false
+   \param iNoLabel Localized label id or string for the no button
+   \param iYesLabel Localized label id or string for the yes button
+   \param autoCloseTime Time in ms before the dialog becomes automatically closed
+   \param defaultButtonId Specifies the default focused button
+   \return true if user selects Yes, otherwise false if user selects No.
+   */
+  static bool ShowAndGetInput(const CVariant& heading,
+                              const CVariant& text,
+                              bool& bCanceled,
+                              const CVariant& noLabel,
+                              const CVariant& yesLabel,
+                              unsigned int autoCloseTime,
+                              int defaultButtonId = CONTROL_NO_BUTTON);
+
+  /*! \brief Show a yes-no dialog with 3rd custom button, then wait for user to dismiss it.
+  \param heading Localized label id or string for the heading of the dialog
+  \param text Localized label id or string for the dialog message
+  \param noLabel Localized label id or string for the no button
+  \param yesLabel Localized label id or string for the yes button
+  \param customLabel Localized label id or string for the custom button
+  \param autoCloseTime Time in ms before the dialog becomes automatically closed
+  \param defaultButtonId Specifies the default focused button
+  \return -1 for cancelled, 0 for No, 1 for Yes and 2 for custom button
+  */
+  static int ShowAndGetInput(const CVariant& heading,
+                             const CVariant& text,
+                             const CVariant& noLabel,
+                             const CVariant& yesLabel,
+                             const CVariant& customLabel,
+                             unsigned int autoCloseTime,
+                             int defaultButtonId = CONTROL_NO_BUTTON);
+
+  /*!
+    \brief Open a Yes/No dialog and wait for input
+
+    \param[in] options  a struct of type DialogYesNoMessage containing
+                        the options to set for this dialog.
+
+    \returns -1 for cancelled, 0 for No and 1 for Yes
+    \sa KODI::MESSAGING::HELPERS::DialogYesNoMessage
+  */
+  int ShowAndGetInput(const KODI::MESSAGING::HELPERS::DialogYesNoMessage& options);
+
+protected:
+  void OnInitWindow() override;
+  int GetDefaultLabelID(int controlId) const override;
+
+  bool m_bCanceled;
+  bool m_bCustom;
+  int m_defaultButtonId;
+};
diff --git a/xbmc/dialogs/IGUIVolumeBarCallback.h b/xbmc/dialogs/IGUIVolumeBarCallback.h
new file mode 100644
index 0000000..5e4012a
--- /dev/null
+++ b/xbmc/dialogs/IGUIVolumeBarCallback.h
@@ -0,0 +1,28 @@
+/*
+ *  Copyright (C) 2017-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
+
+/*!
+ * \brief Interface to expose properties to the volume bar dialog
+ */
+class IGUIVolumeBarCallback
+{
+public:
+  virtual ~IGUIVolumeBarCallback() = default;
+
+  /*!
+   * \brief Return true if the callback is active in the GUI
+   *
+   * If a registered callback is shown in the GUI, the volume bar is disabled
+   * until no more callbacks are shown.
+   *
+   * \return True if the callback is active in the GUI, false otherwise
+   */
+  virtual bool IsShown() const = 0;
+};