# HG changeset patch # User Alain Mazy # Date 1562333582 -7200 # Node ID 9953f16c304dbe2c10adf2fdc8cfa363ef6eb369 # Parent 12b591d5d63cf45e086d7f1fba16f9488ce2a127# Parent 4bc8d9609447376985c129780b22c597503d8805 Merge diff -r 12b591d5d63c -r 9953f16c304d .hgtags --- a/.hgtags Fri Jul 05 14:52:43 2019 +0200 +++ b/.hgtags Fri Jul 05 15:33:02 2019 +0200 @@ -1,2 +1,6 @@ 90f3a60576a9f08dcf783752a7f67ce0615a5371 rtviewer19 6d15261f9c9965a2f4b64658e318b370933b175e toa2019061901 +ff3559c489c98fad1ed174f7be919df6c20d36a9 toa2019062401 +c71ef52602a00dbb35f2b6bd7bd5ed516f1014fa toa2019062501 +fe96057e97b94eb8a46c1a33ba350c354b5c4afc toa2019062502 +60a403f01c3112249f9d4a1a6149bef1de9766bf toa2019062503 diff -r 12b591d5d63c -r 9953f16c304d Applications/Generic/GuiAdapter.cpp --- a/Applications/Generic/GuiAdapter.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Applications/Generic/GuiAdapter.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -44,7 +44,7 @@ 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; @@ -112,10 +112,7 @@ //dest.padding = src.padding; } - void ConvertFromPlatform( - GuiAdapterWheelEvent& dest, - int eventType, - const EmscriptenWheelEvent& src) + void ConvertFromPlatform( GuiAdapterWheelEvent& dest, int eventType, const EmscriptenWheelEvent& src) { ConvertFromPlatform(dest.mouse, eventType, src.mouse); dest.deltaX = src.deltaX; @@ -138,15 +135,15 @@ dest.deltaMode = src.deltaMode; } - void ConvertFromPlatform( - GuiAdapterKeyboardEvent& dest, - const EmscriptenKeyboardEvent& src) + void ConvertFromPlatform(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 struct FuncAdapterPayload { @@ -156,10 +153,10 @@ }; template - EM_BOOL OnEventAdapterFunc( - int eventType, const EmscriptenEvent* emEvent, void* userData) + typename GuiAdapterEvent, + typename EmscriptenEvent> + EM_BOOL OnEventAdapterFunc( + int eventType, const EmscriptenEvent* emEvent, void* userData) { // userData is OnMouseWheelFuncAdapterPayload @@ -170,7 +167,7 @@ // 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); @@ -186,7 +183,7 @@ // userData is OnMouseWheelFuncAdapterPayload FuncAdapterPayload* payload = reinterpret_cast*>(userData); - + GuiAdapterEvent guiEvent; ConvertFromPlatform(guiEvent, *wheelEvent); bool ret = (*(payload->callback))(payload->canvasId, &guiEvent, payload->userData); @@ -194,8 +191,8 @@ } template - EM_BOOL OnEventAdapterFunc3( - double time, void* userData) + EM_BOOL OnEventAdapterFunc3( + double time, void* userData) { // userData is OnMouseWheelFuncAdapterPayload FuncAdapterPayload* payload = @@ -207,17 +204,17 @@ // resize: (const char* target, void* userData, EM_BOOL useCapture, em_ui_callback_func callback) template< - typename GenericFunc, - typename GuiAdapterEvent, - typename EmscriptenEvent, + typename GenericFunc, + typename GuiAdapterEvent, + typename EmscriptenEvent, typename EmscriptenSetCallbackFunc> - static void SetCallback( - EmscriptenSetCallbackFunc emFunc, - std::string canvasId, void* userData, bool capture, GenericFunc func) + 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* payload = + FuncAdapterPayload* payload = new FuncAdapterPayload(); std::auto_ptr > payloadP(payload); payload->canvasId = canvasId; @@ -397,76 +394,107 @@ #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) + // SDL ONLY + void ConvertFromPlatform(GuiAdapterMouseEvent& dest, bool ctrlPressed, bool shiftPressed, bool altPressed, const SDL_Event& source) { - 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"); + 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 = GUIADAPTER_MOUSEBUTTON_MIDDLE; - break; + //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 =GUIADAPTER_MOUSEBUTTON_MIDDLE; + break; - case SDL_BUTTON_RIGHT: - dest.button = GUIADAPTER_MOUSEBUTTON_RIGHT; - break; + case SDL_BUTTON_RIGHT: + dest.button = GUIADAPTER_MOUSEBUTTON_RIGHT; + break; - case SDL_BUTTON_LEFT: - dest.button = GUIADAPTER_MOUSEBUTTON_LEFT; - break; + case SDL_BUTTON_LEFT: + dest.button = GUIADAPTER_MOUSEBUTTON_LEFT; + 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; + 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; -} + 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; + } + + 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; + } @@ -480,43 +508,44 @@ // SDL ONLY void GuiAdapter::SetMouseDownCallback( std::string canvasId, void* userData, bool capture, OnMouseEventFunc func) - { + { mouseDownHandlers_.push_back(EventHandlerData(canvasId, func, userData)); - } + } // SDL ONLY void GuiAdapter::SetMouseMoveCallback( std::string canvasId, void* userData, bool capture, OnMouseEventFunc func) - { + { mouseMoveHandlers_.push_back(EventHandlerData(canvasId, func, userData)); } // SDL ONLY void GuiAdapter::SetMouseUpCallback( std::string canvasId, void* userData, bool capture, OnMouseEventFunc func) - { + { mouseUpHandlers_.push_back(EventHandlerData(canvasId, func, userData)); } // SDL ONLY void GuiAdapter::SetWheelCallback( - std::string canvasId, void* userData, bool capture, OnMouseWheelFunc func) + std::string canvasId, void* userData, bool capture, OnMouseWheelFunc func) { mouseWheelHandlers_.push_back(EventHandlerData(canvasId, func, userData)); } // SDL ONLY void GuiAdapter::SetKeyDownCallback( - std::string canvasId, void* userData, bool capture, OnKeyDownFunc func) - { - } + std::string canvasId, void* userData, bool capture, OnKeyDownFunc func) + { + keyDownHandlers_.push_back(EventHandlerData(canvasId, func, userData)); + } // SDL ONLY void GuiAdapter::SetKeyUpCallback( - std::string canvasId, void* userData, bool capture, OnKeyUpFunc func) - { - } - + std::string canvasId, void* userData, bool capture, OnKeyUpFunc func) + { + keyUpHandlers_.push_back(EventHandlerData(canvasId, func, userData)); + } // SDL ONLY void GuiAdapter::OnAnimationFrame() @@ -558,7 +587,7 @@ 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; @@ -568,14 +597,16 @@ } } - // 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 - // is designed for Wasm + // only one-letter (ascii) keyboard events supported for now + 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!"); @@ -584,42 +615,84 @@ switch (event.type) { - case GUIADAPTER_EVENT_MOUSEDOWN: - for (size_t i = 0; i < mouseDownHandlers_.size(); i++) + case GUIADAPTER_EVENT_KEYDOWN: + for (size_t i = 0; i < keyDownHandlers_.size(); i++) { - if (mouseDownHandlers_[i].canvasName == windowTitle) - (*(mouseDownHandlers_[i].func))(windowTitle, &event, mouseDownHandlers_[i].userData); + (*(keyDownHandlers_[i].func))(windowTitle, &event, keyDownHandlers_[i].userData); } break; - case GUIADAPTER_EVENT_MOUSEMOVE: - for (size_t i = 0; i < mouseMoveHandlers_.size(); i++) + case GUIADAPTER_EVENT_KEYUP: + for (size_t i = 0; i < keyUpHandlers_.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); + (*(keyUpHandlers_[i].func))(windowTitle, &event, keyUpHandlers_[i].userData); } break; default: - ORTHANC_ASSERT(false, "Wrong event.type: " << event.type << " in GuiAdapter::OnMouseEvent(...)"); + ORTHANC_ASSERT(false, "Wrong event.type: " << event.type << " in GuiAdapter::OnKeyboardEvent(...)"); break; } + } - ////boost::shared_ptr GetWidgetFromWindowId(); - //boost::shared_ptr 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::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) + { + 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 GetWidgetFromWindowId(); + //boost::shared_ptr 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 @@ -637,7 +710,7 @@ GLuint id, GLenum severity, GLsizei length, - const GLchar* message, + const GLchar * message, const void* userParam) { if (severity != GL_DEBUG_SEVERITY_NOTIFICATION) @@ -646,7 +719,7 @@ (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""), type, severity, message); } -} + } # endif // SDL ONLY @@ -680,16 +753,16 @@ stop = true; break; } - else if ( (event.type == SDL_MOUSEMOTION) || - (event.type == SDL_MOUSEBUTTONDOWN) || - (event.type == SDL_MOUSEBUTTONUP) ) + 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]) @@ -700,7 +773,7 @@ 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); @@ -768,23 +841,14 @@ // 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_castFitContent(); - }); -#endif - break; - case SDLK_q: stop = true; break; default: + GuiAdapterKeyboardEvent dest; + ConvertFromPlatform(dest, event); + OnKeyboardEvent(event.window.windowID, dest); break; } } diff -r 12b591d5d63c -r 9953f16c304d Applications/Generic/GuiAdapter.h --- a/Applications/Generic/GuiAdapter.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Applications/Generic/GuiAdapter.h Fri Jul 05 15:33:02 2019 +0200 @@ -75,12 +75,14 @@ }; - enum GuiAdapterMouseEventType + enum GuiAdapterHidEventType { GUIADAPTER_EVENT_MOUSEDOWN = 1973, GUIADAPTER_EVENT_MOUSEMOVE = 1974, GUIADAPTER_EVENT_MOUSEUP = 1975, - GUIADAPTER_EVENT_WHEEL = 1976 + GUIADAPTER_EVENT_WHEEL = 1976, + GUIADAPTER_EVENT_KEYDOWN = 1977, + GUIADAPTER_EVENT_KEYUP = 1978, }; const unsigned int GUIADAPTER_DELTA_PIXEL = 2973; @@ -124,8 +126,9 @@ #endif #endif - struct GuiAdapterMouseEvent { - GuiAdapterMouseEventType type; + struct GuiAdapterMouseEvent + { + GuiAdapterHidEventType type; //double timestamp; //long screenX; //long screenY; @@ -168,6 +171,8 @@ // EmscriptenKeyboardEvent struct GuiAdapterKeyboardEvent { + GuiAdapterHidEventType type; + char sym[32]; bool ctrlKey; bool shiftKey; bool altKey; @@ -193,37 +198,21 @@ 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(GuiAdapterUiEvent& dest, int eventType, const EmscriptenUiEvent& src); - void ConvertFromPlatform( - GuiAdapterMouseEvent& dest, - int eventType, - const EmscriptenMouseEvent& src); + void ConvertFromPlatform(GuiAdapterMouseEvent& dest, int eventType, const EmscriptenMouseEvent& src); - void ConvertFromPlatform( - GuiAdapterWheelEvent& dest, - int eventType, - const EmscriptenWheelEvent& src); + void ConvertFromPlatform(GuiAdapterWheelEvent& dest, int eventType, const EmscriptenWheelEvent& src); - void ConvertFromPlatform( - GuiAdapterKeyboardEvent& dest, - const EmscriptenKeyboardEvent& 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(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); + void ConvertFromPlatform(GuiAdapterWheelEvent& dest, bool ctrlPressed, bool shiftPressed, bool altPressed, const SDL_Event& source); + + void ConvertFromPlatform(GuiAdapterKeyboardEvent& dest, const SDL_Event& source); # endif @@ -342,14 +331,17 @@ std::vector > mouseMoveHandlers_; std::vector > mouseUpHandlers_; std::vector > mouseWheelHandlers_; - + std::vector > keyDownHandlers_; + std::vector > keyUpHandlers_; /** This executes all the registered headers if needed (in wasm, the browser deals with this) */ void OnMouseEvent(uint32_t windowID, const GuiAdapterMouseEvent& event); - + + void OnKeyboardEvent(uint32_t windowID, const GuiAdapterKeyboardEvent& event); + /** Same remark as OnMouseEvent */ diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2D/ScenePoint2D.h --- a/Framework/Scene2D/ScenePoint2D.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2D/ScenePoint2D.h Fri Jul 05 15:33:02 2019 +0200 @@ -13,7 +13,7 @@ * 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 . **/ @@ -22,7 +22,7 @@ #pragma once #include "../Toolbox/AffineTransform2D.h" - +#include "../Toolbox/LinearAlgebra.h" namespace OrthancStone { @@ -40,7 +40,7 @@ } ScenePoint2D(double x, - double y) : + double y) : x_(x), y_(y) { @@ -63,5 +63,83 @@ t.Apply(x, y); return ScenePoint2D(x, y); } + + const ScenePoint2D operator-(const ScenePoint2D& a) const + { + ScenePoint2D v; + v.x_ = x_ - a.x_; + v.y_ = y_ - a.y_; + + return v; + } + + const ScenePoint2D operator+(const ScenePoint2D& a) const + { + ScenePoint2D v; + v.x_ = x_ + a.x_; + v.y_ = y_ + a.y_; + + return v; + } + + const ScenePoint2D operator*(double a) const + { + ScenePoint2D v; + v.x_ = x_ * a; + v.y_ = y_ * a; + + return v; + } + + static double Dot(const ScenePoint2D& a, const ScenePoint2D& b) + { + return a.x_ * b.x_ + a.y_ * b.y_; + } + + static double SquaredDistancePtPt(const ScenePoint2D& a, const ScenePoint2D& b) + { + ScenePoint2D n = b - a; + return Dot(n, n); + } + + /** + Distance from point p to [a,b] segment + + Rewritten from https://www.randygaul.net/2014/07/23/distance-point-to-line-segment/ + */ + static double SquaredDistancePtSegment(const ScenePoint2D& a, const ScenePoint2D& b, const ScenePoint2D& p) + { + ScenePoint2D n = b - a; + ScenePoint2D pa = a - p; + + double c = Dot(n, pa); + + // Closest point is a + if (c > 0.0) + return Dot(pa, pa); + + ScenePoint2D bp = p - b; + + // Closest point is b + if (Dot(n, bp) > 0.0) + return Dot(bp, bp); + + // if segment length is very short, we approximate distance to the + // distance with a + double nq = Dot(n, n); + if (LinearAlgebra::IsCloseToZero(nq)) + { + // segment is very small: approximate distance from point to segment + // with distance from p to a + return Dot(pa, pa); + } + else + { + // Closest point is between a and b + ScenePoint2D e = pa - n * (c / nq); + return Dot(e, e); + } + } }; } + diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/AngleMeasureTool.cpp --- a/Framework/Scene2DViewport/AngleMeasureTool.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/AngleMeasureTool.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -20,6 +20,7 @@ #include "AngleMeasureTool.h" #include "MeasureToolsToolbox.h" +#include "EditAngleMeasureTracker.h" #include "LayerHolder.h" #include @@ -43,6 +44,7 @@ MessageBroker& broker, boost::weak_ptr controllerW) : MeasureTool(broker, controllerW) , layerHolder_(boost::make_shared(controllerW,1,5)) + , angleHighlightArea_(AngleHighlightArea_None) { } @@ -75,10 +77,109 @@ RefreshScene(); } + void AngleMeasureTool::SetAngleHighlightArea(AngleHighlightArea area) + { + if (angleHighlightArea_ != area) + { + angleHighlightArea_ = area; + RefreshScene(); + } + } + + void AngleMeasureTool::ResetHighlightState() + { + SetAngleHighlightArea(AngleHighlightArea_None); + } + + + boost::shared_ptr AngleMeasureTool::GetMemento() const + { + boost::shared_ptr memento(new AngleMeasureToolMemento()); + memento->center_ = center_; + memento->side1End_ = side1End_; + memento->side2End_ = side2End_; + return memento; + } + + void AngleMeasureTool::SetMemento(boost::shared_ptr mementoBase) + { + boost::shared_ptr memento = boost::dynamic_pointer_cast(mementoBase); + ORTHANC_ASSERT(memento.get() != NULL, "Internal error: wrong (or bad) memento"); + center_ = memento->center_; + side1End_ = memento->side1End_; + side2End_ = memento->side2End_; + RefreshScene(); + } + + void AngleMeasureTool::Highlight(ScenePoint2D p) + { + AngleHighlightArea angleHighlightArea = AngleHitTest(p); + SetAngleHighlightArea(angleHighlightArea); + } + + AngleMeasureTool::AngleHighlightArea AngleMeasureTool::AngleHitTest(ScenePoint2D p) const + { + const double pixelToScene = + GetScene()->GetCanvasToSceneTransform().ComputeZoom(); + const double SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD = pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD * pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD; + + { + const double sqDistanceFromSide1End = ScenePoint2D::SquaredDistancePtPt(p, side1End_); + if (sqDistanceFromSide1End <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return AngleHighlightArea_Side1End; + } + + { + const double sqDistanceFromSide2End = ScenePoint2D::SquaredDistancePtPt(p, side2End_); + if (sqDistanceFromSide2End <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return AngleHighlightArea_Side2End; + } + + { + const double sqDistanceFromCenter = ScenePoint2D::SquaredDistancePtPt(p, center_); + if (sqDistanceFromCenter <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return AngleHighlightArea_Center; + } + + { + const double sqDistanceFromSide1 = ScenePoint2D::SquaredDistancePtSegment(center_, side1End_, p); + if (sqDistanceFromSide1 <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return AngleHighlightArea_Side1; + } + + { + const double sqDistanceFromSide2 = ScenePoint2D::SquaredDistancePtSegment(center_, side2End_, p); + if (sqDistanceFromSide2 <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return AngleHighlightArea_Side2; + } + + return AngleHighlightArea_None; + } bool AngleMeasureTool::HitTest(ScenePoint2D p) const { - throw std::logic_error("The method or operation is not implemented."); + return AngleHitTest(p) != AngleHighlightArea_None; + } + + + boost::shared_ptr AngleMeasureTool::CreateEditionTracker(const PointerEvent& e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); + + if (!HitTest(scenePos)) + return boost::shared_ptr(); + + /** + new EditLineMeasureTracker( + boost::shared_ptr measureTool; + MessageBroker & broker, + boost::weak_ptr controllerW, + const PointerEvent & e); + */ + boost::shared_ptr editAngleMeasureTracker( + new EditAngleMeasureTracker(shared_from_this(), GetBroker(), GetController(), e)); + return editAngleMeasureTracker; } void AngleMeasureTool::SetCenter(ScenePoint2D pt) @@ -101,7 +202,8 @@ PolylineSceneLayer* polylineLayer = layerHolder_->GetPolylineLayer(0); polylineLayer->ClearAllChains(); - const Color color(0, 183, 17); + const Color color(TOOL_ANGLE_LINES_COLOR_RED, TOOL_ANGLE_LINES_COLOR_GREEN, TOOL_ANGLE_LINES_COLOR_BLUE); + const Color highlightColor(TOOL_ANGLE_LINES_HL_COLOR_RED, TOOL_ANGLE_LINES_HL_COLOR_GREEN, TOOL_ANGLE_LINES_HL_COLOR_BLUE); // sides { @@ -109,13 +211,20 @@ PolylineSceneLayer::Chain chain; chain.push_back(side1End_); chain.push_back(center_); - polylineLayer->AddChain(chain, false, color); + + if ((angleHighlightArea_ == AngleHighlightArea_Side1) || (angleHighlightArea_ == AngleHighlightArea_Side2)) + polylineLayer->AddChain(chain, false, highlightColor); + else + polylineLayer->AddChain(chain, false, color); } { PolylineSceneLayer::Chain chain; chain.push_back(side2End_); chain.push_back(center_); - polylineLayer->AddChain(chain, false, color); + if ((angleHighlightArea_ == AngleHighlightArea_Side1) || (angleHighlightArea_ == AngleHighlightArea_Side2)) + polylineLayer->AddChain(chain, false, highlightColor); + else + polylineLayer->AddChain(chain, false, color); } } @@ -126,14 +235,23 @@ //TODO: take DPI into account AddSquare(chain, GetScene(), side1End_, GetController()->GetHandleSideLengthS()); - polylineLayer->AddChain(chain, true, color); + + if (angleHighlightArea_ == AngleHighlightArea_Side1End) + polylineLayer->AddChain(chain, true, highlightColor); + else + polylineLayer->AddChain(chain, true, color); + } { PolylineSceneLayer::Chain chain; //TODO: take DPI into account AddSquare(chain, GetScene(), side2End_, GetController()->GetHandleSideLengthS()); - polylineLayer->AddChain(chain, true, color); + + if (angleHighlightArea_ == AngleHighlightArea_Side2End) + polylineLayer->AddChain(chain, true, highlightColor); + else + polylineLayer->AddChain(chain, true, color); } } @@ -143,7 +261,10 @@ AddShortestArc(chain, side1End_, center_, side2End_, controller->GetAngleToolArcRadiusS()); - polylineLayer->AddChain(chain, false, color); + if (angleHighlightArea_ == AngleHighlightArea_Center) + polylineLayer->AddChain(chain, false, highlightColor); + else + polylineLayer->AddChain(chain, false, color); } } { diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/AngleMeasureTool.h --- a/Framework/Scene2DViewport/AngleMeasureTool.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/AngleMeasureTool.h Fri Jul 05 15:33:02 2019 +0200 @@ -30,13 +30,14 @@ #include #include +#include #include #include namespace OrthancStone { - class AngleMeasureTool : public MeasureTool + class AngleMeasureTool : public MeasureTool, public boost::enable_shared_from_this { public: AngleMeasureTool(MessageBroker& broker, boost::weak_ptr controllerW); @@ -47,18 +48,45 @@ void SetCenter(ScenePoint2D start); void SetSide2End(ScenePoint2D start); + virtual bool HitTest(ScenePoint2D p) const ORTHANC_OVERRIDE; + virtual void Highlight(ScenePoint2D p) ORTHANC_OVERRIDE; + virtual void ResetHighlightState() ORTHANC_OVERRIDE; + virtual boost::shared_ptr CreateEditionTracker(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual boost::shared_ptr GetMemento() const ORTHANC_OVERRIDE; + virtual void SetMemento(boost::shared_ptr) ORTHANC_OVERRIDE; - virtual bool HitTest(ScenePoint2D p) const ORTHANC_OVERRIDE; + enum AngleHighlightArea + { + AngleHighlightArea_None, + AngleHighlightArea_Side1End, + AngleHighlightArea_Side1, + AngleHighlightArea_Side2End, + AngleHighlightArea_Side2, + AngleHighlightArea_Center + }; + + + AngleHighlightArea AngleHitTest(ScenePoint2D p) const; private: virtual void RefreshScene() ORTHANC_OVERRIDE; void RemoveFromScene(); + void SetAngleHighlightArea(AngleHighlightArea area); private: - ScenePoint2D side1End_; - ScenePoint2D side2End_; - ScenePoint2D center_; + ScenePoint2D side1End_; + ScenePoint2D side2End_; + ScenePoint2D center_; boost::shared_ptr layerHolder_; + AngleHighlightArea angleHighlightArea_; + }; + + class AngleMeasureToolMemento : public MeasureToolMemento + { + public: + ScenePoint2D side1End_; + ScenePoint2D side2End_; + ScenePoint2D center_; }; } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditAngleMeasureCommand.cpp diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditAngleMeasureCommand.h diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditAngleMeasureTracker.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2DViewport/EditAngleMeasureTracker.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -0,0 +1,112 @@ +/** + * 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 . + **/ + +#include "EditAngleMeasureTracker.h" + +namespace OrthancStone +{ + EditAngleMeasureTracker::EditAngleMeasureTracker( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW, + const PointerEvent& e) + : EditMeasureTracker(controllerW, e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); + + modifiedZone_ = measureTool->AngleHitTest(scenePos); + + command_.reset(new EditAngleMeasureCommand(measureTool, broker, controllerW)); + } + + EditAngleMeasureTracker::~EditAngleMeasureTracker() + { + + } + + void EditAngleMeasureTracker::PointerMove(const PointerEvent& e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); + + ScenePoint2D delta = scenePos - GetOriginalClickPosition(); + + boost::shared_ptr memento = + boost::dynamic_pointer_cast(command_->mementoOriginal_); + + ORTHANC_ASSERT(memento.get() != NULL); + + switch (modifiedZone_) + { + case AngleMeasureTool::AngleHighlightArea_Center: + { + ScenePoint2D newCenter = memento->center_ + delta; + GetCommand()->SetCenter(newCenter); + } + break; + case AngleMeasureTool::AngleHighlightArea_Side1: + case AngleMeasureTool::AngleHighlightArea_Side2: + { + ScenePoint2D newCenter = memento->center_ + delta; + ScenePoint2D newSide1End = memento->side1End_ + delta; + ScenePoint2D newSide2End = memento->side2End_ + delta; + GetCommand()->SetCenter(newCenter); + GetCommand()->SetSide1End(newSide1End); + GetCommand()->SetSide2End(newSide2End); + } + break; + case AngleMeasureTool::AngleHighlightArea_Side1End: + { + ScenePoint2D newSide1End = memento->side1End_ + delta; + GetCommand()->SetSide1End(newSide1End); + } + break; + case AngleMeasureTool::AngleHighlightArea_Side2End: + { + ScenePoint2D newSide2End = memento->side2End_ + delta; + GetCommand()->SetSide2End(newSide2End); + } + break; + default: + LOG(WARNING) << "Warning: please retry the measuring tool editing operation!"; + break; + } + } + + void EditAngleMeasureTracker::PointerUp(const PointerEvent& e) + { + alive_ = false; + } + + void EditAngleMeasureTracker::PointerDown(const PointerEvent& e) + { + LOG(WARNING) << "Additional touches (fingers, pen, mouse buttons...) " + "are ignored when the edit angle tracker is active"; + } + + boost::shared_ptr EditAngleMeasureTracker::GetCommand() + { + boost::shared_ptr ret = boost::dynamic_pointer_cast(command_); + ORTHANC_ASSERT(ret.get() != NULL, "Internal error in EditAngleMeasureTracker::GetCommand()"); + return ret; + } + +} diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditAngleMeasureTracker.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2DViewport/EditAngleMeasureTracker.h Fri Jul 05 15:33:02 2019 +0200 @@ -0,0 +1,54 @@ +/** + * 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 . + **/ + +#pragma once + +#include "MeasureTrackers.h" + +namespace OrthancStone +{ + class EditAngleMeasureTracker : public EditMeasureTracker + { + public: + /** + When you create this tracker, you need to supply it with the undo stack + where it will store the commands that perform the actual measure tool + creation and modification. + In turn, a container for these commands to store the actual measuring + must be supplied, too + */ + EditAngleMeasureTracker( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW, + const PointerEvent& e); + + ~EditAngleMeasureTracker(); + + virtual void PointerMove(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual void PointerUp(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual void PointerDown(const PointerEvent& e) ORTHANC_OVERRIDE; + + private: + AngleMeasureTool::AngleHighlightArea modifiedZone_; + + boost::shared_ptr GetCommand(); + }; +} diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditLineMeasureCommand.cpp diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditLineMeasureCommand.h diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditLineMeasureTracker.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2DViewport/EditLineMeasureTracker.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -0,0 +1,107 @@ +/** + * 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 . + **/ + +#include "EditLineMeasureTracker.h" + +namespace OrthancStone +{ + EditLineMeasureTracker::EditLineMeasureTracker( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW, + const PointerEvent& e) + : EditMeasureTracker(controllerW, e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); + + modifiedZone_ = measureTool->LineHitTest(scenePos); + + command_.reset( + new EditLineMeasureCommand( + measureTool, + broker, + controllerW)); + } + + EditLineMeasureTracker::~EditLineMeasureTracker() + { + + } + + void EditLineMeasureTracker::PointerMove(const PointerEvent& e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); + + ScenePoint2D delta = scenePos - GetOriginalClickPosition(); + + boost::shared_ptr memento = + boost::dynamic_pointer_cast(command_->mementoOriginal_); + + ORTHANC_ASSERT(memento.get() != NULL); + + switch (modifiedZone_) + { + case LineMeasureTool::LineHighlightArea_Start: + { + ScenePoint2D newStart = memento->start_ + delta; + GetCommand()->SetStart(newStart); + } + break; + case LineMeasureTool::LineHighlightArea_End: + { + ScenePoint2D newEnd = memento->end_ + delta; + GetCommand()->SetEnd(newEnd); + } + break; + case LineMeasureTool::LineHighlightArea_Segment: + { + ScenePoint2D newStart = memento->start_ + delta; + ScenePoint2D newEnd = memento->end_ + delta; + GetCommand()->SetStart(newStart); + GetCommand()->SetEnd(newEnd); + } + break; + default: + LOG(WARNING) << "Warning: please retry the measuring tool editing operation!"; + break; + } + } + + void EditLineMeasureTracker::PointerUp(const PointerEvent& e) + { + alive_ = false; + } + + void EditLineMeasureTracker::PointerDown(const PointerEvent& e) + { + LOG(WARNING) << "Additional touches (fingers, pen, mouse buttons...) " + "are ignored when the edit line tracker is active"; + } + + boost::shared_ptr EditLineMeasureTracker::GetCommand() + { + boost::shared_ptr ret = boost::dynamic_pointer_cast(command_); + ORTHANC_ASSERT(ret.get() != NULL, "Internal error in EditLineMeasureTracker::GetCommand()"); + return ret; + } + +} \ No newline at end of file diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/EditLineMeasureTracker.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2DViewport/EditLineMeasureTracker.h Fri Jul 05 15:33:02 2019 +0200 @@ -0,0 +1,54 @@ +/** + * 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 . + **/ + +#pragma once + +#include "MeasureTrackers.h" + +namespace OrthancStone +{ + class EditLineMeasureTracker : public EditMeasureTracker + { + public: + /** + When you create this tracker, you need to supply it with the undo stack + where it will store the commands that perform the actual measure tool + creation and modification. + In turn, a container for these commands to store the actual measuring + must be supplied, too + */ + EditLineMeasureTracker( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW, + const PointerEvent& e); + + ~EditLineMeasureTracker(); + + virtual void PointerMove(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual void PointerUp(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual void PointerDown(const PointerEvent& e) ORTHANC_OVERRIDE; + + private: + LineMeasureTool::LineHighlightArea modifiedZone_; + + boost::shared_ptr GetCommand(); + }; +} diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/LineMeasureTool.cpp --- a/Framework/Scene2DViewport/LineMeasureTool.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/LineMeasureTool.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -20,6 +20,7 @@ #include "LineMeasureTool.h" #include "MeasureToolsToolbox.h" +#include "EditLineMeasureTracker.h" #include "LayerHolder.h" #include @@ -33,6 +34,7 @@ MessageBroker& broker, boost::weak_ptr controllerW) : MeasureTool(broker, controllerW) , layerHolder_(boost::make_shared(controllerW, 1, 5)) + , lineHighlightArea_(LineHighlightArea_None) { } @@ -72,26 +74,88 @@ RefreshScene(); } - + void LineMeasureTool::SetLineHighlightArea(LineHighlightArea area) + { + if (lineHighlightArea_ != area) + { + lineHighlightArea_ = area; + RefreshScene(); + } + } - bool LineMeasureTool::HitTest(ScenePoint2D p) const + void LineMeasureTool::ResetHighlightState() + { + SetLineHighlightArea(LineHighlightArea_None); + } + + void LineMeasureTool::Highlight(ScenePoint2D p) + { + LineHighlightArea lineHighlightArea = LineHitTest(p); + SetLineHighlightArea(lineHighlightArea); + } + + LineMeasureTool::LineHighlightArea LineMeasureTool::LineHitTest(ScenePoint2D p) const { const double pixelToScene = GetScene()->GetCanvasToSceneTransform().ComputeZoom(); + const double SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD = pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD * pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD; - // the hit test will return true if the supplied point (in scene coords) - // is close to the handle or to the line. + const double sqDistanceFromStart = ScenePoint2D::SquaredDistancePtPt(p, start_); + if (sqDistanceFromStart <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return LineHighlightArea_Start; + + const double sqDistanceFromEnd = ScenePoint2D::SquaredDistancePtPt(p, end_); + if (sqDistanceFromEnd <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return LineHighlightArea_End; + + const double sqDistanceFromPtSegment = ScenePoint2D::SquaredDistancePtSegment(start_, end_, p); + if (sqDistanceFromPtSegment <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD) + return LineHighlightArea_Segment; + + return LineHighlightArea_None; + } - // since the handle is small, a nice approximation is to defined this - // as a threshold on the distance between the point and the handle center. + bool LineMeasureTool::HitTest(ScenePoint2D p) const + { + return LineHitTest(p) != LineHighlightArea_None; + } + + boost::shared_ptr LineMeasureTool::CreateEditionTracker(const PointerEvent& e) + { + ScenePoint2D scenePos = e.GetMainPosition().Apply( + GetScene()->GetCanvasToSceneTransform()); - // this threshold is defined as a constant value in CANVAS units. + if (!HitTest(scenePos)) + return boost::shared_ptr(); + + /** + new EditLineMeasureTracker( + boost::shared_ptr measureTool; + MessageBroker & broker, + boost::weak_ptr controllerW, + const PointerEvent & e); + */ + boost::shared_ptr editLineMeasureTracker( + new EditLineMeasureTracker(shared_from_this(), GetBroker(), GetController(), e)); + return editLineMeasureTracker; + } - // line equation from two points (non-normalized) - // (y0-y1)*x + (x1-x0)*xy + (x0*y1 - x1*y0) = 0 - // - return false; + boost::shared_ptr LineMeasureTool::GetMemento() const + { + boost::shared_ptr memento(new LineMeasureToolMemento()); + memento->start_ = start_; + memento->end_ = end_; + return memento; + } + + void LineMeasureTool::SetMemento(boost::shared_ptr mementoBase) + { + boost::shared_ptr memento = boost::dynamic_pointer_cast(mementoBase); + ORTHANC_ASSERT(memento.get() != NULL, "Internal error: wrong (or bad) memento"); + start_ = memento->start_; + end_ = memento->end_; + RefreshScene(); } void LineMeasureTool::RefreshScene() @@ -112,11 +176,18 @@ TOOL_LINES_COLOR_GREEN, TOOL_LINES_COLOR_BLUE); + const Color highlightColor(TOOL_LINES_HL_COLOR_RED, + TOOL_LINES_HL_COLOR_GREEN, + TOOL_LINES_HL_COLOR_BLUE); + { PolylineSceneLayer::Chain chain; chain.push_back(start_); chain.push_back(end_); - polylineLayer->AddChain(chain, false, color); + if(lineHighlightArea_ == LineHighlightArea_Segment) + polylineLayer->AddChain(chain, false, highlightColor); + else + polylineLayer->AddChain(chain, false, color); } // handles @@ -128,7 +199,10 @@ AddSquare(chain, GetScene(), start_, GetController()->GetHandleSideLengthS()); - polylineLayer->AddChain(chain, true, color); + if (lineHighlightArea_ == LineHighlightArea_Start) + polylineLayer->AddChain(chain, true, highlightColor); + else + polylineLayer->AddChain(chain, true, color); } { @@ -138,7 +212,10 @@ AddSquare(chain, GetScene(), end_, GetController()->GetHandleSideLengthS()); - polylineLayer->AddChain(chain, true, color); + if (lineHighlightArea_ == LineHighlightArea_End) + polylineLayer->AddChain(chain, true, highlightColor); + else + polylineLayer->AddChain(chain, true, color); } } @@ -150,7 +227,7 @@ double squareDist = deltaX * deltaX + deltaY * deltaY; double dist = sqrt(squareDist); char buf[64]; - sprintf(buf, "%0.02f units", dist); + sprintf(buf, "%0.02f mm", dist); // TODO: for now we simply position the text overlay at the middle // of the measuring segment diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/LineMeasureTool.h --- a/Framework/Scene2DViewport/LineMeasureTool.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/LineMeasureTool.h Fri Jul 05 15:33:02 2019 +0200 @@ -28,13 +28,14 @@ #include #include +#include #include #include namespace OrthancStone { - class LineMeasureTool : public MeasureTool + class LineMeasureTool : public MeasureTool, public boost::enable_shared_from_this { public: LineMeasureTool(MessageBroker& broker, boost::weak_ptr controllerW); @@ -47,16 +48,43 @@ virtual bool HitTest(ScenePoint2D p) const ORTHANC_OVERRIDE; + virtual void Highlight(ScenePoint2D p) ORTHANC_OVERRIDE; + virtual void ResetHighlightState() ORTHANC_OVERRIDE; + virtual boost::shared_ptr CreateEditionTracker(const PointerEvent& e) ORTHANC_OVERRIDE; + virtual boost::shared_ptr GetMemento() const ORTHANC_OVERRIDE; + virtual void SetMemento(boost::shared_ptr) ORTHANC_OVERRIDE; + + enum LineHighlightArea + { + LineHighlightArea_None, + LineHighlightArea_Start, + LineHighlightArea_End, + LineHighlightArea_Segment + }; + + + LineHighlightArea LineHitTest(ScenePoint2D p) const; private: virtual void RefreshScene() ORTHANC_OVERRIDE; void RemoveFromScene(); + void SetLineHighlightArea(LineHighlightArea area); + + private: private: - ScenePoint2D start_; - ScenePoint2D end_; - boost::shared_ptr layerHolder_; - int baseLayerIndex_; + ScenePoint2D start_; + ScenePoint2D end_; + boost::shared_ptr layerHolder_; + int baseLayerIndex_; + LineHighlightArea lineHighlightArea_; + }; + + class LineMeasureToolMemento : public MeasureToolMemento + { + public: + ScenePoint2D start_; + ScenePoint2D end_; }; } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureCommands.cpp --- a/Framework/Scene2DViewport/MeasureCommands.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureCommands.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -50,6 +50,30 @@ // we thus leave it as is } + EditMeasureCommand::EditMeasureCommand(boost::shared_ptr measureTool, boost::weak_ptr controllerW) + : TrackerCommand(controllerW) + , mementoOriginal_(measureTool->GetMemento()) + , mementoModified_(measureTool->GetMemento()) + { + + } + + EditMeasureCommand::~EditMeasureCommand() + { + + } + + void EditMeasureCommand::Undo() + { + // simply disable the measure tool upon undo + GetMeasureTool()->SetMemento(mementoOriginal_); + } + + void EditMeasureCommand::Redo() + { + GetMeasureTool()->SetMemento(mementoModified_); + } + CreateLineMeasureCommand::CreateLineMeasureCommand( MessageBroker& broker, boost::weak_ptr controllerW, @@ -67,6 +91,29 @@ measureTool_->SetEnd(scenePos); } + EditLineMeasureCommand::EditLineMeasureCommand( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW) + : EditMeasureCommand(measureTool,controllerW) + , measureTool_(measureTool) + { + } + + + void EditLineMeasureCommand::SetStart(ScenePoint2D scenePos) + { + measureTool_->SetStart(scenePos); + mementoModified_ = measureTool_->GetMemento(); + } + + + void EditLineMeasureCommand::SetEnd(ScenePoint2D scenePos) + { + measureTool_->SetEnd(scenePos); + mementoModified_ = measureTool_->GetMemento(); + } + CreateAngleMeasureCommand::CreateAngleMeasureCommand( MessageBroker& broker, boost::weak_ptr controllerW, @@ -99,4 +146,34 @@ assert(controller); // accessing dead object? return controller; } + + EditAngleMeasureCommand::EditAngleMeasureCommand( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW) + : EditMeasureCommand(measureTool, controllerW) + , measureTool_(measureTool) + { + } + + void EditAngleMeasureCommand::SetCenter(ScenePoint2D scenePos) + { + measureTool_->SetCenter(scenePos); + mementoModified_ = measureTool_->GetMemento(); + } + + + void EditAngleMeasureCommand::SetSide1End(ScenePoint2D scenePos) + { + measureTool_->SetSide1End(scenePos); + mementoModified_ = measureTool_->GetMemento(); + } + + + void EditAngleMeasureCommand::SetSide2End(ScenePoint2D scenePos) + { + measureTool_->SetSide2End(scenePos); + mementoModified_ = measureTool_->GetMemento(); + } + } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureCommands.h --- a/Framework/Scene2DViewport/MeasureCommands.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureCommands.h Fri Jul 05 15:33:02 2019 +0200 @@ -42,6 +42,8 @@ } virtual void Undo() = 0; virtual void Redo() = 0; + + virtual ~TrackerCommand() {}; protected: boost::shared_ptr GetController(); @@ -52,7 +54,7 @@ { public: CreateMeasureCommand(boost::weak_ptr controllerW); - ~CreateMeasureCommand(); + virtual ~CreateMeasureCommand(); virtual void Undo() ORTHANC_OVERRIDE; virtual void Redo() ORTHANC_OVERRIDE; private: @@ -60,6 +62,27 @@ virtual boost::shared_ptr GetMeasureTool() = 0; }; + class EditMeasureCommand : public TrackerCommand + { + public: + EditMeasureCommand(boost::shared_ptr measureTool, boost::weak_ptr controllerW); + virtual ~EditMeasureCommand(); + virtual void Undo() ORTHANC_OVERRIDE; + virtual void Redo() ORTHANC_OVERRIDE; + + /** This memento is the original object state */ + boost::shared_ptr mementoOriginal_; + + private: + /** Must be implemented by the subclasses that edit the actual tool */ + virtual boost::shared_ptr GetMeasureTool() = 0; + + protected: + + /** This memento is updated by the subclasses upon modifications */ + boost::shared_ptr mementoModified_; + }; + class CreateLineMeasureCommand : public CreateMeasureCommand { public: @@ -80,6 +103,26 @@ }; + class EditLineMeasureCommand : public EditMeasureCommand + { + public: + EditLineMeasureCommand( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW); + + void SetStart(ScenePoint2D scenePos); + void SetEnd(ScenePoint2D scenePos); + + private: + virtual boost::shared_ptr GetMeasureTool() ORTHANC_OVERRIDE + { + return measureTool_; + } + boost::shared_ptr measureTool_; + }; + + class CreateAngleMeasureCommand : public CreateMeasureCommand { public: @@ -103,5 +146,31 @@ boost::shared_ptr measureTool_; }; + class EditAngleMeasureCommand : public EditMeasureCommand + { + public: + /** Ctor sets end of side 1*/ + EditAngleMeasureCommand( + boost::shared_ptr measureTool, + MessageBroker& broker, + boost::weak_ptr controllerW); + + /** This method sets center*/ + void SetCenter(ScenePoint2D scenePos); + + /** This method sets end of side 1*/ + void SetSide1End(ScenePoint2D scenePos); + + /** This method sets end of side 2*/ + void SetSide2End(ScenePoint2D scenePos); + + private: + virtual boost::shared_ptr GetMeasureTool() ORTHANC_OVERRIDE + { + return measureTool_; + } + boost::shared_ptr measureTool_; + }; + } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureTool.h --- a/Framework/Scene2DViewport/MeasureTool.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureTool.h Fri Jul 05 15:33:02 2019 +0200 @@ -35,6 +35,9 @@ namespace OrthancStone { + class IFlexiblePointerTracker; + class MeasureToolMemento; + class MeasureTool : public IObserver { public: @@ -71,6 +74,37 @@ measuring tool */ virtual bool HitTest(ScenePoint2D p) const = 0; + + /** + This method must return a memento the captures the tool state (not including + the highlighting state + */ + virtual boost::shared_ptr GetMemento() const = 0; + + /** + This method must apply the supplied memento (this requires RTTI to check + the type) + */ + virtual void SetMemento(boost::shared_ptr) = 0; + + /** + This must create an edition tracker suitable for the supplied click position, + or an empty pointer if no hit test (although this should have been checked + first) + */ + virtual boost::shared_ptr CreateEditionTracker(const PointerEvent& e) = 0; + + /** + Will change the measuring tool to provide visual feedback on the GUI + element that is in the pointer hit zone + */ + virtual void Highlight(ScenePoint2D p) = 0; + + /** + This function must reset the visual highlighted hot zone feedback + */ + virtual void ResetHighlightState() = 0; + protected: MeasureTool(MessageBroker& broker, boost::weak_ptr controllerW); @@ -104,6 +138,13 @@ boost::weak_ptr controllerW_; bool enabled_; }; + + class MeasureToolMemento + { + public: + virtual ~MeasureToolMemento() {}; + }; + } extern void TrackerSample_SetInfoDisplayMessage( diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureToolsToolbox.cpp --- a/Framework/Scene2DViewport/MeasureToolsToolbox.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureToolsToolbox.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -322,4 +322,11 @@ p.GetY() + yoffsets[i] * pixelToScene); } } + + std::ostream& operator<<(std::ostream& os, const ScenePoint2D& p) + { + os << "x = " << p.GetX() << " , y = " << p.GetY(); + return os; + } + } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureToolsToolbox.h --- a/Framework/Scene2DViewport/MeasureToolsToolbox.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureToolsToolbox.h Fri Jul 05 15:33:02 2019 +0200 @@ -33,7 +33,7 @@ void AddSquare(PolylineSceneLayer::Chain& chain, boost::shared_ptr scene, const ScenePoint2D& centerS, - const double& sideLengthS); + const double& sideLengthS); /** Creates an arc centered on c that goes @@ -48,23 +48,23 @@ Warning: the existing chain content will be wiped out. */ void AddShortestArc( - PolylineSceneLayer::Chain& chain - , const ScenePoint2D& p1 - , const ScenePoint2D& c - , const ScenePoint2D& p2 - , const double& radiusS + PolylineSceneLayer::Chain& chain + , const ScenePoint2D& p1 + , const ScenePoint2D& c + , const ScenePoint2D& p2 + , const double& radiusS , const int subdivisionsCount = 63); /** - Creates an arc (open curve) with "numSubdivisions" (N + 1 points) from + Creates an arc (open curve) with "numSubdivisions" (N + 1 points) from start angle to end angle, by following the shortest arc. Warning: the existing chain content will be wiped out. */ void AddShortestArc( - PolylineSceneLayer::Chain& chain - , const ScenePoint2D& centerS - , const double& radiusS + PolylineSceneLayer::Chain& chain + , const ScenePoint2D& centerS + , const double& radiusS , const double startAngleRad , const double endAngleRad , const int subdivisionsCount = 63); @@ -79,24 +79,24 @@ - so that r2 belongs to the p2,c line - so that the distance from c to r2 equals radius - if clockwise is true, the arc is drawn from r1 to r2 with increasing + if clockwise is true, the arc is drawn from r1 to r2 with increasing angle values. Otherwise, the angle values decrease. Warning: the existing chain content will be wiped out. */ void AddArc( - PolylineSceneLayer::Chain& chain - , const Scene2D& scene - , const ScenePoint2D& p1 - , const ScenePoint2D& c - , const ScenePoint2D& p2 - , const double& radiusS + PolylineSceneLayer::Chain & chain + , const Scene2D & scene + , const ScenePoint2D & p1 + , const ScenePoint2D & c + , const ScenePoint2D & p2 + , const double& radiusS , const bool clockwise , const int subdivisionsCount = 63); - + /** - Creates an arc (open curve) with "numSubdivisions" (N + 1 points) from + Creates an arc (open curve) with "numSubdivisions" (N + 1 points) from start angle to end angle with the supplied radius. if clockwise is true, the arc is drawn from start to end by increasing the @@ -107,10 +107,10 @@ Warning: the existing chain content will be wiped out. */ void AddArc( - PolylineSceneLayer::Chain& chain - , const Scene2D& scene + PolylineSceneLayer::Chain& chain + , const Scene2D& scene , const ScenePoint2D& centerS - , const double& radiusS + , const double& radiusS , const double startAngleRad , const double endAngleRad , const bool clockwise @@ -123,9 +123,9 @@ Warning: the existing chain content will be wiped out. */ void AddCircle(PolylineSceneLayer::Chain& chain, - const Scene2D& scene, + const Scene2D& scene, const ScenePoint2D& centerS, - const double& radiusS, + const double& radiusS, const int numSubdivisions = 63); /** @@ -135,10 +135,10 @@ double NormalizeAngle(double angle); /** - Returns the angle magnitude between the p1,c and p2,c lines. + Returns the angle magnitude between the p1,c and p2,c lines. The returned angle is between 0 and 2*pi - If the angle is between 0 and pi, this means that the shortest arc + If the angle is between 0 and pi, this means that the shortest arc from p1 to p2 is clockwise. If the angle is between pi and 2*pi, this means that the shortest arc @@ -146,7 +146,7 @@ */ double MeasureAngle( - const ScenePoint2D& p1 + const ScenePoint2D& p1 , const ScenePoint2D& c , const ScenePoint2D& p2); @@ -163,7 +163,7 @@ to the *smallest* half-plane defined by the [c,p1[ and [c,p2[ half-lines. */ void GetPositionOnBisectingLine( - ScenePoint2D& result + ScenePoint2D& result , const ScenePoint2D& p1 , const ScenePoint2D& c , const ScenePoint2D& p2 @@ -172,14 +172,18 @@ /** This helper is used when drawing text with an outline. - It set the properties for several text layers at once : first the - four outline layers, with a position shift and then the actual main text + It set the properties for several text layers at once : first the + four outline layers, with a position shift and then the actual main text layer. The five text layers are supposed to already exist in the scene, starting - from layerIndex, up to (and not including) layerIndex+5. + from layerIndex, up to (and not including) layerIndex+5. */ void SetTextLayerOutlineProperties( boost::shared_ptr scene, boost::shared_ptr layerHolder, const char* text, ScenePoint2D p); + + + std::ostream& operator<<(std::ostream& os, const ScenePoint2D& p); } + diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureTrackers.cpp --- a/Framework/Scene2DViewport/MeasureTrackers.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureTrackers.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -46,7 +46,6 @@ { // if the tracker completes successfully, we add the command // to the undo stack - // otherwise, we simply undo it if (commitResult_) controllerW_.lock()->PushCommand(command_); @@ -59,6 +58,41 @@ return controllerW_.lock()->GetScene(); } + EditMeasureTracker::EditMeasureTracker(boost::weak_ptr controllerW, const PointerEvent& e) + : controllerW_(controllerW) + , alive_(true) + , commitResult_(true) + { + boost::shared_ptr controller = controllerW.lock(); + originalClickPosition_ = e.GetMainPosition().Apply(controller->GetScene()->GetCanvasToSceneTransform()); + } + + boost::shared_ptr EditMeasureTracker::GetScene() + { + return controllerW_.lock()->GetScene(); + } + + void EditMeasureTracker::Cancel() + { + commitResult_ = false; + alive_ = false; + } + + bool EditMeasureTracker::IsAlive() const + { + return alive_; + } + + EditMeasureTracker::~EditMeasureTracker() + { + // if the tracker completes successfully, we add the command + // to the undo stack + // otherwise, we simply undo it + if (commitResult_) + controllerW_.lock()->PushCommand(command_); + else + command_->Undo(); + } } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/MeasureTrackers.h --- a/Framework/Scene2DViewport/MeasureTrackers.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/MeasureTrackers.h Fri Jul 05 15:33:02 2019 +0200 @@ -50,5 +50,30 @@ private: bool commitResult_; }; + + class EditMeasureTracker : public IFlexiblePointerTracker + { + public: + virtual void Cancel() ORTHANC_OVERRIDE; + virtual bool IsAlive() const ORTHANC_OVERRIDE; + protected: + EditMeasureTracker(boost::weak_ptr controllerW, const PointerEvent& e); + + ~EditMeasureTracker(); + + protected: + boost::shared_ptr command_; + boost::weak_ptr controllerW_; + bool alive_; + boost::shared_ptr GetScene(); + + ScenePoint2D GetOriginalClickPosition() const + { + return originalClickPosition_; + } + private: + ScenePoint2D originalClickPosition_; + bool commitResult_; + }; } diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/ViewportController.cpp --- a/Framework/Scene2DViewport/ViewportController.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/ViewportController.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -100,6 +100,15 @@ return ret; } + + void ViewportController::ResetMeasuringToolsHighlight() + { + for (size_t i = 0; i < measureTools_.size(); ++i) + { + measureTools_[i]->ResetHighlightState(); + } + } + const OrthancStone::AffineTransform2D& ViewportController::GetCanvasToSceneTransform() const { return scene_->GetCanvasToSceneTransform(); diff -r 12b591d5d63c -r 9953f16c304d Framework/Scene2DViewport/ViewportController.h --- a/Framework/Scene2DViewport/ViewportController.h Fri Jul 05 14:52:43 2019 +0200 +++ b/Framework/Scene2DViewport/ViewportController.h Fri Jul 05 15:33:02 2019 +0200 @@ -42,10 +42,21 @@ const uint8_t TEXT_COLOR_GREEN = 223; const uint8_t TEXT_COLOR_BLUE = 81; + const uint8_t TOOL_ANGLE_LINES_COLOR_RED = 0; + const uint8_t TOOL_ANGLE_LINES_COLOR_GREEN = 183; + const uint8_t TOOL_ANGLE_LINES_COLOR_BLUE = 17; + + const uint8_t TOOL_ANGLE_LINES_HL_COLOR_RED = 0; + const uint8_t TOOL_ANGLE_LINES_HL_COLOR_GREEN = 17; + const uint8_t TOOL_ANGLE_LINES_HL_COLOR_BLUE = 183; + const uint8_t TOOL_LINES_COLOR_RED = 0; const uint8_t TOOL_LINES_COLOR_GREEN = 223; const uint8_t TOOL_LINES_COLOR_BLUE = 21; + const uint8_t TOOL_LINES_HL_COLOR_RED = 0; + const uint8_t TOOL_LINES_HL_COLOR_GREEN = 21; + const uint8_t TOOL_LINES_HL_COLOR_BLUE = 223; const uint8_t TEXT_OUTLINE_COLOR_RED = 0; const uint8_t TEXT_OUTLINE_COLOR_GREEN = 56; @@ -88,6 +99,12 @@ std::vector > HitTestMeasureTools(ScenePoint2D p); /** + This function will traverse the measuring tools and will clear their + highlighted state + */ + void ResetMeasuringToolsHighlight(); + + /** With this method, the object takes ownership of the supplied tracker and updates it according to user interaction */ diff -r 12b591d5d63c -r 9953f16c304d Resources/CMake/OrthancStoneConfiguration.cmake --- a/Resources/CMake/OrthancStoneConfiguration.cmake Fri Jul 05 14:52:43 2019 +0200 +++ b/Resources/CMake/OrthancStoneConfiguration.cmake Fri Jul 05 15:33:02 2019 +0200 @@ -474,6 +474,14 @@ ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/CreateMeasureTracker.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/CreateMeasureTracker.h ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/CreateSimpleTrackerAdapter.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditAngleMeasureCommand.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditAngleMeasureCommand.h + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditAngleMeasureTracker.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditAngleMeasureTracker.h + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditLineMeasureCommand.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditLineMeasureCommand.h + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditLineMeasureTracker.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/EditLineMeasureTracker.h ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/IFlexiblePointerTracker.h ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/LayerHolder.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2DViewport/LayerHolder.h diff -r 12b591d5d63c -r 9953f16c304d Samples/Sdl/TrackerSampleApp.cpp --- a/Samples/Sdl/TrackerSampleApp.cpp Fri Jul 05 14:52:43 2019 +0200 +++ b/Samples/Sdl/TrackerSampleApp.cpp Fri Jul 05 15:33:02 2019 +0200 @@ -247,7 +247,7 @@ DisplayFloatingCtrlInfoText(e); } - else + else if (activeTracker_.get() != NULL) { HideInfoText(); //LOG(TRACE) << "(event.type == SDL_MOUSEMOTION)"; @@ -268,6 +268,32 @@ activeTracker_.reset(); } } + else + { + HideInfoText(); + + PointerEvent e; + e.AddPosition(compositor_->GetPixelCenterCoordinates(event.button.x, event.button.y)); + + ScenePoint2D scenePos = e.GetMainPosition().Apply( + controller_->GetScene()->GetCanvasToSceneTransform()); + //auto measureTools = GetController()->HitTestMeasureTools(scenePos); + //LOG(TRACE) << "# of hit tests: " << measureTools.size(); + + // this returns the collection of measuring tools where hit test is true + std::vector > measureTools = controller_->HitTestMeasureTools(scenePos); + + // let's refresh the measuring tools highlighted state + // first let's tag them as "unhighlighted" + controller_->ResetMeasuringToolsHighlight(); + + // then immediately take the first one and ask it to highlight the + // measuring tool UI part that is hot + if (measureTools.size() > 0) + { + measureTools[0]->Highlight(scenePos); + } + } } else if (event.type == SDL_MOUSEBUTTONUP) { @@ -596,6 +622,15 @@ boost::shared_ptr TrackerSampleApp::TrackerHitTest(const PointerEvent & e) { // std::vector> measureTools_; + ScenePoint2D scenePos = e.GetMainPosition().Apply( + controller_->GetScene()->GetCanvasToSceneTransform()); + + std::vector > measureTools = controller_->HitTestMeasureTools(scenePos); + + if (measureTools.size() > 0) + { + return measureTools[0]->CreateEditionTracker(e); + } return boost::shared_ptr(); }