--- a/.hgignore	Wed Jun 19 17:36:33 2019 +0200
+++ b/.hgignore	Mon Jun 24 14:35:00 2019 +0200
@@ -35,3 +35,6 @@
 Samples/Sdl/CMakeLists.txt.orig
 Samples/Qt/ThirdPartyDownloads/
 
+Samples/WebAssembly/build/
+Samples/WebAssembly/ThirdPartyDownloads/
+Samples/WebAssembly/installDir/

--- a/.hgtags	Wed Jun 19 17:36:33 2019 +0200
+++ b/.hgtags	Mon Jun 24 14:35:00 2019 +0200
@@ -1,1 +1,2 @@
 90f3a60576a9f08dcf783752a7f67ce0615a5371 rtviewer19
+6d15261f9c9965a2f4b64658e318b370933b175e toa2019061901

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Applications/Generic/GuiAdapter.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,799 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+#include "GuiAdapter.h"
+
+#if ORTHANC_ENABLE_OPENGL == 1
+#  include "../../Framework/OpenGL/OpenGLIncludes.h"
+#endif
+
+#if ORTHANC_ENABLE_SDL == 1
+#  include <SDL_video.h>
+#  include <SDL_render.h>
+#  include <SDL.h>
+#endif
+
+#if ORTHANC_ENABLE_THREADS == 1
+#  include "../../Framework/Messages/LockingEmitter.h"
+#endif
+
+namespace OrthancStone
+{
+  void GuiAdapter::RegisterWidget(boost::shared_ptr<IGuiAdapterWidget> widget)
+  {
+    widgets_.push_back(widget);
+  }
+
+  std::ostream& operator<<(
+    std::ostream& os, const GuiAdapterKeyboardEvent& event)
+  {
+    os << "ctrl: " << event.ctrlKey << ", " <<
+      "shift: " << event.shiftKey << ", " <<
+      "alt: " << event.altKey;
+    return os;
+  }
+
+#if ORTHANC_ENABLE_WASM == 1
+  void GuiAdapter::Run()
+  {
+  }
+
+  void ConvertFromPlatform(
+    GuiAdapterUiEvent& dest,
+    int                      eventType,
+    const EmscriptenUiEvent& src)
+  {
+    // no data for now
+  }
+
+  void ConvertFromPlatform(
+    GuiAdapterMouseEvent& dest,
+    int                         eventType,
+    const EmscriptenMouseEvent& src)
+  {
+    memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
+    switch (eventType)
+    {
+    case EMSCRIPTEN_EVENT_CLICK:
+      LOG(ERROR) << "Emscripten EMSCRIPTEN_EVENT_CLICK is not supported";
+      ORTHANC_ASSERT(false, "Not supported");
+      break;
+    case EMSCRIPTEN_EVENT_MOUSEDOWN:
+      dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
+      break;
+    case EMSCRIPTEN_EVENT_MOUSEMOVE:
+      dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
+      break;
+    case EMSCRIPTEN_EVENT_MOUSEUP:
+      dest.type = GUIADAPTER_EVENT_MOUSEUP;
+      break;
+    case EMSCRIPTEN_EVENT_WHEEL:
+      dest.type = GUIADAPTER_EVENT_WHEEL;
+      break;
+
+    default:
+      LOG(ERROR) << "Emscripten event: " << eventType << " is not supported";
+      ORTHANC_ASSERT(false, "Not supported");
+    }
+    //dest.timestamp = src.timestamp;
+    //dest.screenX = src.screenX;
+    //dest.screenY = src.screenY;
+    //dest.clientX = src.clientX;
+    //dest.clientY = src.clientY;
+    dest.ctrlKey = src.ctrlKey;
+    dest.shiftKey = src.shiftKey;
+    dest.altKey = src.altKey;
+    //dest.metaKey = src.metaKey;
+    dest.button = src.button;
+    //dest.buttons = src.buttons;
+    //dest.movementX = src.movementX;
+    //dest.movementY = src.movementY;
+    dest.targetX = src.targetX;
+    dest.targetY = src.targetY;
+    //dest.canvasX = src.canvasX;
+    //dest.canvasY = src.canvasY;
+    //dest.padding = src.padding;
+  }
+
+  void ConvertFromPlatform(
+    GuiAdapterWheelEvent& dest,
+    int                         eventType,
+    const EmscriptenWheelEvent& src)
+  {
+    ConvertFromPlatform(dest.mouse, eventType, src.mouse);
+    dest.deltaX = src.deltaX;
+    dest.deltaY = src.deltaY;
+    switch (src.deltaMode)
+    {
+    case DOM_DELTA_PIXEL:
+      dest.deltaMode = GUIADAPTER_DELTA_PIXEL;
+      break;
+    case DOM_DELTA_LINE:
+      dest.deltaMode = GUIADAPTER_DELTA_LINE;
+      break;
+    case DOM_DELTA_PAGE:
+      dest.deltaMode = GUIADAPTER_DELTA_PAGE;
+      break;
+    default:
+      ORTHANC_ASSERT(false, "Unknown deltaMode: " << src.deltaMode <<
+        " in wheel event...");
+    }
+    dest.deltaMode = src.deltaMode;
+  }
+
+  void ConvertFromPlatform(
+    GuiAdapterKeyboardEvent& dest,
+    const EmscriptenKeyboardEvent& src)
+  {
+    dest.ctrlKey = src.ctrlKey;
+    dest.shiftKey = src.shiftKey;
+    dest.altKey = src.altKey;
+  }
+   
+  template<typename GenericFunc>
+  struct FuncAdapterPayload
+  {
+    std::string canvasId;
+    void* userData;
+    GenericFunc callback;
+  };
+
+  template<typename GenericFunc,
+           typename GuiAdapterEvent,
+           typename EmscriptenEvent>
+  EM_BOOL OnEventAdapterFunc(
+    int eventType, const EmscriptenEvent* emEvent, void* userData)
+  {
+
+    // userData is OnMouseWheelFuncAdapterPayload
+    FuncAdapterPayload<GenericFunc>* payload =
+      reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
+    // LOG(INFO) << "OnEventAdapterFunc";
+    // LOG(INFO) << "------------------";
+    // LOG(INFO) << "eventType: " << eventType << " wheelEvent: " << 
+    //   (int)wheelEvent << " userData: " << userData << 
+    //   " payload->userData: " << payload->userData;
+    
+    GuiAdapterEvent guiEvent;
+    ConvertFromPlatform(guiEvent, eventType, *emEvent);
+    bool ret = (*(payload->callback))(payload->canvasId, &guiEvent, payload->userData);
+    return static_cast<EM_BOOL>(ret);
+  }
+
+  template<typename GenericFunc,
+    typename GuiAdapterEvent,
+    typename EmscriptenEvent>
+    EM_BOOL OnEventAdapterFunc2(
+      int /*eventType*/, const EmscriptenEvent* wheelEvent, void* userData)
+  {
+    // userData is OnMouseWheelFuncAdapterPayload
+    FuncAdapterPayload<GenericFunc>* payload =
+      reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
+    
+    GuiAdapterEvent guiEvent;
+    ConvertFromPlatform(guiEvent, *wheelEvent);
+    bool ret = (*(payload->callback))(payload->canvasId, &guiEvent, payload->userData);
+    return static_cast<EM_BOOL>(ret);
+  }
+
+  template<typename GenericFunc>
+    EM_BOOL OnEventAdapterFunc3(
+      double time, void* userData)
+  {
+    // userData is OnMouseWheelFuncAdapterPayload
+    FuncAdapterPayload<GenericFunc>* payload =
+      reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
+    //std::auto_ptr< FuncAdapterPayload<GenericFunc> > deleter(payload);
+    bool ret = (*(payload->callback))(time, payload->userData);
+    return static_cast<EM_BOOL>(ret);
+  }
+
+  // resize: (const char* target, void* userData, EM_BOOL useCapture, em_ui_callback_func callback)
+  template<
+    typename GenericFunc, 
+    typename GuiAdapterEvent, 
+    typename EmscriptenEvent, 
+    typename EmscriptenSetCallbackFunc>
+  static void SetCallback(
+    EmscriptenSetCallbackFunc emFunc, 
+    std::string canvasId, void* userData, bool capture, GenericFunc func)
+  {
+    // TODO: write RemoveCallback with an int id that gets returned from
+    // here
+    FuncAdapterPayload<GenericFunc>* payload = 
+      new FuncAdapterPayload<GenericFunc>();
+    std::auto_ptr<FuncAdapterPayload<GenericFunc> > payloadP(payload);
+    payload->canvasId = canvasId;
+    payload->callback = func;
+    payload->userData = userData;
+    void* userDataRaw = reinterpret_cast<void*>(payload);
+    // LOG(INFO) << "SetCallback -- userDataRaw: " << userDataRaw <<
+    //   " payload: " << payload << " payload->userData: " << payload->userData;
+    (*emFunc)(
+      canvasId.c_str(),
+      userDataRaw,
+      static_cast<EM_BOOL>(capture),
+      &OnEventAdapterFunc<GenericFunc, GuiAdapterEvent, EmscriptenEvent>,
+      EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
+    payloadP.release();
+  }
+
+  template<
+    typename GenericFunc,
+    typename GuiAdapterEvent,
+    typename EmscriptenEvent,
+    typename EmscriptenSetCallbackFunc>
+    static void SetCallback2(
+      EmscriptenSetCallbackFunc emFunc,
+      std::string canvasId, void* userData, bool capture, GenericFunc func)
+  {
+    std::auto_ptr<FuncAdapterPayload<GenericFunc> > payload(
+      new FuncAdapterPayload<GenericFunc>()
+    );
+    payload->canvasId = canvasId;
+    payload->callback = func;
+    payload->userData = userData;
+    void* userDataRaw = reinterpret_cast<void*>(payload.release());
+    (*emFunc)(
+      canvasId.c_str(),
+      userDataRaw,
+      static_cast<EM_BOOL>(capture),
+      &OnEventAdapterFunc2<GenericFunc, GuiAdapterEvent, EmscriptenEvent>,
+      EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
+  }
+
+  template<
+    typename GenericFunc,
+    typename EmscriptenSetCallbackFunc>
+    static void SetAnimationFrameCallback(
+      EmscriptenSetCallbackFunc emFunc,
+      void* userData, GenericFunc func)
+  {
+    // LOG(ERROR) << "SetAnimationFrameCallback !!!!!! (RequestAnimationFrame)";
+    std::auto_ptr<FuncAdapterPayload<GenericFunc> > payload(
+      new FuncAdapterPayload<GenericFunc>()
+    );
+    payload->canvasId = "UNDEFINED";
+    payload->callback = func;
+    payload->userData = userData;
+    void* userDataRaw = reinterpret_cast<void*>(payload.release());
+    (*emFunc)(
+      &OnEventAdapterFunc3<GenericFunc>,
+      userDataRaw);
+  }
+
+  void GuiAdapter::SetWheelCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseWheelFunc func)
+  {
+    SetCallback<OnMouseWheelFunc, GuiAdapterWheelEvent, EmscriptenWheelEvent>(
+      &emscripten_set_wheel_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetMouseDownCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
+  {
+    SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
+      &emscripten_set_mousedown_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetMouseMoveCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
+  {
+    // LOG(INFO) << "SetMouseMoveCallback -- " << "supplied userData: " << 
+    //   userData;
+
+    SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
+      &emscripten_set_mousemove_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetMouseUpCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
+  {
+    SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
+      &emscripten_set_mouseup_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetKeyDownCallback(
+    std::string canvasId, void* userData, bool capture, OnKeyDownFunc func)
+  {
+    SetCallback2<OnKeyDownFunc, GuiAdapterKeyboardEvent, EmscriptenKeyboardEvent>(
+      &emscripten_set_keydown_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetKeyUpCallback(
+    std::string canvasId, void* userData, bool capture, OnKeyUpFunc func)
+  {
+    SetCallback2<OnKeyUpFunc, GuiAdapterKeyboardEvent, EmscriptenKeyboardEvent>(
+      &emscripten_set_keyup_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::SetResizeCallback(
+    std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
+  {
+    SetCallback<OnWindowResizeFunc, GuiAdapterUiEvent, EmscriptenUiEvent>(
+      &emscripten_set_resize_callback_on_thread,
+      canvasId,
+      userData,
+      capture,
+      func);
+  }
+
+  void GuiAdapter::RequestAnimationFrame(
+    OnAnimationFrameFunc func, void* userData)
+  {
+    // LOG(ERROR) << "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+";
+    // LOG(ERROR) << "RequestAnimationFrame";
+    // LOG(ERROR) << "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+";
+    SetAnimationFrameCallback<OnAnimationFrameFunc>(
+      &emscripten_request_animation_frame_loop,
+      userData,
+      func);
+  }
+
+#if 0
+  void GuiAdapter::SetKeyDownCallback(
+    std::string canvasId, void* userData, bool capture, OnKeyDownFunc func)
+  {
+    emscripten_set_keydown_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
+  }
+  void GuiAdapter::SetKeyUpCallback(
+    std::string canvasId, void* userData, bool capture, OnKeyUpFunc func)
+  {
+    emscripten_set_keyup_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
+  }
+
+  void GuiAdapter::SetResizeCallback(std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
+  {
+    emscripten_set_resize_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
+  }
+
+  void GuiAdapter::RequestAnimationFrame(OnAnimationFrameFunc func, void* userData)
+  {
+    emscripten_request_animation_frame_loop(func, userData);
+  }
+#endif
+
+
+#else
+
+// SDL ONLY
+void ConvertFromPlatform(
+  GuiAdapterMouseEvent& dest,
+  bool ctrlPressed, bool shiftPressed, bool altPressed,
+  const SDL_Event& source)
+{
+  memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
+  switch (source.type)
+  {
+  case SDL_MOUSEBUTTONDOWN:
+    dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
+    break;
+  case SDL_MOUSEMOTION:
+    dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
+    break;
+  case SDL_MOUSEBUTTONUP:
+    dest.type = GUIADAPTER_EVENT_MOUSEUP;
+    break;
+  case SDL_MOUSEWHEEL:
+    dest.type = GUIADAPTER_EVENT_WHEEL;
+    break;
+  default:
+    LOG(ERROR) << "SDL event: " << source.type << " is not supported";
+    ORTHANC_ASSERT(false, "Not supported");
+    }
+  //dest.timestamp = src.timestamp;
+  //dest.screenX = src.screenX;
+  //dest.screenY = src.screenY;
+  //dest.clientX = src.clientX;
+  //dest.clientY = src.clientY;
+  dest.ctrlKey = ctrlPressed;
+  dest.shiftKey = shiftPressed;
+  dest.altKey = altPressed;
+  //dest.metaKey = src.metaKey;
+  switch (source.button.button)
+  {
+  case SDL_BUTTON_MIDDLE:
+    dest.button = 1;
+    break;
+
+  case SDL_BUTTON_RIGHT:
+    dest.button = 2;
+    break;
+
+  case SDL_BUTTON_LEFT:
+    dest.button = 0;
+    break;
+
+  default:
+    break;
+  }
+  //dest.buttons = src.buttons;
+  //dest.movementX = src.movementX;
+  //dest.movementY = src.movementY;
+  dest.targetX = source.button.x;
+  dest.targetY = source.button.y;
+  //dest.canvasX = src.canvasX;
+  //dest.canvasY = src.canvasY;
+  //dest.padding = src.padding;
+  }
+
+void ConvertFromPlatform(
+  GuiAdapterWheelEvent& dest,
+  bool ctrlPressed, bool shiftPressed, bool altPressed,
+  const SDL_Event& source)
+{
+  ConvertFromPlatform(dest.mouse, ctrlPressed, shiftPressed, altPressed, source);
+  dest.deltaX = source.wheel.x;
+  dest.deltaY = source.wheel.y;
+}
+
+
+
+  // SDL ONLY
+  void GuiAdapter::SetResizeCallback(
+    std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
+  {
+    resizeHandlers_.push_back(EventHandlerData<OnWindowResizeFunc>(canvasId, func, userData));
+  }
+
+  // SDL ONLY
+  void GuiAdapter::SetMouseDownCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
+ {
+    mouseDownHandlers_.push_back(EventHandlerData<OnMouseEventFunc>(canvasId, func, userData));
+ }
+
+  // SDL ONLY
+  void GuiAdapter::SetMouseMoveCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc  func)
+ {
+    mouseMoveHandlers_.push_back(EventHandlerData<OnMouseEventFunc>(canvasId, func, userData));
+  }
+
+  // SDL ONLY
+  void GuiAdapter::SetMouseUpCallback(
+    std::string canvasId, void* userData, bool capture, OnMouseEventFunc  func)
+ {
+    mouseUpHandlers_.push_back(EventHandlerData<OnMouseEventFunc>(canvasId, func, userData));
+  }
+
+  // SDL ONLY
+  void GuiAdapter::SetWheelCallback(
+   std::string canvasId, void* userData, bool capture, OnMouseWheelFunc  func)
+  {
+    mouseWheelHandlers_.push_back(EventHandlerData<OnMouseWheelFunc>(canvasId, func, userData));
+  }
+
+  // SDL ONLY
+  void GuiAdapter::SetKeyDownCallback(
+   std::string canvasId, void* userData, bool capture, OnKeyDownFunc   func)
+ {
+ }
+
+  // SDL ONLY
+  void GuiAdapter::SetKeyUpCallback(
+   std::string canvasId, void* userData, bool capture, OnKeyUpFunc    func)
+ {
+ }
+
+
+  // SDL ONLY
+  void GuiAdapter::OnAnimationFrame()
+  {
+    for (size_t i = 0; i < animationFrameHandlers_.size(); i++)
+    {
+      // TODO: fix time 
+      (*(animationFrameHandlers_[i].first))(0, animationFrameHandlers_[i].second);
+    }
+  }
+
+  // SDL ONLY
+  void GuiAdapter::OnResize()
+  {
+    for (size_t i = 0; i < resizeHandlers_.size(); i++)
+    {
+      (*(resizeHandlers_[i].func))(
+        resizeHandlers_[i].canvasName, 0, resizeHandlers_[i].userData);
+    }
+  }
+
+  // SDL ONLY
+  void GuiAdapter::OnMouseWheelEvent(uint32_t windowID, const GuiAdapterWheelEvent& event)
+  {
+
+    // the SDL window name IS the canvas name ("canvas" is used because this lib
+    // is designed for Wasm
+    SDL_Window* sdlWindow = SDL_GetWindowFromID(windowID);
+    ORTHANC_ASSERT(sdlWindow != NULL, "Window ID \"" << windowID << "\" is not a valid SDL window ID!");
+
+    const char* windowTitleSz = SDL_GetWindowTitle(sdlWindow);
+    ORTHANC_ASSERT(windowTitleSz != NULL, "Window ID \"" << windowID << "\" has a NULL window title!");
+
+    std::string windowTitle(windowTitleSz);
+    ORTHANC_ASSERT(windowTitle != "", "Window ID \"" << windowID << "\" has an empty window title!");
+
+    switch (event.mouse.type)
+    {
+    case GUIADAPTER_EVENT_WHEEL:
+      for (size_t i = 0; i < mouseWheelHandlers_.size(); i++)
+      {
+        if(mouseWheelHandlers_[i].canvasName == windowTitle)
+          (*(mouseWheelHandlers_[i].func))(windowTitle, &event, mouseWheelHandlers_[i].userData);
+      }
+      break;
+    default:
+      ORTHANC_ASSERT(false, "Wrong event.type: " << event.mouse.type << " in GuiAdapter::OnMouseWheelEvent(...)");
+      break;
+    }
+  }
+
+  // SDL ONLY
+  void GuiAdapter::OnMouseEvent(uint32_t windowID, const GuiAdapterMouseEvent& event)
+  {
+    // the SDL window name IS the canvas name ("canvas" is used because this lib
+    // is designed for Wasm
+    SDL_Window* sdlWindow = SDL_GetWindowFromID(windowID);
+    ORTHANC_ASSERT(sdlWindow != NULL, "Window ID \"" << windowID << "\" is not a valid SDL window ID!");
+     
+    const char* windowTitleSz = SDL_GetWindowTitle(sdlWindow);
+    ORTHANC_ASSERT(windowTitleSz != NULL, "Window ID \"" << windowID << "\" has a NULL window title!");
+
+    std::string windowTitle(windowTitleSz);
+    ORTHANC_ASSERT(windowTitle != "", "Window ID \"" << windowID << "\" has an empty window title!");
+
+    switch (event.type)
+    {
+    case GUIADAPTER_EVENT_MOUSEDOWN:
+      for (size_t i = 0; i < mouseDownHandlers_.size(); i++)
+      {
+        if (mouseDownHandlers_[i].canvasName == windowTitle)
+          (*(mouseDownHandlers_[i].func))(windowTitle, &event, mouseDownHandlers_[i].userData);
+      }
+      break;
+    case GUIADAPTER_EVENT_MOUSEMOVE:
+      for (size_t i = 0; i < mouseMoveHandlers_.size(); i++)
+      {
+        if (mouseMoveHandlers_[i].canvasName == windowTitle)
+          (*(mouseMoveHandlers_[i].func))(windowTitle, &event, mouseMoveHandlers_[i].userData);
+      }
+      break;
+    case GUIADAPTER_EVENT_MOUSEUP:
+      for (size_t i = 0; i < mouseUpHandlers_.size(); i++)
+      {
+        if (mouseUpHandlers_[i].canvasName == windowTitle)
+          (*(mouseUpHandlers_[i].func))(windowTitle, &event, mouseUpHandlers_[i].userData);
+      }
+      break;
+    default:
+      ORTHANC_ASSERT(false, "Wrong event.type: " << event.type << " in GuiAdapter::OnMouseEvent(...)");
+      break;
+    }
+
+    ////boost::shared_ptr<IGuiAdapterWidget> GetWidgetFromWindowId();
+    //boost::shared_ptr<IGuiAdapterWidget> foundWidget;
+    //VisitWidgets([foundWidget, windowID](auto widget)
+    //  {
+    //    if (widget->GetSdlWindowID() == windowID)
+    //      foundWidget = widget;
+    //  });
+    //ORTHANC_ASSERT(foundWidget, "WindowID " << windowID << " was not found in the registered widgets!");
+    //if(foundWidget)
+    //  foundWidget->
+  }
+
+  // SDL ONLY
+  void GuiAdapter::RequestAnimationFrame(OnAnimationFrameFunc func, void* userData)
+  {
+    animationFrameHandlers_.push_back(std::make_pair(func, userData));
+  }
+
+# if ORTHANC_ENABLE_OPENGL == 1 && !defined(__APPLE__)   /* OpenGL debug is not available on OS X */
+
+  // SDL ONLY
+  static void GLAPIENTRY
+    OpenGLMessageCallback(GLenum source,
+      GLenum type,
+      GLuint id,
+      GLenum severity,
+      GLsizei length,
+      const GLchar* message,
+      const void* userParam)
+  {
+    if (severity != GL_DEBUG_SEVERITY_NOTIFICATION)
+    {
+      fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
+        (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
+        type, severity, message);
+    }
+}
+# endif
+
+  // SDL ONLY
+  void GuiAdapter::Run()
+  {
+# if ORTHANC_ENABLE_OPENGL == 1 && !defined(__APPLE__)
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageCallback(OpenGLMessageCallback, 0);
+# endif
+
+    // Uint32 SDL_GetWindowID(SDL_Window* window)
+    // SDL_Window* SDL_GetWindowFromID(Uint32 id)   // may return NULL
+
+    bool stop = false;
+    while (!stop)
+    {
+      {
+        LockingEmitter::WriterLock lock(lockingEmitter_);
+        OnAnimationFrame(); // in SDL we must call it
+      }
+
+      SDL_Event event;
+
+      while (!stop && SDL_PollEvent(&event))
+      {
+        LockingEmitter::WriterLock lock(lockingEmitter_);
+
+        if (event.type == SDL_QUIT)
+        {
+          // TODO: call exit callbacks here
+          stop = true;
+          break;
+        }
+        else if ( (event.type == SDL_MOUSEMOTION) ||
+                  (event.type == SDL_MOUSEBUTTONDOWN) ||
+                  (event.type == SDL_MOUSEBUTTONUP) )
+        {
+          int scancodeCount = 0;
+          const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount);
+          bool ctrlPressed(false);
+          bool shiftPressed(false);
+          bool altPressed(false);
+            
+          if (SDL_SCANCODE_LCTRL < scancodeCount && keyboardState[SDL_SCANCODE_LCTRL])
+            ctrlPressed = true;
+          if (SDL_SCANCODE_RCTRL < scancodeCount && keyboardState[SDL_SCANCODE_RCTRL])
+            ctrlPressed = true;
+          if (SDL_SCANCODE_LSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_LSHIFT])
+            shiftPressed = true;
+          if (SDL_SCANCODE_RSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_RSHIFT])
+            shiftPressed = true;
+          if (SDL_SCANCODE_LALT < scancodeCount && keyboardState[SDL_SCANCODE_LALT])
+            altPressed = true;
+          
+          GuiAdapterMouseEvent dest;
+          ConvertFromPlatform(dest, ctrlPressed, shiftPressed, altPressed, event);
+          OnMouseEvent(event.window.windowID, dest);
+#if 0
+          // for reference, how to create trackers
+          if (tracker)
+          {
+            PointerEvent e;
+            e.AddPosition(compositor.GetPixelCenterCoordinates(
+              event.button.x, event.button.y));
+            tracker->PointerMove(e);
+          }
+#endif
+        }
+        else if (event.type == SDL_MOUSEWHEEL)
+        {
+
+          int scancodeCount = 0;
+          const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount);
+          bool ctrlPressed(false);
+          bool shiftPressed(false);
+          bool altPressed(false);
+
+          if (SDL_SCANCODE_LCTRL < scancodeCount && keyboardState[SDL_SCANCODE_LCTRL])
+            ctrlPressed = true;
+          if (SDL_SCANCODE_RCTRL < scancodeCount && keyboardState[SDL_SCANCODE_RCTRL])
+            ctrlPressed = true;
+          if (SDL_SCANCODE_LSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_LSHIFT])
+            shiftPressed = true;
+          if (SDL_SCANCODE_RSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_RSHIFT])
+            shiftPressed = true;
+          if (SDL_SCANCODE_LALT < scancodeCount && keyboardState[SDL_SCANCODE_LALT])
+            altPressed = true;
+
+          GuiAdapterWheelEvent dest;
+          ConvertFromPlatform(dest, ctrlPressed, shiftPressed, altPressed, event);
+          OnMouseWheelEvent(event.window.windowID, dest);
+
+          //KeyboardModifiers modifiers = GetKeyboardModifiers(keyboardState, scancodeCount);
+
+          //int x, y;
+          //SDL_GetMouseState(&x, &y);
+
+          //if (event.wheel.y > 0)
+          //{
+          //  locker.GetCentralViewport().MouseWheel(MouseWheelDirection_Up, x, y, modifiers);
+          //}
+          //else if (event.wheel.y < 0)
+          //{
+          //  locker.GetCentralViewport().MouseWheel(MouseWheelDirection_Down, x, y, modifiers);
+          //}
+        }
+        else if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+        {
+#if 0
+          tracker.reset();
+#endif
+          OnResize();
+        }
+        else if (event.type == SDL_KEYDOWN && event.key.repeat == 0 /* Ignore key bounce */)
+        {
+          switch (event.key.keysym.sym)
+          {
+          case SDLK_f:
+            // window.GetWindow().ToggleMaximize(); //TODO: move to particular handler
+            break;
+
+          case SDLK_s:
+#if 0
+            // TODO: re-enable at application-level!!!!
+            VisitWidgets(
+              [](auto value)
+              {
+                auto widget = boost::dynamic_pointer_cast<VolumeSlicerWidget()
+                value->FitContent();
+              });
+#endif
+            break;
+
+          case SDLK_q:
+            stop = true;
+            break;
+
+          default:
+            break;
+          }
+        }
+        //        HandleApplicationEvent(controller, compositor, event, tracker);
+      }
+
+      SDL_Delay(1);
+    }
+  }
+#endif
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Applications/Generic/GuiAdapter.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,363 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+#pragma once
+
+#include <string>
+
+#if ORTHANC_ENABLE_WASM != 1
+# ifdef __EMSCRIPTEN__
+#   error __EMSCRIPTEN__ is defined and ORTHANC_ENABLE_WASM != 1
+# endif
+#endif
+
+#if ORTHANC_ENABLE_WASM == 1
+# ifndef __EMSCRIPTEN__
+#   error __EMSCRIPTEN__ is not defined and ORTHANC_ENABLE_WASM == 1
+# endif
+#endif
+
+#if ORTHANC_ENABLE_WASM == 1
+# include <emscripten/html5.h>
+#else
+# if ORTHANC_ENABLE_SDL == 1
+#   include <SDL.h>
+# endif
+#endif
+
+#include "../../Framework/StoneException.h"
+
+#if ORTHANC_ENABLE_THREADS != 1
+# include "../../Framework/Messages/LockingEmitter.h"
+#endif
+
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+namespace OrthancStone
+{
+
+  /**
+  This interface is used to store the widgets that are controlled by the 
+  GuiAdapter and receive event callbacks.
+  The callbacks may possibly be downcast (using dynamic_cast, for safety) \
+  to the actual widget type
+  */
+  class IGuiAdapterWidget
+  {
+  public:
+    virtual ~IGuiAdapterWidget() {}
+
+  };
+
+  enum GuiAdapterMouseEventType
+  {
+    GUIADAPTER_EVENT_MOUSEDOWN = 1973,
+    GUIADAPTER_EVENT_MOUSEMOVE = 1974,
+    GUIADAPTER_EVENT_MOUSEUP   = 1975,
+    GUIADAPTER_EVENT_WHEEL     = 1976
+  };
+
+  const unsigned int GUIADAPTER_DELTA_PIXEL = 2973;
+  const unsigned int GUIADAPTER_DELTA_LINE  = 2974;
+  const unsigned int GUIADAPTER_DELTA_PAGE  = 2975;
+
+  struct GuiAdapterUiEvent;
+  struct GuiAdapterMouseEvent;
+  struct GuiAdapterWheelEvent;
+  struct GuiAdapterKeyboardEvent;
+
+  class LockingEmitter;
+    
+#if 1
+  typedef bool (*OnMouseEventFunc)(std::string canvasId, const GuiAdapterMouseEvent* mouseEvent, void* userData);
+  typedef bool (*OnMouseWheelFunc)(std::string canvasId, const GuiAdapterWheelEvent* wheelEvent, void* userData);
+  typedef bool (*OnKeyDownFunc)   (std::string canvasId, const GuiAdapterKeyboardEvent*   keyEvent,   void* userData);
+  typedef bool (*OnKeyUpFunc)     (std::string canvasId, const GuiAdapterKeyboardEvent*   keyEvent,   void* userData);
+
+  typedef bool (*OnAnimationFrameFunc)(double time, void* userData);
+  typedef bool (*OnWindowResizeFunc)(std::string canvasId, const GuiAdapterUiEvent* uiEvent, void* userData);
+
+#else
+
+#if ORTHANC_ENABLE_WASM == 1
+  typedef EM_BOOL (*OnMouseEventFunc)(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData);
+  typedef EM_BOOL (*OnMouseWheelFunc)(int eventType, const EmscriptenWheelEvent* wheelEvent, void* userData);
+  typedef EM_BOOL (*OnKeyDownFunc)   (int eventType, const EmscriptenKeyboardEvent* keyEvent, void* userData);
+  typedef EM_BOOL (*OnKeyUpFunc)     (int eventType, const EmscriptenKeyboardEvent* keyEvent, void* userData);
+
+  typedef EM_BOOL (*OnAnimationFrameFunc)(double time, void* userData);
+  typedef EM_BOOL (*OnWindowResizeFunc)(int eventType, const EmscriptenUiEvent* uiEvent, void* userData);
+#else
+  typedef bool    (*OnMouseEventFunc)(int eventType, const SDL_Event* mouseEvent, void* userData);
+  typedef bool    (*OnMouseWheelFunc)(int eventType, const SDL_Event* wheelEvent, void* userData);
+  typedef bool    (*OnKeyDownFunc)   (int eventType, const SDL_Event* keyEvent,   void* userData);
+  typedef bool    (*OnKeyUpFunc)     (int eventType, const SDL_Event* keyEvent,   void* userData);
+
+  typedef bool    (*OnAnimationFrameFunc)(double time, void* userData);
+  typedef bool    (*OnWindowResizeFunc)(int eventType, const GuiAdapterUiEvent* uiEvent, void* userData);
+#endif
+
+#endif
+  struct GuiAdapterMouseEvent {
+    GuiAdapterMouseEventType type;
+    //double                   timestamp;
+    //long                     screenX;
+    //long                     screenY;
+    //long                     clientX;
+    //long                     clientY;
+    bool                     ctrlKey;
+    bool                     shiftKey;
+    bool                     altKey;
+    //bool                     metaKey;
+    unsigned short           button;
+    //unsigned short           buttons;
+    //long                     movementX;
+    //long                     movementY;
+    long                     targetX;
+    long                     targetY;
+    // canvasX and canvasY are deprecated - there no longer exists a Module['canvas'] object, so canvasX/Y are no longer reported (register a listener on canvas directly to get canvas coordinates, or translate manually)
+    //long                     canvasX;
+    //long                     canvasY;
+    //long                     padding;
+  };
+
+  struct GuiAdapterWheelEvent {
+    GuiAdapterMouseEvent mouse;
+    double deltaX;
+    double deltaY;
+    unsigned long deltaMode;
+  };
+
+  // we don't use any data now
+  struct GuiAdapterUiEvent {};
+
+  // EmscriptenKeyboardEvent
+  struct GuiAdapterKeyboardEvent
+  {
+    bool ctrlKey;
+    bool shiftKey;
+    bool altKey;
+  };
+
+  std::ostream& operator<<(std::ostream& os, const GuiAdapterKeyboardEvent& event);
+
+  /*
+    Mousedown event trigger when either the left or right (or middle) mouse is pressed 
+    on the object;
+
+    Mouseup event trigger when either the left or right (or middle) mouse is released
+    above the object after triggered mousedown event and held.
+
+    Click event trigger when the only left mouse button is pressed and released on the
+    same object, requires the Mousedown and Mouseup event happened before Click event.
+
+    The normal expect trigger order: onMousedown >> onMouseup >> onClick
+
+    Testing in Chrome v58, the time between onMouseup and onClick events are around 
+    7ms to 15ms
+
+    FROM: https://codingrepo.com/javascript/2017/05/19/javascript-difference-mousedown-mouseup-click-events/
+  */
+#if ORTHANC_ENABLE_WASM == 1
+  void ConvertFromPlatform(
+    GuiAdapterUiEvent&       dest,
+    int                      eventType,
+    const EmscriptenUiEvent& src);
+
+  void ConvertFromPlatform(
+    GuiAdapterMouseEvent&       dest,
+    int                         eventType,
+    const EmscriptenMouseEvent& src);
+  
+  void ConvertFromPlatform(
+    GuiAdapterWheelEvent&       dest,
+    int                         eventType,
+    const EmscriptenWheelEvent& src);
+
+  void ConvertFromPlatform(
+    GuiAdapterKeyboardEvent&       dest,
+    const EmscriptenKeyboardEvent& src);
+
+#else
+
+# if ORTHANC_ENABLE_SDL == 1
+  void ConvertFromPlatform(
+    GuiAdapterMouseEvent& dest,
+    bool ctrlPressed, bool shiftPressed, bool altPressed,
+    const SDL_Event& source);
+
+  void ConvertFromPlatform(
+    GuiAdapterWheelEvent& dest,
+    bool ctrlPressed, bool shiftPressed, bool altPressed,
+    const SDL_Event& source);
+
+# endif
+
+#endif
+
+  class GuiAdapter
+  {
+  public:
+#if ORTHANC_ENABLE_THREADS == 1
+    GuiAdapter(LockingEmitter& lockingEmitter) : lockingEmitter_(lockingEmitter)
+#else
+    GuiAdapter()
+#endif
+    {
+      static int instanceCount = 0;
+      ORTHANC_ASSERT(instanceCount == 0);
+      instanceCount = 1;
+    }
+
+    void RegisterWidget(boost::shared_ptr<IGuiAdapterWidget> widget);
+    
+    /**
+      emscripten_set_resize_callback("#window", NULL, false, OnWindowResize);
+
+      emscripten_set_wheel_callback("mycanvas1", widget1_.get(), false, OnXXXMouseWheel);
+      emscripten_set_wheel_callback("mycanvas2", widget2_.get(), false, OnXXXMouseWheel);
+      emscripten_set_wheel_callback("mycanvas3", widget3_.get(), false, OnXXXMouseWheel);
+
+      emscripten_set_keydown_callback("#window", NULL, false, OnKeyDown);
+      emscripten_set_keyup_callback("#window", NULL, false, OnKeyUp);
+
+      emscripten_request_animation_frame_loop(OnAnimationFrame, NULL);
+    
+      SDL:
+      see https://wiki.libsdl.org/SDL_CaptureMouse
+
+    */
+
+    void SetMouseDownCallback(std::string canvasId, void* userData, bool capture, OnMouseEventFunc   func);
+    void SetMouseMoveCallback(std::string canvasId, void* userData, bool capture, OnMouseEventFunc   func);
+    void SetMouseUpCallback  (std::string canvasId, void* userData, bool capture, OnMouseEventFunc   func);
+    void SetWheelCallback    (std::string canvasId, void* userData, bool capture, OnMouseWheelFunc   func);
+    void SetKeyDownCallback  (std::string canvasId, void* userData, bool capture, OnKeyDownFunc      func);
+    void SetKeyUpCallback    (std::string canvasId, void* userData, bool capture, OnKeyUpFunc        func);
+    
+    // if you pass "#window", under SDL, then any Window resize will trigger the callback
+    void SetResizeCallback (std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func);
+
+    void RequestAnimationFrame(OnAnimationFrameFunc func, void* userData);
+
+    // TODO: implement and call to remove canvases [in SDL, although code should be generic]
+    void SetOnExitCallback();
+
+    // void 
+    // OnWindowResize
+    // oracle
+    // broker
+
+    /**
+    Under SDL, this function does NOT return until all windows have been closed.
+    Under wasm, it returns without doing anything, since the event loop is managed
+    by the browser.
+    */
+    void Run();
+
+#if ORTHANC_ENABLE_WASM != 1
+    /**
+    This method must be called in order for callback handler to be allowed to 
+    be registered.
+
+    We'll retrieve its name and use it as the canvas name in all subsequent 
+    calls
+    */
+    //void RegisterSdlWindow(SDL_Window* window);
+    //void UnregisterSdlWindow(SDL_Window* window);
+#endif
+
+  private:
+
+#if ORTHANC_ENABLE_THREADS == 1
+    /**
+    This object is used by the multithreaded Oracle to serialize access to
+    shared data. We need to use it as soon as we access the state.
+    */
+    LockingEmitter& lockingEmitter_;
+#endif
+
+    /**
+    In SDL, this executes all the registered headers
+    */
+    void OnAnimationFrame();
+
+    //void RequestAnimationFrame(OnAnimationFrameFunc func, void* userData);
+    std::vector<std::pair<OnAnimationFrameFunc, void*> >  
+      animationFrameHandlers_;
+    
+    void OnResize();
+
+#if ORTHANC_ENABLE_SDL == 1
+    template<typename Func>
+    struct EventHandlerData
+    {
+      EventHandlerData(std::string canvasName, Func func, void* userData) 
+        : canvasName(canvasName)
+        , func(func)
+        , userData(userData)
+      {
+      }
+
+      std::string canvasName;
+      Func        func;
+      void*       userData;
+    };
+    std::vector<EventHandlerData<OnWindowResizeFunc> > resizeHandlers_;
+    std::vector<EventHandlerData<OnMouseEventFunc  > > mouseDownHandlers_;
+    std::vector<EventHandlerData<OnMouseEventFunc  > > mouseMoveHandlers_;
+    std::vector<EventHandlerData<OnMouseEventFunc  > > mouseUpHandlers_;
+    std::vector<EventHandlerData<OnMouseWheelFunc  > > mouseWheelHandlers_;
+    
+
+    /**
+    This executes all the registered headers if needed (in wasm, the browser
+    deals with this)
+    */
+    void OnMouseEvent(uint32_t windowID, const GuiAdapterMouseEvent& event);
+    
+    /**
+    Same remark as OnMouseEvent
+    */
+    void OnMouseWheelEvent(uint32_t windowID, const GuiAdapterWheelEvent& event);
+
+    boost::shared_ptr<IGuiAdapterWidget> GetWidgetFromWindowId();
+
+#endif
+
+    /**
+    This executes all the registered headers if needed (in wasm, the browser
+    deals with this)
+    */
+    void ViewportsUpdateSize();
+
+    std::vector<boost::weak_ptr<IGuiAdapterWidget> > widgets_;
+
+    template<typename F> void VisitWidgets(F func)
+    {
+      for (size_t i = 0; i < widgets_.size(); i++)
+      {
+        boost::shared_ptr<IGuiAdapterWidget> widget = widgets_[i].lock();
+        func(widget);
+      }
+    }
+  };
+}

--- a/Applications/Generic/NativeStoneApplicationContext.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Generic/NativeStoneApplicationContext.h	Mon Jun 24 14:35:00 2019 +0200
@@ -21,9 +21,9 @@
 
 #pragma once
 
-#include "../../Framework/Viewport/WidgetViewport.h"
-#include "../../Framework/Volumes/ISlicedVolume.h"
-#include "../../Framework/Volumes/IVolumeLoader.h"
+#include "../../Framework/Deprecated/Viewport/WidgetViewport.h"
+#include "../../Framework/Deprecated/Volumes/ISlicedVolume.h"
+#include "../../Framework/Deprecated/Volumes/IVolumeLoader.h"
 
 #include <list>
 #include <boost/thread.hpp>

--- a/Applications/Generic/NativeStoneApplicationRunner.cpp	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Generic/NativeStoneApplicationRunner.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -19,13 +19,13 @@
  **/
 
 
-#if ORTHANC_ENABLE_NATIVE != 1
-#error this file shall be included only with the ORTHANC_ENABLE_NATIVE set to 1
+#if ORTHANC_ENABLE_THREADS != 1
+#error this file shall be included only with the ORTHANC_ENABLE_THREADS set to 1
 #endif
 
 #include "NativeStoneApplicationRunner.h"
 
-#include "../../Framework/Toolbox/MessagingToolbox.h"
+#include "../../Framework/Deprecated/Toolbox/MessagingToolbox.h"
 #include "../../Platforms/Generic/OracleWebService.h"
 #include "../../Platforms/Generic/OracleDelayedCallExecutor.h"
 #include "NativeStoneApplicationContext.h"
@@ -180,7 +180,7 @@
 
       {
         OrthancPlugins::OrthancHttpConnection orthanc(webServiceParameters);
-        if (!MessagingToolbox::CheckOrthancVersion(orthanc))
+        if (!Deprecated::MessagingToolbox::CheckOrthancVersion(orthanc))
         {
           LOG(ERROR) << "Your version of Orthanc is incompatible with Stone of "
             << "Orthanc, please upgrade";

--- a/Applications/Generic/NativeStoneApplicationRunner.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Generic/NativeStoneApplicationRunner.h	Mon Jun 24 14:35:00 2019 +0200
@@ -23,8 +23,8 @@
 
 #include "../IStoneApplication.h"
 
-#if ORTHANC_ENABLE_NATIVE != 1
-#error this file shall be included only with the ORTHANC_ENABLE_NATIVE set to 1
+#if ORTHANC_ENABLE_THREADS != 1
+#error this file shall be included only with the ORTHANC_ENABLE_THREADS set to 1
 #endif
 
 namespace OrthancStone

--- a/Applications/IStoneApplication.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/IStoneApplication.h	Mon Jun 24 14:35:00 2019 +0200
@@ -22,9 +22,10 @@
 #pragma once
 
 #include "StoneApplicationContext.h"
+#include "../Framework/Deprecated/Viewport/WidgetViewport.h"
+
 #include <boost/program_options.hpp>
-#include "../Framework/Viewport/WidgetViewport.h"
-#include "json/json.h"
+#include <json/json.h>
 
 namespace OrthancStone
 {

--- a/Applications/Qt/QCairoWidget.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Qt/QCairoWidget.h	Mon Jun 24 14:35:00 2019 +0200
@@ -21,8 +21,8 @@
 #pragma once
 
 #include "../../Applications/Generic/NativeStoneApplicationContext.h"
-#include "../../Framework/Viewport/CairoSurface.h"
-#include "../../Framework/Widgets/IWidget.h"
+#include "../../Framework/Wrappers/CairoSurface.h"
+#include "../../Framework/Deprecated/Widgets/IWidget.h"
 
 #include <QWidget>
 #include <memory>

--- a/Applications/Qt/QtStoneApplicationRunner.cpp	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Qt/QtStoneApplicationRunner.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -27,7 +27,7 @@
 #include <boost/program_options.hpp>
 #include <QApplication>
 
-#include "../../Framework/Toolbox/MessagingToolbox.h"
+#include "../../Framework/Deprecated/Toolbox/MessagingToolbox.h"
 
 #include <Core/Logging.h>
 #include <Core/HttpClient.h>

--- a/Applications/Samples/CMakeLists.txt	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/CMakeLists.txt	Mon Jun 24 14:35:00 2019 +0200
@@ -8,6 +8,9 @@
 
 include(../../Resources/CMake/OrthancStoneParameters.cmake)
 
+set(ENABLE_STONE_DEPRECATED ON)  # Need deprecated classes for these samples
+
+
 if (OPENSSL_NO_CAPIENG)
 add_definitions(-DOPENSSL_NO_CAPIENG=1)
 endif()
@@ -79,6 +82,7 @@
 
 endif()
 
+
 #####################################################################
 ## Configuration for Orthanc
 #####################################################################
@@ -97,6 +101,10 @@
 set(ORTHANC_FRAMEWORK_ARCHIVE "" CACHE STRING "Path to the Orthanc archive, if ORTHANC_FRAMEWORK_SOURCE is \"archive\"")
 set(ORTHANC_FRAMEWORK_ROOT "" CACHE STRING "Path to the Orthanc source directory, if ORTHANC_FRAMEWORK_SOURCE is \"path\"")
 
+add_definitions(
+  -DORTHANC_ENABLE_LOGGING_PLUGIN=0
+  )
+
 
 #####################################################################
 ## Build a static library containing the Orthanc Stone framework
@@ -208,7 +216,6 @@
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/AppStatus.h
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/MainWidgetInteractor.cpp
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/MainWidgetInteractor.h
-      ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/Messages.h
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/SimpleViewerApplication.cpp
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/SimpleViewerApplication.h
       ${ORTHANC_STONE_ROOT}/Applications/Samples/SimpleViewer/ThumbnailInteractor.cpp

--- a/Applications/Samples/SampleApplicationBase.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SampleApplicationBase.h	Mon Jun 24 14:35:00 2019 +0200
@@ -22,7 +22,7 @@
 #pragma once
 
 #include "../../Applications/IStoneApplication.h"
-#include "../../Framework/Widgets/WorldSceneWidget.h"
+#include "../../Framework/Deprecated/Widgets/WorldSceneWidget.h"
 
 #if ORTHANC_ENABLE_WASM==1
 #include "../../Platforms/Wasm/WasmPlatformApplicationAdapter.h"

--- a/Applications/Samples/SimpleViewer/MainWidgetInteractor.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SimpleViewer/MainWidgetInteractor.h	Mon Jun 24 14:35:00 2019 +0200
@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "Framework/Widgets/IWorldSceneInteractor.h"
+#include "../../../Framework/Deprecated/Widgets/IWorldSceneInteractor.h"
 
 using namespace OrthancStone;
 

--- a/Applications/Samples/SimpleViewer/SimpleViewerApplication.cpp	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SimpleViewer/SimpleViewerApplication.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -61,7 +61,7 @@
 
       // sources
       smartLoader_.reset(new Deprecated::SmartLoader(IObserver::GetBroker(), context->GetOrthancApiClient()));
-      smartLoader_->SetImageQuality(SliceImageQuality_FullPam);
+      smartLoader_->SetImageQuality(Deprecated::SliceImageQuality_FullPam);
 
       mainLayout_->SetTransmitMouseOver(true);
       mainWidgetInteractor_.reset(new MainWidgetInteractor(*this));

--- a/Applications/Samples/SimpleViewer/SimpleViewerApplication.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SimpleViewer/SimpleViewerApplication.h	Mon Jun 24 14:35:00 2019 +0200
@@ -29,12 +29,12 @@
 
 #include "Applications/IStoneApplication.h"
 
-#include "Framework/Layers/CircleMeasureTracker.h"
-#include "Framework/Layers/LineMeasureTracker.h"
-#include "Framework/Widgets/SliceViewerWidget.h"
-#include "Framework/Widgets/LayoutWidget.h"
-#include "Framework/Messages/IObserver.h"
-#include "Framework/SmartLoader.h"
+#include "../../../Framework/Deprecated/Layers/CircleMeasureTracker.h"
+#include "../../../Framework/Deprecated/Layers/LineMeasureTracker.h"
+#include "../../../Framework/Deprecated/SmartLoader.h"
+#include "../../../Framework/Deprecated/Widgets/LayoutWidget.h"
+#include "../../../Framework/Deprecated/Widgets/SliceViewerWidget.h"
+#include "../../../Framework/Messages/IObserver.h"
 
 #if ORTHANC_ENABLE_WASM==1
 #include "Platforms/Wasm/WasmPlatformApplicationAdapter.h"

--- a/Applications/Samples/SimpleViewer/ThumbnailInteractor.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SimpleViewer/ThumbnailInteractor.h	Mon Jun 24 14:35:00 2019 +0200
@@ -21,7 +21,7 @@
 
 #pragma once
 
-#include "Framework/Widgets/IWorldSceneInteractor.h"
+#include "../../../Framework/Deprecated/Widgets/IWorldSceneInteractor.h"
 
 using namespace OrthancStone;
 

--- a/Applications/Samples/SimpleViewerApplicationSingleFile.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SimpleViewerApplicationSingleFile.h	Mon Jun 24 14:35:00 2019 +0200
@@ -23,12 +23,12 @@
 
 #include "SampleApplicationBase.h"
 
-#include "../../Framework/Layers/CircleMeasureTracker.h"
-#include "../../Framework/Layers/LineMeasureTracker.h"
-#include "../../Framework/Widgets/SliceViewerWidget.h"
-#include "../../Framework/Widgets/LayoutWidget.h"
+#include "../../Framework/Deprecated/Layers/CircleMeasureTracker.h"
+#include "../../Framework/Deprecated/Layers/LineMeasureTracker.h"
+#include "../../Framework/Deprecated/SmartLoader.h"
+#include "../../Framework/Deprecated/Widgets/LayoutWidget.h"
+#include "../../Framework/Deprecated/Widgets/SliceViewerWidget.h"
 #include "../../Framework/Messages/IObserver.h"
-#include "../../Framework/SmartLoader.h"
 
 #if ORTHANC_ENABLE_WASM==1
 #include "../../Platforms/Wasm/WasmPlatformApplicationAdapter.h"
@@ -312,7 +312,7 @@
 
           // sources
           smartLoader_.reset(new Deprecated::SmartLoader(GetBroker(), context->GetOrthancApiClient()));
-          smartLoader_->SetImageQuality(SliceImageQuality_FullPam);
+          smartLoader_->SetImageQuality(Deprecated::SliceImageQuality_FullPam);
 
           mainLayout_->SetTransmitMouseOver(true);
           mainWidgetInteractor_.reset(new MainWidgetInteractor(*this));

--- a/Applications/Samples/SingleFrameApplication.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/SingleFrameApplication.h	Mon Jun 24 14:35:00 2019 +0200
@@ -23,8 +23,8 @@
 
 #include "SampleApplicationBase.h"
 
-#include "../../Framework/Layers/DicomSeriesVolumeSlicer.h"
-#include "../../Framework/Widgets/SliceViewerWidget.h"
+#include "../../Framework/Deprecated/Layers/DicomSeriesVolumeSlicer.h"
+#include "../../Framework/Deprecated/Widgets/SliceViewerWidget.h"
 
 #include <Core/Logging.h>
 #include <Core/OrthancException.h>

--- a/Applications/Samples/rt-viewer-demo/CMakeLists.txt	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Samples/rt-viewer-demo/CMakeLists.txt	Mon Jun 24 14:35:00 2019 +0200
@@ -81,6 +81,7 @@
 
 endif()
 
+
 #####################################################################
 ## Configuration for Orthanc
 #####################################################################
@@ -97,6 +98,10 @@
 set(ORTHANC_FRAMEWORK_ARCHIVE "" CACHE STRING "Path to the Orthanc archive, if ORTHANC_FRAMEWORK_SOURCE is \"archive\"")
 set(ORTHANC_FRAMEWORK_ROOT "" CACHE STRING "Path to the Orthanc source directory, if ORTHANC_FRAMEWORK_SOURCE is \"path\"")
 
+add_definitions(
+  -DORTHANC_ENABLE_LOGGING_PLUGIN=0
+  )
+
 
 #####################################################################
 ## Build a static library containing the Orthanc Stone framework

--- a/Applications/Sdl/SdlCairoSurface.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Sdl/SdlCairoSurface.h	Mon Jun 24 14:35:00 2019 +0200
@@ -24,8 +24,8 @@
 #if ORTHANC_ENABLE_SDL == 1
 
 #include "SdlWindow.h"
-#include "../../Framework/Viewport/CairoSurface.h"
-#include "../../Framework/Viewport/IViewport.h"
+#include "../../Framework/Wrappers/CairoSurface.h"
+#include "../../Framework/Deprecated/Viewport/IViewport.h"
 
 #include <boost/thread/mutex.hpp>
 

--- a/Applications/Sdl/SdlStoneApplicationRunner.cpp	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/Sdl/SdlStoneApplicationRunner.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -25,7 +25,6 @@
 
 #include "SdlStoneApplicationRunner.h"
 
-#include "../../Framework/Toolbox/MessagingToolbox.h"
 #include "../../Platforms/Generic/OracleWebService.h"
 #include "SdlEngine.h"
 

--- a/Applications/StoneApplicationContext.h	Wed Jun 19 17:36:33 2019 +0200
+++ b/Applications/StoneApplicationContext.h	Mon Jun 24 14:35:00 2019 +0200
@@ -21,10 +21,10 @@
 
 #pragma once
 
-#include "../Framework/Toolbox/IWebService.h"
-#include "../Framework/Toolbox/IDelayedCallExecutor.h"
-#include "../Framework/Toolbox/OrthancApiClient.h"
-#include "../Framework/Viewport/WidgetViewport.h"
+#include "../Framework/Deprecated/Toolbox/IWebService.h"
+#include "../Framework/Deprecated/Toolbox/IDelayedCallExecutor.h"
+#include "../Framework/Deprecated/Toolbox/OrthancApiClient.h"
+#include "../Framework/Deprecated/Viewport/WidgetViewport.h"
 
 
 #ifdef _MSC_VER

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/CircleMeasureTracker.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,106 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "CircleMeasureTracker.h"
+
+#include <stdio.h>
+#include <boost/math/constants/constants.hpp>
+
+namespace Deprecated
+{
+  CircleMeasureTracker::CircleMeasureTracker(IStatusBar* statusBar,
+                                             const OrthancStone::CoordinateSystem3D& slice,
+                                             double x, 
+                                             double y,
+                                             uint8_t red,
+                                             uint8_t green,
+                                             uint8_t blue,
+                                             const Orthanc::Font& font) :
+    statusBar_(statusBar),
+    slice_(slice),
+    x1_(x),
+    y1_(y),
+    x2_(x),
+    y2_(y),
+    font_(font)
+  {
+    color_[0] = red;
+    color_[1] = green;
+    color_[2] = blue;
+  }
+    
+
+  void CircleMeasureTracker::Render(OrthancStone::CairoContext& context,
+                                    double zoom)
+  {
+    double x = (x1_ + x2_) / 2.0;
+    double y = (y1_ + y2_) / 2.0;
+
+    OrthancStone::Vector tmp;
+    OrthancStone::LinearAlgebra::AssignVector(tmp, x2_ - x1_, y2_ - y1_);
+    double r = boost::numeric::ublas::norm_2(tmp) / 2.0;
+
+    context.SetSourceColor(color_[0], color_[1], color_[2]);
+
+    cairo_t* cr = context.GetObject();
+    cairo_save(cr);
+    cairo_set_line_width(cr, 2.0 / zoom);
+    cairo_translate(cr, x, y);
+    cairo_arc(cr, 0, 0, r, 0, 2.0 * boost::math::constants::pi<double>());
+    cairo_stroke_preserve(cr);
+    cairo_stroke(cr);
+    cairo_restore(cr);
+
+    context.DrawText(font_, FormatRadius(), x, y, OrthancStone::BitmapAnchor_Center);
+  }
+    
+
+  double CircleMeasureTracker::GetRadius() const  // In millimeters
+  {
+    OrthancStone::Vector a = slice_.MapSliceToWorldCoordinates(x1_, y1_);
+    OrthancStone::Vector b = slice_.MapSliceToWorldCoordinates(x2_, y2_);
+    return boost::numeric::ublas::norm_2(b - a) / 2.0;
+  }
+
+
+  std::string CircleMeasureTracker::FormatRadius() const
+  {
+    char buf[64];
+    sprintf(buf, "%0.01f cm", GetRadius() / 10.0);
+    return buf;
+  }
+
+  void CircleMeasureTracker::MouseMove(int displayX,
+                                       int displayY,
+                                       double x,
+                                       double y,
+                                       const std::vector<Touch>& displayTouches,
+                                       const std::vector<Touch>& sceneTouches)
+  {
+    x2_ = x;
+    y2_ = y;
+
+    if (statusBar_ != NULL)
+    {
+      statusBar_->SetMessage("Circle radius: " + FormatRadius());
+    }
+  }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/CircleMeasureTracker.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,78 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+#include "../Widgets/IWorldSceneMouseTracker.h"
+#include "../Viewport/IStatusBar.h"
+#include "../../Toolbox/CoordinateSystem3D.h"
+
+#include <Core/Images/Font.h>
+
+namespace Deprecated
+{
+  class CircleMeasureTracker : public IWorldSceneMouseTracker
+  {
+  private:
+    IStatusBar*           statusBar_;
+    OrthancStone::CoordinateSystem3D    slice_;
+    double                x1_;
+    double                y1_;
+    double                x2_;
+    double                y2_;
+    uint8_t               color_[3];
+    const Orthanc::Font&  font_;
+
+  public:
+    CircleMeasureTracker(IStatusBar* statusBar,
+                         const OrthancStone::CoordinateSystem3D& slice,
+                         double x, 
+                         double y,
+                         uint8_t red,
+                         uint8_t green,
+                         uint8_t blue,
+                         const Orthanc::Font& font);
+    
+    virtual bool HasRender() const
+    {
+      return true;
+    }
+
+    virtual void Render(OrthancStone::CairoContext& context,
+                        double zoom);
+    
+    double GetRadius() const;  // In millimeters
+
+    std::string FormatRadius() const;
+
+    virtual void MouseUp()
+    {
+      // Possibly create a new landmark "volume" with the circle in subclasses
+    }
+
+    virtual void MouseMove(int displayX,
+                           int displayY,
+                           double x,
+                           double y,
+                           const std::vector<Touch>& displayTouches,
+                           const std::vector<Touch>& sceneTouches);
+  };
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/ColorFrameRenderer.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,62 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "ColorFrameRenderer.h"
+
+#include <Core/OrthancException.h>
+#include <Core/Images/Image.h>
+#include <Core/Images/ImageProcessing.h>
+
+namespace Deprecated
+{
+  OrthancStone::CairoSurface* ColorFrameRenderer::GenerateDisplay(const RenderStyle& style)
+  {
+    std::auto_ptr<OrthancStone::CairoSurface> display
+      (new OrthancStone::CairoSurface(frame_->GetWidth(), frame_->GetHeight(), false /* no alpha */));
+
+    Orthanc::ImageAccessor target;
+    display->GetWriteableAccessor(target);
+    
+    Orthanc::ImageProcessing::Convert(target, *frame_);
+
+    return display.release();
+  }
+
+
+  ColorFrameRenderer::ColorFrameRenderer(const Orthanc::ImageAccessor& frame,
+                                         const OrthancStone::CoordinateSystem3D& framePlane,
+                                         double pixelSpacingX,
+                                         double pixelSpacingY,
+                                         bool isFullQuality) :
+    FrameRenderer(framePlane, pixelSpacingX, pixelSpacingY, isFullQuality),
+    frame_(Orthanc::Image::Clone(frame))
+  {
+    if (frame_.get() == NULL)
+    {
+      throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+    }
+
+    if (frame_->GetFormat() != Orthanc::PixelFormat_RGB24)
+    {
+      throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
+    }
+  }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/ColorFrameRenderer.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,43 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+#include "FrameRenderer.h"
+
+namespace Deprecated
+{
+  class ColorFrameRenderer : public FrameRenderer
+  {
+  private:
+    std::auto_ptr<Orthanc::ImageAccessor>   frame_;  // In RGB24
+
+  protected:
+    virtual OrthancStone::CairoSurface* GenerateDisplay(const RenderStyle& style);
+
+  public:
+    ColorFrameRenderer(const Orthanc::ImageAccessor& frame,
+                       const OrthancStone::CoordinateSystem3D& framePlane,
+                       double pixelSpacingX,
+                       double pixelSpacingY,
+                       bool isFullQuality);
+  };
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/DicomSeriesVolumeSlicer.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,162 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "DicomSeriesVolumeSlicer.h"
+
+#include "FrameRenderer.h"
+#include "../Toolbox/DicomFrameConverter.h"
+
+#include <Core/Logging.h>
+#include <Core/OrthancException.h>
+
+#include <boost/lexical_cast.hpp>
+
+namespace Deprecated
+{
+
+  void DicomSeriesVolumeSlicer::OnSliceGeometryReady(const OrthancSlicesLoader::SliceGeometryReadyMessage& message)
+  {
+    if (message.GetOrigin().GetSlicesCount() > 0)
+    {
+      BroadcastMessage(IVolumeSlicer::GeometryReadyMessage(*this));
+    }
+    else
+    {
+      BroadcastMessage(IVolumeSlicer::GeometryErrorMessage(*this));
+    }
+  }
+
+  void DicomSeriesVolumeSlicer::OnSliceGeometryError(const OrthancSlicesLoader::SliceGeometryErrorMessage& message)
+  {
+    BroadcastMessage(IVolumeSlicer::GeometryErrorMessage(*this));
+  }
+
+
+  class DicomSeriesVolumeSlicer::RendererFactory : public LayerReadyMessage::IRendererFactory
+  {
+  private:
+    const OrthancSlicesLoader::SliceImageReadyMessage&  message_;
+
+  public:
+    RendererFactory(const OrthancSlicesLoader::SliceImageReadyMessage& message) :
+      message_(message)
+    {
+    }
+
+    virtual ILayerRenderer* CreateRenderer() const
+    {
+      bool isFull = (message_.GetEffectiveQuality() == SliceImageQuality_FullPng ||
+                     message_.GetEffectiveQuality() == SliceImageQuality_FullPam);
+
+      return FrameRenderer::CreateRenderer(message_.GetImage(), message_.GetSlice(), isFull);
+    }
+  };
+
+  void DicomSeriesVolumeSlicer::OnSliceImageReady(const OrthancSlicesLoader::SliceImageReadyMessage& message)
+  {
+    // first notify that the pixel data of the frame is ready (targeted to, i.e: an image cache)
+    BroadcastMessage(FrameReadyMessage(*this, message.GetImage(), 
+                                  message.GetEffectiveQuality(), message.GetSlice()));
+
+    // then notify that the layer is ready for rendering
+    RendererFactory factory(message);
+    BroadcastMessage(IVolumeSlicer::LayerReadyMessage(*this, factory, message.GetSlice().GetGeometry()));
+  }
+
+  void DicomSeriesVolumeSlicer::OnSliceImageError(const OrthancSlicesLoader::SliceImageErrorMessage& message)
+  {
+    BroadcastMessage(IVolumeSlicer::LayerErrorMessage(*this, message.GetSlice().GetGeometry()));
+  }
+
+
+  DicomSeriesVolumeSlicer::DicomSeriesVolumeSlicer(OrthancStone::MessageBroker& broker,
+                                                   OrthancApiClient& orthanc) :
+    IVolumeSlicer(broker),
+    IObserver(broker),
+    loader_(broker, orthanc),
+    quality_(SliceImageQuality_FullPng)
+  {
+    loader_.RegisterObserverCallback(
+      new OrthancStone::Callable<DicomSeriesVolumeSlicer, OrthancSlicesLoader::SliceGeometryReadyMessage>
+        (*this, &DicomSeriesVolumeSlicer::OnSliceGeometryReady));
+
+    loader_.RegisterObserverCallback(
+      new OrthancStone::Callable<DicomSeriesVolumeSlicer, OrthancSlicesLoader::SliceGeometryErrorMessage>
+      (*this, &DicomSeriesVolumeSlicer::OnSliceGeometryError));
+
+    loader_.RegisterObserverCallback(
+      new OrthancStone::Callable<DicomSeriesVolumeSlicer, OrthancSlicesLoader::SliceImageReadyMessage>
+        (*this, &DicomSeriesVolumeSlicer::OnSliceImageReady));
+
+    loader_.RegisterObserverCallback(
+      new OrthancStone::Callable<DicomSeriesVolumeSlicer, OrthancSlicesLoader::SliceImageErrorMessage>
+      (*this, &DicomSeriesVolumeSlicer::OnSliceImageError));
+  }
+
+  
+  void DicomSeriesVolumeSlicer::LoadSeries(const std::string& seriesId)
+  {
+    loader_.ScheduleLoadSeries(seriesId);
+  }
+
+
+  void DicomSeriesVolumeSlicer::LoadInstance(const std::string& instanceId)
+  {
+    loader_.ScheduleLoadInstance(instanceId);
+  }
+
+
+  void DicomSeriesVolumeSlicer::LoadFrame(const std::string& instanceId,
+                                          unsigned int frame)
+  {
+    loader_.ScheduleLoadFrame(instanceId, frame);
+  }
+
+
+  bool DicomSeriesVolumeSlicer::GetExtent(std::vector<OrthancStone::Vector>& points,
+                                          const OrthancStone::CoordinateSystem3D& viewportSlice)
+  {
+    size_t index;
+
+    if (loader_.IsGeometryReady() &&
+        loader_.LookupSlice(index, viewportSlice))
+    {
+      loader_.GetSlice(index).GetExtent(points);
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  
+  void DicomSeriesVolumeSlicer::ScheduleLayerCreation(const OrthancStone::CoordinateSystem3D& viewportSlice)
+  {
+    size_t index;
+
+    if (loader_.IsGeometryReady() &&
+        loader_.LookupSlice(index, viewportSlice))
+    {
+      loader_.ScheduleLoadSliceImage(index, quality_);
+    }
+  }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/DicomSeriesVolumeSlicer.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,127 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+#include "IVolumeSlicer.h"
+#include "../Toolbox/IWebService.h"
+#include "../Toolbox/OrthancSlicesLoader.h"
+#include "../Toolbox/OrthancApiClient.h"
+
+namespace Deprecated
+{  
+  // this class is in charge of loading a Frame.
+  // once it's been loaded (first the geometry and then the image),
+  // messages are sent to observers so they can use it
+  class DicomSeriesVolumeSlicer :
+    public IVolumeSlicer,
+    public OrthancStone::IObserver
+    //private OrthancSlicesLoader::ISliceLoaderObserver
+  {
+  public:
+    // TODO: Add "frame" and "instanceId"
+    class FrameReadyMessage : public OrthancStone::OriginMessage<DicomSeriesVolumeSlicer>
+    {
+      ORTHANC_STONE_MESSAGE(__FILE__, __LINE__);
+      
+    private:
+      const Orthanc::ImageAccessor&  frame_;
+      SliceImageQuality              imageQuality_;
+      const Slice&                   slice_;
+
+    public:
+      FrameReadyMessage(DicomSeriesVolumeSlicer& origin,
+                        const Orthanc::ImageAccessor& frame,
+                        SliceImageQuality imageQuality,
+                        const Slice& slice) :
+        OriginMessage(origin),
+        frame_(frame),
+        imageQuality_(imageQuality),
+        slice_(slice)
+      {
+      }
+
+      const Orthanc::ImageAccessor& GetFrame() const
+      {
+        return frame_;
+      }
+
+      SliceImageQuality GetImageQuality() const
+      {
+        return imageQuality_;
+      }
+
+      const Slice& GetSlice() const
+      {
+        return slice_;
+      }
+    };
+
+    
+  private:
+    class RendererFactory;
+    
+    OrthancSlicesLoader  loader_;
+    SliceImageQuality    quality_;
+
+  public:
+    DicomSeriesVolumeSlicer(OrthancStone::MessageBroker& broker,
+                            OrthancApiClient& orthanc);
+
+    void LoadSeries(const std::string& seriesId);
+
+    void LoadInstance(const std::string& instanceId);
+
+    void LoadFrame(const std::string& instanceId,
+                   unsigned int frame);
+
+    void SetImageQuality(SliceImageQuality quality)
+    {
+      quality_ = quality;
+    }
+
+    SliceImageQuality GetImageQuality() const
+    {
+      return quality_;
+    }
+
+    size_t GetSlicesCount() const
+    {
+      return loader_.GetSlicesCount();
+    }
+
+    const Slice& GetSlice(size_t slice) const 
+    {
+      return loader_.GetSlice(slice);
+    }
+
+    virtual bool GetExtent(std::vector<OrthancStone::Vector>& points,
+                           const OrthancStone::CoordinateSystem3D& viewportSlice);
+
+    virtual void ScheduleLayerCreation(const OrthancStone::CoordinateSystem3D& viewportSlice);
+
+protected:
+    void OnSliceGeometryReady(const OrthancSlicesLoader::SliceGeometryReadyMessage& message);
+    void OnSliceGeometryError(const OrthancSlicesLoader::SliceGeometryErrorMessage& message);
+    void OnSliceImageReady(const OrthancSlicesLoader::SliceImageReadyMessage& message);
+    void OnSliceImageError(const OrthancSlicesLoader::SliceImageErrorMessage& message);
+  };
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/DicomStructureSetSlicer.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,170 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "DicomStructureSetSlicer.h"
+
+namespace Deprecated
+{
+  class DicomStructureSetSlicer::Renderer : public ILayerRenderer
+  {
+  private:
+    class Structure
+    {
+    private:
+      bool                                                         visible_;
+      uint8_t                                                      red_;
+      uint8_t                                                      green_;
+      uint8_t                                                      blue_;
+      std::string                                                  name_;
+      std::vector< std::vector<OrthancStone::DicomStructureSet::PolygonPoint> >  polygons_;
+
+    public:
+      Structure(OrthancStone::DicomStructureSet& structureSet,
+                const OrthancStone::CoordinateSystem3D& plane,
+                size_t index) :
+        name_(structureSet.GetStructureName(index))
+      {
+        structureSet.GetStructureColor(red_, green_, blue_, index);
+        visible_ = structureSet.ProjectStructure(polygons_, index, plane);
+      }
+
+      void Render(OrthancStone::CairoContext& context)
+      {
+        if (visible_)
+        {
+          cairo_t* cr = context.GetObject();
+        
+          context.SetSourceColor(red_, green_, blue_);
+
+          for (size_t i = 0; i < polygons_.size(); i++)
+          {
+            cairo_move_to(cr, polygons_[i][0].first, polygons_[i][0].second);
+
+            for (size_t j = 1; j < polygons_[i].size(); j++)
+            {
+              cairo_line_to(cr, polygons_[i][j].first, polygons_[i][j].second);
+            }
+
+            cairo_line_to(cr, polygons_[i][0].first, polygons_[i][0].second);
+            cairo_stroke(cr);
+          }
+        }
+      }
+    };
+
+    typedef std::list<Structure*>  Structures;
+    
+    OrthancStone::CoordinateSystem3D  plane_;
+    Structures          structures_;
+    
+  public:
+    Renderer(OrthancStone::DicomStructureSet& structureSet,
+             const OrthancStone::CoordinateSystem3D& plane) :
+      plane_(plane)
+    {
+      for (size_t k = 0; k < structureSet.GetStructuresCount(); k++)
+      {
+        structures_.push_back(new Structure(structureSet, plane, k));
+      }
+    }
+
+    virtual ~Renderer()
+    {
+      for (Structures::iterator it = structures_.begin();
+           it != structures_.end(); ++it)
+      {
+        delete *it;
+      }
+    }
+
+    virtual bool RenderLayer(OrthancStone::CairoContext& context,
+                             const ViewportGeometry& view)
+    {
+      cairo_set_line_width(context.GetObject(), 2.0f / view.GetZoom());
+
+      for (Structures::const_iterator it = structures_.begin();
+           it != structures_.end(); ++it)
+      {
+        assert(*it != NULL);
+        (*it)->Render(context);
+      }
+
+      return true;
+    }
+
+    virtual const OrthancStone::CoordinateSystem3D& GetLayerPlane()
+    {
+      return plane_;
+    }
+
+    virtual void SetLayerStyle(const RenderStyle& style)
+    {
+    }
+    
+    virtual bool IsFullQuality()
+    {
+      return true;
+    }
+  };
+
+
+  class DicomStructureSetSlicer::RendererFactory : public LayerReadyMessage::IRendererFactory
+  {
+  private:
+    OrthancStone::DicomStructureSet&         structureSet_;
+    const OrthancStone::CoordinateSystem3D&  plane_;
+
+  public:
+    RendererFactory(OrthancStone::DicomStructureSet& structureSet,
+                    const OrthancStone::CoordinateSystem3D&  plane) :
+      structureSet_(structureSet),
+      plane_(plane)
+    {
+    }
+
+    virtual ILayerRenderer* CreateRenderer() const
+    {
+      return new Renderer(structureSet_, plane_);
+    }
+  };
+  
+
+  DicomStructureSetSlicer::DicomStructureSetSlicer(OrthancStone::MessageBroker& broker,
+                                                   StructureSetLoader& loader) :
+    IVolumeSlicer(broker),
+    IObserver(broker),
+    loader_(loader)
+  {
+    loader_.RegisterObserverCallback(
+      new OrthancStone::Callable<DicomStructureSetSlicer, StructureSetLoader::ContentChangedMessage>
+      (*this, &DicomStructureSetSlicer::OnStructureSetLoaded));
+  }
+
+
+  void DicomStructureSetSlicer::ScheduleLayerCreation(const OrthancStone::CoordinateSystem3D& viewportPlane)
+  {
+    if (loader_.HasStructureSet())
+    {
+      RendererFactory factory(loader_.GetStructureSet(), viewportPlane);
+      BroadcastMessage(IVolumeSlicer::LayerReadyMessage(*this, factory, viewportPlane));
+    }
+  }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/DicomStructureSetSlicer.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,56 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+#include "IVolumeSlicer.h"
+#include "../Volumes/StructureSetLoader.h"
+
+namespace Deprecated
+{
+  class DicomStructureSetSlicer :
+    public IVolumeSlicer,
+    public OrthancStone::IObserver
+  {
+  private:
+    class Renderer;
+    class RendererFactory;
+
+    StructureSetLoader& loader_;
+
+    void OnStructureSetLoaded(const IVolumeLoader::ContentChangedMessage& message)
+    {
+      BroadcastMessage(IVolumeSlicer::ContentChangedMessage(*this));
+    }
+
+  public:
+    DicomStructureSetSlicer(OrthancStone::MessageBroker& broker,
+                            StructureSetLoader& loader);
+
+    virtual bool GetExtent(std::vector<OrthancStone::Vector>& points,
+                           const OrthancStone::CoordinateSystem3D& viewportPlane)
+    {
+      return false;
+    }
+
+    virtual void ScheduleLayerCreation(const OrthancStone::CoordinateSystem3D& viewportPlane);
+  };
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/FrameRenderer.cpp	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,140 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "FrameRenderer.h"
+
+#include "GrayscaleFrameRenderer.h"
+#include "ColorFrameRenderer.h"
+
+#include <Core/OrthancException.h>
+
+namespace Deprecated
+{
+  FrameRenderer::FrameRenderer(const OrthancStone::CoordinateSystem3D& framePlane,
+                               double pixelSpacingX,
+                               double pixelSpacingY,
+                               bool isFullQuality) :
+    framePlane_(framePlane),
+    pixelSpacingX_(pixelSpacingX),
+    pixelSpacingY_(pixelSpacingY),
+    isFullQuality_(isFullQuality)
+  {
+  }
+
+
+  bool FrameRenderer::RenderLayer(OrthancStone::CairoContext& context,
+                                  const ViewportGeometry& view)
+  {    
+    if (!style_.visible_)
+    {
+      return true;
+    }
+
+    if (display_.get() == NULL)
+    {
+      display_.reset(GenerateDisplay(style_));
+    }
+
+    assert(display_.get() != NULL);
+
+    cairo_t *cr = context.GetObject();
+
+    cairo_save(cr);
+
+    cairo_matrix_t transform;
+    cairo_matrix_init_identity(&transform);
+    cairo_matrix_scale(&transform, pixelSpacingX_, pixelSpacingY_);
+    cairo_matrix_translate(&transform, -0.5, -0.5);
+    cairo_transform(cr, &transform);
+
+    //cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+    cairo_set_source_surface(cr, display_->GetObject(), 0, 0);
+
+    switch (style_.interpolation_)
+    {
+      case OrthancStone::ImageInterpolation_Nearest:
+        cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
+        break;
+
+      case OrthancStone::ImageInterpolation_Bilinear:
+        cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_BILINEAR);
+        break;
+
+      default:
+        throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+    }
+
+    cairo_paint_with_alpha(cr, style_.alpha_);
+
+    if (style_.drawGrid_)
+    {
+      context.SetSourceColor(style_.drawColor_);
+      cairo_set_line_width(cr, 0.5 / view.GetZoom());
+
+      for (unsigned int x = 0; x <= display_->GetWidth(); x++)
+      {
+        cairo_move_to(cr, x, 0);
+        cairo_line_to(cr, x, display_->GetHeight());
+      }
+
+      for (unsigned int y = 0; y <= display_->GetHeight(); y++)
+      {
+        cairo_move_to(cr, 0, y);
+        cairo_line_to(cr, display_->GetWidth(), y);
+      }
+
+      cairo_stroke(cr);
+    }
+
+    cairo_restore(cr);
+
+    return true;
+  }
+
+
+  void FrameRenderer::SetLayerStyle(const RenderStyle& style)
+  {
+    style_ = style;
+    display_.reset(NULL);
+  }
+
+
+  ILayerRenderer* FrameRenderer::CreateRenderer(const Orthanc::ImageAccessor& frame,
+                                                const Deprecated::Slice& framePlane,
+                                                bool isFullQuality)
+  {
+    if (frame.GetFormat() == Orthanc::PixelFormat_RGB24)
+    {
+      return new ColorFrameRenderer(frame,
+                                    framePlane.GetGeometry(), 
+                                    framePlane.GetPixelSpacingX(),
+                                    framePlane.GetPixelSpacingY(), isFullQuality);
+    }
+    else
+    {
+      return new GrayscaleFrameRenderer(frame,
+                                        framePlane.GetConverter(),
+                                        framePlane.GetGeometry(), 
+                                        framePlane.GetPixelSpacingX(),
+                                        framePlane.GetPixelSpacingY(), isFullQuality);
+    }
+  }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Deprecated/Layers/FrameRenderer.h	Mon Jun 24 14:35:00 2019 +0200
@@ -0,0 +1,69 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+#include "ILayerRenderer.h"
+
+#include "../Toolbox/Slice.h"
+
+namespace Deprecated
+{
+  class FrameRenderer : public ILayerRenderer
+  {
+  private:
+    OrthancStone::CoordinateSystem3D            framePlane_;
+    double                        pixelSpacingX_;
+    double                        pixelSpacingY_;
+    RenderStyle                   style_;
+    bool                          isFullQuality_;
+    std::auto_ptr<OrthancStone::CairoSurface>   display_;
+
+  protected:
+    virtual OrthancStone::CairoSurface* GenerateDisplay(const RenderStyle& style) = 0;
+
+  public:
+    FrameRenderer(const OrthancStone::CoordinateSystem3D& framePlane,
+                  double pixelSpacingX,
+                  double pixelSpacingY,
+                  bool isFullQuality);
+
+    virtual bool RenderLayer(OrthancStone::CairoContext& context,
+                             const ViewportGeometry& view);
+
+    virtual const OrthancStone::CoordinateSystem3D& GetLayerPlane()
+    {
+      return framePlane_;
+    }
+
+    virtual void SetLayerStyle(const RenderStyle& style);
+
+    virtual bool IsFullQuality() 
+    {
+      return isFullQuality_;
+    }
+
+    // TODO: Avoid cloning the "frame"
+    static ILayerRenderer* CreateRenderer(const Orthanc::ImageAccessor& frame,
+                                          const Deprecated::Slice& framePlane,
+                                          bool isFullQuality);
+  };
+}