Mercurial > hg > orthanc-stone

comparison Applications/Generic/GuiAdapter.cpp @ 843:67f9c27214c5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed extra logging + doc + added GuiAdapter and LockingEmitter
author Benjamin Golinvaux <bgo@osimis.io>
date Fri, 14 Jun 2019 12:14:16 +0200
parents
children cdba0dbb4682
comparison
equal deleted inserted replaced
841:266e2b0b9abc 843:67f9c27214c5
1 /**
2 * Stone of Orthanc
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2019 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU Affero General Public License
9 * as published by the Free Software Foundation, either version 3 of
10 * the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Affero General Public License for more details.
16 *
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/
20
21 #include "GuiAdapter.h"
22
23 #if ORTHANC_ENABLE_SDL == 1
24 # if ORTHANC_ENABLE_OPENGL == 1
25 # include "../../Framework/OpenGL/OpenGLIncludes.h"
26 # include <SDL_video.h>
27 # include <SDL_render.h>
28 # include <SDL.h>
29 # endif
30 #endif
31
32 #if ORTHANC_ENABLE_THREADS == 1
33 # include "../../Framework/Messages/LockingEmitter.h"
34 #endif
35
36 namespace OrthancStone
37 {
38 void GuiAdapter::RegisterWidget(boost::shared_ptr<IGuiAdapterWidget> widget)
39 {
40 widgets_.push_back(widget);
41 }
42
43 #if ORTHANC_ENABLE_WASM == 1
44 void GuiAdapter::Run()
45 {
46 }
47
48 void ConvertFromPlatform(
49 GuiAdapterUiEvent& dest,
50 int eventType,
51 const EmscriptenUiEvent& src)
52 {
53 // no data for now
54 }
55
56 void ConvertFromPlatform(
57 GuiAdapterMouseEvent& dest,
58 int eventType,
59 const EmscriptenMouseEvent& src)
60 {
61 memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
62 switch (eventType)
63 {
64 case EMSCRIPTEN_EVENT_CLICK:
65 LOG(ERROR) << "Emscripten EMSCRIPTEN_EVENT_CLICK is not supported";
66 ORTHANC_ASSERT(false, "Not supported");
67 break;
68 case EMSCRIPTEN_EVENT_MOUSEDOWN:
69 dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
70 break;
71 case EMSCRIPTEN_EVENT_MOUSEMOVE:
72 dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
73 break;
74 case EMSCRIPTEN_EVENT_MOUSEUP:
75 dest.type = GUIADAPTER_EVENT_MOUSEUP;
76 break;
77 case EMSCRIPTEN_EVENT_WHEEL:
78 dest.type = GUIADAPTER_EVENT_WHEEL;
79 break;
80
81 default:
82 LOG(ERROR) << "Emscripten event: " << eventType << " is not supported";
83 ORTHANC_ASSERT(false, "Not supported");
84 }
85 //dest.timestamp = src.timestamp;
86 //dest.screenX = src.screenX;
87 //dest.screenY = src.screenY;
88 //dest.clientX = src.clientX;
89 //dest.clientY = src.clientY;
90 dest.ctrlKey = src.ctrlKey;
91 dest.shiftKey = src.shiftKey;
92 dest.altKey = src.altKey;
93 //dest.metaKey = src.metaKey;
94 dest.button = src.button;
95 //dest.buttons = src.buttons;
96 //dest.movementX = src.movementX;
97 //dest.movementY = src.movementY;
98 dest.targetX = src.targetX;
99 dest.targetY = src.targetY;
100 //dest.canvasX = src.canvasX;
101 //dest.canvasY = src.canvasY;
102 //dest.padding = src.padding;
103 }
104
105 void ConvertFromPlatform(
106 GuiAdapterWheelEvent& dest,
107 int eventType,
108 const EmscriptenWheelEvent& src)
109 {
110 ConvertFromPlatform(dest.mouse, eventType, src.mouse);
111 dest.deltaX = src.deltaX;
112 dest.deltaY = src.deltaY;
113 switch (src.deltaMode)
114 {
115 case DOM_DELTA_PIXEL:
116 dest.deltaMode = GUIADAPTER_DELTA_PIXEL;
117 break;
118 case DOM_DELTA_LINE:
119 dest.deltaMode = GUIADAPTER_DELTA_LINE;
120 break;
121 case DOM_DELTA_PAGE:
122 dest.deltaMode = GUIADAPTER_DELTA_PAGE;
123 break;
124 default:
125 ORTHANC_ASSERT(false, "Unknown deltaMode: " << src.deltaMode <<
126 " in wheel event...");
127 }
128 dest.deltaMode = src.deltaMode;
129 }
130
131 void ConvertFromPlatform(
132 GuiAdapterKeyboardEvent& dest,
133 const EmscriptenKeyboardEvent& src)
134 {
135 dest.ctrlKey = src.ctrlKey;
136 dest.shiftKey = src.shiftKey;
137 dest.altKey = src.altKey;
138 }
139
140 template<typename GenericFunc>
141 struct FuncAdapterPayload
142 {
143 void* userData;
144 GenericFunc callback;
145 };
146
147 template<typename GenericFunc,
148 typename GuiAdapterEvent,
149 typename EmscriptenEvent>
150 EM_BOOL OnEventAdapterFunc(
151 int eventType, const EmscriptenEvent* wheelEvent, void* userData)
152 {
153
154 // userData is OnMouseWheelFuncAdapterPayload
155 FuncAdapterPayload<GenericFunc>* payload =
156 reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
157 // LOG(INFO) << "OnEventAdapterFunc";
158 // LOG(INFO) << "------------------";
159 // LOG(INFO) << "eventType: " << eventType << " wheelEvent: " <<
160 // (int)wheelEvent << " userData: " << userData <<
161 // " payload->userData: " << payload->userData;
162
163 GuiAdapterEvent guiEvent;
164 ConvertFromPlatform(guiEvent, eventType, *wheelEvent);
165 bool ret = (*(payload->callback))(&guiEvent, payload->userData);
166 return static_cast<EM_BOOL>(ret);
167 }
168
169 template<typename GenericFunc,
170 typename GuiAdapterEvent,
171 typename EmscriptenEvent>
172 EM_BOOL OnEventAdapterFunc2(
173 int /*eventType*/, const EmscriptenEvent* wheelEvent, void* userData)
174 {
175 // userData is OnMouseWheelFuncAdapterPayload
176 FuncAdapterPayload<GenericFunc>* payload =
177 reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
178
179 GuiAdapterEvent guiEvent;
180 ConvertFromPlatform(guiEvent, *wheelEvent);
181 bool ret = (*(payload->callback))(&guiEvent, payload->userData);
182 return static_cast<EM_BOOL>(ret);
183 }
184
185 template<typename GenericFunc>
186 EM_BOOL OnEventAdapterFunc3(
187 double time, void* userData)
188 {
189 // userData is OnMouseWheelFuncAdapterPayload
190 FuncAdapterPayload<GenericFunc>* payload =
191 reinterpret_cast<FuncAdapterPayload<GenericFunc>*>(userData);
192 //std::auto_ptr< FuncAdapterPayload<GenericFunc> > deleter(payload);
193 bool ret = (*(payload->callback))(time, payload->userData);
194 return static_cast<EM_BOOL>(ret);
195 }
196
197 // resize: (const char* target, void* userData, EM_BOOL useCapture, em_ui_callback_func callback)
198 template<
199 typename GenericFunc,
200 typename GuiAdapterEvent,
201 typename EmscriptenEvent,
202 typename EmscriptenSetCallbackFunc>
203 static void SetCallback(
204 EmscriptenSetCallbackFunc emFunc,
205 std::string canvasId, void* userData, bool capture, GenericFunc func)
206 {
207 // TODO: write RemoveCallback with an int id that gets returned from
208 // here
209 FuncAdapterPayload<GenericFunc>* payload =
210 new FuncAdapterPayload<GenericFunc>();
211 std::auto_ptr<FuncAdapterPayload<GenericFunc> > payloadP(payload);
212 payload->callback = func;
213 payload->userData = userData;
214 void* userDataRaw = reinterpret_cast<void*>(payload);
215 // LOG(INFO) << "SetCallback -- userDataRaw: " << userDataRaw <<
216 // " payload: " << payload << " payload->userData: " << payload->userData;
217 (*emFunc)(
218 canvasId.c_str(),
219 userDataRaw,
220 static_cast<EM_BOOL>(capture),
221 &OnEventAdapterFunc<GenericFunc, GuiAdapterEvent, EmscriptenEvent>,
222 EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
223 payloadP.release();
224 }
225
226 template<
227 typename GenericFunc,
228 typename GuiAdapterEvent,
229 typename EmscriptenEvent,
230 typename EmscriptenSetCallbackFunc>
231 static void SetCallback2(
232 EmscriptenSetCallbackFunc emFunc,
233 std::string canvasId, void* userData, bool capture, GenericFunc func)
234 {
235 std::auto_ptr<FuncAdapterPayload<GenericFunc> > payload(
236 new FuncAdapterPayload<GenericFunc>()
237 );
238 payload->callback = func;
239 payload->userData = userData;
240 void* userDataRaw = reinterpret_cast<void*>(payload.release());
241 (*emFunc)(
242 canvasId.c_str(),
243 userDataRaw,
244 static_cast<EM_BOOL>(capture),
245 &OnEventAdapterFunc2<GenericFunc, GuiAdapterEvent, EmscriptenEvent>,
246 EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
247 }
248
249 template<
250 typename GenericFunc,
251 typename EmscriptenSetCallbackFunc>
252 static void SetCallback3(
253 EmscriptenSetCallbackFunc emFunc,
254 void* userData, GenericFunc func)
255 {
256 // LOG(ERROR) << "SetCallback3 !!!!!! (RequestAnimationFrame)";
257 std::auto_ptr<FuncAdapterPayload<GenericFunc> > payload(
258 new FuncAdapterPayload<GenericFunc>()
259 );
260 payload->callback = func;
261 payload->userData = userData;
262 void* userDataRaw = reinterpret_cast<void*>(payload.release());
263 (*emFunc)(
264 &OnEventAdapterFunc3<GenericFunc>,
265 userDataRaw);
266 }
267
268 void GuiAdapter::SetWheelCallback(
269 std::string canvasId, void* userData, bool capture, OnMouseWheelFunc func)
270 {
271 SetCallback<OnMouseWheelFunc, GuiAdapterWheelEvent, EmscriptenWheelEvent>(
272 &emscripten_set_wheel_callback_on_thread,
273 canvasId,
274 userData,
275 capture,
276 func);
277 }
278
279 void GuiAdapter::SetMouseDownCallback(
280 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
281 {
282 SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
283 &emscripten_set_mousedown_callback_on_thread,
284 canvasId,
285 userData,
286 capture,
287 func);
288 }
289
290 void GuiAdapter::SetMouseMoveCallback(
291 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
292 {
293 // LOG(INFO) << "SetMouseMoveCallback -- " << "supplied userData: " <<
294 // userData;
295
296 SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
297 &emscripten_set_mousemove_callback_on_thread,
298 canvasId,
299 userData,
300 capture,
301 func);
302 }
303
304 void GuiAdapter::SetMouseUpCallback(
305 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
306 {
307 SetCallback<OnMouseEventFunc, GuiAdapterMouseEvent, EmscriptenMouseEvent>(
308 &emscripten_set_mouseup_callback_on_thread,
309 canvasId,
310 userData,
311 capture,
312 func);
313 }
314
315 void GuiAdapter::SetKeyDownCallback(
316 std::string canvasId, void* userData, bool capture, OnKeyDownFunc func)
317 {
318 SetCallback2<OnKeyDownFunc, GuiAdapterKeyboardEvent, EmscriptenKeyboardEvent>(
319 &emscripten_set_keydown_callback_on_thread,
320 canvasId,
321 userData,
322 capture,
323 func);
324 }
325
326 void GuiAdapter::SetKeyUpCallback(
327 std::string canvasId, void* userData, bool capture, OnKeyUpFunc func)
328 {
329 SetCallback2<OnKeyUpFunc, GuiAdapterKeyboardEvent, EmscriptenKeyboardEvent>(
330 &emscripten_set_keyup_callback_on_thread,
331 canvasId,
332 userData,
333 capture,
334 func);
335 }
336
337 void GuiAdapter::SetResizeCallback(
338 std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
339 {
340 SetCallback<OnWindowResizeFunc, GuiAdapterUiEvent, EmscriptenUiEvent>(
341 &emscripten_set_resize_callback_on_thread,
342 canvasId,
343 userData,
344 capture,
345 func);
346 }
347
348 void GuiAdapter::RequestAnimationFrame(
349 OnAnimationFrameFunc func, void* userData)
350 {
351 // LOG(ERROR) << "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+";
352 // LOG(ERROR) << "RequestAnimationFrame";
353 // LOG(ERROR) << "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+";
354 SetCallback3<OnAnimationFrameFunc>(
355 &emscripten_request_animation_frame_loop,
356 userData,
357 func);
358 }
359
360 #if 0
361 void GuiAdapter::SetKeyDownCallback(
362 std::string canvasId, void* userData, bool capture, OnKeyDownFunc func)
363 {
364 emscripten_set_keydown_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
365 }
366 void GuiAdapter::SetKeyUpCallback(
367 std::string canvasId, void* userData, bool capture, OnKeyUpFunc func)
368 {
369 emscripten_set_keyup_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
370 }
371
372 void GuiAdapter::SetResizeCallback(std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
373 {
374 emscripten_set_resize_callback(canvasId.c_str(), userData, static_cast<EM_BOOL>(capture), func);
375 }
376
377 void GuiAdapter::RequestAnimationFrame(OnAnimationFrameFunc func, void* userData)
378 {
379 emscripten_request_animation_frame_loop(func, userData);
380 }
381 #endif
382
383
384 #else
385
386 void ConvertFromPlatform(
387 GuiAdapterMouseEvent& dest,
388 bool ctrlPressed, bool shiftPressed, bool altPressed,
389 const SDL_Event& source)
390 {
391 memset(&dest, 0, sizeof(GuiAdapterMouseEvent));
392 switch (source.type)
393 {
394 case SDL_MOUSEBUTTONDOWN:
395 dest.type = GUIADAPTER_EVENT_MOUSEDOWN;
396 break;
397 case SDL_MOUSEMOTION:
398 dest.type = GUIADAPTER_EVENT_MOUSEMOVE;
399 break;
400 case SDL_MOUSEBUTTONUP:
401 dest.type = GUIADAPTER_EVENT_MOUSEUP;
402 break;
403 default:
404 LOG(ERROR) << "SDL event: " << source.type << " is not supported";
405 ORTHANC_ASSERT(false, "Not supported");
406 }
407 //dest.timestamp = src.timestamp;
408 //dest.screenX = src.screenX;
409 //dest.screenY = src.screenY;
410 //dest.clientX = src.clientX;
411 //dest.clientY = src.clientY;
412 dest.ctrlKey = ctrlPressed;
413 dest.shiftKey = shiftPressed;
414 dest.altKey = altPressed;
415 //dest.metaKey = src.metaKey;
416 switch (source.button.button)
417 {
418 case SDL_BUTTON_MIDDLE:
419 dest.button = 1;
420 break;
421
422 case SDL_BUTTON_RIGHT:
423 dest.button = 2;
424 break;
425
426 case SDL_BUTTON_LEFT:
427 dest.button = 0;
428 break;
429
430 default:
431 break;
432 }
433 //dest.buttons = src.buttons;
434 //dest.movementX = src.movementX;
435 //dest.movementY = src.movementY;
436 dest.targetX = source.button.x;
437 dest.targetY = source.button.y;
438 //dest.canvasX = src.canvasX;
439 //dest.canvasY = src.canvasY;
440 //dest.padding = src.padding;
441 }
442
443 void GuiAdapter::SetResizeCallback(
444 std::string canvasId, void* userData, bool capture, OnWindowResizeFunc func)
445 {
446 resizeHandlers_.push_back(std::make_pair(func, userData));
447 }
448
449 void GuiAdapter::SetMouseDownCallback(
450 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
451 {
452 }
453
454 void GuiAdapter::SetMouseMoveCallback(
455 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
456 {
457 }
458
459 void GuiAdapter::SetMouseUpCallback(
460 std::string canvasId, void* userData, bool capture, OnMouseEventFunc func)
461 {
462 }
463
464 void GuiAdapter::SetWheelCallback(
465 std::string canvasId, void* userData, bool capture, OnMouseWheelFunc func)
466 {
467 }
468
469 void GuiAdapter::SetKeyDownCallback(
470 std::string canvasId, void* userData, bool capture, OnKeyDownFunc func)
471 {
472 }
473
474 void GuiAdapter::SetKeyUpCallback(
475 std::string canvasId, void* userData, bool capture, OnKeyUpFunc func)
476 {
477 }
478
479
480 void GuiAdapter::OnAnimationFrame()
481 {
482 for (const auto& handler : animationFrameHandlers_)
483 {
484 // TODO: fix time
485 (*(handler.first))(0,handler.second);
486 }
487 }
488
489 void GuiAdapter::OnResize()
490 {
491 for (const auto& handler : resizeHandlers_)
492 {
493 // TODO: fix time
494 (*(handler.first))(0, handler.second);
495 }
496 }
497
498 void GuiAdapter::OnMouseEvent(uint32_t windowID, const GuiAdapterMouseEvent& event)
499 {
500 }
501
502
503 void GuiAdapter::RequestAnimationFrame(OnAnimationFrameFunc func, void* userData)
504 {
505 animationFrameHandlers_.push_back(std::make_pair(func, userData));
506 }
507
508 # if ORTHANC_ENABLE_OPENGL == 1
509
510 static void GLAPIENTRY
511 OpenGLMessageCallback(GLenum source,
512 GLenum type,
513 GLuint id,
514 GLenum severity,
515 GLsizei length,
516 const GLchar* message,
517 const void* userParam)
518 {
519 if (severity != GL_DEBUG_SEVERITY_NOTIFICATION)
520 {
521 fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
522 (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
523 type, severity, message);
524 }
525 }
526 # endif
527
528 void GuiAdapter::Run()
529 {
530 # if ORTHANC_ENABLE_OPENGL == 1
531 glEnable(GL_DEBUG_OUTPUT);
532 glDebugMessageCallback(OpenGLMessageCallback, 0);
533 # endif
534
535 // Uint32 SDL_GetWindowID(SDL_Window* window)
536 // SDL_Window* SDL_GetWindowFromID(Uint32 id) // may return NULL
537
538 bool stop = false;
539 while (!stop)
540 {
541 {
542 LockingEmitter::WriterLock lock(lockingEmitter_);
543 OnAnimationFrame(); // in SDL we must call it
544 }
545
546 SDL_Event event;
547
548 while (!stop && SDL_PollEvent(&event))
549 {
550 LockingEmitter::WriterLock lock(lockingEmitter_);
551
552 if (event.type == SDL_QUIT)
553 {
554 // TODO: call exit callbacks here
555 stop = true;
556 break;
557 }
558 else if ( (event.type == SDL_MOUSEMOTION) ||
559 (event.type == SDL_MOUSEBUTTONDOWN) ||
560 (event.type == SDL_MOUSEBUTTONUP) )
561 {
562 int scancodeCount = 0;
563 const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount);
564 bool ctrlPressed(false);
565 bool shiftPressed(false);
566 bool altPressed(false);
567
568 if (SDL_SCANCODE_LCTRL < scancodeCount && keyboardState[SDL_SCANCODE_LCTRL])
569 ctrlPressed = true;
570 if (SDL_SCANCODE_RCTRL < scancodeCount && keyboardState[SDL_SCANCODE_RCTRL])
571 ctrlPressed = true;
572 if (SDL_SCANCODE_LSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_LSHIFT])
573 shiftPressed = true;
574 if (SDL_SCANCODE_RSHIFT < scancodeCount && keyboardState[SDL_SCANCODE_RSHIFT])
575 shiftPressed = true;
576 if (SDL_SCANCODE_LALT < scancodeCount && keyboardState[SDL_SCANCODE_LALT])
577 altPressed = true;
578
579 GuiAdapterMouseEvent dest;
580 ConvertFromPlatform(dest, ctrlPressed, shiftPressed, altPressed, event);
581 OnMouseEvent(event.window.windowID, dest);
582 #if 0
583 // for reference, how to create trackers
584 if (tracker)
585 {
586 PointerEvent e;
587 e.AddPosition(compositor.GetPixelCenterCoordinates(
588 event.button.x, event.button.y));
589 tracker->PointerMove(e);
590 }
591 #endif
592 }
593 else if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
594 {
595 #if 0
596 tracker.reset();
597 #endif
598 OnResize();
599 }
600 else if (event.type == SDL_KEYDOWN && event.key.repeat == 0 /* Ignore key bounce */)
601 {
602 switch (event.key.keysym.sym)
603 {
604 case SDLK_f:
605 // window.GetWindow().ToggleMaximize(); //TODO: move to particular handler
606 break;
607
608 case SDLK_s:
609 #if 0
610 // TODO: re-enable at application-level!!!!
611 VisitWidgets(
612 [](auto value)
613 {
614 auto widget = boost::dynamic_pointer_cast<VolumeSlicerWidget()
615 value->FitContent();
616 });
617 #endif
618 break;
619
620 case SDLK_q:
621 stop = true;
622 break;
623
624 default:
625 break;
626 }
627 }
628 // HandleApplicationEvent(controller, compositor, event, tracker);
629 }
630
631 SDL_Delay(1);
632 }
633 }
634 #endif
635 }
636