Line data Source code
1 : //# PlotTool.cc: Tool class definitions (higher-level event handlers).
2 : //# Copyright (C) 2008
3 : //# Associated Universities, Inc. Washington DC, USA.
4 : //#
5 : //# This library is free software; you can redistribute it and/or modify it
6 : //# under the terms of the GNU Library General Public License as published by
7 : //# the Free Software Foundation; either version 2 of the License, or (at your
8 : //# option) any later version.
9 : //#
10 : //# This library is distributed in the hope that it will be useful, but WITHOUT
11 : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 : //# License for more details.
14 : //#
15 : //# You should have received a copy of the GNU Library General Public License
16 : //# along with this library; if not, write to the Free Software Foundation,
17 : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 : //#
19 : //# Correspondence concerning AIPS++ should be addressed as follows:
20 : //# Internet email: aips2-request@nrao.edu.
21 : //# Postal address: AIPS++ Project Office
22 : //# National Radio Astronomy Observatory
23 : //# 520 Edgemont Road
24 : //# Charlottesville, VA 22903-2475 USA
25 : //#
26 : //# $Id: $
27 : #include <graphics/GenericPlotter/PlotTool.h>
28 : #include <graphics/GenericPlotter/PlotFactory.h>
29 : /////!!!!! + + ++ + + + + + + + + + #include <qwt/qwt_plot_picker.h> -- needed for draw rubber band box in different color
30 :
31 : #include <iomanip>
32 :
33 : using namespace std;
34 :
35 : using namespace casacore;
36 : namespace casa {
37 :
38 : //////////////////////////
39 : // PLOTTOOL DEFINITIONS //
40 : //////////////////////////
41 :
42 0 : PlotTool::PlotTool(PlotCoordinate::System sys)
43 : : m_canvas(NULL),m_factory(NULL),
44 : m_active(false), m_blocking(true), m_xAxis(X_BOTTOM), m_yAxis(Y_LEFT),
45 0 : m_coordSystem(sys), m_lastEventHandled(false)
46 0 : { }
47 :
48 :
49 0 : PlotTool::PlotTool(PlotAxis xAxis, PlotAxis yAxis, PlotCoordinate::System sys)
50 : : m_canvas(NULL), m_factory(NULL), m_active(false), m_blocking(true),
51 : m_xAxis(xAxis), m_yAxis(yAxis), m_coordSystem(sys),
52 0 : m_lastEventHandled(false)
53 0 : { }
54 :
55 :
56 :
57 0 : PlotTool::~PlotTool() {
58 0 : if(m_factory != NULL) delete m_factory;
59 0 : }
60 :
61 :
62 :
63 0 : bool PlotTool::isActive() const {
64 0 : return m_active;
65 : }
66 :
67 :
68 :
69 0 : void PlotTool::setActive(bool isActive) {
70 0 : m_active = isActive;
71 0 : }
72 :
73 :
74 :
75 0 : bool PlotTool::isBlocking() const {
76 0 : return m_blocking;
77 : }
78 :
79 :
80 :
81 0 : void PlotTool::setBlocking(bool blocking) {
82 0 : m_blocking = blocking;
83 0 : }
84 :
85 :
86 :
87 0 : PlotAxis PlotTool::getXAxis() const {
88 0 : return m_xAxis;
89 : }
90 :
91 :
92 :
93 0 : PlotAxis PlotTool::getYAxis() const {
94 0 : return m_yAxis;
95 : }
96 :
97 :
98 :
99 0 : PlotCoordinate::System PlotTool::getCoordinateSystem() const {
100 0 : return m_coordSystem;
101 : }
102 :
103 :
104 :
105 0 : bool PlotTool::lastEventWasHandled() const {
106 0 : return m_lastEventHandled;
107 : }
108 :
109 :
110 :
111 0 : PlotCanvas* PlotTool::canvas() const {
112 0 : return m_canvas;
113 : }
114 :
115 :
116 :
117 0 : PlotFactory* PlotTool::factory() const {
118 0 : return m_factory;
119 : }
120 :
121 :
122 0 : bool PlotTool::isAttached() const {
123 0 : return m_canvas != NULL;
124 : }
125 :
126 :
127 :
128 0 : void PlotTool::attach(PlotCanvas* canvas) {
129 0 : if(m_canvas != NULL) detach();
130 0 : m_canvas = canvas;
131 0 : if(m_canvas != NULL) {
132 : // only generate a new factory if needed
133 0 : if(m_factory == NULL) m_factory = m_canvas->implementationFactory();
134 0 : else if(m_factory->implementation() != m_canvas->implementation()){
135 0 : delete m_factory;
136 0 : m_factory = m_canvas->implementationFactory();
137 : }
138 : }
139 0 : }
140 :
141 :
142 0 : void PlotTool::detach() { m_canvas = NULL; }
143 :
144 :
145 : ////////////////////////////////
146 : // PLOTSELECTTOOL DEFINITIONS //
147 : ////////////////////////////////
148 :
149 0 : PlotSelectTool::PlotSelectTool(PlotCoordinate::System system)
150 : : PlotMouseTool(system),
151 : m_subtraction_mode(false),
152 0 : m_drawRects(false)
153 : {
154 0 : }
155 :
156 :
157 0 : PlotSelectTool::PlotSelectTool(PlotAxis xAxis, PlotAxis yAxis,
158 0 : PlotCoordinate::System system) : PlotMouseTool(xAxis, yAxis, system),
159 : m_subtraction_mode(false),
160 0 : m_drawRects(false)
161 : {
162 0 : }
163 :
164 :
165 :
166 0 : PlotSelectTool::~PlotSelectTool() { }
167 :
168 :
169 :
170 0 : void PlotSelectTool::addNotifier(PlotSelectToolNotifier* notifier) {
171 0 : if(notifier == NULL) return;
172 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
173 0 : if(m_notifiers[i] == notifier) return;
174 0 : m_notifiers.push_back(notifier);
175 :
176 :
177 : }
178 :
179 :
180 :
181 0 : void PlotSelectTool::setSelectLine(PlotLinePtr line) {
182 0 : if(line != m_selLine) {
183 0 : m_selLine = line;
184 0 : if(m_canvas != NULL) {
185 0 : if(!line.null() && !m_subtraction_mode /*DSW:not sure if this test is needed. fix also next method.*/) m_canvas->setSelectLine(line);
186 0 : else m_canvas->setSelectLineShown(false);
187 : }
188 : }
189 0 : }
190 :
191 :
192 0 : void PlotSelectTool::setSubtractLine(PlotLinePtr line) {
193 0 : if(line != m_subLine) {
194 0 : m_subLine = line;
195 0 : if(m_canvas != NULL) {
196 0 : if(!line.null() && m_subtraction_mode) m_canvas->setSelectLine(line);
197 0 : else m_canvas->setSelectLineShown(false);
198 : }
199 : }
200 0 : }
201 :
202 :
203 :
204 :
205 0 : void PlotSelectTool::setSelectLine(bool on) {
206 0 : if(m_canvas != NULL) m_canvas->setSelectLineShown(on); }
207 :
208 :
209 :
210 0 : void PlotSelectTool::setDrawRects(bool on) {
211 0 : if(on != m_drawRects) {
212 0 : if(m_canvas != NULL && m_rects.size() > 0) {
213 0 : for(unsigned int i = 0; i < m_rects.size(); i++) {
214 0 : if(on) m_canvas->drawShape(m_rects[i]);
215 0 : else m_canvas->removeShape(m_rects[i]);
216 : }
217 : }
218 0 : m_drawRects = on;
219 : }
220 0 : }
221 :
222 :
223 :
224 0 : void PlotSelectTool::setRectLine(PlotLinePtr line) {
225 0 : if(line != m_rectLine) {
226 0 : m_rectLine = line;
227 0 : for(unsigned int i = 0; i < m_rects.size(); i++)
228 0 : m_rects[i]->setLine(line);
229 : }
230 0 : }
231 :
232 :
233 :
234 0 : void PlotSelectTool::setRectFill(PlotAreaFillPtr fill) {
235 0 : if(fill != m_rectFill) {
236 0 : m_rectFill = fill;
237 0 : for(unsigned int i = 0; i < m_rects.size(); i++)
238 0 : m_rects[i]->setAreaFill(fill);
239 : }
240 0 : }
241 :
242 :
243 :
244 0 : unsigned int PlotSelectTool::numSelectedRects() const {
245 0 : return m_rects.size();
246 : }
247 :
248 :
249 :
250 0 : void PlotSelectTool::getSelectedRects(vector<double>& upperLeftXs,
251 : vector<double>& upperLeftYs, vector<double>& lowerRightXs,
252 : vector<double>& lowerRightYs, PlotCoordinate::System system) const {
253 0 : vector<PlotRegion> v = getSelectedRects(system);
254 0 : upperLeftXs.resize(v.size()); upperLeftYs.resize(v.size());
255 0 : lowerRightXs.resize(v.size()); lowerRightYs.resize(v.size());
256 0 : for(unsigned int i = 0; i < v.size(); i++) {
257 0 : upperLeftXs[i] = v[i].upperLeft().x();
258 0 : upperLeftYs[i] = v[i].upperLeft().y();
259 0 : lowerRightXs[i] = v[i].lowerRight().x();
260 0 : lowerRightYs[i] = v[i].lowerRight().y();
261 : }
262 0 : }
263 :
264 0 : int PlotSelectTool::getSelectedRectCount(){
265 0 : return m_rects.size();
266 : }
267 :
268 : vector<PlotRegion>
269 0 : PlotSelectTool::getSelectedRects(PlotCoordinate::System system) const {
270 0 : vector<PlotRegion> v(m_rects.size());
271 0 : vector<PlotCoordinate> coords;
272 0 : for(unsigned int i = 0; i < v.size(); i++) {
273 0 : coords = m_rects[i]->coordinates();
274 : // WARNING: assumption that the PlotRectangle implementation behaves
275 : // correctly.
276 0 : if(coords[0].system() != system && m_canvas != NULL)
277 0 : coords[0] = m_canvas->convertCoordinate(coords[0], system);
278 0 : if(coords[1].system() != system && m_canvas != NULL)
279 0 : coords[1] = m_canvas->convertCoordinate(coords[1], system);
280 0 : v[i] = PlotRegion(coords[0], coords[1]);
281 : }
282 0 : return v;
283 : }
284 :
285 :
286 :
287 0 : void PlotSelectTool::clearSelectedRects() {
288 0 : if(m_drawRects && m_canvas != NULL && m_rects.size() > 0) {
289 0 : vector<PlotItemPtr> v(m_rects.size());
290 0 : for(unsigned int i = 0; i < v.size(); i++) v[i] = m_rects[i];
291 0 : m_canvas->removePlotItems(v);
292 : }
293 0 : m_rects.clear();
294 0 : }
295 :
296 :
297 :
298 0 : void PlotSelectTool::setActive(bool active) {
299 : // We may be acting as either a genuine Select Tool, or as a Subtraction Tool
300 : // The distinction is found from m_subtraction_mode
301 :
302 : // Set line style etc only if different from existing
303 0 : if (active == m_active) return;
304 0 : PlotMouseTool::setActive(active);
305 :
306 0 : if (!m_canvas) return;
307 :
308 0 : if (active) {
309 0 : if (m_subtraction_mode) {
310 0 : if (!m_subLine.null()) m_canvas->setSelectLine(m_subLine);
311 : }
312 : else {
313 0 : if (!m_selLine.null()) m_canvas->setSelectLine(m_selLine);
314 : }
315 : }
316 : else {
317 0 : m_canvas->setCursor(NORMAL_CURSOR);
318 : }
319 :
320 0 : m_canvas->setSelectLineShown(active);
321 : }
322 :
323 :
324 :
325 :
326 0 : void PlotSelectTool::handleMouseEvent(const PlotEvent& event) {
327 0 : m_lastEventHandled = false;
328 0 : if(m_canvas == NULL || !m_active) return; // shouldn't happen
329 :
330 : // cursor nice-ness
331 : const PlotMousePressEvent* mp; const PlotMouseReleaseEvent* mr;
332 0 : if((mp = dynamic_cast<const PlotMousePressEvent*>(&event)) != NULL) {
333 0 : m_canvas->setCursor(CROSSHAIR);
334 : // restore the following lines after figuring out how to make #include <qwt/qwt_plot_picker.h> compile - needs tweak of cmake files
335 : ////!!!!! QwtPlotPicker *pp = m_canvas->getSelecter(); // http://www.qtcentre.org/threads/33160-Different-Colored-Rectangles-in-QwtPlotPicker
336 : ////!!!!! pp->setRubberBandPen( QColor( Qt::blue ) );
337 : }
338 0 : else if((mr = dynamic_cast<const PlotMouseReleaseEvent*>(&event)) != NULL) {
339 0 : m_canvas->setCursor(NORMAL_CURSOR);
340 : }
341 :
342 : // for now we only care about select events, assuming that the canvas has
343 : // done its selection-pen-drawing duty
344 0 : const PlotSelectEvent* select = dynamic_cast<const PlotSelectEvent*>(&event);
345 0 : if(select != NULL && m_canvas != NULL) {
346 0 : PlotRegion r = select->region();
347 0 : if(r.upperLeft().system() != m_coordSystem ||
348 0 : r.lowerRight().system() != m_coordSystem)
349 0 : r = m_canvas->convertRegion(r, m_coordSystem);
350 :
351 : // The rectangle the user just finished dragging out with the mouse
352 0 : PlotShapeRectanglePtr rect = m_factory->shapeRectangle(r.upperLeft(), r.lowerRight());
353 :
354 0 : if (m_subtraction_mode) {
355 :
356 0 : float zapper_x1 = r.upperLeft().x();
357 0 : float zapper_x2 = r.lowerRight().x();
358 0 : float zapper_y1 = r.lowerRight().y();
359 0 : float zapper_y2 = r.upperLeft().y();
360 :
361 0 : int n = m_rects.size();
362 0 : for (int j=n-1; j>=0; j--) {
363 :
364 : // test if [j]th rect in our list m_rects fits inside the newly dragged rect
365 0 : PlotShapeRectanglePtr pr = m_rects[j];
366 0 : vector<PlotCoordinate> coords = pr->coordinates();
367 0 : float x1 = min(coords[0].x(), coords[1].x() );
368 0 : float x2 = max(coords[0].x(), coords[1].x() );
369 0 : float y1 = min(coords[0].y(), coords[1].y() );
370 0 : float y2 = max(coords[0].y(), coords[1].y() );
371 :
372 0 : bool it_fits = (x1 >= zapper_x1)
373 0 : && (x2 <= zapper_x2)
374 0 : && (y1 >= zapper_y1)
375 0 : && (y2 <= zapper_y2);
376 :
377 0 : if (it_fits) {
378 : // Must remove both the PlotItem in the canvas and the rect in our list
379 0 : m_canvas->removePlotItem(pr);
380 0 : m_rects.erase( m_rects.begin()+ j);
381 : }
382 : }
383 : #if (0) // testing overlap logic
384 : printf("\n\n Post-surgical stats: m_rects n=%d \n\n", (int)m_rects.size() );
385 : #endif
386 0 : m_lastEventHandled = true;
387 :
388 : }
389 : else {
390 : // Normal addition of a new region to the list
391 0 : rect->setLine(m_rectLine);
392 0 : rect->setAreaFill(m_rectFill);
393 0 : if(m_drawRects) m_canvas->plotItem(rect, ANNOTATION);
394 0 : m_rects.push_back(rect);
395 0 : m_lastEventHandled = true;
396 : }
397 :
398 : // Whether adding or subtracting regions, notify anyone who asked to be informed
399 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
400 0 : m_notifiers[i]->notifySelectionAdded(*this);
401 : }
402 : }
403 :
404 :
405 :
406 0 : void PlotSelectTool::attach(PlotCanvas* canvas) {
407 0 : PlotMouseTool::attach(canvas);
408 0 : if(canvas != NULL && m_active) {
409 0 : for(unsigned int i = 0; i < m_rects.size(); i++)
410 0 : canvas->drawShape(m_rects[i]);
411 0 : if (m_subtraction_mode) {
412 0 : if(!m_selLine.null()) m_canvas->setSelectLine(m_subLine);
413 0 : else m_canvas->setSelectLineShown(true);
414 : }
415 : else {
416 0 : if(!m_subLine.null()) m_canvas->setSelectLine(m_selLine);
417 0 : else m_canvas->setSelectLineShown(true);
418 : }
419 : }
420 0 : }
421 :
422 :
423 :
424 0 : void PlotSelectTool::detach() {
425 0 : if(m_canvas != NULL && m_drawRects && m_rects.size() > 0) {
426 0 : for(unsigned int i = 0; i < m_rects.size(); i++)
427 0 : m_canvas->removeShape(m_rects[i]);
428 : }
429 0 : if(m_canvas != NULL) {
430 0 : m_canvas->setCursor(NORMAL_CURSOR);
431 0 : m_canvas->setSelectLineShown(false);
432 : }
433 0 : PlotMouseTool::detach();
434 0 : }
435 :
436 :
437 :
438 :
439 :
440 : //////////////////////////////
441 : // PLOTZOOMTOOL DEFINITIONS //
442 : //////////////////////////////
443 :
444 :
445 0 : PlotZoomTool::PlotZoomTool(PlotCoordinate::System sys) : PlotMouseTool(sys),
446 0 : m_stack(NULL) { }
447 :
448 :
449 0 : PlotZoomTool::PlotZoomTool(PlotAxis xAxis, PlotAxis yAxis,
450 0 : PlotCoordinate::System sys) : PlotMouseTool(xAxis, yAxis, sys),
451 0 : m_stack(NULL) { }
452 :
453 :
454 :
455 0 : PlotZoomTool::~PlotZoomTool() { }
456 :
457 :
458 :
459 0 : void PlotZoomTool::addNotifier(PlotZoomToolNotifier* notifier) {
460 0 : if(notifier == NULL) return;
461 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
462 0 : if(m_notifiers[i] == notifier) return;
463 0 : m_notifiers.push_back(notifier);
464 : }
465 :
466 :
467 :
468 0 : void PlotZoomTool::setSelectLine(PlotLinePtr line) {
469 0 : if(line != m_selLine) {
470 0 : m_selLine = line;
471 0 : if(m_canvas != NULL) {
472 0 : if(!line.null()) m_canvas->setSelectLine(line);
473 0 : else m_canvas->setSelectLineShown(false);
474 : }
475 : }
476 0 : }
477 :
478 0 : void PlotZoomTool::setSelectLine(bool on) {
479 0 : if(m_canvas != NULL && m_active) m_canvas->setSelectLineShown(on); }
480 :
481 0 : vector<PlotRegion> PlotZoomTool::getZoomStack(PlotCoordinate::System s) const {
482 0 : if(m_stack == NULL) return vector<PlotRegion>();
483 :
484 0 : vector<PlotRegion> stack = m_stack->stack();
485 0 : if(s == m_coordSystem || m_stack->size() == 0 || m_canvas == NULL)
486 0 : return stack;
487 :
488 0 : vector<PlotRegion> v(stack.size());
489 0 : for(unsigned int i = 0; i < v.size(); i++)
490 0 : v[i] = m_canvas->convertRegion(stack[i], s);
491 0 : return v;
492 : }
493 :
494 0 : unsigned int PlotZoomTool::getStackIndex() const {
495 0 : if(m_stack == NULL) return 0;
496 0 : else return m_stack->stackIndex();
497 : }
498 :
499 0 : void PlotZoomTool::setActive(bool active) {
500 0 : if(active != m_active) {
501 0 : PlotMouseTool::setActive(active);
502 0 : if(m_canvas != NULL) {
503 0 : if(active && !m_selLine.null()) m_canvas->setSelectLine(m_selLine);
504 0 : else m_canvas->setSelectLineShown(active);
505 0 : if(!active) m_canvas->setCursor(NORMAL_CURSOR);
506 0 : if(active && m_stack->size() <= 1)
507 0 : m_stack->setBase(m_canvas->axesRanges(m_xAxis, m_yAxis),
508 : m_xAxis, m_yAxis);
509 : }
510 : }
511 0 : }
512 :
513 0 : void PlotZoomTool::handleMouseEvent(const PlotEvent& event) {
514 0 : m_lastEventHandled = false;
515 0 : if(m_canvas == NULL || !m_active) return;
516 :
517 : // cursor nice-ness
518 : const PlotMousePressEvent* mp; const PlotMouseReleaseEvent* mr;
519 0 : if((mp = dynamic_cast<const PlotMousePressEvent*>(&event)) != NULL)
520 0 : m_canvas->setCursor(CROSSHAIR);
521 0 : else if((mr = dynamic_cast<const PlotMouseReleaseEvent*>(&event)) != NULL)
522 0 : m_canvas->setCursor(NORMAL_CURSOR);
523 :
524 : const PlotSelectEvent* s; const PlotWheelEvent* w; const PlotClickEvent* c;
525 :
526 : // on select: zoom to area
527 0 : if((s = dynamic_cast<const PlotSelectEvent*>(&event)) != NULL) {
528 0 : PlotRegion r = s->region();
529 0 : if(r.upperLeft().system() != m_coordSystem ||
530 0 : r.lowerRight().system() != m_coordSystem)
531 0 : r = m_canvas->convertRegion(r, m_coordSystem);
532 :
533 0 : m_stack->addRegion(r, m_xAxis, m_yAxis);
534 0 : if(m_coordSystem != PlotCoordinate::WORLD)
535 0 : r = m_canvas->convertRegion(r, PlotCoordinate::WORLD);
536 0 : m_canvas->setAxesRegion(m_xAxis, m_yAxis, r);
537 0 : m_lastEventHandled = true;
538 :
539 : // on wheel go through zoom stack
540 0 : } else if((w = dynamic_cast<const PlotWheelEvent*>(&event)) != NULL) {
541 0 : m_canvas->axesStackMove(w->delta());
542 0 : m_lastEventHandled = true;
543 :
544 : // go to base on right click, zoom in 50% centered on double click
545 0 : } else if((c = dynamic_cast<const PlotClickEvent*>(&event)) != NULL) {
546 0 : if(c->button() == PlotClickEvent::CONTEXT) {
547 0 : m_canvas->axesStackMove(0);
548 0 : m_lastEventHandled = true;
549 :
550 0 : } else if(c->button() == PlotClickEvent::DOUBLE) {
551 0 : prange_t xRange = m_canvas->axisRange(m_xAxis),
552 0 : yRange = m_canvas->axisRange(m_yAxis);
553 0 : double xDelta = (xRange.second - xRange.first) / 4,
554 0 : yDelta = (yRange.second - yRange.first) / 4;
555 0 : PlotCoordinate coord = c->where();
556 0 : if(coord.system() != PlotCoordinate::WORLD)
557 0 : coord=m_canvas->convertCoordinate(coord,PlotCoordinate::WORLD);
558 :
559 0 : PlotRegion r(PlotCoordinate(coord.x()- xDelta, coord.y()+ yDelta),
560 0 : PlotCoordinate(coord.x()+ xDelta, coord.y()- yDelta));
561 0 : if(m_coordSystem != PlotCoordinate::WORLD)
562 0 : m_stack->addRegion(m_canvas->convertRegion(r, m_coordSystem),
563 : m_xAxis, m_yAxis);
564 0 : else m_stack->addRegion(r, m_xAxis, m_yAxis);
565 0 : m_canvas->setAxesRegion(m_xAxis, m_yAxis, r);
566 0 : m_lastEventHandled = true;
567 : }
568 : }
569 :
570 0 : if(m_lastEventHandled) notifyWatchers();
571 : }
572 :
573 0 : void PlotZoomTool::reset() {
574 0 : if(m_stack != NULL) m_stack->clearStack(true);
575 0 : }
576 :
577 :
578 0 : void PlotZoomTool::attach(PlotCanvas* canvas) {
579 0 : PlotMouseTool::attach(canvas);
580 0 : if(canvas != NULL) m_stack = &canvas->axesStack();
581 0 : if(canvas != NULL && m_active) {
582 0 : if(!m_selLine.null()) m_canvas->setSelectLine(m_selLine);
583 0 : else m_canvas->setSelectLineShown(false);
584 0 : if(m_stack->size() == 0)
585 0 : m_stack->setBase(m_canvas->axesRanges(m_xAxis, m_yAxis),
586 : m_xAxis, m_yAxis);
587 : }
588 0 : }
589 :
590 0 : void PlotZoomTool::detach() {
591 0 : if(m_canvas != NULL) {
592 0 : m_canvas->setCursor(NORMAL_CURSOR);
593 0 : m_canvas->setSelectLineShown(false);
594 : }
595 0 : m_stack = NULL;
596 0 : PlotMouseTool::detach();
597 0 : }
598 :
599 0 : void PlotZoomTool::notifyWatchers() {
600 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
601 0 : m_notifiers[i]->notifyZoomChanged(*this);
602 0 : }
603 :
604 :
605 : /////////////////////////////
606 : // PLOTPANTOOL DEFINITIONS //
607 : /////////////////////////////
608 :
609 0 : PlotPanTool::PlotPanTool(PlotCoordinate::System sys) : PlotMouseTool(sys),
610 0 : m_inDraggingMode(false), m_stack(NULL) { }
611 :
612 0 : PlotPanTool::PlotPanTool(PlotAxis xAxis, PlotAxis yAxis,
613 0 : PlotCoordinate::System sys) : PlotMouseTool(xAxis, yAxis, sys),
614 0 : m_inDraggingMode(false), m_stack(NULL) { }
615 :
616 0 : PlotPanTool::~PlotPanTool() { }
617 :
618 0 : void PlotPanTool::addNotifier(PlotPanToolNotifier* notifier) {
619 0 : if(notifier == NULL) return;
620 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
621 0 : if(m_notifiers[i] == notifier) return;
622 0 : m_notifiers.push_back(notifier);
623 : }
624 :
625 0 : vector<PlotRegion> PlotPanTool::getPanStack(PlotCoordinate::System s) const {
626 0 : if(m_stack == NULL) return vector<PlotRegion>();
627 :
628 0 : vector<PlotRegion> stack = m_stack->stack();
629 0 : if(s == m_coordSystem || m_stack->size() == 0 || m_canvas == NULL)
630 0 : return stack;
631 :
632 0 : vector<PlotRegion> v(stack.size());
633 0 : for(unsigned int i = 0; i < v.size(); i++)
634 0 : v[i] = m_canvas->convertRegion(stack[i], s);
635 0 : return v;
636 : }
637 :
638 0 : unsigned int PlotPanTool::getStackIndex() const {
639 0 : if(m_stack == NULL) return 0;
640 0 : else return m_stack->stackIndex();
641 : }
642 :
643 0 : void PlotPanTool::setActive(bool active) {
644 0 : if(active != m_active) {
645 0 : PlotMouseTool::setActive(active);
646 0 : if(m_canvas != NULL) {
647 0 : m_canvas->setCursor(active ? HAND_OPEN : NORMAL_CURSOR);
648 0 : if(active && m_stack->size() == 0)
649 0 : m_stack->setBase(m_canvas->axesRanges(m_xAxis, m_yAxis),
650 : m_xAxis, m_yAxis);
651 : }
652 : }
653 0 : }
654 :
655 0 : void PlotPanTool::handleMouseEvent(const PlotEvent& event) {
656 0 : m_lastEventHandled = false;
657 0 : if(m_canvas == NULL) return;
658 :
659 : const PlotMousePressEvent* mp;
660 : const PlotMouseReleaseEvent* mr;
661 : const PlotMouseDragEvent* mm;
662 : const PlotWheelEvent* w;
663 : const PlotClickEvent* c;
664 :
665 : // dragging
666 0 : if((mp = dynamic_cast<const PlotMousePressEvent*>(&event)) != NULL) {
667 0 : if(mp->button() != PlotClickEvent::SINGLE &&
668 0 : mp->button() != PlotClickEvent::DOUBLE) return;
669 0 : m_inDraggingMode = true;
670 0 : m_canvas->setCursor(HAND_CLOSED);
671 0 : m_lastCoord = mp->where();
672 0 : if(m_lastCoord.system() != PlotCoordinate::WORLD)
673 0 : m_lastCoord = m_canvas->convertCoordinate(m_lastCoord);
674 0 : m_lastEventHandled = true;
675 :
676 0 : } else if((mr= dynamic_cast<const PlotMouseReleaseEvent*>(&event))!= NULL){
677 0 : if(!m_inDraggingMode) return;
678 0 : m_inDraggingMode = false;
679 0 : m_canvas->setCursor(HAND_OPEN);
680 0 : m_stack->addRegion(m_canvas->axesRanges(m_xAxis, m_yAxis),
681 : m_xAxis, m_yAxis);
682 0 : m_lastEventHandled = true;
683 :
684 0 : } else if((mm = dynamic_cast<const PlotMouseDragEvent*>(&event)) != NULL) {
685 0 : if(!m_inDraggingMode) return;
686 0 : PlotCoordinate c = mm->where();
687 0 : if(c.system() != PlotCoordinate::WORLD)
688 0 : c = m_canvas->convertCoordinate(c);
689 0 : m_canvas->moveAxesRanges(m_xAxis, m_lastCoord.x() - c.x(),
690 0 : m_yAxis, m_lastCoord.y() - c.y());
691 0 : m_lastCoord = c;
692 0 : m_lastEventHandled = true;
693 :
694 : // stack navigation
695 0 : } else if((w = dynamic_cast<const PlotWheelEvent*>(&event)) != NULL) {
696 0 : m_canvas->axesStackMove(w->delta());
697 0 : m_lastEventHandled = true;
698 :
699 0 : } else if((c = dynamic_cast<const PlotClickEvent*>(&event)) != NULL) {
700 0 : if(c->button() == PlotClickEvent::CONTEXT) {
701 0 : m_canvas->axesStackMove(0);
702 0 : m_lastEventHandled = true;
703 : }
704 : }
705 :
706 0 : if(m_lastEventHandled) notifyWatchers();
707 : }
708 :
709 0 : void PlotPanTool::reset() {
710 0 : if(m_stack != NULL) m_stack->clearStack(true);
711 0 : }
712 :
713 :
714 0 : void PlotPanTool::attach(PlotCanvas* canvas) {
715 0 : PlotMouseTool::attach(canvas);
716 0 : if(canvas != NULL) {
717 0 : m_stack = &canvas->axesStack();
718 0 : if(m_active && m_stack->size() == 0)
719 0 : m_stack->setBase(m_canvas->axesRanges(m_xAxis, m_yAxis),
720 : m_xAxis, m_yAxis);
721 : }
722 0 : }
723 :
724 0 : void PlotPanTool::detach() {
725 0 : if(m_canvas != NULL) m_canvas->setCursor(NORMAL_CURSOR);
726 0 : m_stack = NULL;
727 0 : PlotMouseTool::detach();
728 0 : }
729 :
730 0 : void PlotPanTool::notifyWatchers() {
731 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
732 0 : m_notifiers[i]->notifyPanChanged(*this);
733 0 : }
734 :
735 :
736 : /////////////////////////////////
737 : // PLOTTRACKERTOOL DEFINITIONS //
738 : /////////////////////////////////
739 :
740 0 : PlotTrackerTool::PlotTrackerTool(PlotCoordinate::System sys) :
741 0 : PlotMouseTool(sys), m_drawText(false), m_format(DEFAULT_FORMAT) { }
742 :
743 0 : PlotTrackerTool::PlotTrackerTool(PlotAxis xAxis, PlotAxis yAxis,
744 0 : PlotCoordinate::System sys) : PlotMouseTool(xAxis, yAxis, sys),
745 0 : m_drawText(false), m_format(DEFAULT_FORMAT) { }
746 :
747 0 : PlotTrackerTool::~PlotTrackerTool() { }
748 :
749 0 : void PlotTrackerTool::addNotifier(PlotTrackerToolNotifier* notifier) {
750 0 : if(notifier == NULL) return;
751 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
752 0 : if(m_notifiers[i] == notifier) return;
753 0 : m_notifiers.push_back(notifier);
754 : }
755 :
756 0 : void PlotTrackerTool::setDrawText(bool draw) { m_drawText = draw; }
757 0 : bool PlotTrackerTool::drawsText() const { return m_drawText; }
758 :
759 0 : void PlotTrackerTool::setFormat(const String& format) { m_format = format; }
760 :
761 0 : PlotAnnotationPtr PlotTrackerTool::getAnnotation() { return m_annotation; }
762 :
763 0 : PlotCoordinate PlotTrackerTool::getCoordinate(PlotCoordinate::System s) const {
764 0 : if(m_annotation.null() || m_canvas == NULL) return PlotCoordinate();
765 0 : PlotCoordinate c = m_annotation->coordinate();
766 0 : if(s == c.system()) return c;
767 0 : else return m_canvas->convertCoordinate(c, s);
768 : }
769 :
770 0 : void PlotTrackerTool::setActive(bool active) {
771 0 : if(active != m_active) {
772 0 : PlotMouseTool::setActive(active);
773 0 : if(m_canvas != NULL && !m_annotation.null())
774 0 : m_canvas->removeAnnotation(m_annotation);
775 : }
776 0 : }
777 :
778 0 : void PlotTrackerTool::handleMouseEvent(const PlotEvent& ev) {
779 0 : m_lastEventHandled = false;
780 0 : if(m_canvas == NULL) return;
781 :
782 0 : const PlotMouseMoveEvent* m = dynamic_cast<const PlotMouseMoveEvent*>(&ev);
783 0 : if(m != NULL) {
784 0 : bool autorescale = m_canvas->axesAutoRescale();
785 0 : if(m_drawText && !m_annotation.null()) {
786 0 : m_canvas->removeAnnotation(m_annotation);
787 0 : m_canvas->setAxesAutoRescale(false);
788 : }
789 0 : PlotCoordinate c = m->where();
790 0 : m_annotation->setCoordinate(c);
791 0 : m_annotation->setText(formattedString(c.x(), c.y()));
792 0 : if(m_drawText) {
793 0 : m_canvas->plotItem(m_annotation, ANNOTATION);
794 0 : m_canvas->setAxesAutoRescale(autorescale);
795 : }
796 0 : m_lastEventHandled = true;
797 : }
798 :
799 0 : if(m_lastEventHandled) notifyWatchers();
800 : }
801 :
802 :
803 : // Protected Methods //
804 :
805 0 : void PlotTrackerTool::attach(PlotCanvas* canvas) {
806 0 : PlotMouseTool::attach(canvas);
807 0 : if(m_canvas != NULL) {
808 0 : m_annotation = m_factory->annotation("", PlotCoordinate());
809 0 : if(m_active) {
810 0 : PlotMouseMoveEventHandlerPtr h(this, false);
811 0 : m_canvas->registerMouseMoveHandler(h, m_coordSystem);
812 : }
813 : }
814 0 : }
815 :
816 0 : void PlotTrackerTool::detach() {
817 0 : if(m_canvas != NULL && m_active) {
818 0 : PlotMouseMoveEventHandlerPtr h(this, false);
819 0 : m_canvas->unregisterMouseMoveHandler(h);
820 0 : m_canvas->removePlotItem(m_annotation);
821 : }
822 0 : PlotMouseTool::detach();
823 0 : m_annotation = NULL;
824 0 : }
825 :
826 0 : void PlotTrackerTool::notifyWatchers() {
827 0 : for(unsigned int i = 0; i < m_notifiers.size(); i++)
828 0 : m_notifiers[i]->notifyTrackerChanged(*this);
829 0 : }
830 :
831 :
832 : // Static Members //
833 :
834 0 : String PlotTrackerTool::formattedString(const String& format, double x,
835 : double y, PlotCanvas* canvas, PlotAxis xAxis, PlotAxis yAxis) {
836 0 : stringstream ss;
837 :
838 0 : unsigned int i = 0, j = 0;
839 0 : String token;
840 0 : while(i < format.length()) {
841 : // get the next token
842 0 : j = format.find(FORMAT_DIVIDER, i);
843 0 : if(j > i) {
844 0 : if(j < format.size()) { // text between i and token
845 0 : ss << format.substr(i, (j - i));
846 0 : i = j;
847 :
848 : } else { // no next tokens
849 0 : ss << format.substr(i);
850 0 : break;
851 : }
852 : }
853 :
854 : // i points to the first character of the divider
855 0 : i += FORMAT_DIVIDER.size();
856 : // i points to the first character of the token
857 :
858 0 : j = format.find(FORMAT_DIVIDER, i);
859 0 : if(j >= format.size()) {
860 : // no closing divider
861 0 : i -= FORMAT_DIVIDER.size();
862 0 : ss << format.substr(i);
863 0 : break;
864 : }
865 :
866 0 : token = format.substr(i, (j - i));
867 0 : i = j + FORMAT_DIVIDER.size(); // i after token
868 :
869 0 : if(token == FORMAT_X) {
870 0 : PlotAxisScale scale = canvas->axisScale(xAxis);
871 0 : String format(canvas->dateFormat()); format.gsub("\n", " ");
872 0 : if(scale == DATE_MJ_SEC || scale == DATE_MJ_DAY)
873 0 : ss << Plotter::formattedDateString(format, x, scale);
874 0 : else ss << x;
875 :
876 0 : } else if(token == FORMAT_Y) {
877 0 : PlotAxisScale scale = canvas->axisScale(yAxis);
878 0 : String format(canvas->dateFormat()); format.gsub("\n", " ");
879 0 : if(scale == DATE_MJ_SEC || scale == DATE_MJ_DAY)
880 0 : ss << Plotter::formattedDateString(format, y, scale);
881 0 : else ss << y;
882 :
883 0 : } else if(token.substr(0, FORMAT_PRECISION.size())== FORMAT_PRECISION){
884 0 : if(token.size() == FORMAT_PRECISION.size()) // invalid
885 0 : ss << FORMAT_DIVIDER << FORMAT_PRECISION << FORMAT_DIVIDER;
886 : else {
887 0 : token = token.substr(FORMAT_PRECISION.size());
888 : int prec;
889 0 : if(sscanf(token.c_str(), "%d", &prec) == 1)
890 0 : ss << setprecision(prec);
891 : else // invalid
892 : ss << FORMAT_DIVIDER << FORMAT_PRECISION << token
893 0 : << FORMAT_DIVIDER;
894 : }
895 :
896 : } else {
897 : // not a valid token
898 0 : ss << FORMAT_DIVIDER << token << FORMAT_DIVIDER;
899 : }
900 : }
901 :
902 0 : return ss.str();
903 : }
904 :
905 : const String PlotTrackerTool::FORMAT_DIVIDER = "%%";
906 : const String PlotTrackerTool::FORMAT_X = "x";
907 : const String PlotTrackerTool::FORMAT_Y = "y";
908 : const String PlotTrackerTool::FORMAT_PRECISION = "p";
909 :
910 : const String PlotTrackerTool::DEFAULT_FORMAT = "("+FORMAT_DIVIDER+FORMAT_X+
911 : FORMAT_DIVIDER + ", " + FORMAT_DIVIDER+FORMAT_Y+FORMAT_DIVIDER + ")";
912 :
913 :
914 : /////////////////////////////////
915 : // PLOTFLAGALLTOOL DEFINITIONS //
916 : /////////////////////////////////
917 :
918 0 : PlotFlagAllTool::PlotFlagAllTool(PlotCoordinate::System sys) :
919 : PlotMouseTool(sys),
920 : m_draw(true),
921 : m_bgcolor_changed(false),
922 : m_marked(PlotFlagAllTool::PPFLAG_NONE),
923 0 : m_defaultBackground(NULL)
924 0 : { }
925 :
926 0 : PlotFlagAllTool::PlotFlagAllTool(PlotAxis xAxis, PlotAxis yAxis,
927 0 : PlotCoordinate::System sys) : PlotMouseTool(xAxis, yAxis, sys),
928 : m_draw(true),
929 : m_bgcolor_changed(false),
930 : m_marked(PlotFlagAllTool::PPFLAG_NONE),
931 0 : m_defaultBackground(NULL)
932 0 : { }
933 :
934 0 : PlotFlagAllTool::~PlotFlagAllTool() { }
935 :
936 0 : void PlotFlagAllTool::setUpdateBackground(bool on) {
937 0 : m_draw = on;
938 0 : }
939 :
940 0 : bool PlotFlagAllTool::isUpdateBackgroundActive() {
941 0 : return m_draw;
942 : }
943 :
944 0 : void PlotFlagAllTool::clearMark() {
945 0 : m_marked = PlotFlagAllTool::PPFLAG_NONE;
946 0 : m_bgcolor_changed = false;
947 0 : }
948 :
949 0 : bool PlotFlagAllTool::isMarkedForFlag() const {
950 0 : return m_marked == PlotFlagAllTool::PPFLAG_FLAG;
951 : }
952 :
953 0 : bool PlotFlagAllTool::isMarkedForUnflag() const {
954 0 : return m_marked == PlotFlagAllTool::PPFLAG_UNFLAG;
955 : }
956 :
957 0 : bool PlotFlagAllTool::isBackgroundColorChanged() const {
958 0 : return m_bgcolor_changed;
959 : }
960 :
961 0 : void PlotFlagAllTool::setAllFlagged() {
962 0 : m_canvas->setBackground("yellow", PlotAreaFill::MESH1);
963 0 : m_bgcolor_changed = true;
964 0 : }
965 :
966 0 : void PlotFlagAllTool::markAsFlag() {
967 0 : if (m_draw) {
968 0 : m_canvas->setBackground("yellow", PlotAreaFill::MESH1);
969 0 : m_bgcolor_changed = true;
970 : }
971 0 : m_marked = PlotFlagAllTool::PPFLAG_FLAG;
972 0 : }
973 :
974 0 : void PlotFlagAllTool::markAsUnflag() {
975 0 : if (m_draw) {
976 0 : m_canvas->setBackground(m_defaultBackground);
977 0 : m_bgcolor_changed = false;
978 : }
979 0 : m_marked = PlotFlagAllTool::PPFLAG_UNFLAG;
980 0 : }
981 :
982 0 : void PlotFlagAllTool::handleMouseEvent(const PlotEvent& event) {
983 0 : m_lastEventHandled = false;
984 0 : if(m_canvas == NULL) return;
985 :
986 0 : const PlotClickEvent *c = dynamic_cast<const PlotClickEvent*>(&event);
987 0 : if(c != NULL) {
988 : // get default background setting
989 0 : auto const canvas = c->canvas();
990 :
991 : // do nothing if canvas is empty
992 0 : if (canvas->title().empty()) {
993 0 : return;
994 : }
995 :
996 0 : if (m_defaultBackground.null()) {
997 0 : m_defaultBackground = canvas->defaultBackground();
998 : }
999 :
1000 : // mark canvas and change background
1001 0 : switch (m_marked) {
1002 0 : case PlotFlagAllTool::PPFLAG_FLAG:
1003 0 : markAsUnflag();
1004 0 : break;
1005 0 : case PlotFlagAllTool::PPFLAG_UNFLAG:
1006 0 : markAsFlag();
1007 0 : break;
1008 0 : default:
1009 0 : if (m_bgcolor_changed) {
1010 0 : markAsUnflag();
1011 : } else {
1012 0 : markAsFlag();
1013 : }
1014 0 : break;
1015 : }
1016 0 : m_canvas->refresh();
1017 :
1018 0 : m_lastEventHandled = true;
1019 : }
1020 : }
1021 :
1022 : ////////////////////////////////////
1023 : // PLOTMOUSETOOLGROUP DEFINITIONS //
1024 : ////////////////////////////////////
1025 :
1026 : // Public Methods //
1027 :
1028 0 : PlotMouseToolGroup::PlotMouseToolGroup() { }
1029 :
1030 :
1031 0 : PlotMouseToolGroup::~PlotMouseToolGroup() { }
1032 :
1033 :
1034 :
1035 0 : unsigned int PlotMouseToolGroup::numTools() const { return m_tools.size(); }
1036 :
1037 :
1038 0 : vector<PlotMouseToolPtr> PlotMouseToolGroup::tools() const { return m_tools; }
1039 :
1040 :
1041 0 : unsigned int PlotMouseToolGroup::addTool(PlotMouseToolPtr tool) {
1042 0 : if(tool.null()) return m_tools.size();
1043 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1044 0 : if(m_tools[i] == tool) return i;
1045 :
1046 0 : m_tools.push_back(tool);
1047 0 : if(m_canvas != NULL) tool->attach(m_canvas);
1048 :
1049 : // bookkeeping: blocking, active, active tool
1050 0 : tool->setBlocking(m_blocking);
1051 0 : tool->setActive(false);
1052 :
1053 0 : return m_tools.size() - 1;
1054 : }
1055 :
1056 :
1057 :
1058 0 : bool PlotMouseToolGroup::removeTool(PlotMouseToolPtr tool) {
1059 0 : if (tool.null()) return false;
1060 0 : for (unsigned int i = 0; i < m_tools.size(); i++) {
1061 0 : if (m_tools[i] == tool) {
1062 0 : m_tools.erase(m_tools.begin() + i);
1063 0 : if (tool == m_activeTool) {
1064 0 : if (m_tools.size() > 0) setActiveTool(m_tools[0]);
1065 0 : else m_activeTool = PlotMouseToolPtr();
1066 : }
1067 0 : return true;
1068 : }
1069 : }
1070 0 : return false;
1071 : }
1072 :
1073 :
1074 :
1075 0 : PlotMouseToolPtr PlotMouseToolGroup::toolAt(unsigned int index) const {
1076 0 : if(index < m_tools.size()) return m_tools[index];
1077 0 : else return PlotMouseToolPtr();
1078 : }
1079 :
1080 :
1081 :
1082 0 : unsigned int PlotMouseToolGroup::indexOf(PlotMouseToolPtr tool) const {
1083 0 : if(tool.null()) return m_tools.size();
1084 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1085 0 : if(m_tools[i] == tool) return i;
1086 0 : return m_tools.size();
1087 : }
1088 :
1089 :
1090 :
1091 0 : void PlotMouseToolGroup::setActiveTool(PlotMouseToolPtr tool, ToolCode toolcode) {
1092 :
1093 0 : addTool(tool);
1094 0 : m_activeTool = tool; /* FIND-ME DEBUG - DSW 878*/
1095 :
1096 0 : for (unsigned int i = 0; i < m_tools.size(); i++)
1097 0 : m_tools[i]->setActive(false);
1098 :
1099 0 : if (!tool.null()) {
1100 0 : PlotSelectTool* seltool = dynamic_cast<PlotSelectTool*> (&*tool);
1101 0 : if (seltool!=NULL) {
1102 0 : seltool->m_subtraction_mode = (toolcode==SUBTRACT_TOOL);
1103 : }
1104 0 : tool->setActive(m_active);
1105 : }
1106 0 : }
1107 :
1108 :
1109 :
1110 0 : void PlotMouseToolGroup::setActive(bool isActive) {
1111 0 : PlotMouseTool::setActive(isActive);
1112 0 : if(!m_activeTool.null()) m_activeTool->setActive(isActive);
1113 0 : }
1114 :
1115 :
1116 :
1117 0 : void PlotMouseToolGroup::setBlocking(bool blocking) {
1118 0 : PlotMouseTool::setBlocking(blocking);
1119 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1120 0 : m_tools[i]->setBlocking(blocking);
1121 0 : }
1122 :
1123 :
1124 :
1125 0 : void PlotMouseToolGroup::handleMouseEvent(const PlotEvent& event) {
1126 0 : if(m_active && !m_activeTool.null()) {
1127 0 : m_activeTool->handleMouseEvent(event);
1128 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1129 0 : } else m_lastEventHandled = false;
1130 0 : }
1131 :
1132 :
1133 :
1134 0 : void PlotMouseToolGroup::handleSelect(const PlotSelectEvent& event) {
1135 0 : if(m_active && !m_activeTool.null()) {
1136 0 : m_activeTool->handleSelect(event);
1137 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1138 0 : } else m_lastEventHandled = false;
1139 0 : }
1140 :
1141 :
1142 :
1143 0 : void PlotMouseToolGroup::handleClick(const PlotClickEvent& event) {
1144 0 : if(m_active && !m_activeTool.null()) {
1145 0 : m_activeTool->handleClick(event);
1146 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1147 0 : } else m_lastEventHandled = false;
1148 0 : }
1149 :
1150 :
1151 :
1152 0 : void PlotMouseToolGroup::handleMousePress(const PlotMousePressEvent& event) {
1153 0 : if(m_active && !m_activeTool.null()) {
1154 0 : m_activeTool->handleMousePress(event);
1155 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1156 0 : } else m_lastEventHandled = false;
1157 0 : }
1158 :
1159 :
1160 :
1161 0 : void PlotMouseToolGroup::handleMouseRelease(const PlotMouseReleaseEvent& event) {
1162 0 : if(m_active && !m_activeTool.null()) {
1163 0 : m_activeTool->handleMouseRelease(event);
1164 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1165 0 : } else m_lastEventHandled = false;
1166 0 : }
1167 :
1168 :
1169 :
1170 0 : void PlotMouseToolGroup::handleMouseDrag(const PlotMouseDragEvent& event) {
1171 0 : if(m_active && !m_activeTool.null()) {
1172 0 : m_activeTool->handleMouseDrag(event);
1173 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1174 0 : } else m_lastEventHandled = false;
1175 0 : }
1176 :
1177 :
1178 :
1179 0 : void PlotMouseToolGroup::handleMouseMove(const PlotMouseMoveEvent& event) {
1180 0 : if(m_active && !m_activeTool.null()) {
1181 0 : m_activeTool->handleMouseMove(event);
1182 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1183 0 : } else m_lastEventHandled = false;
1184 0 : }
1185 :
1186 :
1187 :
1188 0 : void PlotMouseToolGroup::handleWheel(const PlotWheelEvent& event) {
1189 0 : if(m_active && !m_activeTool.null()) {
1190 0 : m_activeTool->handleWheel(event);
1191 0 : m_lastEventHandled = m_activeTool->lastEventWasHandled();
1192 0 : } else m_lastEventHandled = false;
1193 0 : }
1194 :
1195 :
1196 :
1197 0 : PlotAxis PlotMouseToolGroup::getXAxis() const {
1198 0 : if(!m_activeTool.null()) return m_activeTool->getXAxis();
1199 0 : else if(m_tools.size() > 0) return m_tools[0]->getXAxis();
1200 0 : else return m_xAxis;
1201 : }
1202 :
1203 :
1204 :
1205 0 : PlotAxis PlotMouseToolGroup::getYAxis() const {
1206 0 : if(!m_activeTool.null()) return m_activeTool->getYAxis();
1207 0 : else if(m_tools.size() > 0) return m_tools[0]->getYAxis();
1208 0 : else return m_yAxis;
1209 : }
1210 :
1211 :
1212 :
1213 0 : PlotCoordinate::System PlotMouseToolGroup::getCoordinateSystem() const {
1214 0 : if(!m_activeTool.null()) return m_activeTool->getCoordinateSystem();
1215 0 : else if(m_tools.size() > 0) return m_tools[0]->getCoordinateSystem();
1216 0 : else return m_coordSystem;
1217 : }
1218 :
1219 :
1220 :
1221 0 : bool PlotMouseToolGroup::lastEventWasHandled() const {
1222 0 : if(!m_activeTool.null()) return m_activeTool->lastEventWasHandled();
1223 0 : else return false;
1224 : }
1225 :
1226 :
1227 :
1228 0 : void PlotMouseToolGroup::reset() {
1229 0 : for(unsigned int i = 0; i < m_tools.size(); i++) {
1230 0 : m_tools[i]->reset();
1231 : }
1232 0 : }
1233 :
1234 :
1235 : // Protected Methods //
1236 :
1237 0 : void PlotMouseToolGroup::attach(PlotCanvas* canvas) {
1238 0 : PlotMouseTool::attach(canvas);
1239 0 : for(unsigned int i = 0; i< m_tools.size(); i++) m_tools[i]->attach(canvas);
1240 0 : }
1241 :
1242 :
1243 :
1244 0 : void PlotMouseToolGroup::detach() {
1245 0 : PlotMouseTool::detach();
1246 0 : for(unsigned int i = 0; i < m_tools.size(); i++) m_tools[i]->detach();
1247 0 : }
1248 :
1249 :
1250 :
1251 :
1252 :
1253 :
1254 : ////////////////////////////////////////////
1255 : // PLOTSTANDARDMOUSETOOLGROUP DEFINITIONS //
1256 : ////////////////////////////////////////////
1257 :
1258 :
1259 0 : PlotStandardMouseToolGroup::PlotStandardMouseToolGroup(ToolCode activeTool,
1260 0 : PlotCoordinate::System system) {
1261 :
1262 0 : addTool(new PlotSelectTool(system));
1263 0 : addTool(new PlotZoomTool(system));
1264 0 : addTool(new PlotPanTool(system));
1265 0 : addTool(new PlotFlagAllTool(system));
1266 0 : setActiveTool(activeTool);
1267 0 : m_tracker = new PlotTrackerTool(system);
1268 0 : m_tracker->setBlocking(false);
1269 0 : m_coordSystem = system;
1270 0 : }
1271 :
1272 :
1273 :
1274 0 : PlotStandardMouseToolGroup::PlotStandardMouseToolGroup(PlotAxis xAxis,
1275 : PlotAxis yAxis,
1276 : ToolCode activeTool,
1277 0 : PlotCoordinate::System system) {
1278 :
1279 0 : addTool(new PlotSelectTool(xAxis, yAxis, system));
1280 0 : addTool(new PlotZoomTool(xAxis, yAxis, system));
1281 0 : addTool(new PlotPanTool(xAxis, yAxis, system));
1282 0 : addTool(new PlotFlagAllTool(xAxis, yAxis, system));
1283 0 : setActiveTool(activeTool);
1284 0 : m_tracker = new PlotTrackerTool(xAxis, yAxis, system);
1285 0 : m_tracker->setBlocking(false);
1286 0 : m_xAxis = xAxis;
1287 0 : m_yAxis = yAxis;
1288 0 : m_coordSystem = system;
1289 0 : }
1290 :
1291 :
1292 :
1293 0 : PlotStandardMouseToolGroup::PlotStandardMouseToolGroup(
1294 : PlotSelectToolPtr selectTool,
1295 : PlotZoomToolPtr zoomTool,
1296 : PlotPanToolPtr panTool,
1297 : PlotFlagAllToolPtr flagAllTool,
1298 : PlotTrackerToolPtr trackerTool,
1299 0 : ToolCode activeTool) {
1300 :
1301 0 : addTool(!selectTool.null() ? selectTool : new PlotSelectTool());
1302 0 : addTool(!zoomTool.null() ? zoomTool : new PlotZoomTool());
1303 0 : addTool(!panTool.null() ? panTool : new PlotPanTool());
1304 0 : addTool(!flagAllTool.null() ? flagAllTool : new PlotFlagAllTool());
1305 0 : setActiveTool(activeTool);
1306 0 : m_tracker = !trackerTool.null() ? trackerTool : new PlotTrackerTool();
1307 0 : m_tracker->setBlocking(false);
1308 0 : }
1309 :
1310 :
1311 :
1312 0 : PlotStandardMouseToolGroup::~PlotStandardMouseToolGroup() { }
1313 :
1314 :
1315 :
1316 :
1317 0 : void PlotStandardMouseToolGroup::setActiveTool(ToolCode toolcode) {
1318 :
1319 0 : if(toolcode == NONE_TOOL) {
1320 0 : PlotMouseToolGroup::setActiveTool(PlotMouseToolPtr());
1321 0 : return;
1322 : }
1323 0 : for(unsigned int i = 0; i < m_tools.size(); i++) {
1324 0 : if (((dynamic_cast<PlotSelectTool*>(&*m_tools[i]) != NULL && toolcode==SELECT_TOOL))
1325 0 : || ((dynamic_cast<PlotSelectTool*>(&*m_tools[i]) != NULL && toolcode==SUBTRACT_TOOL))
1326 0 : || ((dynamic_cast<PlotZoomTool*>(&*m_tools[i]) != NULL && toolcode==ZOOM_TOOL))
1327 0 : || ((dynamic_cast<PlotPanTool*>(&*m_tools[i]) != NULL) && toolcode==PAN_TOOL)
1328 0 : || ((dynamic_cast<PlotFlagAllTool*>(&*m_tools[i]) != NULL) && toolcode == FLAGALL_TOOL))
1329 : {
1330 0 : PlotMouseToolGroup::setActiveTool(i, toolcode);
1331 0 : return;
1332 : }
1333 : }
1334 : }
1335 :
1336 :
1337 :
1338 0 : ToolCode PlotStandardMouseToolGroup::activeToolType() const {
1339 0 : if(m_activeTool.null()) return NONE_TOOL;
1340 0 : if(dynamic_cast<const PlotSelectTool*>(&*m_activeTool)!=NULL) return SELECT_TOOL;
1341 0 : if(dynamic_cast<const PlotZoomTool*>(&*m_activeTool) != NULL) return ZOOM_TOOL;
1342 0 : if(dynamic_cast<const PlotPanTool*>(&*m_activeTool) != NULL) return PAN_TOOL;
1343 0 : return NONE_TOOL;
1344 : }
1345 :
1346 :
1347 :
1348 0 : void PlotStandardMouseToolGroup::turnTracker(bool on) {
1349 0 : m_tracker->setActive(on);
1350 0 : }
1351 :
1352 :
1353 0 : bool PlotStandardMouseToolGroup::trackerIsOn() const {
1354 0 : return m_tracker->isActive();
1355 : }
1356 :
1357 :
1358 0 : void PlotStandardMouseToolGroup::turnTrackerDrawText(bool on) {
1359 0 : m_tracker->setDrawText(on);
1360 0 : }
1361 :
1362 :
1363 0 : bool PlotStandardMouseToolGroup::trackerDrawsText() const {
1364 0 : return m_tracker->drawsText();
1365 : }
1366 :
1367 0 : int PlotStandardMouseToolGroup::getSelectedRectCount(){
1368 0 : PlotSelectToolPtr selectPtr = selectTool();
1369 0 : int rectCount = selectPtr->getSelectedRectCount();
1370 0 : return rectCount;
1371 : }
1372 :
1373 0 : void PlotStandardMouseToolGroup::clearSelectedRects(){
1374 0 : PlotSelectToolPtr selectPtr = selectTool();
1375 0 : selectPtr->clearSelectedRects();
1376 0 : }
1377 :
1378 0 : vector<PlotRegion> PlotStandardMouseToolGroup::getSelectedRects(){
1379 0 : PlotSelectToolPtr selectPtr = selectTool();
1380 0 : vector<PlotRegion> regions = selectPtr->getSelectedRects();
1381 0 : return regions;
1382 : }
1383 :
1384 0 : void PlotStandardMouseToolGroup::clearMark() {
1385 0 : auto ptr = flagAllTool();
1386 0 : ptr->clearMark();
1387 0 : }
1388 :
1389 0 : bool PlotStandardMouseToolGroup::isMarkedForFlag() {
1390 0 : auto ptr = flagAllTool();
1391 0 : return ptr->isMarkedForFlag();
1392 : }
1393 :
1394 0 : bool PlotStandardMouseToolGroup::isMarkedForUnflag() {
1395 0 : auto ptr = flagAllTool();
1396 0 : return ptr->isMarkedForUnflag();
1397 : }
1398 :
1399 0 : bool PlotStandardMouseToolGroup::isBackgroundColorChanged() {
1400 0 : auto ptr = flagAllTool();
1401 0 : return ptr->isBackgroundColorChanged();
1402 : }
1403 :
1404 0 : void PlotStandardMouseToolGroup::setAllFlagged() {
1405 0 : auto ptr = flagAllTool();
1406 0 : ptr->setAllFlagged();
1407 0 : }
1408 :
1409 0 : PlotSelectToolPtr PlotStandardMouseToolGroup::selectTool() {
1410 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1411 0 : if(dynamic_cast<PlotSelectTool*>(&*m_tools[i]) != NULL)
1412 0 : return PlotSelectToolPtr(m_tools[i]);
1413 :
1414 : // shouldn't happen!
1415 0 : PlotSelectToolPtr t = new PlotSelectTool();
1416 0 : m_tools.push_back(t);
1417 0 : return t;
1418 : }
1419 :
1420 :
1421 0 : PlotZoomToolPtr PlotStandardMouseToolGroup::zoomTool() {
1422 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1423 0 : if(dynamic_cast<PlotZoomTool*>(&*m_tools[i]) != NULL)
1424 0 : return PlotZoomToolPtr(m_tools[i]);
1425 :
1426 : // shouldn't happen!
1427 0 : PlotZoomToolPtr t = new PlotZoomTool();
1428 0 : m_tools.push_back(t);
1429 0 : return t;
1430 : }
1431 :
1432 :
1433 0 : PlotPanToolPtr PlotStandardMouseToolGroup::panTool() {
1434 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1435 0 : if(dynamic_cast<PlotPanTool*>(&*m_tools[i]) != NULL)
1436 0 : return PlotPanToolPtr(m_tools[i]);
1437 :
1438 : // shouldn't happen!
1439 0 : PlotPanToolPtr t = new PlotPanTool();
1440 0 : m_tools.push_back(t);
1441 0 : return t;
1442 : }
1443 :
1444 0 : PlotFlagAllToolPtr PlotStandardMouseToolGroup::flagAllTool() {
1445 0 : for(unsigned int i = 0; i < m_tools.size(); i++)
1446 0 : if(dynamic_cast<PlotFlagAllTool*>(&*m_tools[i]) != NULL)
1447 0 : return PlotFlagAllToolPtr(m_tools[i]);
1448 :
1449 : // shouldn't happen!
1450 0 : PlotFlagAllToolPtr t = new PlotFlagAllTool();
1451 0 : m_tools.push_back(t);
1452 0 : return t;
1453 : }
1454 :
1455 :
1456 0 : PlotTrackerToolPtr PlotStandardMouseToolGroup::trackerTool() {
1457 0 : return m_tracker;
1458 : }
1459 :
1460 :
1461 :
1462 :
1463 : // Protected Methods //
1464 :
1465 0 : void PlotStandardMouseToolGroup::attach(PlotCanvas* canvas) {
1466 0 : PlotMouseToolGroup::attach(canvas);
1467 0 : m_tracker->attach(canvas);
1468 0 : }
1469 :
1470 :
1471 :
1472 0 : void PlotStandardMouseToolGroup::detach() {
1473 0 : PlotMouseToolGroup::detach();
1474 0 : m_tracker->detach();
1475 0 : }
1476 :
1477 :
1478 :
1479 : } // namespace
1480 :
|
