Eclipse SUMO - Simulation of Urban MObility
GNEViewNetHelper.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
19// A file used to reduce the size of GNEViewNet.h grouping structs and classes
20/****************************************************************************/
37
38#include "GNEViewNetHelper.h"
39#include "GNEViewNet.h"
40#include "GNENet.h"
41#include "GNEUndoList.h"
42#include "GNEViewParent.h"
44
45
46// ===========================================================================
47// static members
48// ===========================================================================
49
50std::vector<RGBColor> GNEViewNetHelper::myRainbowScaledColors;
51
52// ---------------------------------------------------------------------------
53// GNEViewNetHelper::LockManager - methods
54// ---------------------------------------------------------------------------
55
57 myViewNet(viewNet) {
58 // fill myLockedElements objects
71 // fill myLockedElements objects
82 // fill myLockedElements objects
86}
87
88
90
91
92bool
93GNEViewNetHelper::LockManager::isObjectLocked(GUIGlObjectType objectType, const bool selected) const {
94 if (selected && (myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck() == TRUE)) {
95 return true;
96 } else if ((objectType >= GLO_ADDITIONALELEMENT) && (objectType <= GLO_ACCESS)) {
97 // additionals
98 return myLockedElements.at(GLO_ADDITIONALELEMENT).lock;
99 } else if ((objectType >= GLO_WIRE) && (objectType <= GLO_TRACTIONSUBSTATION)) {
100 // wires
101 return myLockedElements.at(GLO_WIRE).lock;
102 } else if ((objectType >= GLO_VEHICLE) && (objectType <= GLO_ROUTEFLOW)) {
103 // vehicles
104 return myLockedElements.at(GLO_VEHICLE).lock;
105 } else if ((objectType == GLO_PERSON) || (objectType == GLO_PERSONFLOW)) {
106 // persons
107 return myLockedElements.at(GLO_PERSON).lock;
108 } else if ((objectType == GLO_CONTAINER) || (objectType == GLO_CONTAINERFLOW)) {
109 // containers
110 return myLockedElements.at(GLO_PERSON).lock;
111 } else if ((objectType >= GLO_STOP) && (objectType <= GLO_STOP_CONTAINER)) {
112 // stops
113 return myLockedElements.at(GLO_ADDITIONALELEMENT).lock;
114 } else {
115 return myLockedElements.at(objectType).lock;
116 }
117}
118
119
120void
122 // get lock menu commands
123 GNEApplicationWindowHelper::LockMenuCommands& lockMenuCommands = myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands();
124 // network
125 myLockedElements[GLO_JUNCTION].lock = lockMenuCommands.menuCheckLockJunction->getCheck() == TRUE;
126 myLockedElements[GLO_EDGE].lock = lockMenuCommands.menuCheckLockEdges->getCheck() == TRUE;
127 myLockedElements[GLO_LANE].lock = lockMenuCommands.menuCheckLockLanes->getCheck() == TRUE;
128 myLockedElements[GLO_CONNECTION].lock = lockMenuCommands.menuCheckLockConnections->getCheck() == TRUE;
129 myLockedElements[GLO_CROSSING].lock = lockMenuCommands.menuCheckLockCrossings->getCheck() == TRUE;
130 myLockedElements[GLO_WALKINGAREA].lock = lockMenuCommands.menuCheckLockWalkingAreas->getCheck() == TRUE;
131 myLockedElements[GLO_ADDITIONALELEMENT].lock = lockMenuCommands.menuCheckLockAdditionals->getCheck() == TRUE;
132 myLockedElements[GLO_WIRE].lock = lockMenuCommands.menuCheckLockWires->getCheck() == TRUE;
133 myLockedElements[GLO_TAZ].lock = lockMenuCommands.menuCheckLockTAZs->getCheck() == TRUE;
134 myLockedElements[GLO_POLYGON].lock = lockMenuCommands.menuCheckLockPolygons->getCheck() == TRUE;
135 myLockedElements[GLO_POI].lock = lockMenuCommands.menuCheckLockPOIs->getCheck() == TRUE;
136 // demand
137 myLockedElements[GLO_ROUTE].lock = lockMenuCommands.menuCheckLockRoutes->getCheck() == TRUE;
138 myLockedElements[GLO_VEHICLE].lock = lockMenuCommands.menuCheckLockVehicles->getCheck() == TRUE;
139 myLockedElements[GLO_PERSON].lock = lockMenuCommands.menuCheckLockPersons->getCheck() == TRUE;
140 myLockedElements[GLO_PERSONTRIP].lock = lockMenuCommands.menuCheckLockPersonTrip->getCheck() == TRUE;
141 myLockedElements[GLO_WALK].lock = lockMenuCommands.menuCheckLockWalk->getCheck() == TRUE;
142 myLockedElements[GLO_RIDE].lock = lockMenuCommands.menuCheckLockRides->getCheck() == TRUE;
143 myLockedElements[GLO_CONTAINER].lock = lockMenuCommands.menuCheckLockContainers->getCheck() == TRUE;
144 myLockedElements[GLO_TRANSPORT].lock = lockMenuCommands.menuCheckLockTransports->getCheck() == TRUE;
145 myLockedElements[GLO_TRANSHIP].lock = lockMenuCommands.menuCheckLockTranships->getCheck() == TRUE;
146 myLockedElements[GLO_STOP].lock = lockMenuCommands.menuCheckLockStops->getCheck() == TRUE;
147 // data
148 myLockedElements[GLO_EDGEDATA].lock = lockMenuCommands.menuCheckLockEdgeDatas->getCheck() == TRUE;
149 myLockedElements[GLO_EDGERELDATA].lock = lockMenuCommands.menuCheckLockEdgeRelDatas->getCheck() == TRUE;
150 myLockedElements[GLO_TAZRELDATA].lock = lockMenuCommands.menuCheckLockEdgeTAZRels->getCheck() == TRUE;
151}
152
153
154void
156 // get lock menu commands
157 GNEApplicationWindowHelper::LockMenuCommands& lockMenuCommands = myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands();
158 // network
159 lockMenuCommands.menuCheckLockJunction->setCheck(myLockedElements[GLO_JUNCTION].lock);
160 lockMenuCommands.menuCheckLockEdges->setCheck(myLockedElements[GLO_EDGE].lock);
161 lockMenuCommands.menuCheckLockLanes->setCheck(myLockedElements[GLO_LANE].lock);
162 lockMenuCommands.menuCheckLockConnections->setCheck(myLockedElements[GLO_CONNECTION].lock);
163 lockMenuCommands.menuCheckLockCrossings->setCheck(myLockedElements[GLO_CROSSING].lock);
164 lockMenuCommands.menuCheckLockWalkingAreas->setCheck(myLockedElements[GLO_WALKINGAREA].lock);
165 lockMenuCommands.menuCheckLockAdditionals->setCheck(myLockedElements[GLO_ADDITIONALELEMENT].lock);
166 lockMenuCommands.menuCheckLockWires->setCheck(myLockedElements[GLO_WIRE].lock);
167 lockMenuCommands.menuCheckLockTAZs->setCheck(myLockedElements[GLO_TAZ].lock);
168 lockMenuCommands.menuCheckLockPolygons->setCheck(myLockedElements[GLO_POLYGON].lock);
169 lockMenuCommands.menuCheckLockPOIs->setCheck(myLockedElements[GLO_POI].lock);
170 // demand
171 lockMenuCommands.menuCheckLockRoutes->setCheck(myLockedElements[GLO_ROUTE].lock);
172 lockMenuCommands.menuCheckLockVehicles->setCheck(myLockedElements[GLO_VEHICLE].lock);
173 lockMenuCommands.menuCheckLockPersons->setCheck(myLockedElements[GLO_PERSON].lock);
174 lockMenuCommands.menuCheckLockPersonTrip->setCheck(myLockedElements[GLO_PERSONTRIP].lock);
175 lockMenuCommands.menuCheckLockWalk->setCheck(myLockedElements[GLO_WALK].lock);
176 lockMenuCommands.menuCheckLockRides->setCheck(myLockedElements[GLO_RIDE].lock);
177 lockMenuCommands.menuCheckLockContainers->setCheck(myLockedElements[GLO_CONTAINER].lock);
178 lockMenuCommands.menuCheckLockTransports->setCheck(myLockedElements[GLO_TRANSPORT].lock);
179 lockMenuCommands.menuCheckLockTranships->setCheck(myLockedElements[GLO_TRANSHIP].lock);
180 lockMenuCommands.menuCheckLockStops->setCheck(myLockedElements[GLO_STOP].lock);
181 // data
182 lockMenuCommands.menuCheckLockEdgeDatas->setCheck(myLockedElements[GLO_EDGEDATA].lock);
183 lockMenuCommands.menuCheckLockEdgeRelDatas->setCheck(myLockedElements[GLO_EDGERELDATA].lock);
184 lockMenuCommands.menuCheckLockEdgeTAZRels->setCheck(myLockedElements[GLO_TAZRELDATA].lock);
185}
186
187
189 mySupermode(Supermode::NETWORK) {
190}
191
192
194 mySupermode(supermode) {
195}
196
197
199
200
203 return mySupermode;
204}
205
206// ---------------------------------------------------------------------------
207// GNEViewNetHelper::ObjectsUnderCursor - methods
208// ---------------------------------------------------------------------------
209
211 myViewNet(viewNet),
212 mySwapLane2edge(false) {
213}
214
215
216void
217GNEViewNetHelper::ObjectsUnderCursor::updateObjectUnderCursor(const std::vector<GUIGlObject*>& GUIGlObjects) {
218 // reset flag
219 mySwapLane2edge = false;
220 // clear elements
221 myEdgeObjects.clearElements();
222 myLaneObjects.clearElements();
223 // sort GUIGLObjects
224 sortGUIGlObjects(GUIGlObjects);
225 // process GUIGLObjects using myEdgeObjects.GUIGlObjects and myLaneObjects.GUIGlObjects
226 processGUIGlObjects();
227}
228
229
230void
232 // enable flag
233 mySwapLane2edge = true;
234}
235
236
237void
238GNEViewNetHelper::ObjectsUnderCursor::filterLockedElements(const GNEViewNetHelper::LockManager& lockManager, std::vector<GUIGlObjectType> forcedIgnoredTiped) {
239 // make a copy of edge and lane Attribute carriers
240 auto edgeACs = myEdgeObjects.attributeCarriers;
241 auto laneACs = myLaneObjects.attributeCarriers;
242 // clear elements
243 myEdgeObjects.clearElements();
244 myLaneObjects.clearElements();
245 // filter GUIGLObjects
246 for (const auto& edgeAC : edgeACs) {
247 if (std::find(forcedIgnoredTiped.begin(), forcedIgnoredTiped.end(), edgeAC->getGUIGlObject()->getType()) != forcedIgnoredTiped.end()) {
248 continue;
249 } else if (!lockManager.isObjectLocked(edgeAC->getGUIGlObject()->getType(), edgeAC->isAttributeCarrierSelected())) {
250 myEdgeObjects.GUIGlObjects.push_back(edgeAC->getGUIGlObject());
251 }
252 }
253 for (const auto& laneAC : laneACs) {
254 if (std::find(forcedIgnoredTiped.begin(), forcedIgnoredTiped.end(), laneAC->getGUIGlObject()->getType()) != forcedIgnoredTiped.end()) {
255 continue;
256 } else if (!lockManager.isObjectLocked(laneAC->getGUIGlObject()->getType(), laneAC->isAttributeCarrierSelected())) {
257 myLaneObjects.GUIGlObjects.push_back(laneAC->getGUIGlObject());
258 }
259 }
260 // process GUIGLObjects using myEdgeObjects.GUIGlObjects and myLaneObjects.GUIGlObjects
261 processGUIGlObjects();
262}
263
264
267 if (getGUIGlObjectFront()) {
268 return getGUIGlObjectFront()->getGlID();
269 } else {
270 return 0;
271 }
272}
273
274
277 if (getGUIGlObjectFront()) {
278 return getGUIGlObjectFront()->getType();
279 } else {
280 return GLO_NETWORK;
281 }
282}
283
284
287 if (mySwapLane2edge) {
288 if (myEdgeObjects.attributeCarriers.size() > 0) {
289 return myEdgeObjects.GUIGlObjects.front();
290 } else {
291 return nullptr;
292 }
293 } else {
294 if (myLaneObjects.attributeCarriers.size() > 0) {
295 return myLaneObjects.GUIGlObjects.front();
296 } else {
297 return nullptr;
298 }
299 }
300}
301
302
305 if (mySwapLane2edge) {
306 if (myEdgeObjects.attributeCarriers.size() > 0) {
307 return myEdgeObjects.attributeCarriers.front();
308 } else {
309 return nullptr;
310 }
311 } else {
312 if (myLaneObjects.attributeCarriers.size() > 0) {
313 return myLaneObjects.attributeCarriers.front();
314 } else {
315 return nullptr;
316 }
317 }
318}
319
320
323 if (mySwapLane2edge) {
324 if (myEdgeObjects.networkElements.size() > 0) {
325 return myEdgeObjects.networkElements.front();
326 } else {
327 return nullptr;
328 }
329 } else {
330 if (myLaneObjects.networkElements.size() > 0) {
331 return myLaneObjects.networkElements.front();
332 } else {
333 return nullptr;
334 }
335 }
336}
337
338
341 if (mySwapLane2edge) {
342 if (myEdgeObjects.additionals.size() > 0) {
343 return myEdgeObjects.additionals.front();
344 } else {
345 return nullptr;
346 }
347 } else {
348 if (myLaneObjects.additionals.size() > 0) {
349 return myLaneObjects.additionals.front();
350 } else {
351 return nullptr;
352 }
353 }
354}
355
356
359 if (mySwapLane2edge) {
360 if (myEdgeObjects.demandElements.size() > 0) {
361 return myEdgeObjects.demandElements.front();
362 } else {
363 return nullptr;
364 }
365 } else {
366 if (myLaneObjects.demandElements.size() > 0) {
367 return myLaneObjects.demandElements.front();
368 } else {
369 return nullptr;
370 }
371 }
372}
373
374
377 if (mySwapLane2edge) {
378 if (myEdgeObjects.genericDatas.size() > 0) {
379 return myEdgeObjects.genericDatas.front();
380 } else {
381 return nullptr;
382 }
383 } else {
384 if (myLaneObjects.genericDatas.size() > 0) {
385 return myLaneObjects.genericDatas.front();
386 } else {
387 return nullptr;
388 }
389 }
390}
391
392
395 if (mySwapLane2edge) {
396 if (myEdgeObjects.junctions.size() > 0) {
397 return myEdgeObjects.junctions.front();
398 } else {
399 return nullptr;
400 }
401 } else {
402 if (myLaneObjects.junctions.size() > 0) {
403 return myLaneObjects.junctions.front();
404 } else {
405 return nullptr;
406 }
407 }
408}
409
410
411GNEEdge*
413 if (mySwapLane2edge) {
414 if (myEdgeObjects.edges.size() > 0) {
415 return myEdgeObjects.edges.front();
416 } else {
417 return nullptr;
418 }
419 } else {
420 if (myLaneObjects.edges.size() > 0) {
421 return myLaneObjects.edges.front();
422 } else {
423 return nullptr;
424 }
425 }
426}
427
428
429GNELane*
431 if (mySwapLane2edge) {
432 if (myEdgeObjects.lanes.size() > 0) {
433 return myEdgeObjects.lanes.front();
434 } else {
435 return nullptr;
436 }
437 } else {
438 if (myLaneObjects.lanes.size() > 0) {
439 return myLaneObjects.lanes.front();
440 } else {
441 return nullptr;
442 }
443 }
444}
445
446
447GNELane*
449 if (mySwapLane2edge) {
450 if (myEdgeObjects.lanes.size() > 0) {
451 for (auto& lane : myEdgeObjects.lanes) {
452 if (!(lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) ||
453 !myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck()) {
454 return lane;
455 }
456 }
457 // all locked, then return nullptr
458 return nullptr;
459 } else {
460 return nullptr;
461 }
462 } else {
463 if (myLaneObjects.lanes.size() > 0) {
464 for (auto& lane : myLaneObjects.lanes) {
465 if (!(lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) ||
466 !myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck()) {
467 return lane;
468 }
469 }
470 // all locked, then return nullptr
471 return nullptr;
472 } else {
473 return nullptr;
474 }
475 }
476}
477
478
479const std::vector<GNELane*>&
481 if (mySwapLane2edge) {
482 return myEdgeObjects.lanes;
483 } else {
484 return myLaneObjects.lanes;
485 }
486}
487
488
491 if (mySwapLane2edge) {
492 if (myEdgeObjects.crossings.size() > 0) {
493 return myEdgeObjects.crossings.front();
494 } else {
495 return nullptr;
496 }
497 } else {
498 if (myLaneObjects.crossings.size() > 0) {
499 return myLaneObjects.crossings.front();
500 } else {
501 return nullptr;
502 }
503 }
504}
505
506
509 if (mySwapLane2edge) {
510 if (myEdgeObjects.walkingAreas.size() > 0) {
511 return myEdgeObjects.walkingAreas.front();
512 } else {
513 return nullptr;
514 }
515 } else {
516 if (myLaneObjects.walkingAreas.size() > 0) {
517 return myLaneObjects.walkingAreas.front();
518 } else {
519 return nullptr;
520 }
521 }
522}
523
524
527 if (mySwapLane2edge) {
528 if (myEdgeObjects.connections.size() > 0) {
529 return myEdgeObjects.connections.front();
530 } else {
531 return nullptr;
532 }
533 } else {
534 if (myLaneObjects.connections.size() > 0) {
535 return myLaneObjects.connections.front();
536 } else {
537 return nullptr;
538 }
539 }
540}
541
542
545 if (mySwapLane2edge) {
546 if (myEdgeObjects.internalLanes.size() > 0) {
547 return myEdgeObjects.internalLanes.front();
548 } else {
549 return nullptr;
550 }
551 } else {
552 if (myLaneObjects.internalLanes.size() > 0) {
553 return myLaneObjects.internalLanes.front();
554 } else {
555 return nullptr;
556 }
557 }
558}
559
560
561GNEPOI*
563 if (mySwapLane2edge) {
564 if (myEdgeObjects.POIs.size() > 0) {
565 return myEdgeObjects.POIs.front();
566 } else {
567 return nullptr;
568 }
569 } else {
570 if (myLaneObjects.POIs.size() > 0) {
571 return myLaneObjects.POIs.front();
572 } else {
573 return nullptr;
574 }
575 }
576}
577
578
579GNEPoly*
581 if (mySwapLane2edge) {
582 if (myEdgeObjects.polys.size() > 0) {
583 return myEdgeObjects.polys.front();
584 } else {
585 return nullptr;
586 }
587 } else {
588 if (myLaneObjects.polys.size() > 0) {
589 return myLaneObjects.polys.front();
590 } else {
591 return nullptr;
592 }
593 }
594}
595
596
597GNETAZ*
599 if (mySwapLane2edge) {
600 if (myEdgeObjects.TAZs.size() > 0) {
601 return myEdgeObjects.TAZs.front();
602 } else {
603 return nullptr;
604 }
605 } else {
606 if (myLaneObjects.TAZs.size() > 0) {
607 return myLaneObjects.TAZs.front();
608 } else {
609 return nullptr;
610 }
611 }
612}
613
614
617 if (mySwapLane2edge) {
618 if (myEdgeObjects.edgeDatas.size() > 0) {
619 return myEdgeObjects.edgeDatas.front();
620 } else {
621 return nullptr;
622 }
623 } else {
624 if (myLaneObjects.edgeDatas.size() > 0) {
625 return myLaneObjects.edgeDatas.front();
626 } else {
627 return nullptr;
628 }
629 }
630}
631
632
635 if (mySwapLane2edge) {
636 if (myEdgeObjects.edgeRelDatas.size() > 0) {
637 return myEdgeObjects.edgeRelDatas.front();
638 } else {
639 return nullptr;
640 }
641 } else {
642 if (myLaneObjects.edgeRelDatas.size() > 0) {
643 return myLaneObjects.edgeRelDatas.front();
644 } else {
645 return nullptr;
646 }
647 }
648}
649
650const std::vector<GUIGlObject*>&
652 if (mySwapLane2edge) {
653 return myEdgeObjects.GUIGlObjects;
654 } else {
655 return myLaneObjects.GUIGlObjects;
656 }
657}
658
659
660const std::vector<GNEAttributeCarrier*>&
662 if (mySwapLane2edge) {
663 return myEdgeObjects.attributeCarriers;
664 } else {
665 return myLaneObjects.attributeCarriers;
666 }
667}
668
669
670const std::vector<GNEDemandElement*>&
672 if (mySwapLane2edge) {
673 return myEdgeObjects.demandElements;
674 } else {
675 return myLaneObjects.demandElements;
676 }
677}
678
679
681
682
683void
685 // just clear all containers
686 GUIGlObjects.clear();
687 attributeCarriers.clear();
688 networkElements.clear();
689 additionals.clear();
690 demandElements.clear();
691 junctions.clear();
692 edges.clear();
693 lanes.clear();
694 crossings.clear();
695 walkingAreas.clear();
696 connections.clear();
697 internalLanes.clear();
698 TAZs.clear();
699 POIs.clear();
700 polys.clear();
701 genericDatas.clear();
702 edgeDatas.clear();
703 edgeRelDatas.clear();
704}
705
706
707void
708GNEViewNetHelper::ObjectsUnderCursor::sortGUIGlObjects(const std::vector<GUIGlObject*>& GUIGlObjects) {
709 // declare a map to save GUIGlObjects sorted by GLO_TYPE
710 std::map<double, std::vector<GUIGlObject*> > mySortedGUIGlObjects;
711 // iterate over set
712 for (const auto& GLObject : GUIGlObjects) {
713 // try to parse shape
714 const Shape* shape = dynamic_cast<Shape*>(GLObject);
715 if (shape) {
716 mySortedGUIGlObjects[shape->getShapeLayer()].push_back(GLObject);
717 } else {
718 mySortedGUIGlObjects[GLObject->getType()].push_back(GLObject);
719 }
720 }
721 // move sorted GUIGlObjects into myGUIGlObjectLanes using a reverse iterator
722 for (std::map<double, std::vector<GUIGlObject*> >::reverse_iterator i = mySortedGUIGlObjects.rbegin(); i != mySortedGUIGlObjects.rend(); i++) {
723 for (const auto& GlObject : i->second) {
724 // avoid GLO_NETWORKELEMENT
725 if (GlObject->getType() != GLO_NETWORKELEMENT) {
726 // add it in GUIGlObject splitting by edge/lanes
727 if (GlObject->getType() == GLO_LANE) {
728 myLaneObjects.GUIGlObjects.push_back(GlObject);
729 } else {
730 myEdgeObjects.GUIGlObjects.push_back(GlObject);
731 myLaneObjects.GUIGlObjects.push_back(GlObject);
732 }
733 }
734 }
735 }
736}
737
738
739void
741 // get front AC
742 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
743 // special case for edges and lanes
744 if (frontAC && (frontAC->getTagProperty().getTag() == SUMO_TAG_EDGE) && (AC->getTagProperty().getTag() == SUMO_TAG_LANE)) {
745 // compare IDs
746 if (AC->getAttribute(GNE_ATTR_PARENT) == frontAC->getID()) {
747 // insert at front
748 container.attributeCarriers.insert(container.attributeCarriers.begin(), AC);
749 } else {
750 // insert at back
751 container.attributeCarriers.push_back(AC);
752 }
753 } else {
754 // add it in attributeCarriers
755 if (AC == frontAC) {
756 // insert at front
757 container.attributeCarriers.insert(container.attributeCarriers.begin(), AC);
758 } else {
759 // insert at back
760 container.attributeCarriers.push_back(AC);
761 }
762 }
763}
764
765
766void
768 // get front AC
769 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
770 // check front element
771 if (AC == frontAC) {
772 // insert at front
773 container.networkElements.insert(container.networkElements.begin(), dynamic_cast<GNENetworkElement*>(AC));
774 } else {
775 // insert at back
776 container.networkElements.push_back(dynamic_cast<GNENetworkElement*>(AC));
777 }
778 // cast specific network element
779 switch (AC->getGUIGlObject()->getType()) {
780 case GLO_JUNCTION: {
781 // check front element
782 if (AC == frontAC) {
783 // insert at front
784 container.junctions.insert(container.junctions.begin(), dynamic_cast<GNEJunction*>(AC));
785 } else {
786 // insert at back
787 container.junctions.push_back(dynamic_cast<GNEJunction*>(AC));
788 }
789 break;
790 }
791 case GLO_EDGE: {
792 // check front element
793 if (AC == frontAC) {
794 // insert at front
795 container.edges.insert(container.edges.begin(), dynamic_cast<GNEEdge*>(AC));
796 } else {
797 // insert at back
798 container.edges.push_back(dynamic_cast<GNEEdge*>(AC));
799 }
800 break;
801 }
802 case GLO_LANE: {
803 // check front element
804 if (AC == frontAC) {
805 // insert at front
806 container.lanes.insert(container.lanes.begin(), dynamic_cast<GNELane*>(AC));
807 } else {
808 // insert at back
809 container.lanes.push_back(dynamic_cast<GNELane*>(AC));
810 }
811 break;
812 }
813 case GLO_CROSSING: {
814 // check front element
815 if (AC == frontAC) {
816 // insert at front
817 container.crossings.insert(container.crossings.begin(), dynamic_cast<GNECrossing*>(AC));
818 } else {
819 // insert at back
820 container.crossings.push_back(dynamic_cast<GNECrossing*>(AC));
821 }
822 break;
823 }
824 case GLO_WALKINGAREA: {
825 // check front element
826 if (AC == frontAC) {
827 // insert at front
828 container.walkingAreas.insert(container.walkingAreas.begin(), dynamic_cast<GNEWalkingArea*>(AC));
829 } else {
830 // insert at back
831 container.walkingAreas.push_back(dynamic_cast<GNEWalkingArea*>(AC));
832 }
833 break;
834 }
835 case GLO_CONNECTION: {
836 // check front element
837 if (AC == frontAC) {
838 // insert at front
839 container.connections.insert(container.connections.begin(), dynamic_cast<GNEConnection*>(AC));
840 } else {
841 // insert at back
842 container.connections.push_back(dynamic_cast<GNEConnection*>(AC));
843 }
844 break;
845 }
846 case GLO_TLLOGIC: {
847 // check front element
848 if (AC == frontAC) {
849 // insert at front
850 container.internalLanes.insert(container.internalLanes.begin(), dynamic_cast<GNEInternalLane*>(AC));
851 } else {
852 // insert at back
853 container.internalLanes.push_back(dynamic_cast<GNEInternalLane*>(AC));
854 }
855 break;
856 }
857 default:
858 break;
859 }
860}
861
862
863void
865 // get additional element
866 GNEAdditional* additionalElement = myViewNet->getNet()->getAttributeCarriers()->retrieveAdditional(AC);
867 // insert depending if is the front attribute carrier
868 if (additionalElement == myViewNet->getFrontAttributeCarrier()) {
869 // insert at front
870 container.additionals.insert(container.additionals.begin(), additionalElement);
871 } else {
872 // insert at back
873 container.additionals.push_back(additionalElement);
874 }
875}
876
877
878void
880 // cast specific shape
881 if (AC->getGUIGlObject()->getType() == GLO_POI) {
882 // cast POI
883 GNEPOI* POI = dynamic_cast<GNEPOI*>(AC);
884 if (POI) {
885 // check front element
886 if (AC == myViewNet->getFrontAttributeCarrier()) {
887 // insert at front
888 container.POIs.insert(container.POIs.begin(), POI);
889 } else {
890 // insert at back
891 container.POIs.push_back(POI);
892 }
893 }
894 } else if (AC->getGUIGlObject()->getType() == GLO_POLYGON) {
895 // cast poly
896 GNEPoly* poly = dynamic_cast<GNEPoly*>(AC);
897 if (poly) {
898 // check front element
899 if (AC == myViewNet->getFrontAttributeCarrier()) {
900 // insert at front
901 container.polys.insert(container.polys.begin(), poly);
902 } else {
903 // insert at back
904 container.polys.push_back(poly);
905 }
906 }
907 }
908}
909
910
911void
913 // cast specific TAZ
914 if (AC->getGUIGlObject()->getType() == GLO_TAZ) {
915 // cast TAZ
916 GNETAZ* TAZ = dynamic_cast<GNETAZ*>(AC);
917 if (TAZ) {
918 // check front element
919 if (AC == myViewNet->getFrontAttributeCarrier()) {
920 // insert at front
921 container.TAZs.insert(container.TAZs.begin(), TAZ);
922 } else {
923 // insert at back
924 container.TAZs.push_back(TAZ);
925 }
926 }
927 }
928}
929
930
931void
933 // get demandElement
934 GNEDemandElement* demandElement = myViewNet->getNet()->getAttributeCarriers()->retrieveDemandElement(AC);
935 // insert depending if is the front attribute carrier
936 if (demandElement == myViewNet->getFrontAttributeCarrier()) {
937 // insert at front
938 container.demandElements.insert(container.demandElements.begin(), demandElement);
939 } else {
940 // insert at back
941 container.demandElements.push_back(demandElement);
942 }
943}
944
945
946void
948 // get front AC
949 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
950 // cast generic data from attribute carrier
951 if (AC == frontAC) {
952 // insert at front
953 container.genericDatas.insert(container.genericDatas.begin(), dynamic_cast<GNEGenericData*>(AC));
954 } else {
955 // insert at back
956 container.genericDatas.push_back(dynamic_cast<GNEGenericData*>(AC));
957 }
958 // cast specific generic data
959 switch (AC->getGUIGlObject()->getType()) {
960 case GLO_EDGEDATA:
961 // check front element
962 if (AC == frontAC) {
963 // insert at front
964 container.edgeDatas.insert(container.edgeDatas.begin(), dynamic_cast<GNEEdgeData*>(AC));
965 } else {
966 // insert at back
967 container.edgeDatas.push_back(dynamic_cast<GNEEdgeData*>(AC));
968 }
969 break;
970 case GLO_EDGERELDATA:
971 // check front element
972 if (AC == frontAC) {
973 // insert at front
974 container.edgeRelDatas.insert(container.edgeRelDatas.begin(), dynamic_cast<GNEEdgeRelData*>(AC));
975 } else {
976 // insert at back
977 container.edgeRelDatas.push_back(dynamic_cast<GNEEdgeRelData*>(AC));
978 }
979 break;
980 default:
981 break;
982 }
983}
984
985
986void
988 // first clear GUIGlObjects
989 container.GUIGlObjects.clear();
990 // reserve
991 container.GUIGlObjects.reserve(container.attributeCarriers.size());
992 // iterate over atribute carriers
993 for (const auto& attributeCarrrier : container.attributeCarriers) {
994 // add GUIGlObject in GUIGlObjects container
995 container.GUIGlObjects.push_back(attributeCarrrier->getGUIGlObject());
996 }
997}
998
999
1000void
1002 // iterate over myGUIGlObjectLanes
1003 for (const auto& glObject : myEdgeObjects.GUIGlObjects) {
1004 // cast attribute carrier from glObject
1005 GNEAttributeCarrier* AC = dynamic_cast<GNEAttributeCarrier*>(glObject);
1006 // only continue if attributeCarrier isn't nullptr;
1007 if (AC) {
1008 // update attribute carrier
1009 updateAttributeCarriers(myEdgeObjects, AC);
1010 // cast specific network elemetns
1011 if (AC->getTagProperty().isNetworkElement()) {
1012 // update network elements
1013 updateNetworkElements(myEdgeObjects, AC);
1014 } else if (AC->getTagProperty().isAdditionalElement()) {
1015 // update additional elements
1016 updateAdditionalElements(myEdgeObjects, AC);
1017 // update shapes and TAZs
1018 if (AC->getTagProperty().isShapeElement()) {
1019 // update shape elements
1020 updateShapeElements(myEdgeObjects, AC);
1021 }
1022 if (AC->getTagProperty().isTAZElement()) {
1023 // update TAZ elements
1024 updateTAZElements(myEdgeObjects, AC);
1025 }
1026 } else if (AC->getTagProperty().isDemandElement()) {
1027 // update demand elements
1028 updateDemandElements(myEdgeObjects, AC);
1029 } else if (AC->getTagProperty().isGenericData()) {
1030 // update generic datas
1031 updateGenericDataElements(myEdgeObjects, AC);
1032 }
1033 }
1034 }
1035 // update GUIGlObjects (due front element)
1036 updateGUIGlObjects(myEdgeObjects);
1037 // iterate over myGUIGlObjectLanes
1038 for (const auto& glObject : myLaneObjects.GUIGlObjects) {
1039 // cast attribute carrier from glObject
1040 GNEAttributeCarrier* AC = dynamic_cast<GNEAttributeCarrier*>(glObject);
1041 // only continue if attributeCarrier isn't nullptr;
1042 if (AC) {
1043 // update attribute carrier
1044 updateAttributeCarriers(myLaneObjects, AC);
1045 // cast specific network elemetns
1046 if (AC->getTagProperty().isNetworkElement()) {
1047 // update network elements
1048 updateNetworkElements(myLaneObjects, AC);
1049 } else if (AC->getTagProperty().isAdditionalElement()) {
1050 // update additional elements
1051 updateAdditionalElements(myLaneObjects, AC);
1052 // update shapes and TAZs
1053 if (AC->getTagProperty().isShapeElement()) {
1054 // update shape elements
1055 updateShapeElements(myLaneObjects, AC);
1056 }
1057 if (AC->getTagProperty().isTAZElement()) {
1058 // update TAZ elements
1059 updateTAZElements(myLaneObjects, AC);
1060 }
1061 } else if (AC->getTagProperty().isDemandElement()) {
1062 // update demand elements
1063 updateDemandElements(myLaneObjects, AC);
1064 } else if (AC->getTagProperty().isGenericData()) {
1065 // update generic datas
1066 updateGenericDataElements(myLaneObjects, AC);
1067 }
1068 }
1069 }
1070 // update GUIGlObjects (due front element)
1071 updateGUIGlObjects(myLaneObjects);
1072}
1073
1074
1076 myViewNet(nullptr),
1077 mySwapLane2edge(false) {
1078}
1079
1080// ---------------------------------------------------------------------------
1081// GNEViewNetHelper::MouseButtonKeyPressed - methods
1082// ---------------------------------------------------------------------------
1083
1085 myEventInfo(nullptr) {
1086}
1087
1088
1089void
1091 myEventInfo = (FXEvent*) eventData;
1092}
1093
1094
1095bool
1097 if (myEventInfo) {
1098 return (myEventInfo->state & SHIFTMASK) != 0;
1099 } else {
1100 return false;
1101 }
1102}
1103
1104
1105bool
1107 if (myEventInfo) {
1108 return (myEventInfo->state & CONTROLMASK) != 0;
1109 } else {
1110 return false;
1111 }
1112}
1113
1114
1115bool
1117 if (myEventInfo) {
1118 return (myEventInfo->state & ALTMASK) != 0;
1119 } else {
1120 return false;
1121 }
1122}
1123
1124
1125bool
1127 if (myEventInfo) {
1128 return (myEventInfo->state & LEFTBUTTONMASK) != 0;
1129 } else {
1130 return false;
1131 }
1132}
1133
1134
1135bool
1137 if (myEventInfo) {
1138 return (myEventInfo->state & RIGHTBUTTONMASK) != 0;
1139 } else {
1140 return false;
1141 }
1142}
1143
1144// ---------------------------------------------------------------------------
1145// GNEViewNetHelper::MoveSingleElementValues - methods
1146// ---------------------------------------------------------------------------
1147
1149 myViewNet(viewNet) {
1150}
1151
1152
1153bool
1155 // first obtain moving reference (common for all)
1156 myRelativeClickedPosition = myViewNet->getPositionInformation();
1157 // get edited element
1158 const GNENetworkElement* editedElement = myViewNet->myEditNetworkElementShapes.getEditedNetworkElement();
1159 // check what type of AC will be moved
1160 if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (myViewNet->myObjectsUnderCursor.getJunctionFront() == editedElement)) {
1161 // get move operation
1162 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
1163 // continue if move operation is valid
1164 if (moveOperation) {
1165 myMoveOperations.push_back(moveOperation);
1166 return true;
1167 } else {
1168 return false;
1169 }
1170 } else if (myViewNet->myObjectsUnderCursor.getLaneFront() && (myViewNet->myObjectsUnderCursor.getLaneFront() == editedElement)) {
1171 // get move operation
1172 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getLaneFront()->getMoveOperation();
1173 // continue if move operation is valid
1174 if (moveOperation) {
1175 myMoveOperations.push_back(moveOperation);
1176 return true;
1177 } else {
1178 return false;
1179 }
1180 } else if (myViewNet->myObjectsUnderCursor.getCrossingFront() && (myViewNet->myObjectsUnderCursor.getCrossingFront() == editedElement)) {
1181 // get move operation
1182 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getCrossingFront()->getMoveOperation();
1183 // continue if move operation is valid
1184 if (moveOperation) {
1185 myMoveOperations.push_back(moveOperation);
1186 return true;
1187 } else {
1188 return false;
1189 }
1190 } else if (myViewNet->myObjectsUnderCursor.getConnectionFront() && (myViewNet->myObjectsUnderCursor.getConnectionFront() == editedElement)) {
1191 // get move operation
1192 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getConnectionFront()->getMoveOperation();
1193 // continue if move operation is valid
1194 if (moveOperation) {
1195 myMoveOperations.push_back(moveOperation);
1196 return true;
1197 } else {
1198 return false;
1199 }
1200 } else if (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() && (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() == editedElement)) {
1201 // get move operation
1202 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getWalkingAreaFront()->getMoveOperation();
1203 // continue if move operation is valid
1204 if (moveOperation) {
1205 myMoveOperations.push_back(moveOperation);
1206 return true;
1207 } else {
1208 return false;
1209 }
1210 } else {
1211 // there isn't moved items, then return false
1212 return false;
1213 }
1214}
1215
1216
1217bool
1219 // first obtain moving reference (common for all)
1220 myRelativeClickedPosition = myViewNet->getPositionInformation();
1221 // get front AC
1222 const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
1223 // check what type of AC will be moved
1224 if (myViewNet->myObjectsUnderCursor.getPolyFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPolyFront())) {
1225 // get move operation
1226 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPolyFront()->getMoveOperation();
1227 // continue if move operation is valid
1228 if (moveOperation) {
1229 myMoveOperations.push_back(moveOperation);
1230 return true;
1231 } else {
1232 return false;
1233 }
1234 } else if (myViewNet->myObjectsUnderCursor.getPOIFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPOIFront())) {
1235 // get move operation
1236 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPOIFront()->getMoveOperation();
1237 // continue if move operation is valid
1238 if (moveOperation) {
1239 myMoveOperations.push_back(moveOperation);
1240 return true;
1241 } else {
1242 return false;
1243 }
1244 } else if (myViewNet->myObjectsUnderCursor.getAdditionalFront() && (frontAC == myViewNet->myObjectsUnderCursor.getAdditionalFront())) {
1245 // get move operation
1246 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getAdditionalFront()->getMoveOperation();
1247 // continue if move operation is valid
1248 if (moveOperation) {
1249 myMoveOperations.push_back(moveOperation);
1250 return true;
1251 } else {
1252 return false;
1253 }
1254 } else if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (frontAC == myViewNet->myObjectsUnderCursor.getJunctionFront())) {
1255 // get move operation
1256 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
1257 // continue if move operation is valid
1258 if (moveOperation) {
1259 myMoveOperations.push_back(moveOperation);
1260 return true;
1261 } else {
1262 return false;
1263 }
1264 } else if ((myViewNet->myObjectsUnderCursor.getEdgeFront() && (frontAC == myViewNet->myObjectsUnderCursor.getEdgeFront())) ||
1265 (myViewNet->myObjectsUnderCursor.getLaneFront() && (frontAC == myViewNet->myObjectsUnderCursor.getLaneFront()))) {
1266 // calculate Edge movement values (can be entire shape, single geometry points, altitude, etc.)
1267 if (myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1268 // edit end point
1269 myViewNet->myObjectsUnderCursor.getEdgeFront()->editEndpoint(myViewNet->getPositionInformation(), myViewNet->myUndoList);
1270 // edge values wasn't calculated, then return false
1271 return false;
1272 } else {
1273 // get move operation
1274 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getEdgeFront()->getMoveOperation();
1275 // continue if move operation is valid
1276 if (moveOperation) {
1277 myMoveOperations.push_back(moveOperation);
1278 return true;
1279 } else {
1280 return false;
1281 }
1282 }
1283 } else {
1284 // there isn't moved items, then return false
1285 return false;
1286 }
1287}
1288
1289
1290bool
1292 // first obtain moving reference (common for all)
1293 myRelativeClickedPosition = myViewNet->getPositionInformation();
1294 // get front AC
1295 const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
1296 // check demand element
1297 if (myViewNet->myObjectsUnderCursor.getDemandElementFront() && (frontAC == myViewNet->myObjectsUnderCursor.getDemandElementFront())) {
1298 // get move operation
1299 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getDemandElementFront()->getMoveOperation();
1300 // continue if move operation is valid
1301 if (moveOperation) {
1302 myMoveOperations.push_back(moveOperation);
1303 return true;
1304 } else {
1305 return false;
1306 }
1307
1308 } else {
1309 // there isn't moved items, then return false
1310 return false;
1311 }
1312}
1313
1314
1315void
1317 // calculate moveOffset
1318 const GNEMoveOffset moveOffset = calculateMoveOffset();
1319 // check if mouse button is pressed
1320 if (mouseLeftButtonPressed) {
1321 // iterate over all operations
1322 for (const auto& moveOperation : myMoveOperations) {
1323 // move elements
1324 GNEMoveElement::moveElement(myViewNet, moveOperation, moveOffset);
1325 }
1326 } else {
1327 // iterate over all operations
1328 for (const auto& moveOperation : myMoveOperations) {
1329 // commit move
1330 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1331 // don't forget delete move operation
1332 delete moveOperation;
1333 }
1334 // clear move operations
1335 myMoveOperations.clear();
1336 }
1337}
1338
1339
1340void
1342 // calculate moveOffset
1343 const GNEMoveOffset moveOffset = calculateMoveOffset();
1344 // finish all move operations
1345 for (const auto& moveOperation : myMoveOperations) {
1346 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1347 // don't forget delete move operation
1348 delete moveOperation;
1349 }
1350 // clear move operations
1351 myMoveOperations.clear();
1352}
1353
1354
1355const GNEMoveOffset
1357 // calculate moveOffset depending of current mouse position and relative clicked position
1358 // @note #3521: Add checkBox to allow moving elements... has to be implemented and used here
1359 Position moveOffset = (myViewNet->getPositionInformation() - myViewNet->myMoveSingleElementValues.myRelativeClickedPosition);
1360 // calculate Z depending of moveElevation
1361 if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
1362 // use Y as Z value and return Z move offset
1363 return GNEMoveOffset(moveOffset.y());
1364 } else {
1365 // return X-Y move offset
1366 return GNEMoveOffset(moveOffset.x(), moveOffset.y());
1367 }
1368}
1369
1370// ---------------------------------------------------------------------------
1371// GNEViewNetHelper::MoveMultipleElementValues - methods
1372// ---------------------------------------------------------------------------
1373
1375 myViewNet(viewNet),
1376 myMovingSelectedEdge(false),
1377 myEdgeOffset(0) {
1378}
1379
1380
1381void
1383 // save clicked position (to calculate offset)
1384 myClickedPosition = myViewNet->getPositionInformation();
1385 // continue depending of clicked element
1386 if (myViewNet->myObjectsUnderCursor.getJunctionFront()) {
1387 calculateJunctionSelection();
1388 } else if (myViewNet->myObjectsUnderCursor.getEdgeFront()) {
1389 calculateEdgeSelection(myViewNet->myObjectsUnderCursor.getEdgeFront());
1390 }
1391}
1392
1393
1394void
1396 // calculate moveOffset
1397 const GNEMoveOffset moveOffset = calculateMoveOffset();
1398 // check if mouse button is pressed
1399 if (mouseLeftButtonPressed) {
1400 // iterate over all operations
1401 for (const auto& moveOperation : myMoveOperations) {
1402 // move elements
1403 GNEMoveElement::moveElement(myViewNet, moveOperation, moveOffset);
1404 }
1405 } else if (myMoveOperations.size() > 0) {
1406 // begin undo list
1407 myViewNet->getUndoList()->begin(GUIIcon::MODEMOVE, "moving selection");
1408 // iterate over all operations
1409 for (const auto& moveOperation : myMoveOperations) {
1410 // commit move
1411 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1412 // don't forget delete move operation
1413 delete moveOperation;
1414 }
1415 // end undo list
1416 myViewNet->getUndoList()->end();
1417 // clear move operations
1418 myMoveOperations.clear();
1419 }
1420}
1421
1422
1423void
1425 // calculate moveOffset
1426 const GNEMoveOffset moveOffset = calculateMoveOffset();
1427 // begin undo list
1428 myViewNet->getUndoList()->begin(GUIIcon::MODEMOVE, "moving selection");
1429 // finish all move operations
1430 for (const auto& moveOperation : myMoveOperations) {
1431 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1432 // don't forget delete move operation
1433 delete moveOperation;
1434 }
1435 // end undo list
1436 myViewNet->getUndoList()->end();
1437 // clear move operations
1438 myMoveOperations.clear();
1439}
1440
1441
1442bool
1444 return (myMoveOperations.size() > 0);
1445}
1446
1447
1448bool
1450 return myMovingSelectedEdge;
1451}
1452
1453
1454void
1456 myMovingSelectedEdge = false;
1457}
1458
1459
1460double
1462 return myEdgeOffset;
1463}
1464
1465
1466const GNEMoveOffset
1468 // calculate moveOffset depending of current mouse position and relative clicked position
1469 // @note #3521: Add checkBox to allow moving elements... has to be implemented and used here
1470 Position moveOffset = (myViewNet->getPositionInformation() - myClickedPosition);
1471 // calculate Z depending of moveElevation
1472 if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
1473 // use Y for Z and return X move offset
1474 return GNEMoveOffset(moveOffset.y());
1475 } else {
1476 // return X-Y move offset
1477 return GNEMoveOffset(moveOffset.x(), moveOffset.y());
1478 }
1479}
1480
1481
1482void
1484 // declare move operation
1485 GNEMoveOperation* moveOperation = nullptr;
1486 // first move all selected junctions
1487 const auto selectedJunctions = myViewNet->getNet()->getAttributeCarriers()->getSelectedJunctions();
1488 // iterate over selected junctions
1489 for (const auto& junction : selectedJunctions) {
1490 moveOperation = junction->getMoveOperation();
1491 if (moveOperation) {
1492 myMoveOperations.push_back(moveOperation);
1493 }
1494 }
1495 // now move all selected edges
1496 const auto selectedEdges = myViewNet->getNet()->getAttributeCarriers()->getSelectedEdges();
1497 // iterate over selected edges
1498 for (const auto& edge : selectedEdges) {
1499 moveOperation = edge->getMoveOperation();
1500 if (moveOperation) {
1501 myMoveOperations.push_back(moveOperation);
1502 }
1503 }
1504}
1505
1506
1507void
1509 // first move all selected junctions
1510 const auto selectedJunctions = myViewNet->getNet()->getAttributeCarriers()->getSelectedJunctions();
1511 // iterate over selected junctions
1512 for (const auto& junction : selectedJunctions) {
1513 GNEMoveOperation* moveOperation = junction->getMoveOperation();
1514 if (moveOperation) {
1515 myMoveOperations.push_back(moveOperation);
1516 }
1517 }
1518 // enable moving selected edge flag
1519 myMovingSelectedEdge = true;
1520 // get edge shape
1521 const auto& shape = clickedEdge->getNBEdge()->getGeometry();
1522 // calculate offset based on the clicked edge shape and convex angle
1523 if (clickedEdge->isConvexAngle()) {
1524 myEdgeOffset = shape.nearest_offset_to_point2D(myViewNet->getPositionInformation());
1525 } else {
1526 myEdgeOffset = shape.length2D() - shape.nearest_offset_to_point2D(myViewNet->getPositionInformation());
1527 }
1528 // now move all selected edges
1529 const auto selectedEdges = myViewNet->getNet()->getAttributeCarriers()->getSelectedEdges();
1530 // iterate over edges betwen 0 and 180 degrees
1531 for (const auto& edge : selectedEdges) {
1532 GNEMoveOperation* moveOperation = edge->getMoveOperation();
1533 // continue if move operation is valid
1534 if (moveOperation) {
1535 myMoveOperations.push_back(moveOperation);
1536 }
1537 }
1538}
1539
1540// ---------------------------------------------------------------------------
1541// GNEViewNetHelper::VehicleOptions - methods
1542// ---------------------------------------------------------------------------
1543
1545 myViewNet(viewNet) {
1546}
1547
1548
1549void
1551 UNUSED_PARAMETER(myViewNet);
1552 // currently unused
1553}
1554
1555
1556void
1558 // currently unused
1559}
1560
1561// ---------------------------------------------------------------------------
1562// GNEViewNetHelper::VehicleTypeOptions - methods
1563// ---------------------------------------------------------------------------
1564
1566 myViewNet(viewNet) {
1567}
1568
1569
1570void
1572 UNUSED_PARAMETER(myViewNet);
1573 // currently unused
1574}
1575
1576
1577void
1579 // currently unused
1580}
1581
1582// ---------------------------------------------------------------------------
1583// GNEViewNetHelper::SelectingArea - methods
1584// ---------------------------------------------------------------------------
1585
1587 selectingUsingRectangle(false),
1588 startDrawing(false),
1589 myViewNet(viewNet) {
1590}
1591
1592
1593void
1595 selectingUsingRectangle = true;
1596 selectionCorner1 = myViewNet->getPositionInformation();
1597 selectionCorner2 = selectionCorner1;
1598}
1599
1600
1601void
1603 // start drawing
1604 startDrawing = true;
1605 // only update selection corner 2
1606 selectionCorner2 = myViewNet->getPositionInformation();
1607 // update status bar
1608 myViewNet->setStatusBarText("Selection width:" + toString(fabs(selectionCorner1.x() - selectionCorner2.x()))
1609 + " height:" + toString(fabs(selectionCorner1.y() - selectionCorner2.y()))
1610 + " diagonal:" + toString(selectionCorner1.distanceTo2D(selectionCorner2)));
1611}
1612
1613
1614void
1616 // finish rectangle selection
1617 selectingUsingRectangle = false;
1618 startDrawing = false;
1619 // clear status bar
1620 myViewNet->setStatusBarText("");
1621}
1622
1623
1624void
1626 // shift held down on mouse-down and mouse-up and check that rectangle exist
1627 if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1628 (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1629 myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1630 // create boundary between two corners
1631 Boundary rectangleBoundary;
1632 rectangleBoundary.add(selectionCorner1);
1633 rectangleBoundary.add(selectionCorner2);
1634 // process selection within boundary
1635 processBoundarySelection(rectangleBoundary);
1636 }
1637}
1638
1639
1640std::vector<GNEEdge*>
1642 // declare vector for selection
1643 std::vector<GNEEdge*> result;
1644 // shift held down on mouse-down and mouse-up and check that rectangle exist
1645 if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1646 (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1647 myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1648 // create boundary between two corners
1649 Boundary rectangleBoundary;
1650 rectangleBoundary.add(selectionCorner1);
1651 rectangleBoundary.add(selectionCorner2);
1652 if (myViewNet->makeCurrent()) {
1653 // obtain all ACs in Rectangle BOundary
1654 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(rectangleBoundary);
1655 // Filter ACs in Boundary and get only edges
1656 for (const auto& AC : ACsInBoundary) {
1657 if (AC.second->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1658 result.push_back(dynamic_cast<GNEEdge*>(AC.second));
1659 }
1660 }
1661 myViewNet->makeNonCurrent();
1662 }
1663 }
1664 return result;
1665}
1666
1667
1668void
1670 processBoundarySelection(shape.getBoxBoundary());
1671}
1672
1673
1674void
1676 if (selectingUsingRectangle) {
1678 glTranslated(0, 0, GLO_RECTANGLESELECTION);
1679 GLHelper::setColor(color);
1680 glLineWidth(2);
1681 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1682 glBegin(GL_QUADS);
1683 glVertex2d(selectionCorner1.x(), selectionCorner1.y());
1684 glVertex2d(selectionCorner1.x(), selectionCorner2.y());
1685 glVertex2d(selectionCorner2.x(), selectionCorner2.y());
1686 glVertex2d(selectionCorner2.x(), selectionCorner1.y());
1687 glEnd();
1689 }
1690}
1691
1692
1693void
1695 if (myViewNet->makeCurrent()) {
1696 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(boundary);
1697 // filter ACsInBoundary depending of current supermode
1698 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundaryFiltered;
1699 for (const auto& AC : ACsInBoundary) {
1700 if (myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
1701 if (AC.second->getTagProperty().isNetworkElement() || AC.second->getTagProperty().isAdditionalElement()) {
1702 ACsInBoundaryFiltered.insert(AC);
1703 }
1704 } else if (myViewNet->myEditModes.isCurrentSupermodeDemand() && AC.second->getTagProperty().isDemandElement()) {
1705 ACsInBoundaryFiltered.insert(AC);
1706 } else if (myViewNet->myEditModes.isCurrentSupermodeData() && AC.second->getTagProperty().isGenericData()) {
1707 ACsInBoundaryFiltered.insert(AC);
1708 }
1709 }
1710 // declare two sets of attribute carriers, one for select and another for unselect
1711 std::vector<GNEAttributeCarrier*> ACToSelect;
1712 std::vector<GNEAttributeCarrier*> ACToUnselect;
1713 // reserve memory (we assume that in the worst case we're going to insert all elements of ACsInBoundaryFiltered
1714 ACToSelect.reserve(ACsInBoundaryFiltered.size());
1715 ACToUnselect.reserve(ACsInBoundaryFiltered.size());
1716 // in restrict AND replace mode all current selected attribute carriers will be unselected
1717 if ((myViewNet->myViewParent->getSelectorFrame()->getModificationModeModule()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::RESTRICT) ||
1718 (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModule()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::REPLACE)) {
1719 // obtain selected ACs depending of current supermode
1720 const auto selectedAC = myViewNet->getNet()->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1721 // add id into ACs to unselect
1722 for (const auto& AC : selectedAC) {
1723 ACToUnselect.push_back(AC);
1724 }
1725 }
1726 // iterate over AttributeCarriers obtained of boundary an place it in ACToSelect or ACToUnselect
1727 for (const auto& AC : ACsInBoundaryFiltered) {
1728 switch (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModule()->getModificationMode()) {
1730 ACToUnselect.push_back(AC.second);
1731 break;
1733 if (std::find(ACToUnselect.begin(), ACToUnselect.end(), AC.second) != ACToUnselect.end()) {
1734 ACToSelect.push_back(AC.second);
1735 }
1736 break;
1737 default:
1738 ACToSelect.push_back(AC.second);
1739 break;
1740 }
1741 }
1742 // select junctions and their connections and crossings if Auto select junctions is enabled (note: only for "add mode")
1743 if (myViewNet->autoSelectNodes() && (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModule()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::ADD)) {
1744 std::vector<GNEEdge*> edgesToSelect;
1745 // iterate over ACToSelect and extract edges
1746 for (const auto& AC : ACToSelect) {
1747 if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1748 edgesToSelect.push_back(dynamic_cast<GNEEdge*>(AC));
1749 }
1750 }
1751 // iterate over extracted edges
1752 for (const auto& edge : edgesToSelect) {
1753 // select junction source and all their connections and crossings
1754 ACToSelect.push_back(edge->getFromJunction());
1755 for (const auto& connection : edge->getFromJunction()->getGNEConnections()) {
1756 ACToSelect.push_back(connection);
1757 }
1758 for (const auto& crossing : edge->getFromJunction()->getGNECrossings()) {
1759 ACToSelect.push_back(crossing);
1760 }
1761 // select junction destiny and all their connections crossings
1762 ACToSelect.push_back(edge->getToJunction());
1763 for (const auto& connection : edge->getToJunction()->getGNEConnections()) {
1764 ACToSelect.push_back(connection);
1765 }
1766 for (const auto& crossing : edge->getToJunction()->getGNECrossings()) {
1767 ACToSelect.push_back(crossing);
1768 }
1769 }
1770 }
1771 // only continue if there is ACs to select or unselect
1772 if ((ACToSelect.size() + ACToUnselect.size()) > 0) {
1773 // first unselect AC of ACToUnselect and then selects AC of ACToSelect
1774 myViewNet->myUndoList->begin(GUIIcon::MODESELECT, "selection using rectangle");
1775 for (const auto& AC : ACToUnselect) {
1776 AC->setAttribute(GNE_ATTR_SELECTED, "0", myViewNet->myUndoList);
1777 }
1778 for (const auto& AC : ACToSelect) {
1779 if (AC->getTagProperty().isSelectable()) {
1780 AC->setAttribute(GNE_ATTR_SELECTED, "1", myViewNet->myUndoList);
1781 }
1782 }
1783 myViewNet->myUndoList->end();
1784 }
1785 myViewNet->makeNonCurrent();
1786 }
1787}
1788
1789// ---------------------------------------------------------------------------
1790// GNEViewNetHelper::TestingMode - methods
1791// ---------------------------------------------------------------------------
1792
1794 myViewNet(viewNet),
1795 myTestingEnabled(OptionsCont::getOptions().getBool("gui-testing")),
1796 myTestingWidth(0),
1797 myTestingHeight(0) {
1798}
1799
1800
1801void
1803 // first check if testing mode is enabled and window size is correct
1804 if (myTestingEnabled && OptionsCont::getOptions().isSet("window-size")) {
1805 std::vector<std::string> windowSize = OptionsCont::getOptions().getStringVector("window-size");
1806 // make sure that given windows size has exactly two valid int values
1807 if ((windowSize.size() == 2) && GNEAttributeCarrier::canParse<int>(windowSize[0]) && GNEAttributeCarrier::canParse<int>(windowSize[1])) {
1808 myTestingWidth = GNEAttributeCarrier::parse<int>(windowSize[0]);
1809 myTestingHeight = GNEAttributeCarrier::parse<int>(windowSize[1]);
1810 } else {
1811 WRITE_ERROR("Invalid windows size-format: " + toString(windowSize) + "for option 'window-size'");
1812 }
1813 }
1814}
1815
1816
1817void
1819 // first check if testing mode is enabled
1820 if (myTestingEnabled) {
1821 // check if main windows has to be resized
1822 if (myTestingWidth > 0) {
1823 mainWindow->resize(myTestingWidth, myTestingHeight);
1824 }
1825 //std::cout << " fixed: view=" << getWidth() << ", " << getHeight() << " app=" << mainWindow->getWidth() << ", " << mainWindow->getHeight() << "\n";
1826 // draw pink square in the upper left corner on top of everything
1827 const double size = myViewNet->p2m(32);
1828 Position center = myViewNet->screenPos2NetPos(8, 8);
1829 // magenta
1832 glTranslated(center.x(), center.y(), GLO_TESTELEMENT);
1833 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1834 glBegin(GL_QUADS);
1835 glVertex2d(0, 0);
1836 glVertex2d(0, -size);
1837 glVertex2d(size, -size);
1838 glVertex2d(size, 0);
1839 glEnd();
1841 // blue
1844 glTranslated(center.x(), center.y(), GLO_TESTELEMENT + 1);
1845 glScaled(0.7, 0.7, 0);
1846 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1847 glBegin(GL_QUADS);
1848 glVertex2d(0, 0);
1849 glVertex2d(0, -size);
1850 glVertex2d(size, -size);
1851 glVertex2d(size, 0);
1852 glEnd();
1854 // yellow
1857 glTranslated(center.x(), center.y(), GLO_TESTELEMENT + 2);
1858 glScaled(0.4, 0.4, 0);
1859 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1860 glBegin(GL_QUADS);
1861 glVertex2d(0, 0);
1862 glVertex2d(0, -size);
1863 glVertex2d(size, -size);
1864 glVertex2d(size, 0);
1865 glEnd();
1867 }
1868}
1869
1870
1871bool
1873 return myTestingEnabled;
1874}
1875
1876// ---------------------------------------------------------------------------
1877// GNEViewNetHelper::SaveElements - methods
1878// ---------------------------------------------------------------------------
1879
1881 saveAll(nullptr),
1882 saveNetwork(nullptr),
1883 saveAdditionalElements(nullptr),
1884 saveDemandElements(nullptr),
1885 saveDataElements(nullptr),
1886 myViewNet(viewNet) {
1887}
1888
1889
1890void
1892 // create save network button
1893 saveAll = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1894 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1895 "\tSave all\tSave all elements.", GUIIconSubSys::getIcon(GUIIcon::SAVEALLELEMENTS),
1896 myViewNet->getViewParent()->getGNEAppWindows(), MID_GNE_SAVEALLELEMENTS, GUIDesignButtonToolbar);
1897 saveAll->create();
1898 // create save network button
1899 saveNetwork = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1900 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1901 "\tSave network\tSave network. (Ctrl+S)", GUIIconSubSys::getIcon(GUIIcon::SAVENETWORKELEMENTS),
1902 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK, GUIDesignButtonToolbar);
1903 saveNetwork->create();
1904 // create save additional elements button
1905 saveAdditionalElements = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1906 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1907 "\tSave additional elements\tSave additional elements. (Ctrl+Shift+A)", GUIIconSubSys::getIcon(GUIIcon::SAVEADDITIONALELEMENTS),
1908 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALS, GUIDesignButtonToolbar);
1909 saveAdditionalElements->create();
1910 // create save demand elements button
1911 saveDemandElements = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1912 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1913 "\tSave demand elements\tSave demand elements. (Ctrl+Shift+D)", GUIIconSubSys::getIcon(GUIIcon::SAVEDEMANDELEMENTS),
1914 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS, GUIDesignButtonToolbar);
1915 saveDemandElements->create();
1916 // create save data elements button
1917 saveDataElements = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1918 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1919 "\tSave data elements\tSave data elements. (Ctrl+Shift+B)", GUIIconSubSys::getIcon(GUIIcon::SAVEDATAELEMENTS),
1920 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS, GUIDesignButtonToolbar);
1921 saveDataElements->create();
1922 // recalc menu bar because there is new elements
1923 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements->recalc();
1924 // show menu bar modes
1925 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements->show();
1926}
1927
1928// ---------------------------------------------------------------------------
1929// GNEViewNetHelper::EditModes - methods
1930// ---------------------------------------------------------------------------
1931
1933 currentSupermode(Supermode::NETWORK),
1935 demandEditMode(DemandEditMode::DEMAND_INSPECT),
1936 dataEditMode(DataEditMode::DATA_INSPECT),
1937 networkButton(nullptr),
1938 demandButton(nullptr),
1939 dataButton(nullptr),
1940 myViewNet(viewNet)
1941{ }
1942
1943
1944void
1946 // create network button
1947 networkButton = new MFXCheckableButton(false,
1948 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
1949 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1950 "Network\tEdit network elements\tSet mode for edit network elements. (F2)",
1952 networkButton->create();
1953 // create demand button
1954 demandButton = new MFXCheckableButton(false,
1955 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
1956 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1957 "Demand\tEdit traffic demand elements\tSet mode for edit traffic demand. (F3)",
1959 demandButton->create();
1960 // create data button
1961 dataButton = new MFXCheckableButton(false,
1962 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
1963 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1964 "Data\tEdit data elements\tSet mode for edit data demand. (F4)",
1966 dataButton->create();
1967 // recalc menu bar because there is new elements
1968 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
1969 // show menu bar modes
1970 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->show();
1971}
1972
1973
1974void
1976 if (!force && (supermode == currentSupermode)) {
1977 myViewNet->setStatusBarText("Mode already selected");
1978 if (myViewNet->myCurrentFrame != nullptr) {
1979 myViewNet->myCurrentFrame->focusUpperElement();
1980 }
1981 } else {
1982 myViewNet->setStatusBarText("");
1983 // abort current operation
1984 myViewNet->abortOperation(false);
1985 // set super mode
1986 currentSupermode = supermode;
1987 // set supermodes
1988 if (supermode == Supermode::NETWORK) {
1989 // change buttons
1990 networkButton->setChecked(true);
1991 demandButton->setChecked(false);
1992 dataButton->setChecked(false);
1993 // show network buttons
1994 myViewNet->myNetworkCheckableButtons.showNetworkCheckableButtons();
1995 // hide demand buttons
1996 myViewNet->myDemandCheckableButtons.hideDemandCheckableButtons();
1997 // hide data buttons
1998 myViewNet->myDataCheckableButtons.hideDataCheckableButtons();
1999 // force update network mode
2000 setNetworkEditMode(networkEditMode, true);
2001 } else if (supermode == Supermode::DEMAND) {
2002 // change buttons
2003 networkButton->setChecked(false);
2004 demandButton->setChecked(true);
2005 dataButton->setChecked(false);
2006 // hide network buttons
2007 myViewNet->myNetworkCheckableButtons.hideNetworkCheckableButtons();
2008 // show demand buttons
2009 myViewNet->myDemandCheckableButtons.showDemandCheckableButtons();
2010 // hide data buttons
2011 myViewNet->myDataCheckableButtons.hideDataCheckableButtons();
2012 // force update demand mode
2013 setDemandEditMode(demandEditMode, true);
2014 // demand modes require ALWAYS a recomputing
2015 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2016 // check if update path calculator
2017 if (!myViewNet->myNet->getPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2018 // update DijkstraRouter of RouteCalculatorInstance
2019 myViewNet->myNet->getPathManager()->getPathCalculator()->updatePathCalculator();
2020 // compute all demand elements
2021 myViewNet->myNet->computeDemandElements(myViewNet->myViewParent->getGNEAppWindows());
2022 }
2023 } else if (supermode == Supermode::DATA) {
2024 // change buttons
2025 networkButton->setChecked(false);
2026 demandButton->setChecked(false);
2027 dataButton->setChecked(true);
2028 // hide network buttons
2029 myViewNet->myNetworkCheckableButtons.hideNetworkCheckableButtons();
2030 // hide demand buttons
2031 myViewNet->myDemandCheckableButtons.hideDemandCheckableButtons();
2032 // show data buttons
2033 myViewNet->myDataCheckableButtons.showDataCheckableButtons();
2034 // force update data mode
2035 setDataEditMode(dataEditMode, true);
2036 // check if recompute
2037 if (myViewNet->getViewParent()->getGNEAppWindows()->getProcessingMenuCommands().menuCheckRecomputeDataMode->getCheck() == TRUE) {
2038 // demand modes require ALWAYS a recomputing
2039 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2040 }
2041 // check if update path calculator
2042 if (!myViewNet->myNet->getPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2043 // update DijkstraRouter of RouteCalculatorInstance
2044 myViewNet->myNet->getPathManager()->getPathCalculator()->updatePathCalculator();
2045 // compute all demand elements
2046 myViewNet->myNet->computeDemandElements(myViewNet->myViewParent->getGNEAppWindows());
2047 }
2048 }
2049 // update buttons
2050 networkButton->update();
2051 demandButton->update();
2052 dataButton->update();
2053 // update Supermode CommandButtons in GNEAppWindows
2054 myViewNet->myViewParent->getGNEAppWindows()->updateSuperModeMenuCommands(currentSupermode);
2055 }
2056}
2057
2058
2059void
2061 if ((mode == networkEditMode) && !force) {
2062 myViewNet->setStatusBarText("Network mode already selected");
2063 if (myViewNet->myCurrentFrame != nullptr) {
2064 myViewNet->myCurrentFrame->focusUpperElement();
2065 }
2066 } else if (networkEditMode == NetworkEditMode::NETWORK_TLS && !myViewNet->myViewParent->getTLSEditorFrame()->isTLSSaved()) {
2067 myViewNet->setStatusBarText("Save modifications in TLS before change mode");
2068 myViewNet->myCurrentFrame->focusUpperElement();
2069 } else {
2070 myViewNet->setStatusBarText("");
2071 myViewNet->abortOperation(false);
2072 // stop editing of custom shapes
2073 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2074 // set new Network mode
2075 networkEditMode = mode;
2076 // for common modes (Inspect/Delete/Select/move) change also the other supermode
2077 if (networkEditMode == NetworkEditMode::NETWORK_INSPECT) {
2078 demandEditMode = DemandEditMode::DEMAND_INSPECT;
2079 dataEditMode = DataEditMode::DATA_INSPECT;
2080 } else if (networkEditMode == NetworkEditMode::NETWORK_DELETE) {
2081 demandEditMode = DemandEditMode::DEMAND_DELETE;
2082 dataEditMode = DataEditMode::DATA_DELETE;
2083 } else if (networkEditMode == NetworkEditMode::NETWORK_SELECT) {
2084 demandEditMode = DemandEditMode::DEMAND_SELECT;
2085 dataEditMode = DataEditMode::DATA_SELECT;
2086 } else if (networkEditMode == NetworkEditMode::NETWORK_MOVE) {
2087 demandEditMode = DemandEditMode::DEMAND_MOVE;
2088 }
2089 // certain modes require a recomputing
2090 switch (mode) {
2095 // modes which depend on computed data
2096 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2097 break;
2098 default:
2099 break;
2100 }
2101 // update cursors
2102 myViewNet->updateCursor();
2103 // update network mode specific controls
2104 myViewNet->updateNetworkModeSpecificControls();
2105 }
2106}
2107
2108
2109void
2111 if ((mode == demandEditMode) && !force) {
2112 myViewNet->setStatusBarText("Demand mode already selected");
2113 if (myViewNet->myCurrentFrame != nullptr) {
2114 myViewNet->myCurrentFrame->focusUpperElement();
2115 }
2116 } else {
2117 myViewNet->setStatusBarText("");
2118 myViewNet->abortOperation(false);
2119 // stop editing of custom shapes
2120 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2121 // set new Demand mode
2122 demandEditMode = mode;
2123 // for common modes (Inspect/Delete/Select/Move) change also the other supermode
2124 if (demandEditMode == DemandEditMode::DEMAND_INSPECT) {
2125 networkEditMode = NetworkEditMode::NETWORK_INSPECT;
2126 dataEditMode = DataEditMode::DATA_INSPECT;
2127 } else if (demandEditMode == DemandEditMode::DEMAND_DELETE) {
2128 networkEditMode = NetworkEditMode::NETWORK_DELETE;
2129 dataEditMode = DataEditMode::DATA_DELETE;
2130 } else if (demandEditMode == DemandEditMode::DEMAND_SELECT) {
2131 networkEditMode = NetworkEditMode::NETWORK_SELECT;
2132 dataEditMode = DataEditMode::DATA_SELECT;
2133 } else if (demandEditMode == DemandEditMode::DEMAND_MOVE) {
2134 networkEditMode = NetworkEditMode::NETWORK_MOVE;
2135 }
2136 // update cursors
2137 myViewNet->updateCursor();
2138 // update network mode specific controls
2139 myViewNet->updateDemandModeSpecificControls();
2140 }
2141}
2142
2143
2144void
2146 if ((mode == dataEditMode) && !force) {
2147 myViewNet->setStatusBarText("Data mode already selected");
2148 if (myViewNet->myCurrentFrame != nullptr) {
2149 myViewNet->myCurrentFrame->focusUpperElement();
2150 }
2151 } else {
2152 myViewNet->setStatusBarText("");
2153 myViewNet->abortOperation(false);
2154 // stop editing of custom shapes
2155 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2156 // set new Data mode
2157 dataEditMode = mode;
2158 // for common modes (Inspect/Delete/Select/Move) change also the other supermode
2159 if (dataEditMode == DataEditMode::DATA_INSPECT) {
2160 networkEditMode = NetworkEditMode::NETWORK_INSPECT;
2161 demandEditMode = DemandEditMode::DEMAND_INSPECT;
2162 } else if (dataEditMode == DataEditMode::DATA_DELETE) {
2163 networkEditMode = NetworkEditMode::NETWORK_DELETE;
2164 demandEditMode = DemandEditMode::DEMAND_DELETE;
2165 } else if (dataEditMode == DataEditMode::DATA_SELECT) {
2166 networkEditMode = NetworkEditMode::NETWORK_SELECT;
2167 demandEditMode = DemandEditMode::DEMAND_SELECT;
2168 }
2169 // update all datasets
2170 for (const auto& dataSet : myViewNet->getNet()->getAttributeCarriers()->getDataSets()) {
2171 dataSet->updateAttributeColors();
2172 }
2173 // update cursors
2174 myViewNet->updateCursor();
2175 // update network mode specific controls
2176 myViewNet->updateDataModeSpecificControls();
2177 }
2178}
2179
2180
2181bool
2183 return (currentSupermode == Supermode::NETWORK);
2184}
2185
2186
2187bool
2189 return (currentSupermode == Supermode::DEMAND);
2190}
2191
2192
2193bool
2195 return (currentSupermode == Supermode::DATA);
2196}
2197
2198// ---------------------------------------------------------------------------
2199// GNEViewNetHelper::NetworkViewOptions - methods
2200// ---------------------------------------------------------------------------
2201
2203 menuCheckToggleGrid(nullptr),
2204 menuCheckToggleDrawJunctionShape(nullptr),
2205 menuCheckDrawSpreadVehicles(nullptr),
2206 menuCheckShowDemandElements(nullptr),
2207 menuCheckSelectEdges(nullptr),
2208 menuCheckShowConnections(nullptr),
2209 menuCheckHideConnections(nullptr),
2210 menuCheckShowAdditionalSubElements(nullptr),
2211 menuCheckShowTAZElements(nullptr),
2212 menuCheckExtendSelection(nullptr),
2213 menuCheckChangeAllPhases(nullptr),
2214 menuCheckWarnAboutMerge(nullptr),
2215 menuCheckShowJunctionBubble(nullptr),
2216 menuCheckMoveElevation(nullptr),
2217 menuCheckChainEdges(nullptr),
2218 menuCheckAutoOppositeEdge(nullptr),
2219 myViewNet(viewNet) {
2220}
2221
2222
2223void
2225 // create menu checks
2226 menuCheckToggleGrid = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2227 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2228 ("\tShow grid\tShow grid and restrict movement to the grid - define grid size in visualization options. (Ctrl+G)"),
2231 menuCheckToggleGrid->setChecked(false);
2232 menuCheckToggleGrid->create();
2233
2234 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2235 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2236 ("\tHide junction shape\tToggle hidding junction shape. (Ctrl+J)"),
2239 menuCheckToggleDrawJunctionShape->setChecked(false);
2240 menuCheckToggleDrawJunctionShape->create();
2241
2242 menuCheckDrawSpreadVehicles = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2243 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2244 ("\tDraw vehicles spread in lane or depart position\tDraw vehicles spread in lane or in depart position."),
2247 menuCheckDrawSpreadVehicles->setChecked(false);
2248 menuCheckDrawSpreadVehicles->create();
2249
2250 menuCheckShowDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2251 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2252 ("\tShow demand elements\tToggle show demand elements."),
2255 menuCheckShowDemandElements->setChecked(false);
2256 menuCheckShowDemandElements->create();
2257
2258 menuCheckSelectEdges = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2259 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2260 ("\tclicks target lanes\tToggle whether clicking should inspect/select/delete lanes instead of edges."),
2263 menuCheckSelectEdges->create();
2264
2265 menuCheckShowConnections = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2266 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2267 ("\tShow connections over junctions\tToggle show connections over junctions."),
2270 menuCheckShowConnections->setChecked(myViewNet->getVisualisationSettings().showLane2Lane);
2271 menuCheckShowConnections->create();
2272
2273 menuCheckHideConnections = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2274 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2275 ("\tHide connections\tToggle hide connections."),
2278 menuCheckHideConnections->setChecked(false);
2279 menuCheckHideConnections->create();
2280
2281 menuCheckShowAdditionalSubElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2282 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2283 ("\tShow additional sub-elements\tToggle show additional sub-elements."),
2286 menuCheckShowAdditionalSubElements->setChecked(false);
2287 menuCheckShowAdditionalSubElements->create();
2288
2289 menuCheckShowTAZElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2290 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2291 ("\tShow TAZ elements\tToggle show TAZ elements."),
2294 menuCheckShowTAZElements->setChecked(false);
2295 menuCheckShowTAZElements->create();
2296
2297 menuCheckExtendSelection = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2298 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2299 ("\tAutomatic select junctions\tToggle whether selecting multiple edges should automatically select their junctions."),
2302 menuCheckExtendSelection->setChecked(true);
2303 menuCheckExtendSelection->create();
2304
2305 menuCheckChangeAllPhases = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2306 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2307 ("\tApply state to all phases\tToggle whether clicking should apply state changes to all phases of the current TLS plan."),
2310 menuCheckChangeAllPhases->setChecked(false);
2311 menuCheckChangeAllPhases->create();
2312
2313 menuCheckWarnAboutMerge = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2314 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2315 ("\tAutomatic merging junction\tToggle ask for confirmation before merging junction."),
2318 menuCheckWarnAboutMerge->create();
2319
2320 menuCheckShowJunctionBubble = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2321 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2322 ("\tShow bubbles\tToggle show bubbles over junctions shapes."),
2325 menuCheckShowJunctionBubble->setChecked(false);
2326 menuCheckShowJunctionBubble->create();
2327
2328 menuCheckMoveElevation = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2329 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2330 ("\tMove elevation\tApply mouse movement to elevation instead of x,y position."),
2333 menuCheckMoveElevation->setChecked(false);
2334 menuCheckMoveElevation->create();
2335
2336 menuCheckChainEdges = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2337 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2338 ("\tEdge chain mode\tCreate consecutive edges with a single click (hit ESC to cancel chain)."),
2341 menuCheckChainEdges->setChecked(false);
2342 menuCheckChainEdges->create();
2343
2344 menuCheckAutoOppositeEdge = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2345 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2346 ("\tEdge opposite direction\tAutomatically create an edge in the opposite direction."),
2349 menuCheckAutoOppositeEdge->setChecked(false);
2350 menuCheckAutoOppositeEdge->create();
2351
2352 // always recalc after creating new elements
2353 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2354}
2355
2356
2357void
2359 menuCheckToggleGrid->hide();
2360 menuCheckToggleDrawJunctionShape->hide();
2361 menuCheckDrawSpreadVehicles->hide();
2362 menuCheckShowDemandElements->hide();
2363 menuCheckSelectEdges->hide();
2364 menuCheckShowConnections->hide();
2365 menuCheckHideConnections->hide();
2366 menuCheckShowAdditionalSubElements->hide();
2367 menuCheckShowTAZElements->hide();
2368 menuCheckExtendSelection->hide();
2369 menuCheckChangeAllPhases->hide();
2370 menuCheckWarnAboutMerge->hide();
2371 menuCheckShowJunctionBubble->hide();
2372 menuCheckMoveElevation->hide();
2373 menuCheckChainEdges->hide();
2374 menuCheckAutoOppositeEdge->hide();
2375 // Also hide toolbar grip
2376 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2377}
2378
2379
2380void
2381GNEViewNetHelper::NetworkViewOptions::getVisibleNetworkMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2382 // save visible menu commands in commands vector
2383 if (menuCheckToggleGrid->shown()) {
2384 commands.push_back(menuCheckToggleGrid);
2385 }
2386 if (menuCheckToggleDrawJunctionShape->shown()) {
2387 commands.push_back(menuCheckToggleDrawJunctionShape);
2388 }
2389 if (menuCheckDrawSpreadVehicles->shown()) {
2390 commands.push_back(menuCheckDrawSpreadVehicles);
2391 }
2392 if (menuCheckShowDemandElements->shown()) {
2393 commands.push_back(menuCheckShowDemandElements);
2394 }
2395 if (menuCheckSelectEdges->shown()) {
2396 commands.push_back(menuCheckSelectEdges);
2397 }
2398 if (menuCheckShowConnections->shown()) {
2399 commands.push_back(menuCheckShowConnections);
2400 }
2401 if (menuCheckHideConnections->shown()) {
2402 commands.push_back(menuCheckHideConnections);
2403 }
2404 if (menuCheckShowAdditionalSubElements->shown()) {
2405 commands.push_back(menuCheckShowAdditionalSubElements);
2406 }
2407 if (menuCheckShowTAZElements->shown()) {
2408 commands.push_back(menuCheckShowTAZElements);
2409 }
2410 if (menuCheckExtendSelection->shown()) {
2411 commands.push_back(menuCheckExtendSelection);
2412 }
2413 if (menuCheckChangeAllPhases->shown()) {
2414 commands.push_back(menuCheckChangeAllPhases);
2415 }
2416 if (menuCheckWarnAboutMerge->shown()) {
2417 commands.push_back(menuCheckWarnAboutMerge);
2418 }
2419 if (menuCheckShowJunctionBubble->shown()) {
2420 commands.push_back(menuCheckShowJunctionBubble);
2421 }
2422 if (menuCheckMoveElevation->shown()) {
2423 commands.push_back(menuCheckMoveElevation);
2424 }
2425 if (menuCheckChainEdges->shown()) {
2426 commands.push_back(menuCheckChainEdges);
2427 }
2428 if (menuCheckAutoOppositeEdge->shown()) {
2429 commands.push_back(menuCheckAutoOppositeEdge);
2430 }
2431}
2432
2433
2434bool
2436 return (menuCheckDrawSpreadVehicles->amChecked() == TRUE);
2437}
2438
2439
2440bool
2442 if (menuCheckShowDemandElements->shown()) {
2443 return (menuCheckShowDemandElements->amChecked() == TRUE);
2444 } else {
2445 // by default, if menuCheckShowDemandElements isn't shown, always show demand elements
2446 return true;
2447 }
2448}
2449
2450
2451bool
2453 if (menuCheckSelectEdges->shown()) {
2454 return (menuCheckSelectEdges->amChecked() != TRUE);
2455 } else {
2456 // by default, if menuCheckSelectEdges isn't shown, always select edges
2457 return true;
2458 }
2459}
2460
2461
2462bool
2464 if (myViewNet->myEditModes.isCurrentSupermodeData()) {
2465 return false;
2466 } else if (myViewNet->myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
2467 // check if menu check hide connections ins shown
2468 return (menuCheckHideConnections->amChecked() == FALSE);
2469 } else if (myViewNet->myEditModes.networkEditMode == NetworkEditMode::NETWORK_PROHIBITION) {
2470 return true;
2471 } else if (myViewNet->myEditModes.isCurrentSupermodeNetwork() && menuCheckShowConnections->shown() == false) {
2472 return false;
2473 } else {
2474 return (myViewNet->getVisualisationSettings().showLane2Lane);
2475 }
2476}
2477
2478
2479bool
2481 if (!myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
2482 return false;
2483 } else if (menuCheckShowAdditionalSubElements->shown() == false) {
2484 return false;
2485 } else {
2486 return menuCheckShowAdditionalSubElements->amChecked();
2487 }
2488}
2489
2490
2491bool
2493 if (!myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
2494 return false;
2495 } else if (menuCheckShowTAZElements->shown() == false) {
2496 return false;
2497 } else {
2498 return menuCheckShowTAZElements->amChecked();
2499 }
2500}
2501
2502
2503bool
2505 if (menuCheckMoveElevation->shown()) {
2506 return (menuCheckMoveElevation->amChecked() == TRUE);
2507 } else {
2508 return false;
2509 }
2510}
2511
2512// ---------------------------------------------------------------------------
2513// GNEViewNetHelper::DemandViewOptions - methods
2514// ---------------------------------------------------------------------------
2515
2517 menuCheckToggleGrid(nullptr),
2518 menuCheckToggleDrawJunctionShape(nullptr),
2519 menuCheckDrawSpreadVehicles(nullptr),
2520 menuCheckHideShapes(nullptr),
2521 menuCheckShowAllTrips(nullptr),
2522 menuCheckShowAllPersonPlans(nullptr),
2523 menuCheckLockPerson(nullptr),
2524 menuCheckShowAllContainerPlans(nullptr),
2525 menuCheckLockContainer(nullptr),
2526 menuCheckHideNonInspectedDemandElements(nullptr),
2527 menuCheckShowOverlappedRoutes(nullptr),
2528 myViewNet(viewNet),
2529 myLockedPerson(nullptr),
2530 myLockedContainer(nullptr) {
2531}
2532
2533
2534void
2536 // create menu checks
2537 menuCheckToggleGrid = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2538 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2539 ("\tShow grid\tShow grid and restrict movement to the grid - define grid size in visualization options. (Ctrl+G)"),
2542 menuCheckToggleGrid->setChecked(false);
2543 menuCheckToggleGrid->create();
2544
2545 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2546 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2547 ("\tHide junction shape\tToggle hidding junction shape. (Ctrl+J)"),
2550 menuCheckToggleDrawJunctionShape->setChecked(false);
2551 menuCheckToggleDrawJunctionShape->create();
2552
2553 menuCheckDrawSpreadVehicles = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2554 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2555 ("\tDraw vehicles spread/depart position\tDraw vehicles spread in lane or in depart position."),
2558 menuCheckDrawSpreadVehicles->setChecked(false);
2559 menuCheckDrawSpreadVehicles->create();
2560
2561 menuCheckHideShapes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2562 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2563 ("\tShow shapes\tToggle show shapes (Polygons and POIs)."),
2566 menuCheckHideShapes->setChecked(false);
2567 menuCheckHideShapes->create();
2568
2569 menuCheckShowAllTrips = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2570 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2571 ("\tShow all trips\tToggle show all trips (requires updated demand - F5)."),
2574 menuCheckShowAllTrips->setChecked(false);
2575 menuCheckShowAllTrips->create();
2576
2577 menuCheckShowAllPersonPlans = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2578 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2579 ("\tShow all person plans\tToggle show all person plans."),
2582 menuCheckShowAllPersonPlans->setChecked(false);
2583 menuCheckShowAllPersonPlans->create();
2584
2585 menuCheckLockPerson = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2586 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2587 ("\tLock selected person\tToggle lock selected person."),
2590 menuCheckLockPerson->setChecked(false);
2591 menuCheckLockPerson->create();
2592
2593 menuCheckShowAllContainerPlans = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2594 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2595 ("\tShow all containers plans\tToggle show all container plans."),
2598 menuCheckShowAllContainerPlans->setChecked(false);
2599 menuCheckShowAllContainerPlans->create();
2600
2601 menuCheckLockContainer = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2602 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2603 ("\tLock selected container\tToggle lock selected container."),
2606 menuCheckLockContainer->setChecked(false);
2607 menuCheckLockContainer->create();
2608
2609 menuCheckHideNonInspectedDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2610 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2611 ("\tShow non-inspected demand elements\tToggle show non-inspected demand elements."),
2614 menuCheckHideNonInspectedDemandElements->setChecked(false);
2615 menuCheckHideNonInspectedDemandElements->create();
2616
2617 menuCheckShowOverlappedRoutes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2618 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2619 ("\tShow number of overlapped routes\tToggle show number of overlapped routes."),
2622 menuCheckShowOverlappedRoutes->setChecked(false);
2623 menuCheckShowOverlappedRoutes->create();
2624
2625 // always recalc after creating new elements
2626 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2627}
2628
2629
2630void
2632 menuCheckToggleGrid->hide();
2633 menuCheckToggleDrawJunctionShape->hide();
2634 menuCheckDrawSpreadVehicles->hide();
2635 menuCheckHideShapes->hide();
2636 menuCheckShowAllTrips->hide();
2637 menuCheckShowAllPersonPlans->hide();
2638 menuCheckLockPerson->hide();
2639 menuCheckShowAllContainerPlans->hide();
2640 menuCheckLockContainer->hide();
2641 menuCheckHideNonInspectedDemandElements->hide();
2642 menuCheckShowOverlappedRoutes->hide();
2643 // Also hide toolbar grip
2644 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2645}
2646
2647
2648void
2649GNEViewNetHelper::DemandViewOptions::getVisibleDemandMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2650 // save visible menu commands in commands vector
2651 if (menuCheckToggleGrid->shown()) {
2652 commands.push_back(menuCheckToggleGrid);
2653 }
2654 if (menuCheckToggleDrawJunctionShape->shown()) {
2655 commands.push_back(menuCheckToggleDrawJunctionShape);
2656 }
2657 if (menuCheckDrawSpreadVehicles->shown()) {
2658 commands.push_back(menuCheckDrawSpreadVehicles);
2659 }
2660 if (menuCheckHideShapes->shown()) {
2661 commands.push_back(menuCheckHideShapes);
2662 }
2663 if (menuCheckShowAllTrips->shown()) {
2664 commands.push_back(menuCheckShowAllTrips);
2665 }
2666 if (menuCheckShowAllPersonPlans->shown() && menuCheckShowAllPersonPlans->isEnabled()) {
2667 commands.push_back(menuCheckShowAllPersonPlans);
2668 }
2669 if (menuCheckLockPerson->shown() && menuCheckLockPerson->isEnabled()) {
2670 commands.push_back(menuCheckLockPerson);
2671 }
2672 if (menuCheckShowAllContainerPlans->shown() && menuCheckShowAllContainerPlans->isEnabled()) {
2673 commands.push_back(menuCheckShowAllContainerPlans);
2674 }
2675 if (menuCheckLockContainer->shown() && menuCheckLockContainer->isEnabled()) {
2676 commands.push_back(menuCheckLockContainer);
2677 }
2678 if (menuCheckHideNonInspectedDemandElements->shown()) {
2679 commands.push_back(menuCheckHideNonInspectedDemandElements);
2680 }
2681 if (menuCheckShowOverlappedRoutes->shown()) {
2682 commands.push_back(menuCheckShowOverlappedRoutes);
2683 }
2684}
2685
2686
2687bool
2689 return (menuCheckDrawSpreadVehicles->amChecked() == TRUE);
2690}
2691
2692
2693bool
2695 if (menuCheckHideNonInspectedDemandElements->shown()) {
2696 // check conditions
2697 if ((menuCheckHideNonInspectedDemandElements->amChecked() == FALSE) || (myViewNet->getInspectedAttributeCarriers().empty())) {
2698 // if checkbox is disabled or there isn't insepected element, then return true
2699 return true;
2700 } else if (myViewNet->getInspectedAttributeCarriers().front()->getTagProperty().isDemandElement()) {
2701 if (myViewNet->isAttributeCarrierInspected(demandElement)) {
2702 // if inspected element correspond to demandElement, return true
2703 return true;
2704 } else {
2705 // if demandElement is a route, check if dottedAC is one of their children (Vehicle or Stop)
2706 for (const auto& i : demandElement->getChildDemandElements()) {
2707 if (myViewNet->isAttributeCarrierInspected(i)) {
2708 return true;
2709 }
2710 }
2711 // if demandElement is a vehicle, check if dottedAC is one of his route Parent
2712 for (const auto& i : demandElement->getParentDemandElements()) {
2713 if (myViewNet->isAttributeCarrierInspected(i)) {
2714 return true;
2715 }
2716 }
2717 // dottedAC isn't one of their parent, then return false
2718 return false;
2719 }
2720 } else {
2721 // we're inspecting a demand element, then return true
2722 return true;
2723 }
2724 } else {
2725 // we're inspecting a demand element, then return true
2726 return true;
2727 }
2728}
2729
2730
2731bool
2733 if (menuCheckHideShapes->shown()) {
2734 return (menuCheckHideShapes->amChecked() == FALSE);
2735 } else {
2736 return true;
2737 }
2738}
2739
2740
2741bool
2743 return (menuCheckShowAllTrips->amChecked() == TRUE);
2744}
2745
2746
2747bool
2749 if (menuCheckShowAllPersonPlans->isEnabled()) {
2750 return (menuCheckShowAllPersonPlans->amChecked() == TRUE);
2751 } else {
2752 return false;
2753 }
2754}
2755
2756
2757void
2759 myLockedPerson = person;
2760}
2761
2762
2763void
2765 myLockedPerson = nullptr;
2766}
2767
2768
2769const GNEDemandElement*
2771 return myLockedPerson;
2772}
2773
2774
2775bool
2777 if (menuCheckShowAllContainerPlans->isEnabled()) {
2778 return (menuCheckShowAllContainerPlans->amChecked() == TRUE);
2779 } else {
2780 return false;
2781 }
2782}
2783
2784
2785void
2787 myLockedContainer = container;
2788}
2789
2790
2791void
2793 myLockedContainer = nullptr;
2794}
2795
2796
2797bool
2799 if (menuCheckShowOverlappedRoutes->isEnabled()) {
2800 return (menuCheckShowOverlappedRoutes->amChecked() == TRUE);
2801 } else {
2802 return false;
2803 }
2804}
2805
2806
2807const GNEDemandElement*
2809 return myLockedContainer;
2810}
2811
2812// ---------------------------------------------------------------------------
2813// GNEViewNetHelper::DataViewOptions - methods
2814// ---------------------------------------------------------------------------
2815
2817 menuCheckToggleDrawJunctionShape(nullptr),
2818 menuCheckShowAdditionals(nullptr),
2819 menuCheckShowShapes(nullptr),
2820 menuCheckShowDemandElements(nullptr),
2821 menuCheckToggleTAZRelDrawing(nullptr),
2822 menuCheckToggleTAZDrawFill(nullptr),
2823 menuCheckToggleTAZRelOnlyFrom(nullptr),
2824 menuCheckToggleTAZRelOnlyTo(nullptr),
2825 myViewNet(viewNet) {
2826}
2827
2828
2829void
2831 // create menu checks
2832 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2833 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2834 ("\tHide junction shape\tToggle hidding junction shape. (Ctrl+J)"),
2837 menuCheckToggleDrawJunctionShape->setChecked(false);
2838 menuCheckToggleDrawJunctionShape->create();
2839
2840 menuCheckShowAdditionals = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2841 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2842 ("\tShow additionals\tToggle show additionals."),
2845 menuCheckShowAdditionals->create();
2846
2847 menuCheckShowShapes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2848 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2849 ("\tShow shapes\tToggle show shapes (Polygons and POIs)."),
2852 menuCheckShowShapes->create();
2853
2854 menuCheckShowDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2855 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2856 ("\tShow demand elements\tToggle show demand elements."),
2859 menuCheckShowDemandElements->create();
2860
2861 menuCheckToggleTAZRelDrawing = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2862 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2863 ("\tDraw TAZREL drawing mode\tToggle draw TAZREL drawing mode."),
2866 menuCheckToggleTAZRelDrawing->create();
2867
2868 menuCheckToggleTAZDrawFill = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2869 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2870 ("\tToggle draw TAZ fill\tToggle draw TAZ fill"),
2873 menuCheckToggleTAZDrawFill->create();
2874
2875 menuCheckToggleTAZRelOnlyFrom = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2876 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2877 ("\tToggle draw TAZRel only from\tToggle draw TAZRel only from"),
2880 menuCheckToggleTAZRelOnlyFrom->create();
2881
2882 menuCheckToggleTAZRelOnlyTo = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2883 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2884 ("\tToggle draw TAZRel only to\tToggle draw TAZRel only to"),
2887 menuCheckToggleTAZRelOnlyTo->create();
2888
2889 // always recalc after creating new elements
2890 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2891}
2892
2893
2894void
2896 menuCheckToggleDrawJunctionShape->hide();
2897 menuCheckShowAdditionals->hide();
2898 menuCheckShowShapes->hide();
2899 menuCheckShowDemandElements->hide();
2900 menuCheckToggleTAZRelDrawing->hide();
2901 menuCheckToggleTAZDrawFill->hide();
2902 menuCheckToggleTAZRelOnlyFrom->hide();
2903 menuCheckToggleTAZRelOnlyTo->hide();
2904 // Also hide toolbar grip
2905 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2906}
2907
2908
2909void
2910GNEViewNetHelper::DataViewOptions::getVisibleDataMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2911 // save visible menu commands in commands vector
2912 if (menuCheckToggleDrawJunctionShape->shown()) {
2913 commands.push_back(menuCheckToggleDrawJunctionShape);
2914 }
2915 if (menuCheckShowAdditionals->shown()) {
2916 commands.push_back(menuCheckShowAdditionals);
2917 }
2918 if (menuCheckShowShapes->shown()) {
2919 commands.push_back(menuCheckShowShapes);
2920 }
2921 if (menuCheckShowDemandElements->shown()) {
2922 commands.push_back(menuCheckShowDemandElements);
2923 }
2924 if (menuCheckToggleTAZRelDrawing->shown()) {
2925 commands.push_back(menuCheckToggleTAZRelDrawing);
2926 }
2927 if (menuCheckToggleTAZDrawFill->shown()) {
2928 commands.push_back(menuCheckToggleTAZDrawFill);
2929 }
2930 if (menuCheckToggleTAZRelOnlyFrom->shown()) {
2931 commands.push_back(menuCheckToggleTAZRelOnlyFrom);
2932 }
2933 if (menuCheckToggleTAZRelOnlyTo->shown()) {
2934 commands.push_back(menuCheckToggleTAZRelOnlyTo);
2935 }
2936}
2937
2938
2939bool
2941 if (menuCheckShowAdditionals->shown()) {
2942 return (menuCheckShowAdditionals->amChecked() == TRUE);
2943 } else {
2944 return true;
2945 }
2946}
2947
2948
2949bool
2951 if (menuCheckShowShapes->shown()) {
2952 return (menuCheckShowShapes->amChecked() == TRUE);
2953 } else {
2954 return true;
2955 }
2956}
2957
2958
2959bool
2961 if (menuCheckShowDemandElements->shown()) {
2962 return (menuCheckShowDemandElements->amChecked() == TRUE);
2963 } else {
2964 return true;
2965 }
2966}
2967
2968
2969bool
2971 return (menuCheckToggleTAZRelDrawing->amChecked() != TRUE);
2972}
2973
2974
2975bool
2977 if (menuCheckToggleTAZDrawFill->shown()) {
2978 return (menuCheckToggleTAZDrawFill->amChecked() != TRUE);
2979 } else {
2980 return false;
2981 }
2982}
2983
2984
2985bool
2987 if (menuCheckToggleTAZRelOnlyFrom->shown()) {
2988 return (menuCheckToggleTAZRelOnlyFrom->amChecked() != TRUE);
2989 } else {
2990 return false;
2991 }
2992}
2993
2994
2995bool
2997 if (menuCheckToggleTAZRelOnlyTo->shown()) {
2998 return (menuCheckToggleTAZRelOnlyTo->amChecked() != TRUE);
2999 } else {
3000 return false;
3001 }
3002}
3003
3004// ---------------------------------------------------------------------------
3005// GNEViewNetHelper::IntervalBar - methods
3006// ---------------------------------------------------------------------------
3007
3009 myViewNet(viewNet),
3010 myUpdateInterval(true),
3011 myGenericDataTypesComboBox(nullptr),
3012 myDataSetsComboBox(nullptr),
3013 myIntervalCheckBox(nullptr),
3014 myBeginTextField(nullptr),
3015 myEndTextField(nullptr),
3016 myParametersComboBox(nullptr) {
3017}
3018
3019
3020void
3022 // create interval label
3023 FXLabel* genericDataLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3024 "Data type", 0, GUIDesignLabelAttribute);
3025 genericDataLabel->create();
3026 // create combo box for generic datas
3027 myGenericDataTypesComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3029 myGenericDataTypesComboBox->create();
3030 // fill combo box
3031 myGenericDataTypesComboBox->appendItem("<all>");
3032 myGenericDataTypesComboBox->appendItem(toString(SUMO_TAG_MEANDATA_EDGE).c_str());
3033 myGenericDataTypesComboBox->appendItem(toString(SUMO_TAG_EDGEREL).c_str());
3034 myGenericDataTypesComboBox->appendItem(toString(SUMO_TAG_TAZREL).c_str());
3035 myGenericDataTypesComboBox->setNumVisible(myGenericDataTypesComboBox->getNumItems());
3036 // create dataSet label
3037 FXLabel* dataSetLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3038 "Data sets", 0, GUIDesignLabelAttribute);
3039 dataSetLabel->create();
3040 // create combo box for sets
3041 myDataSetsComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3043 myDataSetsComboBox->create();
3044 // create checkbutton for myLimitByInterval
3045 myIntervalCheckBox = new FXCheckButton(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3047 myIntervalCheckBox->create();
3048 // create textfield for begin
3049 myBeginTextField = new FXTextField(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3051 myBeginTextField->create();
3052 // create text field for end
3053 myEndTextField = new FXTextField(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3055 myEndTextField->create();
3056 // create parameter label
3057 FXLabel* parameterLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3058 "Parameter", 0, GUIDesignLabelAttribute);
3059 parameterLabel->create();
3060 // create combo box for attributes
3061 myParametersComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3063 myParametersComboBox->create();
3064 // always recalc after creating new elements
3065 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->recalc();
3066}
3067
3068
3069void
3071 // first update interval bar
3072 updateIntervalBar();
3073 // show toolbar grip
3074 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->show();
3075}
3076
3077
3078void
3080 // hide toolbar grip
3081 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->hide();
3082}
3083
3084
3085void
3087 // check if intervalBar has to be updated
3088 if (myUpdateInterval && myViewNet->getNet()) {
3089 // clear data sets
3090 myDataSets.clear();
3091 // declare intervals
3092 double begin = INVALID_DOUBLE;
3093 double end = INVALID_DOUBLE;
3094 // clear parameters
3095 myParameters.clear();
3096 // iterate over all data elements
3097 for (const auto& dataSet : myViewNet->getNet()->getAttributeCarriers()->getDataSets()) {
3098 // add data set ID
3099 myDataSets.push_back(dataSet->getID());
3100 // iterate over all intervals
3101 for (const auto& interval : dataSet->getDataIntervalChildren()) {
3102 // set intervals
3103 if ((begin == INVALID_DOUBLE) || (interval.first < begin)) {
3104 begin = interval.first;
3105 }
3106 if ((end == INVALID_DOUBLE) || (interval.first > end)) {
3107 end = interval.first;
3108 }
3109 // iterate over all generic datas
3110 for (const auto& genericData : interval.second->getGenericDataChildren()) {
3111 // iterate over parameters
3112 for (const auto& parameter : genericData->getParametersMap()) {
3113 myParameters.insert(parameter.first);
3114 }
3115 }
3116 }
3117 }
3118 // get previous dataSet
3119 const std::string previousDataSet = myDataSetsComboBox->getText().text();
3120 // get previous interval
3121 const std::string previousBegin = (myIntervalCheckBox->getCheck() == TRUE) ? myBeginTextField->getText().text() : "";
3122 const std::string previousEnd = (myIntervalCheckBox->getCheck() == TRUE) ? myEndTextField->getText().text() : "";
3123 // get previous parameter
3124 const std::string previousParameter = myParametersComboBox->getText().text();
3125 // clear comboBoxes
3126 myDataSetsComboBox->clearItems();
3127 myParametersComboBox->clearItems();
3128 // add first item (all)
3129 myDataSetsComboBox->appendItem("<all>");
3130 myParametersComboBox->appendItem("<all>");
3131 // fill dataSet comboBox
3132 for (const auto& dataSet : myDataSets) {
3133 myDataSetsComboBox->appendItem(dataSet.c_str());
3134 }
3135 // set begin/end
3136 myBeginTextField->setText(toString(begin).c_str());
3137 myEndTextField->setText(toString(end).c_str());
3138 // fill parameter comboBox
3139 for (const auto& parameter : myParameters) {
3140 myParametersComboBox->appendItem(parameter.c_str());
3141 }
3142 // check previous dataSet
3143 myDataSetsComboBox->setCurrentItem(0, FALSE);
3144 for (int i = 0; i < myDataSetsComboBox->getNumItems(); i++) {
3145 if (myDataSetsComboBox->getItem(i).text() == previousDataSet) {
3146 myDataSetsComboBox->setCurrentItem(i);
3147 }
3148 }
3149 // set previous interval
3150 if (myIntervalCheckBox->getCheck() == TRUE) {
3151 myBeginTextField->setText(previousBegin.c_str());
3152 myEndTextField->setText(previousEnd.c_str());
3153 }
3154 // check previous parameter
3155 myParametersComboBox->setCurrentItem(0, FALSE);
3156 for (int i = 0; i < myParametersComboBox->getNumItems(); i++) {
3157 if (myParametersComboBox->getItem(i).text() == previousParameter) {
3158 myParametersComboBox->setCurrentItem(i);
3159 }
3160 }
3161 // set visible elements
3162 if (myDataSetsComboBox->getNumItems() < 10) {
3163 myDataSetsComboBox->setNumVisible(myDataSetsComboBox->getNumItems());
3164 } else {
3165 myDataSetsComboBox->setNumVisible(10);
3166 }
3167 if (myParametersComboBox->getNumItems() < 10) {
3168 myParametersComboBox->setNumVisible(myParametersComboBox->getNumItems());
3169 } else {
3170 myParametersComboBox->setNumVisible(10);
3171 }
3172 // check if enable or disable
3173 if ((myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_INSPECT) ||
3174 (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_SELECT) ||
3175 (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_DELETE)) {
3176 enableIntervalBar();
3177 } else {
3178 disableIntervalBar();
3179 }
3180 // intervalBar updated, then change flag
3181 myUpdateInterval = false;
3182 }
3183}
3184
3185
3186void
3188 myUpdateInterval = true;
3189}
3190
3191
3194 if (myGenericDataTypesComboBox->isEnabled() && (myGenericDataTypesComboBox->getTextColor() == FXRGB(0, 0, 0))) {
3195 if (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_MEANDATA_EDGE).c_str()) {
3197 } else if (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_EDGEREL).c_str()) {
3198 return SUMO_TAG_EDGEREL;
3199 } else if (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_TAZREL).c_str()) {
3200 return SUMO_TAG_TAZREL;
3201 }
3202 }
3203 return SUMO_TAG_NOTHING;
3204}
3205
3206
3209 if (!myDataSetsComboBox->isEnabled() ||
3210 (myDataSetsComboBox->getCurrentItem() == 0) ||
3211 (myDataSetsComboBox->getTextColor() == FXRGB(255, 0, 0))) {
3212 return nullptr;
3213 } else {
3214 return myViewNet->getNet()->getAttributeCarriers()->retrieveDataSet(myDataSetsComboBox->getText().text());
3215 }
3216}
3217
3218
3219double
3221 if (!myIntervalCheckBox->isEnabled() || (myIntervalCheckBox->getCheck() == FALSE)) {
3222 return INVALID_DOUBLE;
3223 } else {
3224 return GNEAttributeCarrier::parse<double>(myBeginTextField->getText().text());
3225 }
3226}
3227
3228
3229double
3231 if (!myIntervalCheckBox->isEnabled() || (myIntervalCheckBox->getCheck() == FALSE)) {
3232 return INVALID_DOUBLE;
3233 } else {
3234 return GNEAttributeCarrier::parse<double>(myEndTextField->getText().text());
3235 }
3236}
3237
3238
3239std::string
3241 if (!myParametersComboBox->isEnabled() ||
3242 (myParametersComboBox->getCurrentItem() == 0) ||
3243 (myParametersComboBox->getTextColor() == FXRGB(255, 0, 0))) {
3244 return "";
3245 } else {
3246 return myParametersComboBox->getText().text();
3247 }
3248}
3249
3250
3251void
3253 if ((myGenericDataTypesComboBox->getText() == "<all>") ||
3254 (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_MEANDATA_EDGE).c_str()) ||
3255 (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_EDGEREL).c_str()) ||
3256 (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_TAZREL).c_str())) {
3257 myGenericDataTypesComboBox->setTextColor(FXRGB(0, 0, 0));
3258 } else {
3259 myGenericDataTypesComboBox->setTextColor(FXRGB(255, 0, 0));
3260 }
3261 // update view net
3262 myViewNet->updateViewNet();
3263}
3264
3265
3266void
3268 // check if exist
3269 if (std::find(myDataSets.begin(), myDataSets.end(), myDataSetsComboBox->getText().text()) != myDataSets.end()) {
3270 myDataSetsComboBox->setTextColor(FXRGB(0, 0, 0));
3271 } else {
3272 myDataSetsComboBox->setTextColor(FXRGB(255, 0, 0));
3273 }
3274 // update view net
3275 myViewNet->updateViewNet();
3276}
3277
3278
3279void
3281 // enable or disable text fields
3282 if (myIntervalCheckBox->isEnabled() && (myIntervalCheckBox->getCheck() == TRUE)) {
3283 myBeginTextField->enable();
3284 myEndTextField->enable();
3285 } else {
3286 myBeginTextField->disable();
3287 myEndTextField->disable();
3288 }
3289 // update view net
3290 myViewNet->updateViewNet();
3291}
3292
3293
3294void
3296 if (myBeginTextField->getText().empty()) {
3297 myBeginTextField->setText(toString(myViewNet->getNet()->getDataSetIntervalMinimumBegin()).c_str());
3298 myBeginTextField->setTextColor(FXRGB(0, 0, 0));
3299 } else if (GNEAttributeCarrier::canParse<double>(myBeginTextField->getText().text())) {
3300 myBeginTextField->setTextColor(FXRGB(0, 0, 0));
3301 } else {
3302 myBeginTextField->setTextColor(FXRGB(255, 0, 0));
3303 }
3304 // update view net
3305 myViewNet->updateViewNet();
3306}
3307
3308
3309void
3311 if (myEndTextField->getText().empty()) {
3312 myEndTextField->setText(toString(myViewNet->getNet()->getDataSetIntervalMaximumEnd()).c_str());
3313 myEndTextField->setTextColor(FXRGB(0, 0, 0));
3314 } else if (GNEAttributeCarrier::canParse<double>(myEndTextField->getText().text())) {
3315 myEndTextField->setTextColor(FXRGB(0, 0, 0));
3316 } else {
3317 myEndTextField->setTextColor(FXRGB(255, 0, 0));
3318 }
3319 // update view net
3320 myViewNet->updateViewNet();
3321}
3322
3323
3324void
3326 // check if exist
3327 if (myParameters.count(myParametersComboBox->getText().text()) > 0) {
3328 myParametersComboBox->setTextColor(FXRGB(0, 0, 0));
3329 } else {
3330 myParametersComboBox->setTextColor(FXRGB(255, 0, 0));
3331 }
3332 // update view net
3333 myViewNet->updateViewNet();
3334}
3335
3336
3337
3338void
3340 // enable elements
3341 myGenericDataTypesComboBox->enable();
3342 myDataSetsComboBox->enable();
3343 myIntervalCheckBox->enable();
3344 if (myIntervalCheckBox->getCheck() == TRUE) {
3345 myBeginTextField->enable();
3346 myEndTextField->enable();
3347 } else {
3348 myBeginTextField->disable();
3349 myEndTextField->disable();
3350 }
3351 myParametersComboBox->enable();
3352}
3353
3354
3355void
3357 // disable all elements
3358 myGenericDataTypesComboBox->disable();
3359 myDataSetsComboBox->disable();
3360 myIntervalCheckBox->disable();
3361 myBeginTextField->disable();
3362 myEndTextField->disable();
3363 myParametersComboBox->disable();
3364}
3365
3366// ---------------------------------------------------------------------------
3367// GNEViewNetHelper::CommonCheckableButtons - methods
3368// ---------------------------------------------------------------------------
3369
3371 inspectButton(nullptr),
3372 deleteButton(nullptr),
3373 selectButton(nullptr),
3374 myViewNet(viewNet) {
3375}
3376
3377
3378void
3380 // inspect button
3381 inspectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3382 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3383 "\tSet inspect mode\tMode for inspect elements and change their attributes. (I)",
3385 inspectButton->create();
3386 // delete button
3387 deleteButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3388 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3389 "\tSet delete mode\tMode for delete elements. (D)",
3391 deleteButton->create();
3392 // select button
3393 selectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3394 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3395 "\tSet select mode\tMode for select elements. (S)",
3397 selectButton->create();
3398 // always recalc menu bar after creating new elements
3399 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3400}
3401
3402
3403void
3405 inspectButton->show();
3406 deleteButton->show();
3407 selectButton->show();
3408}
3409
3410
3411void
3413 inspectButton->hide();
3414 deleteButton->hide();
3415 selectButton->hide();
3416}
3417
3418
3419void
3421 inspectButton->setChecked(false);
3422 deleteButton->setChecked(false);
3423 selectButton->setChecked(false);
3424}
3425
3426
3427void
3429 inspectButton->update();
3430 deleteButton->update();
3431 selectButton->update();
3432}
3433
3434// ---------------------------------------------------------------------------
3435// GNEViewNetHelper::NetworkCheckableButtons - methods
3436// ---------------------------------------------------------------------------
3437
3439 moveNetworkElementsButton(nullptr),
3440 createEdgeButton(nullptr),
3441 connectionButton(nullptr),
3442 trafficLightButton(nullptr),
3443 additionalButton(nullptr),
3444 crossingButton(nullptr),
3445 TAZButton(nullptr),
3446 shapeButton(nullptr),
3447 prohibitionButton(nullptr),
3448 wireButton(nullptr),
3449 myViewNet(viewNet) {
3450}
3451
3452
3453void
3455 // move button
3456 moveNetworkElementsButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3457 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3458 "\tSet move mode\tMode for move elements. (M)",
3460 moveNetworkElementsButton->create();
3461 // create edge
3462 createEdgeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3463 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3464 "\tSet create edge mode\tMode for creating junction and edges. (E)",
3466 createEdgeButton->create();
3467 // connection mode
3468 connectionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3469 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3470 "\tSet connection mode\tMode for edit connections between lanes. (C)",
3472 connectionButton->create();
3473 // prohibition mode
3474 prohibitionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3475 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3476 "\tSet prohibition mode\tMode for editing connection prohibitions. (H)",
3478 prohibitionButton->create();
3479 // traffic light mode
3480 trafficLightButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3481 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3482 "\tSet traffic light mode\tMode for edit traffic lights over junctions. (T)",
3484 trafficLightButton->create();
3485 // additional mode
3486 additionalButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3487 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3488 "\tSet additional mode\tMode for adding additional elements. (A)",
3490 additionalButton->create();
3491 // crossing mode
3492 crossingButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3493 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3494 "\tSet crossing mode\tMode for creating crossings between edges. (R)",
3496 crossingButton->create();
3497 // TAZ Mode
3498 TAZButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3499 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3500 "\tSet TAZ mode\tMode for creating Traffic Assignment Zones. (Z)",
3502 TAZButton->create();
3503 // shape mode
3504 shapeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3505 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3506 "\tSet polygon mode\tMode for creating polygons and POIs. (P)",
3508 shapeButton->create();
3509 // wire mode
3510 wireButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3511 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3512 "\tSet wire mode\tMode for editing wires. (W)",
3514 wireButton->create();
3515 // always recalc after creating new elements
3516 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3517}
3518
3519
3520void
3522 moveNetworkElementsButton->show();
3523 createEdgeButton->show();
3524 connectionButton->show();
3525 trafficLightButton->show();
3526 additionalButton->show();
3527 crossingButton->show();
3528 TAZButton->show();
3529 shapeButton->show();
3530 prohibitionButton->show();
3531 wireButton->show();
3532}
3533
3534
3535void
3537 moveNetworkElementsButton->hide();
3538 createEdgeButton->hide();
3539 connectionButton->hide();
3540 trafficLightButton->hide();
3541 additionalButton->hide();
3542 crossingButton->hide();
3543 TAZButton->hide();
3544 shapeButton->hide();
3545 prohibitionButton->hide();
3546 wireButton->hide();
3547}
3548
3549
3550void
3552 moveNetworkElementsButton->setChecked(false);
3553 createEdgeButton->setChecked(false);
3554 connectionButton->setChecked(false);
3555 trafficLightButton->setChecked(false);
3556 additionalButton->setChecked(false);
3557 crossingButton->setChecked(false);
3558 TAZButton->setChecked(false);
3559 shapeButton->setChecked(false);
3560 prohibitionButton->setChecked(false);
3561 wireButton->setChecked(false);
3562}
3563
3564
3565void
3567 moveNetworkElementsButton->update();
3568 createEdgeButton->update();
3569 connectionButton->update();
3570 trafficLightButton->update();
3571 additionalButton->update();
3572 crossingButton->update();
3573 TAZButton->update();
3574 shapeButton->update();
3575 prohibitionButton->update();
3576 wireButton->update();
3577}
3578
3579// ---------------------------------------------------------------------------
3580// GNEViewNetHelper::DemandCheckableButtons - methods
3581// ---------------------------------------------------------------------------
3582
3584 moveDemandElementsButton(nullptr),
3585 routeButton(nullptr),
3586 vehicleButton(nullptr),
3587 typeButton(nullptr),
3588 stopButton(nullptr),
3589 personButton(nullptr),
3590 personPlanButton(nullptr),
3591 containerButton(nullptr),
3592 containerPlanButton(nullptr),
3593 myViewNet(viewNet) {
3594}
3595
3596
3597void
3599 // move button
3600 moveDemandElementsButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3601 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3602 "\tSet move mode\tMode for move elements. (M)",
3604 moveDemandElementsButton->create();
3605 // route mode
3606 routeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3607 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3608 "\tCreate route mode\tMode for creating routes. (R)",
3610 routeButton->create();
3611 // vehicle mode
3612 vehicleButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3613 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3614 "\tCreate vehicle mode\tMode for creating vehicles. (V)",
3616 vehicleButton->create();
3617 // type mode
3618 typeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3619 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3620 "\tCreate type mode\tMode for creating types (vehicles, person and containers). (T)",
3622 typeButton->create();
3623 // stop mode
3624 stopButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3625 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3626 "\tCreate stop mode\tMode for creating stops. (A)",
3628 stopButton->create();
3629 // person mode
3630 personButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3631 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3632 "\tCreate person mode\tMode for creating persons. (P)",
3634 personButton->create();
3635 // person plan mode
3636 personPlanButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3637 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3638 "\tCreate person plan mode\tMode for creating person plans. (C)",
3640 personPlanButton->create();
3641 // container mode
3642 containerButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3643 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3644 "\tCreate container mode\tMode for creating containers. (P)",
3646 containerButton->create();
3647 // container plan mode
3648 containerPlanButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3649 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3650 "\tCreate container plan mode\tMode for creating container plans. (C)",
3652 containerPlanButton->create();
3653 // always recalc after creating new elements
3654 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3655}
3656
3657
3658void
3660 moveDemandElementsButton->show();
3661 routeButton->show();
3662 vehicleButton->show();
3663 typeButton->show();
3664 stopButton->show();
3665 personButton->show();
3666 personPlanButton->show();
3667 containerButton->show();
3668 containerPlanButton->show();
3669}
3670
3671
3672void
3674 moveDemandElementsButton->hide();
3675 routeButton->hide();
3676 vehicleButton->hide();
3677 typeButton->hide();
3678 stopButton->hide();
3679 personButton->hide();
3680 personPlanButton->hide();
3681 containerButton->hide();
3682 containerPlanButton->hide();
3683}
3684
3685
3686void
3688 moveDemandElementsButton->setChecked(false);
3689 routeButton->setChecked(false);
3690 vehicleButton->setChecked(false);
3691 typeButton->setChecked(false);
3692 stopButton->setChecked(false);
3693 personButton->setChecked(false);
3694 personPlanButton->setChecked(false);
3695 containerButton->setChecked(false);
3696 containerPlanButton->setChecked(false);
3697}
3698
3699
3700void
3702 moveDemandElementsButton->update();
3703 routeButton->update();
3704 vehicleButton->update();
3705 typeButton->update();
3706 stopButton->update();
3707 personButton->update();
3708 personPlanButton->update();
3709 containerButton->update();
3710 containerPlanButton->update();
3711}
3712
3713// ---------------------------------------------------------------------------
3714// GNEViewNetHelper::DataCheckableButtons - methods
3715// ---------------------------------------------------------------------------
3716
3718 edgeDataButton(nullptr),
3719 edgeRelDataButton(nullptr),
3720 TAZRelDataButton(nullptr),
3721 myViewNet(viewNet) {
3722}
3723
3724
3725void
3727 // edgeData mode
3728 edgeDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3729 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3730 "\tCreate edge data mode\tMode for creating edge datas. (E)",
3732 edgeDataButton->create();
3733 // edgeRelData mode
3734 edgeRelDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3735 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3736 "\tCreate edge relation data mode\tMode for creating edge relation datas. (R)",
3738 edgeRelDataButton->create();
3739 // TAZRelData mode
3740 TAZRelDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3741 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3742 "\tCreate TAZ relation data mode\tMode for creating TAZ relation datas. (Z)",
3744
3745 TAZRelDataButton->create();
3746 // always recalc after creating new elements
3747 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3748}
3749
3750
3751void
3753 edgeDataButton->show();
3754 edgeRelDataButton->show();
3755 TAZRelDataButton->show();
3756}
3757
3758
3759void
3761 edgeDataButton->hide();
3762 edgeRelDataButton->hide();
3763 TAZRelDataButton->hide();
3764}
3765
3766
3767void
3769 edgeDataButton->setChecked(false);
3770 edgeRelDataButton->setChecked(false);
3771 TAZRelDataButton->setChecked(false);
3772}
3773
3774
3775void
3777 edgeDataButton->update();
3778 edgeRelDataButton->update();
3779 TAZRelDataButton->update();
3780}
3781
3782// ---------------------------------------------------------------------------
3783// GNEViewNetHelper::EditNetworkElementShapes - methods
3784// ---------------------------------------------------------------------------
3785
3787 myViewNet(viewNet),
3788 myEditedNetworkElement(nullptr),
3789 myPreviousNetworkEditMode(NetworkEditMode::NETWORK_NONE) {
3790}
3791
3792
3793void
3795 if (element && (myEditedNetworkElement == nullptr)) {
3796 // save current edit mode before starting
3797 myPreviousNetworkEditMode = myViewNet->myEditModes.networkEditMode;
3798 // set move mode
3799 myViewNet->myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_MOVE);
3800 //set editedNetworkElement
3801 myEditedNetworkElement = element;
3802 // enable shape edited flag
3803 myEditedNetworkElement->setShapeEdited(true);
3804 // update view net to show the new editedShapePoly
3805 myViewNet->updateViewNet();
3806 }
3807}
3808
3809
3810void
3812 // stop edit shape junction deleting editedShapePoly
3813 if (myEditedNetworkElement != nullptr) {
3814 // disable shape edited flag
3815 myEditedNetworkElement->setShapeEdited(false);
3816 // reset editedNetworkElement
3817 myEditedNetworkElement = nullptr;
3818 // restore previous edit mode
3819 if (myViewNet->myEditModes.networkEditMode != myPreviousNetworkEditMode) {
3820 myViewNet->myEditModes.setNetworkEditMode(myPreviousNetworkEditMode);
3821 }
3822 }
3823}
3824
3825
3826void
3828 // save edited junction's shape
3829 if (myEditedNetworkElement != nullptr) {
3830
3831 /* */
3832
3833 // stop edit custom shape
3834 stopEditCustomShape();
3835 }
3836}
3837
3838
3841 return myEditedNetworkElement;
3842}
3843
3844// ---------------------------------------------------------------------------
3845// GNEViewNetHelper::BlockIcon - methods
3846// ---------------------------------------------------------------------------
3847
3848void
3850 const Position viewPosition, const double exaggeration, const double size,
3851 const double offsetx, const double offsety) {
3852 // first check if icon can be drawn
3853 if (checkDrawing(AC, type, exaggeration)) {
3854 // Start pushing matrix
3856 // Traslate to position
3857 glTranslated(viewPosition.x(), viewPosition.y(), GLO_LOCKICON);
3858 // Traslate depending of the offset
3859 glTranslated(offsetx, offsety, 0);
3860 // rotate to avoid draw invert
3861 glRotated(180, 0, 0, 1);
3862 // Set draw color
3863 glColor3d(1, 1, 1);
3864 // Draw lock icon
3866 // Pop matrix
3868 }
3869}
3870
3871
3873
3874
3875bool
3877 // get view net
3878 const auto viewNet = AC->getNet()->getViewNet();
3879 // get visualization settings
3880 const auto& s = viewNet->getVisualisationSettings();
3881 // check exaggeration
3882 if (exaggeration == 0) {
3883 return false;
3884 }
3885 // check supermodes
3886 if (viewNet->getEditModes().isCurrentSupermodeNetwork() &&
3888 return false;
3889 }
3890 if (viewNet->getEditModes().isCurrentSupermodeDemand() && (!AC->getTagProperty().isDemandElement())) {
3891 return false;
3892 }
3893 if (viewNet->getEditModes().isCurrentSupermodeData() && (!AC->getTagProperty().isDataElement())) {
3894 return false;
3895 }
3896 // check if is locked
3897 if (!viewNet->getLockManager().isObjectLocked(type, AC->isAttributeCarrierSelected())) {
3898 return false;
3899 }
3900 // check visualizationSettings
3901 if (s.drawForPositionSelection || s.drawForRectangleSelection) {
3902 return false;
3903 }
3904 // check detail
3905 if (!s.drawDetail(s.detailSettings.lockIcon, exaggeration)) {
3906 return false;
3907 }
3908 // all ok, then draw
3909 return true;
3910}
3911
3912// ---------------------------------------------------------------------------
3913// GNEViewNetHelper - methods
3914// ---------------------------------------------------------------------------
3915
3916const std::vector<RGBColor>&
3918 // if is empty, fill it
3919 if (myRainbowScaledColors.empty()) {
3920 // fill scale colors (10)
3921 myRainbowScaledColors.push_back(RGBColor(232, 35, 0, 255));
3922 myRainbowScaledColors.push_back(RGBColor(255, 165, 0, 255));
3923 myRainbowScaledColors.push_back(RGBColor(255, 255, 0, 255));
3924 myRainbowScaledColors.push_back(RGBColor(28, 215, 0, 255));
3925 myRainbowScaledColors.push_back(RGBColor(0, 181, 100, 255));
3926 myRainbowScaledColors.push_back(RGBColor(0, 255, 191, 255));
3927 myRainbowScaledColors.push_back(RGBColor(178, 255, 255, 255));
3928 myRainbowScaledColors.push_back(RGBColor(0, 112, 184, 255));
3929 myRainbowScaledColors.push_back(RGBColor(56, 41, 131, 255));
3930 myRainbowScaledColors.push_back(RGBColor(127, 0, 255, 255));
3931 }
3932 return myRainbowScaledColors;
3933}
3934
3935
3936const RGBColor&
3937GNEViewNetHelper::getRainbowScaledColor(const double min, const double max, const double value) {
3938 // check extremes
3939 if (value <= min) {
3940 return getRainbowScaledColors().front();
3941 } else if (value >= max) {
3942 return getRainbowScaledColors().back();
3943 } else {
3944 // calculate value procent between [min, max]
3945 const double procent = ((value - min) * 100) / (max - min);
3946 // check if is valid
3947 if (procent <= 0) {
3948 return getRainbowScaledColors().front();
3949 } else if (procent >= 100) {
3950 return getRainbowScaledColors().back();
3951 } else {
3952 // return scaled color
3953 return getRainbowScaledColors().at((int)(procent / 10.0));
3954 }
3955 }
3956}
3957
3958
3959std::vector<GUIGlObject*>
3960GNEViewNetHelper::filterElementsByLayer(const std::vector<GUIGlObject*>& GLObjects) {
3961 std::vector<GUIGlObject*> filteredGLObjects;
3962 if (GLObjects.size() > 0) {
3963 const auto firstLayer = GLObjects.front()->getType();
3964 for (const auto& GLObject : GLObjects) {
3965 if ((GLO_RIDE <= firstLayer) && (firstLayer <= GLO_TRANSHIP) &&
3966 (GLO_RIDE <= GLObject->getType()) && (GLObject->getType() <= GLO_TRANSHIP)) {
3967 filteredGLObjects.push_back(GLObject);
3968 } else if ((GLO_STOP <= firstLayer) && (firstLayer <= GLO_STOP_CONTAINER) &&
3969 (GLO_STOP <= GLObject->getType()) && (GLObject->getType() <= GLO_STOP_CONTAINER)) {
3970 filteredGLObjects.push_back(GLObject);
3971 } else if ((GLO_VEHICLE <= firstLayer) && (firstLayer <= GLO_ROUTEFLOW) &&
3972 (GLO_VEHICLE <= GLObject->getType()) && (GLObject->getType() <= GLO_ROUTEFLOW)) {
3973 filteredGLObjects.push_back(GLObject);
3974 } else if ((GLO_PERSON <= firstLayer) && (firstLayer <= GLO_PERSONFLOW) &&
3975 (GLO_PERSON <= GLObject->getType()) && (GLObject->getType() <= GLO_PERSONFLOW)) {
3976 filteredGLObjects.push_back(GLObject);
3977 } else if ((GLO_CONTAINER <= firstLayer) && (firstLayer <= GLO_CONTAINERFLOW) &&
3978 (GLO_CONTAINER <= GLObject->getType()) && (GLObject->getType() <= GLO_CONTAINERFLOW)) {
3979 filteredGLObjects.push_back(GLObject);
3980 } else if (GLObject->getType() == firstLayer) {
3981 filteredGLObjects.push_back(GLObject);
3982 }
3983 }
3984 }
3985 return filteredGLObjects;
3986}
3987
3988/****************************************************************************/
DataEditMode
@brie enum for data edit modes
@ DATA_SELECT
mode for selecting data elements
@ DATA_INSPECT
mode for inspecting data elements
@ DATA_DELETE
mode for deleting data elements
Supermode
@brie enum for supermodes
@ NETWORK
Network mode (Edges, junctions, etc..)
@ DATA
Data mode (edgeData, LaneData etc..)
@ DEMAND
Demand mode (Routes, Vehicles etc..)
NetworkEditMode
@brie enum for network edit modes
@ NETWORK_DELETE
mode for deleting network elements
@ NETWORK_MOVE
mode for moving network elements
@ NETWORK_WIRE
Mode for editing wires.
@ NETWORK_CREATE_EDGE
mode for creating new edges
@ NETWORK_TLS
mode for editing tls
@ NETWORK_SELECT
mode for selecting network elements
@ NETWORK_INSPECT
mode for inspecting network elements
@ NETWORK_PROHIBITION
Mode for editing connection prohibitions.
@ NETWORK_NONE
empty Network mode
@ NETWORK_CONNECT
mode for connecting lanes
DemandEditMode
@brie enum for demand edit modes
@ DEMAND_INSPECT
mode for inspecting demand elements
@ DEMAND_DELETE
mode for deleting demand elements
@ DEMAND_SELECT
mode for selecting demand elements
@ DEMAND_MOVE
mode for moving demand elements
@ MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES
automatically create opposite edge
Definition: GUIAppEnum.h:777
@ MID_HOTKEY_A_MODE_ADDITIONAL_STOP
hotkey for mode editing additionals AND stops
Definition: GUIAppEnum.h:43
@ MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS
save Data Elements
Definition: GUIAppEnum.h:163
@ MID_HOTKEY_F3_SUPERMODE_DEMAND
select demand supermode in NETEDIT
Definition: GUIAppEnum.h:193
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
show all person plans
Definition: GUIAppEnum.h:809
@ MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING
toggle TAZRel drawing
Definition: GUIAppEnum.h:833
@ MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition: GUIAppEnum.h:751
@ MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
move elevation instead of x,y
Definition: GUIAppEnum.h:773
@ MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
hide connections
Definition: GUIAppEnum.h:759
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
show connections
Definition: GUIAppEnum.h:757
@ MID_GNE_SAVEALLELEMENTS
save all element
Definition: GUIAppEnum.h:683
@ MID_GNE_INTERVALBAR_BEGIN
begin changed in InterbalBar
Definition: GUIAppEnum.h:853
@ MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO
toggle draw TAZRel only to
Definition: GUIAppEnum.h:839
@ MID_HOTKEY_M_MODE_MOVE
hotkey for mode moving element
Definition: GUIAppEnum.h:57
@ MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:825
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS
show TAZ elements
Definition: GUIAppEnum.h:763
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
lock person
Definition: GUIAppEnum.h:811
@ MID_HOTKEY_Z_MODE_TAZ_TAZREL
hotkey for mode editing TAZ and TAZRel
Definition: GUIAppEnum.h:71
@ MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:799
@ MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
ask before merging junctions
Definition: GUIAppEnum.h:769
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID
show grid
Definition: GUIAppEnum.h:797
@ MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS
Save Demand Elements.
Definition: GUIAppEnum.h:165
@ MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK
Stop the simulation in SUMO and save network in NETEDIT.
Definition: GUIAppEnum.h:107
@ MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
create edges in chain mode
Definition: GUIAppEnum.h:775
@ MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition: GUIAppEnum.h:831
@ MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN
hotkey for mode prohibition AND container plan
Definition: GUIAppEnum.h:53
@ MID_HOTKEY_T_MODE_TLS_TYPE
hotkey for mode editing TLS AND Vehicle Types
Definition: GUIAppEnum.h:65
@ MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES
hide shapes
Definition: GUIAppEnum.h:805
@ MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS
show additionals
Definition: GUIAppEnum.h:827
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
show junctions as bubbles
Definition: GUIAppEnum.h:771
@ MID_GNE_INTERVALBAR_END
end changed in InterbalBar
Definition: GUIAppEnum.h:855
@ MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
extend selection
Definition: GUIAppEnum.h:765
@ MID_HOTKEY_S_MODE_SELECT
hotkey for mode selecting objects
Definition: GUIAppEnum.h:61
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS
show sub-additionals
Definition: GUIAppEnum.h:761
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS
show all container plans
Definition: GUIAppEnum.h:813
@ MID_HOTKEY_F4_SUPERMODE_DATA
select data supermode in NETEDIT
Definition: GUIAppEnum.h:195
@ MID_GNE_INTERVALBAR_PARAMETER
parameter changed in InterbalBar
Definition: GUIAppEnum.h:857
@ MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA
hotkey for mode editing crossing, routes and edge rel datas
Definition: GUIAppEnum.h:63
@ MID_HOTKEY_W_MODE_WIRE
hotkey for mode editing overhead wires
Definition: GUIAppEnum.h:69
@ MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL
toggle draw TAZ fill
Definition: GUIAppEnum.h:835
@ MID_HOTKEY_D_MODE_DELETE
hotkey for mode deleting things
Definition: GUIAppEnum.h:47
@ MID_HOTKEY_V_MODE_VEHICLE
hotkey for mode create vehicles
Definition: GUIAppEnum.h:67
@ MID_HOTKEY_I_MODE_INSPECT
hotkey for mode inspecting object attributes
Definition: GUIAppEnum.h:55
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition: GUIAppEnum.h:753
@ MID_HOTKEY_C_MODE_CONNECT_PERSONPLAN
hotkey for mode connecting lanes ABD person plan
Definition: GUIAppEnum.h:45
@ MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
hide non-inspected demand element
Definition: GUIAppEnum.h:803
@ MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALS
Save Additional Elements.
Definition: GUIAppEnum.h:159
@ MID_GNE_INTERVALBAR_GENERICDATATYPE
generic data selected
Definition: GUIAppEnum.h:847
@ MID_HOTKEY_G_MODE_CONTAINER
hotkey for mode container
Definition: GUIAppEnum.h:51
@ MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
change all phases
Definition: GUIAppEnum.h:767
@ MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES
show shapes
Definition: GUIAppEnum.h:829
@ MID_HOTKEY_E_MODE_EDGE_EDGEDATA
hotkey for mode adding edges AND edgeDatas
Definition: GUIAppEnum.h:49
@ MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM
toggle draw TAZRel only from
Definition: GUIAppEnum.h:837
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:749
@ MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition: GUIAppEnum.h:801
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES
show overlapped routes
Definition: GUIAppEnum.h:817
@ MID_GNE_INTERVALBAR_DATASET
data set selected
Definition: GUIAppEnum.h:849
@ MID_HOTKEY_F2_SUPERMODE_NETWORK
select network supermode in NETEDIT
Definition: GUIAppEnum.h:191
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER
lock container
Definition: GUIAppEnum.h:815
@ MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
select edges
Definition: GUIAppEnum.h:755
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS
show all trips
Definition: GUIAppEnum.h:807
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID
show grid
Definition: GUIAppEnum.h:747
@ MID_GNE_INTERVALBAR_LIMITED
enable/disable show data elements by interval
Definition: GUIAppEnum.h:851
@ MID_HOTKEY_P_MODE_POLYGON_PERSON
hotkey for mode creating polygons
Definition: GUIAppEnum.h:59
#define GUIDesignComboBoxWidth180
comboBox with thick frame, width 180
Definition: GUIDesigns.h:318
#define GUIDesignComboBoxNCol
number of column of every combo box
Definition: GUIDesigns.h:321
#define GUIDesignLabelAttribute
label extended over the matrix column with thick frame
Definition: GUIDesigns.h:241
#define GUIDesignButtonToolbar
little button with icon placed in navigation toolbar
Definition: GUIDesigns.h:115
#define GUIDesignTextFieldNCol
Num of column of text field.
Definition: GUIDesigns.h:69
#define GUIDesignMFXCheckableButtonSquare
Definition: GUIDesigns.h:129
#define GUIDesignTextFielWidth50Real
text field with thick frame and width 50 and limited to doubles
Definition: GUIDesigns.h:60
#define GUIDesignMFXCheckableButtonSupermode
checkable button with icon placed in navigation toolbar for supermodes
Definition: GUIDesigns.h:132
#define GUIDesignCheckButtonAttribute
checkButton without thick extended over the frame used for attributes
Definition: GUIDesigns.h:175
unsigned int GUIGlID
Definition: GUIGlObject.h:43
GUIGlObjectType
@ GLO_EDGERELDATA
edge relation data
@ GLO_TAZRELDATA
TAZ relation data.
@ GLO_WALKINGAREA
a walkingArea
@ GLO_STOP_CONTAINER
a container stop
@ GLO_TESTELEMENT
test element (used in NETEDIT)
@ GLO_TRANSHIP
a container tranship
@ GLO_ACCESS
a Acces
@ GLO_ROUTEFLOW
a routeFlow
@ GLO_WALK
a walk
@ GLO_ROUTE
a route
@ GLO_WIRE
reserved GLO type for packing all wire elements
@ GLO_JUNCTION
a junction
@ GLO_LANE
a lane
@ GLO_RIDE
a ride
@ GLO_TAZ
Traffic Assignment Zones (TAZs)
@ GLO_CONTAINER
a container
@ GLO_EDGEDATA
edge data
@ GLO_CONNECTION
a connection
@ GLO_ADDITIONALELEMENT
reserved GLO type for packing all additionals elements
@ GLO_PERSONTRIP
a person trip
@ GLO_EDGE
an edge
@ GLO_VEHICLE
a vehicle
@ GLO_PERSON
a person
@ GLO_TRANSPORT
a container transport
@ GLO_NETWORK
The network - empty.
@ GLO_POI
a poi
@ GLO_RECTANGLESELECTION
rectangle selection shape (used in NETEDIT)
@ GLO_STOP
a stop
@ GLO_NETWORKELEMENT
reserved GLO type to pack all network elements
@ GLO_CONTAINERFLOW
a person flow
@ GLO_POLYGON
a polygon
@ GLO_TLLOGIC
a tl-logic
@ GLO_CROSSING
a tl-logic
@ GLO_PERSONFLOW
a person flow
@ GLO_TRACTIONSUBSTATION
a segment of an overhead line
@ GLO_LOCKICON
Lock icon (used in NETEDIT)
@ DATAMODE_CHECKBOX_SHOWADDITIONALS
@ SAVEALLELEMENTS
@ NETWORKMODE_CHECKBOX_BUBBLES
@ DATAMODE_CHECKBOX_TAZRELONLYFROM
@ MODEPERSONPLAN
@ MODECROSSING
@ MODEADDITIONAL
@ MODEEDGERELDATA
@ SUPERMODEDEMAND
@ MODEPROHIBITION
@ DEMANDMODE_CHECKBOX_HIDENONINSPECTEDDEMANDELEMENTS
@ NETWORKMODE_CHECKBOX_HIDECONNECTIONS
@ DEMANDMODE_CHECKBOX_SHOWTRIPS
@ COMMONMODE_CHECKBOX_TOGGLEDRAWJUNCTIONSHAPE
@ DATAMODE_CHECKBOX_SHOWSHAPES
@ NETWORKMODE_CHECKBOX_SELECTEDGES
@ COMMONMODE_CHECKBOX_SHOWDEMANDELEMENTS
@ DEMANDMODE_CHECKBOX_LOCKPERSON
@ NETWORKMODE_CHECKBOX_APPLYTOALLPHASES
@ MODECREATEEDGE
@ DATAMODE_CHECKBOX_TAZRELONLYTO
@ NETWORKMODE_CHECKBOX_AUTOSELECTJUNCTIONS
@ DATAMODE_CHECKBOX_TAZRELDRAWING
@ NETWORKMODE_CHECKBOX_SHOWCONNECTIONS
@ DEMANDMODE_CHECKBOX_SHOWPERSONPLANS
@ MODECONTAINER
@ DEMANDMODE_CHECKBOX_HIDESHAPES
@ SAVEDATAELEMENTS
@ DATAMODE_CHECKBOX_TAZDRAWFILL
@ SAVENETWORKELEMENTS
@ MODEEDGEDATA
@ NETWORKMODE_CHECKBOX_ELEVATION
@ SUPERMODENETWORK
@ COMMONMODE_CHECKBOX_SPREADVEHICLE
@ DEMANDMODE_CHECKBOX_LOCKCONTAINER
@ NETWORKMODE_CHECKBOX_SHOWSUBADDITIONALS
@ SAVEDEMANDELEMENTS
@ NETWORKMODE_CHECKBOX_SHOWTAZELEMENTS
@ SUPERMODEDATA
@ SAVEADDITIONALELEMENTS
@ MODECONNECTION
@ MODECONTAINERPLAN
@ NETWORKMODE_CHECKBOX_CHAIN
@ DEMANDMODE_CHECKBOX_SHOWOVERLAPPEDROUTES
@ NETWORKMODE_CHECKBOX_ASKFORMERGE
@ COMMONMODE_CHECKBOX_TOGGLEGRID
@ MODETAZRELDATA
@ DEMANDMODE_CHECKBOX_SHOWCONTAINERPLANS
@ NETWORKMODE_CHECKBOX_TWOWAY
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_EDGEREL
a relation between two edges
@ SUMO_TAG_NOTHING
invalid tag
@ SUMO_TAG_MEANDATA_EDGE
an edge based mean data detector
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_TAZREL
a relation between two TAZs
@ SUMO_TAG_EDGE
begin/end of the description of an edge
@ GNE_ATTR_PARENT
parent of an additional element
@ GNE_ATTR_SELECTED
element is selected
const double INVALID_DOUBLE
Definition: StdDefs.h:60
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:583
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:130
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEAdditional.h:48
const std::string getID() const
get ID (all Attribute Carriers have one)
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
GNENet * getNet() const
get pointer to net
virtual std::string getAttribute(SumoXMLAttr key) const =0
virtual GUIGlObject * getGUIGlObject()=0
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNECrossing.h:42
An Element which don't belong to GNENet but has influence in the simulation.
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEEdgeData.h:38
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
bool isConvexAngle() const
check if edge makes a convex angle [0 - 180) degrees
Definition: GNEEdge.cpp:1518
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:481
An Element which don't belong to GNENet but has influence in the simulation.
An Element which don't belong to GNENet but has influence in the simulation.
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
static void commitMove(const GNEViewNet *viewNet, GNEMoveOperation *moveOperation, const GNEMoveOffset &offset, GNEUndoList *undoList)
commit move element for the given offset
static void moveElement(const GNEViewNet *viewNet, GNEMoveOperation *moveOperation, const GNEMoveOffset &offset)
move element the for given offset (note: offset can be X-Y-0, 0-0-Z or X-Y-Z)
move offset
move operation
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
GNEDataSet * retrieveDataSet(const std::string &id, bool hardFail=true) const
Returns the named data set.
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:132
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:1987
void setShapeEdited(const bool value)
set shape edited
Definition: GNEPOI.h:43
Definition: GNETAZ.h:34
bool isShapeElement() const
return true if tag correspond to a shape
bool isTAZElement() const
return true if tag correspond to a TAZ element
bool isGenericData() const
return true if tag correspond to a generic data element
bool isNetworkElement() const
return true if tag correspond to a network element
bool isDataElement() const
return true if tag correspond to a data element
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
bool isDemandElement() const
return true if tag correspond to a demand element
bool isAdditionalElement() const
return true if tag correspond to an additional element (note: this include TAZ, shapes and wires)
std::string getParameter() const
get parameter
void hideIntervalBar()
hide all options menu checks
void setGenericDataType()
set generic data type
double getBegin() const
get begin
void showIntervalBar()
show interval option bar
void disableIntervalBar()
disable interval bar
void updateIntervalBar()
update interval bar
void buildIntervalBarElements()
build interval bar elements
GNEDataSet * getDataSet() const
get dataSet
IntervalBar(GNEViewNet *viewNet)
default constructor
void enableIntervalBar()
enable interval bar
void setInterval()
update limit by interval
SumoXMLTag getGenericDataType() const
get generic data type
void updateLockMenuBar()
update lock inspect menuBar
bool isObjectLocked(GUIGlObjectType objectType, const bool selected) const
check if given GLObject is locked for inspect, select, delete and move
LockManager(GNEViewNet *viewNet)
constructor
std::map< GUIGlObjectType, OperationLocked > myLockedElements
map with locked elements
GNEViewNet * myViewNet
pointer to viewNet
std::vector< GNEEdgeRelData * > edgeRelDatas
vector with the clicked edge relation datas
std::vector< GNEWalkingArea * > walkingAreas
vector with the clicked walkingAreas
std::vector< GNENetworkElement * > networkElements
vector with the clicked network elements
std::vector< GNEEdge * > edges
vector with the clicked edges
std::vector< GNEGenericData * > genericDatas
vector with the clicked generic datas
std::vector< GNEJunction * > junctions
vector with the clicked junctions
std::vector< GNEConnection * > connections
vector with the clicked connections
std::vector< GNEEdgeData * > edgeDatas
vector with the clicked edge datas
std::vector< GNECrossing * > crossings
vector with the clicked crossings
std::vector< GNEPOI * > POIs
vector with the clicked POIs
std::vector< GNEDemandElement * > demandElements
vector with the clicked demand elements
std::vector< GNEAttributeCarrier * > attributeCarriers
vector with the clicked attribute carriers
std::vector< GNEPoly * > polys
vector with the clicked polys
std::vector< GNELane * > lanes
vector with the clicked lanes
std::vector< GNEInternalLane * > internalLanes
vector with the clicked internal lanes
std::vector< GNETAZ * > TAZs
vector with the clicked TAZ elements
std::vector< GNEAdditional * > additionals
vector with the clicked additional elements
std::vector< GUIGlObject * > GUIGlObjects
vector with the clicked GUIGlObjects
GNEPoly * getPolyFront() const
get front Poly or a pointer to nullptr
void updateObjectUnderCursor(const std::vector< GUIGlObject * > &GUIGlObjects)
update objects under cursor (Called only in onLeftBtnPress(...) function)
void updateNetworkElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update network elements
void sortGUIGlObjects(const std::vector< GUIGlObject * > &GUIGlObjects)
sort by altitude and update GUIGlObjects
const std::vector< GUIGlObject * > & getClickedGLObjects() const
get vector with clicked GL objects
GUIGlID getGlIDFront() const
get front GUI GL ID or a pointer to nullptr
void updateAdditionalElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update additional elements
GNEGenericData * getGenericDataElementFront() const
get generic data element or a pointer to nullptr
GNENetworkElement * getNetworkElementFront() const
get front network element or a pointer to nullptr
GNEAttributeCarrier * getAttributeCarrierFront() const
get front attribute carrier or a pointer to nullptr
GNEInternalLane * getInternalLaneFront() const
get front internal lane or a pointer to nullptr
GNECrossing * getCrossingFront() const
get front crossing or a pointer to nullptr
void updateShapeElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update shape elements
void updateTAZElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update TAZ elements
GNELane * getLaneFront() const
get front lane or a pointer to nullptr
const std::vector< GNEDemandElement * > & getClickedDemandElements() const
get vector with clicked Demand Elements
void updateGenericDataElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update generic data elements
void updateGUIGlObjects(ObjectsContainer &container)
updateGUIGlObjects
GNEEdgeData * getEdgeDataElementFront() const
get edge data element or a pointer to nullptr
void updateDemandElements(ObjectsContainer &container, GNEAttributeCarrier *AC)
update demand elements
GNEAdditional * getAdditionalFront() const
get front additional element or a pointer to nullptr
GUIGlObjectType getGlTypeFront() const
get front GUI GL object type or a pointer to nullptr
GNEJunction * getJunctionFront() const
get front junction or a pointer to nullptr
void processGUIGlObjects()
process GL objects
GNEDemandElement * getDemandElementFront() const
get front demand element or a pointer to nullptr
const std::vector< GNELane * > & getLanes() const
get lanes
void filterLockedElements(const GNEViewNetHelper::LockManager &lockManager, std::vector< GUIGlObjectType > forcedIgnoredTiped={})
filter locked elements
void updateAttributeCarriers(ObjectsContainer &container, GNEAttributeCarrier *AC)
update attribute carrier elements
GNEEdge * getEdgeFront() const
get front edge or a pointer to nullptr
GNEWalkingArea * getWalkingAreaFront() const
get front walkingArea or a pointer to nullptr
GUIGlObject * getGUIGlObjectFront() const
get front attribute carrier or a pointer to nullptr
GNETAZ * getTAZFront() const
get front TAZ or a pointer to nullptr
const std::vector< GNEAttributeCarrier * > & getClickedAttributeCarriers() const
get vector with clicked ACs
GNEEdgeRelData * getEdgeRelDataElementFront() const
get edge rel data element or a pointer to nullptr
GNEConnection * getConnectionFront() const
get front connection or a pointer to nullptr
GNEPOI * getPOIFront() const
get front POI or a pointer to nullptr
GNELane * getLaneFrontNonLocked() const
get front lane or a pointer to nullptr checking if is locked
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.h:154
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
const GUIVisualizationSettings & getVisualisationSettings() const
get visualization settings (read only)
static GUIGlID getTexture(GUITexture which)
returns a texture previously defined in the enum GUITexture
static void drawTexturedBox(int which, double size)
Draws a named texture as a box with the given size.
FXbool getCheck() const
Get check state (TRUE, FALSE or MAYBE)
void setCheck(FXbool s=TRUE)
Set check state (TRUE, FALSE or MAYBE)
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:787
A storage for options typed value containers)
Definition: OptionsCont.h:89
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
C++ TraCI client API implementation.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double x() const
Returns the x-position.
Definition: Position.h:55
double y() const
Returns the y-position.
Definition: Position.h:60
A list of positions.
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
static const RGBColor BLUE
Definition: RGBColor.h:187
static const RGBColor YELLOW
Definition: RGBColor.h:188
static const RGBColor MAGENTA
Definition: RGBColor.h:190
A 2D- or 3D-Shape.
Definition: Shape.h:38
double getShapeLayer() const
Returns the layer of the Shape.
Definition: Shape.h:91
MFXMenuCheckIcon * menuCheckLockConnections
menu check to lock connections
MFXMenuCheckIcon * menuCheckLockPersonTrip
menu check to lock personTrips
MFXMenuCheckIcon * menuCheckLockPersons
menu check to lock persons
MFXMenuCheckIcon * menuCheckLockVehicles
menu check to lock vehicles
MFXMenuCheckIcon * menuCheckLockCrossings
menu check to lock crossings
MFXMenuCheckIcon * menuCheckLockTAZs
menu check to lock TAZs
MFXMenuCheckIcon * menuCheckLockWalk
menu check to lock walks
MFXMenuCheckIcon * menuCheckLockEdgeTAZRels
menu check to lock edgeTAZRels
MFXMenuCheckIcon * menuCheckLockWires
menu check to lock Wires
MFXMenuCheckIcon * menuCheckLockPOIs
menu check to lock POIs
MFXMenuCheckIcon * menuCheckLockPolygons
menu check to lock polygons
MFXMenuCheckIcon * menuCheckLockWalkingAreas
menu check to lock walkingAreas
MFXMenuCheckIcon * menuCheckLockEdges
menu check to lock edges
MFXMenuCheckIcon * menuCheckLockRides
menu check to lock rides
MFXMenuCheckIcon * menuCheckLockContainers
menu check to lock containers
MFXMenuCheckIcon * menuCheckLockEdgeRelDatas
menu check to lock edgeRelDatas
MFXMenuCheckIcon * menuCheckLockStops
menu check to lock stops
MFXMenuCheckIcon * menuCheckLockLanes
menu check to lock lanes
MFXMenuCheckIcon * menuCheckLockAdditionals
menu check to lock additionals
MFXMenuCheckIcon * menuCheckLockTranships
menu check to lock tranships
MFXMenuCheckIcon * menuCheckLockTransports
menu check to lock transports
CommonCheckableButtons(GNEViewNet *viewNet)
default constructor
void buildCommonCheckableButtons()
build checkable buttons
void updateCommonCheckableButtons()
update Common checkable buttons
void disableCommonCheckableButtons()
hide all options menu checks
void hideCommonCheckableButtons()
hide all Common Checkable Buttons
void showCommonCheckableButtons()
show all Common Checkable Buttons
void hideDataCheckableButtons()
hide all Data Checkable Buttons
void showDataCheckableButtons()
show all Data Checkable Buttons
void disableDataCheckableButtons()
hide all options menu checks
void buildDataCheckableButtons()
build checkable buttons
void updateDataCheckableButtons()
update Data checkable buttons
DataCheckableButtons(GNEViewNet *viewNet)
default constructor
DataViewOptions(GNEViewNet *viewNet)
default constructor
bool TAZRelOnlyTo() const
check if toggle TAZRel only to checkbox is enabled
void hideDataViewOptionsMenuChecks()
hide all options menu checks
bool showAdditionals() const
check if additionals has to be drawn
bool showDemandElements() const
check if show demand elements checkbox is enabled
bool TAZRelOnlyFrom() const
check if toggle TAZRel only from checkbox is enabled
bool TAZDrawFill() const
check if toggle TAZ draw fill checkbox is enabled
void buildDataViewOptionsMenuChecks()
build menu checks
void getVisibleDataMenuCommands(std::vector< MFXCheckableButton * > &commands) const
get visible demand menu commands
bool showShapes() const
check if shapes has to be drawn
bool TAZRelDrawing() const
check if toggle TAZRel drawing checkbox is enabled
void hideDemandCheckableButtons()
hide all Demand Checkable Buttons
DemandCheckableButtons(GNEViewNet *viewNet)
default constructor
void buildDemandCheckableButtons()
build checkable buttons
void showDemandCheckableButtons()
show all Demand Checkable Buttons
void updateDemandCheckableButtons()
update Demand checkable buttons
void disableDemandCheckableButtons()
hide all options menu checks
void lockPerson(const GNEDemandElement *person)
lock person
bool showAllPersonPlans() const
check all person plans has to be show
void lockContainer(const GNEDemandElement *container)
lock container
void buildDemandViewOptionsMenuChecks()
build menu checks
const GNEDemandElement * getLockedPerson() const
get locked person
const GNEDemandElement * getLockedContainer() const
get locked container
bool showShapes() const
check if shapes has to be drawn
void hideDemandViewOptionsMenuChecks()
hide all options menu checks
bool showAllContainerPlans() const
check all container plans has to be show
bool drawSpreadVehicles() const
check if vehicles must be drawn spread
bool showNonInspectedDemandElements(const GNEDemandElement *demandElement) const
check if non inspected element has to be hidden
DemandViewOptions(GNEViewNet *viewNet)
default constructor
bool showOverlappedRoutes() const
show overlapped routes
void getVisibleDemandMenuCommands(std::vector< MFXCheckableButton * > &commands) const
get visible demand menu commands
bool showAllTrips() const
check if trips has to be drawn
void buildSuperModeButtons()
build checkable buttons
bool isCurrentSupermodeDemand() const
@check if current supermode is Demand
void setDemandEditMode(DemandEditMode demandMode, const bool force=false)
set Demand edit mode
EditModes(GNEViewNet *viewNet, const bool newNet)
default constructor
bool isCurrentSupermodeData() const
@check if current supermode is Data
bool isCurrentSupermodeNetwork() const
@check if current supermode is Network
void setSupermode(Supermode supermode, const bool force)
set supermode
void setNetworkEditMode(NetworkEditMode networkMode, const bool force=false)
set Network edit mode
void setDataEditMode(DataEditMode dataMode, const bool force=false)
set Data edit mode
GNENetworkElement * getEditedNetworkElement() const
pointer to edited network element
EditNetworkElementShapes(GNEViewNet *viewNet)
default constructor
void startEditCustomShape(GNENetworkElement *element)
start edit custom shape
static void drawLockIcon(const GNEAttributeCarrier *AC, GUIGlObjectType type, const Position viewPosition, const double exaggeration, const double size=0.5, const double offsetx=0, const double offsety=0)
draw lock icon
static bool checkDrawing(const GNEAttributeCarrier *AC, GUIGlObjectType type, const double exaggeration)
check if icon can be drawn
bool shiftKeyPressed() const
check if SHIFT is pressed during current event
bool altKeyPressed() const
check if ALT is pressed during current event
void update(void *eventData)
update status of MouseButtonKeyPressed during current event
bool mouseRightButtonPressed() const
check if mouse right button is pressed during current event
bool controlKeyPressed() const
check if CONTROL is pressed during current event
bool mouseLeftButtonPressed() const
check if mouse left button is pressed during current event
void calculateJunctionSelection()
calculate junction selection
MoveMultipleElementValues(GNEViewNet *viewNet)
constructor
const GNEMoveOffset calculateMoveOffset() const
calculate move offset
void moveSelection(const bool mouseLeftButtonPressed)
move selection
bool isMovingSelection() const
check if currently there is element being moved
bool isMovingSelectedEdge() const
flag for moving edge
void finishMoveSelection()
finish moving selection
void calculateEdgeSelection(const GNEEdge *clickedEdge)
calculate edge selection
void resetMovingSelectedEdge()
reset flag for moving edge
void finishMoveSingleElement()
finish moving single elements in Network AND Demand mode
void moveSingleElement(const bool mouseLeftButtonPressed)
move single element in Network AND Demand mode
MoveSingleElementValues(GNEViewNet *viewNet)
constructor
bool beginMoveSingleElementNetworkMode()
begin move single element in Network mode
bool beginMoveNetworkElementShape()
begin move network elementshape
bool beginMoveSingleElementDemandMode()
begin move single element in Demand mode
const GNEMoveOffset calculateMoveOffset() const
calculate offset
void updateNetworkCheckableButtons()
update network checkable buttons
void showNetworkCheckableButtons()
show all Network Checkable Buttons
void buildNetworkCheckableButtons()
build checkable buttons
NetworkCheckableButtons(GNEViewNet *viewNet)
default constructor
void hideNetworkCheckableButtons()
hide all Network Checkable Buttons
void disableNetworkCheckableButtons()
hide all options menu checks
bool showConnections() const
check if select show connections checkbox is enabled
bool drawSpreadVehicles() const
check if vehicles must be drawn spread
bool editingElevation() const
check if we're editing elevation
void getVisibleNetworkMenuCommands(std::vector< MFXCheckableButton * > &commands) const
get visible network menu commands
bool showDemandElements() const
check if show demand elements checkbox is enabled
bool showSubAdditionals() const
check if show sub-additionals
bool selectEdges() const
check if select edges checkbox is enabled
bool showTAZElements() const
check if show TAZ Elements
NetworkViewOptions(GNEViewNet *viewNet)
default constructor
void hideNetworkViewOptionsMenuChecks()
hide all options menu checks
void buildNetworkViewOptionsMenuChecks()
build menu checks
SaveElements(GNEViewNet *viewNet)
default constructor
void buildSaveElementsButtons()
build save buttons
void finishRectangleSelection()
finish rectangle selection
void drawRectangleSelection(const RGBColor &color) const
draw rectangle selection
void beginRectangleSelection()
begin rectangle selection
void moveRectangleSelection()
move rectangle selection
void processBoundarySelection(const Boundary &boundary)
Process boundary Selection.
void processShapeSelection(const PositionVector &shape)
process shape selection
void processRectangleSelection()
process rectangle Selection
std::vector< GNEEdge * > processEdgeRectangleSelection()
process rectangle Selection (only limited to Edges)
SelectingArea(GNEViewNet *viewNet)
default constructor
bool isTestingEnabled() const
check if testing mode is enabled
void drawTestingElements(GUIMainWindow *mainWindow)
draw testing element
TestingMode(GNEViewNet *viewNet)
default constructor
void initTestingMode()
init testing mode
void buildVehicleOptionsMenuChecks()
build menu checks
VehicleOptions(GNEViewNet *viewNet)
constructor
void hideVehicleOptionsMenuChecks()
hide all options menu checks
VehicleTypeOptions(GNEViewNet *viewNet)
constructor
void buildVehicleTypeOptionsMenuChecks()
build menu checks
void hideVehicleTypeOptionsMenuChecks()
hide all options menu checks
static std::vector< RGBColor > myRainbowScaledColors
scale (rainbow) colors
static const RGBColor & getRainbowScaledColor(const double min, const double max, const double value)
get rainbow scaled color
static std::vector< GUIGlObject * > filterElementsByLayer(const std::vector< GUIGlObject * > &GLObjects)
filter elements based on the layer
static const std::vector< RGBColor > & getRainbowScaledColors()
get scaled rainbow colors