Mercurial > hg > orthanc-stone

comparison Samples/Sdl/TrackerSampleApp.cpp @ 818:e42b491f1fb2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed typedefs to shared_ptr by making them explicit. Removed using namespace directives to make usage more explicit, too.
author Benjamin Golinvaux <bgo@osimis.io>
date Wed, 29 May 2019 10:51:28 +0200
parents 61ba4b504e9a
children 80829436ce0c e3c56d4f863f
comparison
equal deleted inserted replaced
817:68f888812af4 818:e42b491f1fb2
44 #include <boost/make_shared.hpp> 44 #include <boost/make_shared.hpp>
45 #include <SDL.h> 45 #include <SDL.h>
46 46
47 #include <stdio.h> 47 #include <stdio.h>
48 48
49 using namespace Orthanc;
50
51 namespace OrthancStone 49 namespace OrthancStone
52 { 50 {
53 const char* MeasureToolToString(size_t i) 51 const char* MeasureToolToString(size_t i)
54 { 52 {
55 static const char* descs[] = { 53 static const char* descs[] = {
67 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index"); 65 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index");
68 } 66 }
69 return descs[i]; 67 return descs[i];
70 } 68 }
71 69
72 Scene2DPtr TrackerSampleApp::GetScene() 70 boost::shared_ptr<Scene2D> TrackerSampleApp::GetScene()
73 { 71 {
74 return controller_->GetScene(); 72 return controller_->GetScene();
75 } 73 }
76 74
77 Scene2DConstPtr TrackerSampleApp::GetScene() const 75 boost::shared_ptr<const Scene2D> TrackerSampleApp::GetScene() const
78 { 76 {
79 return controller_->GetScene(); 77 return controller_->GetScene();
80 } 78 }
81 79
82 void TrackerSampleApp::SelectNextTool() 80 void TrackerSampleApp::SelectNextTool()
199 switch (i) 197 switch (i)
200 { 198 {
201 case 0: 199 case 0:
202 // line measure 200 // line measure
203 { 201 {
204 CreateLineMeasureCommandPtr cmd = 202 boost::shared_ptr<CreateLineMeasureCommand> cmd =
205 boost::make_shared<CreateLineMeasureCommand>( 203 boost::make_shared<CreateLineMeasureCommand>(
206 boost::ref(IObserver::GetBroker()), 204 boost::ref(IObserver::GetBroker()),
207 controller_, 205 controller_,
208 GetRandomPointInScene()); 206 GetRandomPointInScene());
209 cmd->SetEnd(GetRandomPointInScene()); 207 cmd->SetEnd(GetRandomPointInScene());
211 } 209 }
212 break; 210 break;
213 case 1: 211 case 1:
214 // angle measure 212 // angle measure
215 { 213 {
216 CreateAngleMeasureCommandPtr cmd = 214 boost::shared_ptr<CreateAngleMeasureCommand> cmd =
217 boost::make_shared<CreateAngleMeasureCommand>( 215 boost::make_shared<CreateAngleMeasureCommand>(
218 boost::ref(IObserver::GetBroker()), 216 boost::ref(IObserver::GetBroker()),
219 controller_, 217 controller_,
220 GetRandomPointInScene()); 218 GetRandomPointInScene());
221 cmd->SetCenter(GetRandomPointInScene()); 219 cmd->SetCenter(GetRandomPointInScene());
380 const ViewportController::SceneTransformChanged& message) 378 const ViewportController::SceneTransformChanged& message)
381 { 379 {
382 DisplayInfoText(); 380 DisplayInfoText();
383 } 381 }
384 382
385 FlexiblePointerTrackerPtr TrackerSampleApp::CreateSuitableTracker( 383 boost::shared_ptr<IFlexiblePointerTracker> TrackerSampleApp::CreateSuitableTracker(
386 const SDL_Event & event, 384 const SDL_Event & event,
387 const PointerEvent & e) 385 const PointerEvent & e)
388 { 386 {
387 using namespace Orthanc;
388
389 switch (event.button.button) 389 switch (event.button.button)
390 { 390 {
391 case SDL_BUTTON_MIDDLE: 391 case SDL_BUTTON_MIDDLE:
392 return FlexiblePointerTrackerPtr(new PanSceneTracker 392 return boost::shared_ptr<IFlexiblePointerTracker>(new PanSceneTracker
393 (controller_, e)); 393 (controller_, e));
394 394
395 case SDL_BUTTON_RIGHT: 395 case SDL_BUTTON_RIGHT:
396 return FlexiblePointerTrackerPtr(new ZoomSceneTracker 396 return boost::shared_ptr<IFlexiblePointerTracker>(new ZoomSceneTracker
397 (controller_, e, compositor_->GetCanvasHeight())); 397 (controller_, e, compositor_->GetCanvasHeight()));
398 398
399 case SDL_BUTTON_LEFT: 399 case SDL_BUTTON_LEFT:
400 { 400 {
401 //LOG(TRACE) << "CreateSuitableTracker: case SDL_BUTTON_LEFT:"; 401 //LOG(TRACE) << "CreateSuitableTracker: case SDL_BUTTON_LEFT:";
404 // Otherwise, depending upon the active tool, we might want to create 404 // Otherwise, depending upon the active tool, we might want to create
405 // a "measuring tool creation" tracker 405 // a "measuring tool creation" tracker
406 406
407 // TODO: if there are conflicts, we should prefer a tracker that 407 // TODO: if there are conflicts, we should prefer a tracker that
408 // pertains to the type of measuring tool currently selected (TBD?) 408 // pertains to the type of measuring tool currently selected (TBD?)
409 FlexiblePointerTrackerPtr hitTestTracker = TrackerHitTest(e); 409 boost::shared_ptr<IFlexiblePointerTracker> hitTestTracker = TrackerHitTest(e);
410 410
411 if (hitTestTracker != NULL) 411 if (hitTestTracker != NULL)
412 { 412 {
413 //LOG(TRACE) << "hitTestTracker != NULL"; 413 //LOG(TRACE) << "hitTestTracker != NULL";
414 return hitTestTracker; 414 return hitTestTracker;
417 { 417 {
418 switch (currentTool_) 418 switch (currentTool_)
419 { 419 {
420 case GuiTool_Rotate: 420 case GuiTool_Rotate:
421 //LOG(TRACE) << "Creating RotateSceneTracker"; 421 //LOG(TRACE) << "Creating RotateSceneTracker";
422 return FlexiblePointerTrackerPtr(new RotateSceneTracker( 422 return boost::shared_ptr<IFlexiblePointerTracker>(new RotateSceneTracker(
423 controller_, e)); 423 controller_, e));
424 case GuiTool_Pan: 424 case GuiTool_Pan:
425 return FlexiblePointerTrackerPtr(new PanSceneTracker( 425 return boost::shared_ptr<IFlexiblePointerTracker>(new PanSceneTracker(
426 controller_, e)); 426 controller_, e));
427 case GuiTool_Zoom: 427 case GuiTool_Zoom:
428 return FlexiblePointerTrackerPtr(new ZoomSceneTracker( 428 return boost::shared_ptr<IFlexiblePointerTracker>(new ZoomSceneTracker(
429 controller_, e, compositor_->GetCanvasHeight())); 429 controller_, e, compositor_->GetCanvasHeight()));
430 //case GuiTool_AngleMeasure: 430 //case GuiTool_AngleMeasure:
431 // return new AngleMeasureTracker(GetScene(), e); 431 // return new AngleMeasureTracker(GetScene(), e);
432 //case GuiTool_CircleMeasure: 432 //case GuiTool_CircleMeasure:
433 // return new CircleMeasureTracker(GetScene(), e); 433 // return new CircleMeasureTracker(GetScene(), e);
434 //case GuiTool_EllipseMeasure: 434 //case GuiTool_EllipseMeasure:
435 // return new EllipseMeasureTracker(GetScene(), e); 435 // return new EllipseMeasureTracker(GetScene(), e);
436 case GuiTool_LineMeasure: 436 case GuiTool_LineMeasure:
437 return FlexiblePointerTrackerPtr(new CreateLineMeasureTracker( 437 return boost::shared_ptr<IFlexiblePointerTracker>(new CreateLineMeasureTracker(
438 IObserver::GetBroker(), controller_, e)); 438 IObserver::GetBroker(), controller_, e));
439 case GuiTool_AngleMeasure: 439 case GuiTool_AngleMeasure:
440 return FlexiblePointerTrackerPtr(new CreateAngleMeasureTracker( 440 return boost::shared_ptr<IFlexiblePointerTracker>(new CreateAngleMeasureTracker(
441 IObserver::GetBroker(), controller_, e)); 441 IObserver::GetBroker(), controller_, e));
442 case GuiTool_CircleMeasure: 442 case GuiTool_CircleMeasure:
443 LOG(ERROR) << "Not implemented yet!"; 443 LOG(ERROR) << "Not implemented yet!";
444 return FlexiblePointerTrackerPtr(); 444 return boost::shared_ptr<IFlexiblePointerTracker>();
445 case GuiTool_EllipseMeasure: 445 case GuiTool_EllipseMeasure:
446 LOG(ERROR) << "Not implemented yet!"; 446 LOG(ERROR) << "Not implemented yet!";
447 return FlexiblePointerTrackerPtr(); 447 return boost::shared_ptr<IFlexiblePointerTracker>();
448 default: 448 default:
449 throw OrthancException(ErrorCode_InternalError, "Wrong tool!"); 449 throw OrthancException(ErrorCode_InternalError, "Wrong tool!");
450 } 450 }
451 } 451 }
452 } 452 }
453 default: 453 default:
454 return FlexiblePointerTrackerPtr(); 454 return boost::shared_ptr<IFlexiblePointerTracker>();
455 } 455 }
456 } 456 }
457 457
458 458
459 TrackerSampleApp::TrackerSampleApp(MessageBroker& broker) : IObserver(broker) 459 TrackerSampleApp::TrackerSampleApp(MessageBroker& broker) : IObserver(broker)
460 , currentTool_(GuiTool_Rotate) 460 , currentTool_(GuiTool_Rotate)
461 { 461 {
462 controller_ = ViewportControllerPtr(new ViewportController(broker)); 462 controller_ = boost::shared_ptr<ViewportController>(new ViewportController(broker));
463 463
464 controller_->RegisterObserverCallback( 464 controller_->RegisterObserverCallback(
465 new Callable<TrackerSampleApp, ViewportController::SceneTransformChanged> 465 new Callable<TrackerSampleApp, ViewportController::SceneTransformChanged>
466 (*this, &TrackerSampleApp::OnSceneTransformChanged)); 466 (*this, &TrackerSampleApp::OnSceneTransformChanged));
467 467
588 Orthanc::PngWriter writer; 588 Orthanc::PngWriter writer;
589 writer.WriteToFile(target, png); 589 writer.WriteToFile(target, png);
590 } 590 }
591 591
592 592
593 FlexiblePointerTrackerPtr TrackerSampleApp::TrackerHitTest(const PointerEvent & e) 593 boost::shared_ptr<IFlexiblePointerTracker> TrackerSampleApp::TrackerHitTest(const PointerEvent & e)
594 { 594 {
595 // std::vector<MeasureToolPtr> measureTools_; 595 // std::vector<boost::shared_ptr<MeasureTool>> measureTools_;
596 return FlexiblePointerTrackerPtr(); 596 return boost::shared_ptr<IFlexiblePointerTracker>();
597 } 597 }
598 598
599 static void GLAPIENTRY 599 static void GLAPIENTRY
600 OpenGLMessageCallback(GLenum source, 600 OpenGLMessageCallback(GLenum source,
601 GLenum type, 601 GLenum type,