Mercurial > hg > orthanc-stone
comparison Framework/Scene2DViewport/LayerHolder.cpp @ 1305:a5326ce4f24b broker
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 |