Mercurial > hg > orthanc-stone

comparison Framework/Scene2DViewport/LayerHolder.cpp @ 1305:a5326ce4f24b broker

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Trackers and measuring tools now use the viewport instead of ViewportController, so that proper locks can be used
author Benjamin Golinvaux <bgo@osimis.io>
date Wed, 04 Mar 2020 09:45:38 +0100
parents 7ec8fea061b9
children adf234ecaa00
comparison
equal deleted inserted replaced
1304:b7fa67bf87fa 1305:a5326ce4f24b
20 20
21 #include "LayerHolder.h" 21 #include "LayerHolder.h"
22 #include "../Scene2D/TextSceneLayer.h" 22 #include "../Scene2D/TextSceneLayer.h"
23 #include "../Scene2D/PolylineSceneLayer.h" 23 #include "../Scene2D/PolylineSceneLayer.h"
24 #include "../Scene2D/Scene2D.h" 24 #include "../Scene2D/Scene2D.h"
25 #include "../Scene2DViewport/ViewportController.h" 25 #include "../Viewport/IViewport.h"
26 #include "../StoneException.h" 26 #include "../StoneException.h"
27 27
28 namespace OrthancStone 28 namespace OrthancStone
29 { 29 {
30 LayerHolder::LayerHolder( 30 LayerHolder::LayerHolder(
31 boost::weak_ptr<ViewportController> controllerW, 31 IViewport& viewport,
32 int polylineLayerCount, 32 int polylineLayerCount,
33 int textLayerCount, 33 int textLayerCount,
34 int infoTextCount) 34 int infoTextCount)
35 : textLayerCount_(textLayerCount) 35 : textLayerCount_(textLayerCount)
36 , polylineLayerCount_(polylineLayerCount) 36 , polylineLayerCount_(polylineLayerCount)
37 , infoTextCount_(infoTextCount) 37 , infoTextCount_(infoTextCount)
38 , controllerW_(controllerW) 38 , viewport_(viewport)
39 , baseLayerIndex_(-1) 39 , baseLayerIndex_(-1)
40 { 40 {
41 41
42 } 42 }
43 43
44 void LayerHolder::CreateLayers() 44 void LayerHolder::CreateLayers()
45 { 45 {
46 boost::shared_ptr<ViewportController> controller = controllerW_.lock(); 46 std::unique_ptr<IViewport::ILock> lock(viewport_.Lock());
47 47
48 if (controller) 48 assert(baseLayerIndex_ == -1);
49
50 baseLayerIndex_ = lock->GetController().GetScene().GetMaxDepth() + 100;
51
52 for (int i = 0; i < polylineLayerCount_; ++i)
49 { 53 {
50 assert(baseLayerIndex_ == -1); 54 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer());
55 lock->GetController().GetScene().SetLayer(baseLayerIndex_ + i, layer.release());
56 }
51 57
52 baseLayerIndex_ = controller->GetScene().GetMaxDepth() + 100; 58 for (int i = 0; i < textLayerCount_; ++i)
53 59 {
54 for (int i = 0; i < polylineLayerCount_; ++i) 60 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
55 { 61 lock->GetController().GetScene().SetLayer(
56 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer()); 62 baseLayerIndex_ + polylineLayerCount_ + i,
57 controller->GetScene().SetLayer(baseLayerIndex_ + i, layer.release()); 63 layer.release());
58 }
59
60 for (int i = 0; i < textLayerCount_; ++i)
61 {
62 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
63 controller->GetScene().SetLayer(
64 baseLayerIndex_ + polylineLayerCount_ + i,
65 layer.release());
66 }
67 } 64 }
65 lock->Invalidate();
68 } 66 }
69 67
70 void LayerHolder::CreateLayersIfNeeded() 68 void LayerHolder::CreateLayersIfNeeded()
71 { 69 {
72 if (baseLayerIndex_ == -1) 70 if (baseLayerIndex_ == -1)
84 DeleteLayers(); 82 DeleteLayers();
85 } 83 }
86 84
87 void LayerHolder::DeleteLayers() 85 void LayerHolder::DeleteLayers()
88 { 86 {
89 boost::shared_ptr<ViewportController> controller = controllerW_.lock(); 87 std::unique_ptr<IViewport::ILock> lock(viewport_.Lock());
88 Scene2D& scene = lock->GetController().GetScene();
90 89
91 if (controller) 90 for (int i = 0; i < textLayerCount_ + polylineLayerCount_; ++i)
92 { 91 {
93 for (int i = 0; i < textLayerCount_ + polylineLayerCount_; ++i) 92 ORTHANC_ASSERT(scene.HasLayer(baseLayerIndex_ + i), "No layer");
94 { 93 scene.DeleteLayer(baseLayerIndex_ + i);
95 ORTHANC_ASSERT(controller->GetScene().HasLayer(baseLayerIndex_ + i), "No layer");
96 controller->GetScene().DeleteLayer(baseLayerIndex_ + i);
97 }
98 baseLayerIndex_ = -1;
99 } 94 }
95 baseLayerIndex_ = -1;
96 lock->Invalidate();
100 } 97 }
101 98
102 PolylineSceneLayer* LayerHolder::GetPolylineLayer(int index /*= 0*/) 99 PolylineSceneLayer* LayerHolder::GetPolylineLayer(int index /*= 0*/)
103 { 100 {
104 boost::shared_ptr<ViewportController> controller = controllerW_.lock(); 101 std::unique_ptr<IViewport::ILock> lock(viewport_.Lock());
102 Scene2D& scene = lock->GetController().GetScene();
105 103
106 if (controller) 104 using namespace Orthanc;
107 { 105 ORTHANC_ASSERT(baseLayerIndex_ != -1);
108 using namespace Orthanc; 106 ORTHANC_ASSERT(scene.HasLayer(GetPolylineLayerIndex(index)));
109 ORTHANC_ASSERT(baseLayerIndex_ != -1); 107 ISceneLayer* layer = &(scene.GetLayer(GetPolylineLayerIndex(index)));
110 ORTHANC_ASSERT(controller->GetScene().HasLayer(GetPolylineLayerIndex(index)));
111 ISceneLayer* layer =
112 &(controller->GetScene().GetLayer(GetPolylineLayerIndex(index)));
113 108
114 PolylineSceneLayer* concreteLayer = 109 PolylineSceneLayer* concreteLayer =
115 dynamic_cast<PolylineSceneLayer*>(layer); 110 dynamic_cast<PolylineSceneLayer*>(layer);
116 111
117 ORTHANC_ASSERT(concreteLayer != NULL); 112 ORTHANC_ASSERT(concreteLayer != NULL);
118 return concreteLayer; 113 return concreteLayer;
119 }
120 else
121 {
122 return NULL; // TODO
123 }
124 } 114 }
125 115
126 TextSceneLayer* LayerHolder::GetTextLayer(int index /*= 0*/) 116 TextSceneLayer* LayerHolder::GetTextLayer(int index /*= 0*/)
127 { 117 {
128 boost::shared_ptr<ViewportController> controller = controllerW_.lock(); 118 std::unique_ptr<IViewport::ILock> lock(viewport_.Lock());
119 Scene2D& scene = lock->GetController().GetScene();
129 120
130 if (controller) 121 using namespace Orthanc;
131 { 122 ORTHANC_ASSERT(baseLayerIndex_ != -1);
132 using namespace Orthanc; 123 ORTHANC_ASSERT(scene.HasLayer(GetTextLayerIndex(index)));
133 ORTHANC_ASSERT(baseLayerIndex_ != -1); 124 ISceneLayer* layer = &(scene.GetLayer(GetTextLayerIndex(index)));
134 ORTHANC_ASSERT(controller->GetScene().HasLayer(GetTextLayerIndex(index)));
135 ISceneLayer* layer =
136 &(controller->GetScene().GetLayer(GetTextLayerIndex(index)));
137 125
138 TextSceneLayer* concreteLayer = 126 TextSceneLayer* concreteLayer =
139 dynamic_cast<TextSceneLayer*>(layer); 127 dynamic_cast<TextSceneLayer*>(layer);
140 128
141 ORTHANC_ASSERT(concreteLayer != NULL); 129 ORTHANC_ASSERT(concreteLayer != NULL);
142 return concreteLayer; 130 return concreteLayer;
143 }
144 else
145 {
146 return NULL; // TODO
147 }
148 } 131 }
149 132
150 int LayerHolder::GetPolylineLayerIndex(int index /*= 0*/) 133 int LayerHolder::GetPolylineLayerIndex(int index /*= 0*/)
151 { 134 {
152 using namespace Orthanc; 135 using namespace Orthanc;
153 ORTHANC_ASSERT(index < polylineLayerCount_); 136 ORTHANC_ASSERT(index < polylineLayerCount_);
154 return baseLayerIndex_ + index; 137 return baseLayerIndex_ + index;
155 } 138 }
156 139
157
158 int LayerHolder::GetTextLayerIndex(int index /*= 0*/) 140 int LayerHolder::GetTextLayerIndex(int index /*= 0*/)
159 { 141 {
160 using namespace Orthanc; 142 using namespace Orthanc;
161 ORTHANC_ASSERT(index < textLayerCount_); 143 ORTHANC_ASSERT(index < textLayerCount_);
162 144