orthanc-stone: Applications/Generic/GuiAdapter.cpp comparison

comparison Applications/Generic/GuiAdapter.cpp @ 880:9953f16c304d am-dev

Merge

author	Alain Mazy <alain@mazy.be>
date	Fri, 05 Jul 2019 15:33:02 +0200
parents	12b591d5d63c 60a403f01c31
children	64e5f3ff6360

comparison

equal deleted inserted replaced

-:12b591d5d63c
+:9953f16c304d
 }
 std::ostream& operator<<(
 std::ostream& os, const GuiAdapterKeyboardEvent& event)
 {
-os << "ctrl: " << event.ctrlKey << ", " <<
+os << "sym: " << event.sym << " (" << (int)(event.sym[0]) << ") ctrl: " << event.ctrlKey << ", " <<
 "shift: " << event.shiftKey << ", " <<
 "alt: " << event.altKey;
 return os;
 }
 //dest.canvasX = src.canvasX;
 //dest.canvasY = src.canvasY;
 //dest.padding = src.padding;
 }
-void ConvertFromPlatform(
+void ConvertFromPlatform( GuiAdapterWheelEvent& dest, int eventType, const EmscriptenWheelEvent& src)
-GuiAdapterWheelEvent& dest,
-int                         eventType,
-const EmscriptenWheelEvent& src)
 {
 ConvertFromPlatform(dest.mouse, eventType, src.mouse);
 dest.deltaX = src.deltaX;
 dest.deltaY = src.deltaY;
 switch (src.deltaMode)
 " in wheel event...");
 }
 dest.deltaMode = src.deltaMode;
 }
-void ConvertFromPlatform(
+void ConvertFromPlatform(GuiAdapterKeyboardEvent& dest, const EmscriptenKeyboardEvent& src)
-GuiAdapterKeyboardEvent& dest,
+{
-const EmscriptenKeyboardEvent& src)
+dest.sym[0] = src.key[0];
-{
+dest.sym[1] = 0;
 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);
 }
 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);
 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;
 #endif
 #else
 // SDL ONLY
-void ConvertFromPlatform(
+void ConvertFromPlatform(GuiAdapterMouseEvent& dest, bool ctrlPressed, bool shiftPressed, bool altPressed, const SDL_Event& source)
-GuiAdapterMouseEvent& dest,
+{
-bool ctrlPressed, bool shiftPressed, bool altPressed,
+memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
-const SDL_Event& source)
+switch (source.type)
 {
-memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
+case SDL_MOUSEBUTTONDOWN:
-switch (source.type)
+dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
-{
+break;
-case SDL_MOUSEBUTTONDOWN:
+case SDL_MOUSEMOTION:
-dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
+dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
 break;
-case SDL_MOUSEMOTION:
+case SDL_MOUSEBUTTONUP:
-dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
+dest.type = GUIADAPTER_EVENT_MOUSEUP;
 break;
-case SDL_MOUSEBUTTONUP:
+case SDL_MOUSEWHEEL:
-dest.type = GUIADAPTER_EVENT_MOUSEUP;
+dest.type = GUIADAPTER_EVENT_WHEEL;
 break;
-case SDL_MOUSEWHEEL:
+default:
-dest.type = GUIADAPTER_EVENT_WHEEL;
+LOG(ERROR) << "SDL event: " << source.type << " is not supported";
-break;
+ORTHANC_ASSERT(false, "Not supported");
-default:
+}
-LOG(ERROR) << "SDL event: " << source.type << " is not supported";
+//dest.timestamp = src.timestamp;
-ORTHANC_ASSERT(false, "Not supported");
+//dest.screenX = src.screenX;
-}
+//dest.screenY = src.screenY;
-//dest.timestamp = src.timestamp;
+//dest.clientX = src.clientX;
-//dest.screenX = src.screenX;
+//dest.clientY = src.clientY;
-//dest.screenY = src.screenY;
+dest.ctrlKey = ctrlPressed;
-//dest.clientX = src.clientX;
+dest.shiftKey = shiftPressed;
-//dest.clientY = src.clientY;
+dest.altKey = altPressed;
-dest.ctrlKey = ctrlPressed;
+//dest.metaKey = src.metaKey;
-dest.shiftKey = shiftPressed;
+switch (source.button.button)
-dest.altKey = altPressed;
+{
-//dest.metaKey = src.metaKey;
+case SDL_BUTTON_MIDDLE:
-switch (source.button.button)
+dest.button =GUIADAPTER_MOUSEBUTTON_MIDDLE;
-{
+break;
-case SDL_BUTTON_MIDDLE:
-dest.button = GUIADAPTER_MOUSEBUTTON_MIDDLE;
+case SDL_BUTTON_RIGHT:
-break;
+dest.button = GUIADAPTER_MOUSEBUTTON_RIGHT;
+break;
-case SDL_BUTTON_RIGHT:
-dest.button = GUIADAPTER_MOUSEBUTTON_RIGHT;
+case SDL_BUTTON_LEFT:
-break;
+dest.button = GUIADAPTER_MOUSEBUTTON_LEFT;
+break;
-case SDL_BUTTON_LEFT:
-dest.button = GUIADAPTER_MOUSEBUTTON_LEFT;
+default:
 break;
+}
-default:
+//dest.buttons = src.buttons;
-break;
+//dest.movementX = src.movementX;
-}
+//dest.movementY = src.movementY;
-//dest.buttons = src.buttons;
+dest.targetX = source.button.x;
-//dest.movementX = src.movementX;
+dest.targetY = source.button.y;
-//dest.movementY = src.movementY;
+//dest.canvasX = src.canvasX;
-dest.targetX = source.button.x;
+//dest.canvasY = src.canvasY;
-dest.targetY = source.button.y;
+//dest.padding = src.padding;
-//dest.canvasX = src.canvasX;
+}
-//dest.canvasY = src.canvasY;
-//dest.padding = src.padding;
+void ConvertFromPlatform(
-}
+GuiAdapterWheelEvent& dest,
+bool ctrlPressed, bool shiftPressed, bool altPressed,
-void ConvertFromPlatform(
+const SDL_Event& source)
-GuiAdapterWheelEvent& dest,
+{
-bool ctrlPressed, bool shiftPressed, bool altPressed,
+ConvertFromPlatform(dest.mouse, ctrlPressed, shiftPressed, altPressed, source);
-const SDL_Event& source)
+dest.deltaX = source.wheel.x;
-{
+dest.deltaY = source.wheel.y;
-ConvertFromPlatform(dest.mouse, ctrlPressed, shiftPressed, altPressed, source);
+}
-dest.deltaX = source.wheel.x;
-dest.deltaY = source.wheel.y;
+void ConvertFromPlatform(GuiAdapterKeyboardEvent& dest, const SDL_Event& src)
-}
+{
+memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
+switch (src.type)
+{
+case SDL_KEYDOWN:
+dest.type = GUIADAPTER_EVENT_KEYDOWN;
+break;
+case SDL_KEYUP:
+dest.type = GUIADAPTER_EVENT_KEYUP;
+break;
+default:
+LOG(ERROR) << "SDL event: " << src.type << " is not supported";
+ORTHANC_ASSERT(false, "Not supported");
+}
+dest.sym[0] = src.key.keysym.sym;
+dest.sym[1] = 0;
+if (src.key.keysym.mod & KMOD_CTRL)
+dest.ctrlKey = true;
+else
+dest.ctrlKey = false;
+if (src.key.keysym.mod & KMOD_SHIFT)
+dest.shiftKey = true;
+else
+dest.shiftKey = false;
+if (src.key.keysym.mod & KMOD_ALT)
+dest.altKey = true;
+else
+dest.altKey = false;
+}
 // SDL ONLY
 void GuiAdapter::SetResizeCallback(
 }
 // 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)
 {
-}
+keyDownHandlers_.push_back(EventHandlerData<OnKeyDownFunc>(canvasId, func, userData));
+}
 // SDL ONLY
 void GuiAdapter::SetKeyUpCallback(
 std::string canvasId, void* userData, bool capture, OnKeyUpFunc    func)
 {
-}
+keyUpHandlers_.push_back(EventHandlerData<OnKeyUpFunc>(canvasId, func, userData));
+}
 // SDL ONLY
 void GuiAdapter::OnAnimationFrame()
 {
 for (size_t i = 0; i < animationFrameHandlers_.size(); i++)
 switch (event.mouse.type)
 {
 case GUIADAPTER_EVENT_WHEEL:
 for (size_t i = 0; i < mouseWheelHandlers_.size(); i++)
 {
-if(mouseWheelHandlers_[i].canvasName == windowTitle)
+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)
+void GuiAdapter::OnKeyboardEvent(uint32_t windowID, const GuiAdapterKeyboardEvent& event)
 {
-// the SDL window name IS the canvas name ("canvas" is used because this lib
+// only one-letter (ascii) keyboard events supported for now
-// is designed for Wasm
+ORTHANC_ASSERT(event.sym[0] != 0);
+ORTHANC_ASSERT(event.sym[1] == 0);
 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:
+case GUIADAPTER_EVENT_KEYDOWN:
-for (size_t i = 0; i < mouseDownHandlers_.size(); i++)
+for (size_t i = 0; i < keyDownHandlers_.size(); i++)
 {
-if (mouseDownHandlers_[i].canvasName == windowTitle)
+(*(keyDownHandlers_[i].func))(windowTitle, &event, keyDownHandlers_[i].userData);
-(*(mouseDownHandlers_[i].func))(windowTitle, &event, mouseDownHandlers_[i].userData);
 }
 break;
-case GUIADAPTER_EVENT_MOUSEMOVE:
+case GUIADAPTER_EVENT_KEYUP:
-for (size_t i = 0; i < mouseMoveHandlers_.size(); i++)
+for (size_t i = 0; i < keyUpHandlers_.size(); i++)
 {
-if (mouseMoveHandlers_[i].canvasName == windowTitle)
+(*(keyUpHandlers_[i].func))(windowTitle, &event, keyUpHandlers_[i].userData);
-(*(mouseMoveHandlers_[i].func))(windowTitle, &event, mouseMoveHandlers_[i].userData);
 }
 break;
-case GUIADAPTER_EVENT_MOUSEUP:
+default:
-for (size_t i = 0; i < mouseUpHandlers_.size(); i++)
+ORTHANC_ASSERT(false, "Wrong event.type: " << event.type << " in GuiAdapter::OnKeyboardEvent(...)");
+break;
+}
+}
+// SDL ONLY
+void GuiAdapter::OnMouseEvent(uint32_t windowID, const GuiAdapterMouseEvent& event)
+{
+if (windowID == 0)
+{
+LOG(WARNING) << "GuiAdapter::OnMouseEvent -- windowID == 0 and event won't be routed!";
+}
+else
+{
+// 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)
 {
-if (mouseUpHandlers_[i].canvasName == windowTitle)
+case GUIADAPTER_EVENT_MOUSEDOWN:
-(*(mouseUpHandlers_[i].func))(windowTitle, &event, mouseUpHandlers_[i].userData);
+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;
 }
-break;
-default:
+////boost::shared_ptr<IGuiAdapterWidget> GetWidgetFromWindowId();
-ORTHANC_ASSERT(false, "Wrong event.type: " << event.type << " in GuiAdapter::OnMouseEvent(...)");
+//boost::shared_ptr<IGuiAdapterWidget> foundWidget;
-break;
+//VisitWidgets([foundWidget, windowID](auto widget)
-}
+//  {
+//    if (widget->GetSdlWindowID() == windowID)
-////boost::shared_ptr<IGuiAdapterWidget> GetWidgetFromWindowId();
+//      foundWidget = widget;
-//boost::shared_ptr<IGuiAdapterWidget> foundWidget;
+//  });
-//VisitWidgets([foundWidget, windowID](auto widget)
+//ORTHANC_ASSERT(foundWidget, "WindowID " << windowID << " was not found in the registered widgets!");
-//  {
+//if(foundWidget)
-//    if (widget->GetSdlWindowID() == windowID)
+//  foundWidget->
-//      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)
 {
 OpenGLMessageCallback(GLenum source,
 GLenum type,
 GLuint id,
 GLenum severity,
 GLsizei length,
-const GLchar* message,
+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()
 {
 {
 // TODO: call exit callbacks here
 stop = true;
 break;
 }
-else if ( (event.type == SDL_MOUSEMOTION) ||
+else if ((event.type == SDL_MOUSEMOTION) ||
 (event.type == SDL_MOUSEBUTTONDOWN) ||
-(event.type == SDL_MOUSEBUTTONUP) )
+(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
 {
 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:
+GuiAdapterKeyboardEvent dest;
+ConvertFromPlatform(dest, event);
+OnKeyboardEvent(event.window.windowID, dest);
 break;
 }
 }
 //        HandleApplicationEvent(controller, compositor, event, tracker);
 }

Mercurial > hg > orthanc-stone

comparison Applications/Generic/GuiAdapter.cpp @ 880:9953f16c304d am-dev