Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GNEViewNetHelper.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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
191
192
196
197
199
200
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 // filter duplicated objects
224 const auto filteredObjects = filterDuplicatedObjects(GUIGlObjects);
225 // sort GUIGLObjects
226 sortGUIGlObjects(filteredObjects);
227 // process GUIGLObjects using myEdgeObjects.GUIGlObjects and myLaneObjects.GUIGlObjects
228 processGUIGlObjects();
229}
230
231
232void
234 // enable flag
235 mySwapLane2edge = true;
236}
237
238
239void
240GNEViewNetHelper::ObjectsUnderCursor::filterLockedElements(const GNEViewNetHelper::LockManager& lockManager, std::vector<GUIGlObjectType> forcedIgnoredTiped) {
241 // make a copy of edge and lane Attribute carriers
242 auto edgeACs = myEdgeObjects.attributeCarriers;
243 auto laneACs = myLaneObjects.attributeCarriers;
244 // clear elements
245 myEdgeObjects.clearElements();
246 myLaneObjects.clearElements();
247 // filter GUIGLObjects
248 for (const auto& edgeAC : edgeACs) {
249 if (std::find(forcedIgnoredTiped.begin(), forcedIgnoredTiped.end(), edgeAC->getGUIGlObject()->getType()) != forcedIgnoredTiped.end()) {
250 continue;
251 } else if (!lockManager.isObjectLocked(edgeAC->getGUIGlObject()->getType(), edgeAC->isAttributeCarrierSelected())) {
252 myEdgeObjects.GUIGlObjects.push_back(edgeAC->getGUIGlObject());
253 }
254 }
255 for (const auto& laneAC : laneACs) {
256 if (std::find(forcedIgnoredTiped.begin(), forcedIgnoredTiped.end(), laneAC->getGUIGlObject()->getType()) != forcedIgnoredTiped.end()) {
257 continue;
258 } else if (!lockManager.isObjectLocked(laneAC->getGUIGlObject()->getType(), laneAC->isAttributeCarrierSelected())) {
259 myLaneObjects.GUIGlObjects.push_back(laneAC->getGUIGlObject());
260 }
261 }
262 // process GUIGLObjects using myEdgeObjects.GUIGlObjects and myLaneObjects.GUIGlObjects
263 processGUIGlObjects();
264}
265
266
267void
269 // declare set for sort generic datas by begin->end->AC
270 std::set<std::pair<double, std::pair<double, GNEAttributeCarrier*> > > sortedDataElements;
271 // short only lane objects (because shortData elements is used only in data mode)
272 for (const auto& AC : myLaneObjects.attributeCarriers) {
273 if (AC->getTagProperty().isGenericData()) {
274 const double begin = GNEAttributeCarrier::parse<double>(AC->getAttribute(SUMO_ATTR_BEGIN));
275 const double end = GNEAttributeCarrier::parse<double>(AC->getAttribute(SUMO_ATTR_END));
276 sortedDataElements.insert(std::make_pair(begin, std::make_pair(end, AC)));
277 }
278 }
279 myLaneObjects.attributeCarriers.clear();
280 for (const auto& sortedDataElement : sortedDataElements) {
281 myLaneObjects.attributeCarriers.push_back(sortedDataElement.second.second);
282 }
283}
284
285
288 if (getGUIGlObjectFront()) {
289 return getGUIGlObjectFront()->getGlID();
290 } else {
291 return 0;
292 }
293}
294
295
298 if (getGUIGlObjectFront()) {
299 return getGUIGlObjectFront()->getType();
300 } else {
301 return GLO_NETWORK;
302 }
303}
304
305
308 if (mySwapLane2edge) {
309 if (myEdgeObjects.attributeCarriers.size() > 0) {
310 return myEdgeObjects.GUIGlObjects.front();
311 } else {
312 return nullptr;
313 }
314 } else {
315 if (myLaneObjects.attributeCarriers.size() > 0) {
316 return myLaneObjects.GUIGlObjects.front();
317 } else {
318 return nullptr;
319 }
320 }
321}
322
323
326 if (mySwapLane2edge) {
327 if (myEdgeObjects.attributeCarriers.size() > 0) {
328 return myEdgeObjects.attributeCarriers.front();
329 } else {
330 return nullptr;
331 }
332 } else {
333 if (myLaneObjects.attributeCarriers.size() > 0) {
334 return myLaneObjects.attributeCarriers.front();
335 } else {
336 return nullptr;
337 }
338 }
339}
340
341
344 if (mySwapLane2edge) {
345 if (myEdgeObjects.networkElements.size() > 0) {
346 return myEdgeObjects.networkElements.front();
347 } else {
348 return nullptr;
349 }
350 } else {
351 if (myLaneObjects.networkElements.size() > 0) {
352 return myLaneObjects.networkElements.front();
353 } else {
354 return nullptr;
355 }
356 }
357}
358
359
362 if (mySwapLane2edge) {
363 if (myEdgeObjects.additionals.size() > 0) {
364 return myEdgeObjects.additionals.front();
365 } else {
366 return nullptr;
367 }
368 } else {
369 if (myLaneObjects.additionals.size() > 0) {
370 return myLaneObjects.additionals.front();
371 } else {
372 return nullptr;
373 }
374 }
375}
376
377
380 if (mySwapLane2edge) {
381 if (myEdgeObjects.demandElements.size() > 0) {
382 return myEdgeObjects.demandElements.front();
383 } else {
384 return nullptr;
385 }
386 } else {
387 if (myLaneObjects.demandElements.size() > 0) {
388 return myLaneObjects.demandElements.front();
389 } else {
390 return nullptr;
391 }
392 }
393}
394
395
398 if (mySwapLane2edge) {
399 if (myEdgeObjects.genericDatas.size() > 0) {
400 return myEdgeObjects.genericDatas.front();
401 } else {
402 return nullptr;
403 }
404 } else {
405 if (myLaneObjects.genericDatas.size() > 0) {
406 return myLaneObjects.genericDatas.front();
407 } else {
408 return nullptr;
409 }
410 }
411}
412
413
416 if (mySwapLane2edge) {
417 if (myEdgeObjects.junctions.size() > 0) {
418 return myEdgeObjects.junctions.front();
419 } else {
420 return nullptr;
421 }
422 } else {
423 if (myLaneObjects.junctions.size() > 0) {
424 return myLaneObjects.junctions.front();
425 } else {
426 return nullptr;
427 }
428 }
429}
430
431
432GNEEdge*
434 if (mySwapLane2edge) {
435 if (myEdgeObjects.edges.size() > 0) {
436 return myEdgeObjects.edges.front();
437 } else {
438 return nullptr;
439 }
440 } else {
441 if (myLaneObjects.edges.size() > 0) {
442 return myLaneObjects.edges.front();
443 } else {
444 return nullptr;
445 }
446 }
447}
448
449
450GNELane*
452 if (mySwapLane2edge) {
453 if (myEdgeObjects.lanes.size() > 0) {
454 return myEdgeObjects.lanes.front();
455 } else {
456 return nullptr;
457 }
458 } else {
459 if (myLaneObjects.lanes.size() > 0) {
460 return myLaneObjects.lanes.front();
461 } else {
462 return nullptr;
463 }
464 }
465}
466
467
468GNELane*
470 if (mySwapLane2edge) {
471 if (myEdgeObjects.lanes.size() > 0) {
472 for (auto& lane : myEdgeObjects.lanes) {
473 if (!(lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) ||
474 !myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck()) {
475 return lane;
476 }
477 }
478 // all locked, then return nullptr
479 return nullptr;
480 } else {
481 return nullptr;
482 }
483 } else {
484 if (myLaneObjects.lanes.size() > 0) {
485 for (auto& lane : myLaneObjects.lanes) {
486 if (!(lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) ||
487 !myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck()) {
488 return lane;
489 }
490 }
491 // all locked, then return nullptr
492 return nullptr;
493 } else {
494 return nullptr;
495 }
496 }
497}
498
499
500const std::vector<GNELane*>&
502 if (mySwapLane2edge) {
503 return myEdgeObjects.lanes;
504 } else {
505 return myLaneObjects.lanes;
506 }
507}
508
509
512 if (mySwapLane2edge) {
513 if (myEdgeObjects.crossings.size() > 0) {
514 return myEdgeObjects.crossings.front();
515 } else {
516 return nullptr;
517 }
518 } else {
519 if (myLaneObjects.crossings.size() > 0) {
520 return myLaneObjects.crossings.front();
521 } else {
522 return nullptr;
523 }
524 }
525}
526
527
530 if (mySwapLane2edge) {
531 if (myEdgeObjects.walkingAreas.size() > 0) {
532 return myEdgeObjects.walkingAreas.front();
533 } else {
534 return nullptr;
535 }
536 } else {
537 if (myLaneObjects.walkingAreas.size() > 0) {
538 return myLaneObjects.walkingAreas.front();
539 } else {
540 return nullptr;
541 }
542 }
543}
544
545
548 if (mySwapLane2edge) {
549 if (myEdgeObjects.connections.size() > 0) {
550 return myEdgeObjects.connections.front();
551 } else {
552 return nullptr;
553 }
554 } else {
555 if (myLaneObjects.connections.size() > 0) {
556 return myLaneObjects.connections.front();
557 } else {
558 return nullptr;
559 }
560 }
561}
562
563
566 if (mySwapLane2edge) {
567 if (myEdgeObjects.internalLanes.size() > 0) {
568 return myEdgeObjects.internalLanes.front();
569 } else {
570 return nullptr;
571 }
572 } else {
573 if (myLaneObjects.internalLanes.size() > 0) {
574 return myLaneObjects.internalLanes.front();
575 } else {
576 return nullptr;
577 }
578 }
579}
580
581
582GNEPOI*
584 if (mySwapLane2edge) {
585 if (myEdgeObjects.POIs.size() > 0) {
586 return myEdgeObjects.POIs.front();
587 } else {
588 return nullptr;
589 }
590 } else {
591 if (myLaneObjects.POIs.size() > 0) {
592 return myLaneObjects.POIs.front();
593 } else {
594 return nullptr;
595 }
596 }
597}
598
599
600GNEPoly*
602 if (mySwapLane2edge) {
603 if (myEdgeObjects.polys.size() > 0) {
604 return myEdgeObjects.polys.front();
605 } else {
606 return nullptr;
607 }
608 } else {
609 if (myLaneObjects.polys.size() > 0) {
610 return myLaneObjects.polys.front();
611 } else {
612 return nullptr;
613 }
614 }
615}
616
617
618GNETAZ*
620 if (mySwapLane2edge) {
621 if (myEdgeObjects.TAZs.size() > 0) {
622 return myEdgeObjects.TAZs.front();
623 } else {
624 return nullptr;
625 }
626 } else {
627 if (myLaneObjects.TAZs.size() > 0) {
628 return myLaneObjects.TAZs.front();
629 } else {
630 return nullptr;
631 }
632 }
633}
634
635
638 if (mySwapLane2edge) {
639 if (myEdgeObjects.edgeDatas.size() > 0) {
640 return myEdgeObjects.edgeDatas.front();
641 } else {
642 return nullptr;
643 }
644 } else {
645 if (myLaneObjects.edgeDatas.size() > 0) {
646 return myLaneObjects.edgeDatas.front();
647 } else {
648 return nullptr;
649 }
650 }
651}
652
653
656 if (mySwapLane2edge) {
657 if (myEdgeObjects.edgeRelDatas.size() > 0) {
658 return myEdgeObjects.edgeRelDatas.front();
659 } else {
660 return nullptr;
661 }
662 } else {
663 if (myLaneObjects.edgeRelDatas.size() > 0) {
664 return myLaneObjects.edgeRelDatas.front();
665 } else {
666 return nullptr;
667 }
668 }
669}
670
671const std::vector<GUIGlObject*>&
673 if (mySwapLane2edge) {
674 return myEdgeObjects.GUIGlObjects;
675 } else {
676 return myLaneObjects.GUIGlObjects;
677 }
678}
679
680
681const std::vector<GNEAttributeCarrier*>&
683 if (mySwapLane2edge) {
684 return myEdgeObjects.attributeCarriers;
685 } else {
686 return myLaneObjects.attributeCarriers;
687 }
688}
689
690
691const std::vector<GNEJunction*>&
693 if (mySwapLane2edge) {
694 return myEdgeObjects.junctions;
695 } else {
696 return myLaneObjects.junctions;
697 }
698}
699
700
701const std::vector<GNEDemandElement*>&
703 if (mySwapLane2edge) {
704 return myEdgeObjects.demandElements;
705 } else {
706 return myLaneObjects.demandElements;
707 }
708}
709
710
712
713
714void
716 // just clear all containers
717 GUIGlObjects.clear();
718 attributeCarriers.clear();
719 networkElements.clear();
720 additionals.clear();
721 demandElements.clear();
722 junctions.clear();
723 edges.clear();
724 lanes.clear();
725 crossings.clear();
726 walkingAreas.clear();
727 connections.clear();
728 internalLanes.clear();
729 TAZs.clear();
730 POIs.clear();
731 polys.clear();
732 genericDatas.clear();
733 edgeDatas.clear();
734 edgeRelDatas.clear();
735}
736
737
738std::vector<GUIGlObject*>
739GNEViewNetHelper::ObjectsUnderCursor::filterDuplicatedObjects(const std::vector<GUIGlObject*>& GUIGlObjects) const {
740 // declare vector for filter objects
741 std::vector<GUIGlObject*> filteredGUIGlObjects;
742 // iterate over GUIGlObjects
743 for (const auto& GLObject : GUIGlObjects) {
744 // find GLObject in filteredGUIGlObjects
745 const auto it = std::find(filteredGUIGlObjects.begin(), filteredGUIGlObjects.end(), GLObject);
746 if (it == filteredGUIGlObjects.end()) {
747 filteredGUIGlObjects.push_back(GLObject);
748 }
749 }
750 return filteredGUIGlObjects;
751}
752
753
754void
755GNEViewNetHelper::ObjectsUnderCursor::sortGUIGlObjects(const std::vector<GUIGlObject*>& GUIGlObjects) {
756 // declare a map to save GUIGlObjects sorted by GLO_TYPE
757 std::map<double, std::vector<GUIGlObject*> > mySortedGUIGlObjects;
758 // iterate over set
759 for (const auto& GLObject : GUIGlObjects) {
760 // try to parse shape
761 const Shape* shape = dynamic_cast<Shape*>(GLObject);
762 if (shape) {
763 mySortedGUIGlObjects[shape->getShapeLayer()].push_back(GLObject);
764 } else {
765 mySortedGUIGlObjects[GLObject->getType()].push_back(GLObject);
766 }
767 }
768 // move sorted GUIGlObjects into myGUIGlObjectLanes using a reverse iterator
769 for (std::map<double, std::vector<GUIGlObject*> >::reverse_iterator i = mySortedGUIGlObjects.rbegin(); i != mySortedGUIGlObjects.rend(); i++) {
770 for (const auto& GlObject : i->second) {
771 // avoid GLO_NETWORKELEMENT
772 if (GlObject->getType() != GLO_NETWORKELEMENT) {
773 // add it in GUIGlObject splitting by edge/lanes
774 if (GlObject->getType() == GLO_LANE) {
775 myLaneObjects.GUIGlObjects.push_back(GlObject);
776 } else {
777 myEdgeObjects.GUIGlObjects.push_back(GlObject);
778 myLaneObjects.GUIGlObjects.push_back(GlObject);
779 }
780 }
781 }
782 }
783}
784
785
786void
788 // get front AC
789 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
790 // special case for edges and lanes
791 if (frontAC && (frontAC->getTagProperty().getTag() == SUMO_TAG_EDGE) && (AC->getTagProperty().getTag() == SUMO_TAG_LANE)) {
792 // compare IDs
793 if (AC->getAttribute(GNE_ATTR_PARENT) == frontAC->getID()) {
794 // insert at front
795 container.attributeCarriers.insert(container.attributeCarriers.begin(), AC);
796 } else {
797 // insert at back
798 container.attributeCarriers.push_back(AC);
799 }
800 } else {
801 // add it in attributeCarriers
802 if (AC == frontAC) {
803 // insert at front
804 container.attributeCarriers.insert(container.attributeCarriers.begin(), AC);
805 } else {
806 // insert at back
807 container.attributeCarriers.push_back(AC);
808 }
809 }
810}
811
812
813void
815 // get front AC
816 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
817 // check front element
818 if (AC == frontAC) {
819 // insert at front
820 container.networkElements.insert(container.networkElements.begin(), dynamic_cast<GNENetworkElement*>(AC));
821 } else {
822 // insert at back
823 container.networkElements.push_back(dynamic_cast<GNENetworkElement*>(AC));
824 }
825 // cast specific network element
826 switch (AC->getGUIGlObject()->getType()) {
827 case GLO_JUNCTION: {
828 // check front element
829 if (AC == frontAC) {
830 // insert at front
831 container.junctions.insert(container.junctions.begin(), dynamic_cast<GNEJunction*>(AC));
832 } else {
833 // insert at back
834 container.junctions.push_back(dynamic_cast<GNEJunction*>(AC));
835 }
836 break;
837 }
838 case GLO_EDGE: {
839 // check front element
840 if (AC == frontAC) {
841 // insert at front
842 container.edges.insert(container.edges.begin(), dynamic_cast<GNEEdge*>(AC));
843 } else {
844 // insert at back
845 container.edges.push_back(dynamic_cast<GNEEdge*>(AC));
846 }
847 break;
848 }
849 case GLO_LANE: {
850 // check front element
851 if (AC == frontAC) {
852 // insert at front
853 container.lanes.insert(container.lanes.begin(), dynamic_cast<GNELane*>(AC));
854 } else {
855 // insert at back
856 container.lanes.push_back(dynamic_cast<GNELane*>(AC));
857 }
858 break;
859 }
860 case GLO_CROSSING: {
861 // check front element
862 if (AC == frontAC) {
863 // insert at front
864 container.crossings.insert(container.crossings.begin(), dynamic_cast<GNECrossing*>(AC));
865 } else {
866 // insert at back
867 container.crossings.push_back(dynamic_cast<GNECrossing*>(AC));
868 }
869 break;
870 }
871 case GLO_WALKINGAREA: {
872 // check front element
873 if (AC == frontAC) {
874 // insert at front
875 container.walkingAreas.insert(container.walkingAreas.begin(), dynamic_cast<GNEWalkingArea*>(AC));
876 } else {
877 // insert at back
878 container.walkingAreas.push_back(dynamic_cast<GNEWalkingArea*>(AC));
879 }
880 break;
881 }
882 case GLO_CONNECTION: {
883 // check front element
884 if (AC == frontAC) {
885 // insert at front
886 container.connections.insert(container.connections.begin(), dynamic_cast<GNEConnection*>(AC));
887 } else {
888 // insert at back
889 container.connections.push_back(dynamic_cast<GNEConnection*>(AC));
890 }
891 break;
892 }
893 case GLO_TLLOGIC: {
894 // check front element
895 if (AC == frontAC) {
896 // insert at front
897 container.internalLanes.insert(container.internalLanes.begin(), dynamic_cast<GNEInternalLane*>(AC));
898 } else {
899 // insert at back
900 container.internalLanes.push_back(dynamic_cast<GNEInternalLane*>(AC));
901 }
902 break;
903 }
904 default:
905 break;
906 }
907}
908
909
910void
912 // get additional element
913 GNEAdditional* additionalElement = myViewNet->getNet()->getAttributeCarriers()->retrieveAdditional(AC);
914 // insert depending if is the front attribute carrier
915 if (additionalElement == myViewNet->getFrontAttributeCarrier()) {
916 // insert at front
917 container.additionals.insert(container.additionals.begin(), additionalElement);
918 } else {
919 // insert at back
920 container.additionals.push_back(additionalElement);
921 }
922}
923
924
925void
927 // cast specific shape
928 if (AC->getGUIGlObject()->getType() == GLO_POI) {
929 // cast POI
930 GNEPOI* POI = dynamic_cast<GNEPOI*>(AC);
931 if (POI) {
932 // check front element
933 if (AC == myViewNet->getFrontAttributeCarrier()) {
934 // insert at front
935 container.POIs.insert(container.POIs.begin(), POI);
936 } else {
937 // insert at back
938 container.POIs.push_back(POI);
939 }
940 }
941 } else if (AC->getGUIGlObject()->getType() == GLO_POLYGON) {
942 // cast poly
943 GNEPoly* poly = dynamic_cast<GNEPoly*>(AC);
944 if (poly) {
945 // check front element
946 if (AC == myViewNet->getFrontAttributeCarrier()) {
947 // insert at front
948 container.polys.insert(container.polys.begin(), poly);
949 } else {
950 // insert at back
951 container.polys.push_back(poly);
952 }
953 }
954 }
955}
956
957
958void
960 // cast specific TAZ
961 if (AC->getGUIGlObject()->getType() == GLO_TAZ) {
962 // cast TAZ
963 GNETAZ* TAZ = dynamic_cast<GNETAZ*>(AC);
964 if (TAZ) {
965 // check front element
966 if (AC == myViewNet->getFrontAttributeCarrier()) {
967 // insert at front
968 container.TAZs.insert(container.TAZs.begin(), TAZ);
969 } else {
970 // insert at back
971 container.TAZs.push_back(TAZ);
972 }
973 }
974 }
975}
976
977
978void
980 // get demandElement
981 GNEDemandElement* demandElement = myViewNet->getNet()->getAttributeCarriers()->retrieveDemandElement(AC);
982 // insert depending if is the front attribute carrier
983 if (demandElement == myViewNet->getFrontAttributeCarrier()) {
984 // insert at front
985 container.demandElements.insert(container.demandElements.begin(), demandElement);
986 } else {
987 // insert at back
988 container.demandElements.push_back(demandElement);
989 }
990}
991
992
993void
995 // get front AC
996 const GNEAttributeCarrier* frontAC = myViewNet->getFrontAttributeCarrier();
997 // cast generic data from attribute carrier
998 if (AC == frontAC) {
999 // insert at front
1000 container.genericDatas.insert(container.genericDatas.begin(), dynamic_cast<GNEGenericData*>(AC));
1001 } else {
1002 // insert at back
1003 container.genericDatas.push_back(dynamic_cast<GNEGenericData*>(AC));
1004 }
1005 // cast specific generic data
1006 switch (AC->getGUIGlObject()->getType()) {
1007 case GLO_EDGEDATA:
1008 // check front element
1009 if (AC == frontAC) {
1010 // insert at front
1011 container.edgeDatas.insert(container.edgeDatas.begin(), dynamic_cast<GNEEdgeData*>(AC));
1012 } else {
1013 // insert at back
1014 container.edgeDatas.push_back(dynamic_cast<GNEEdgeData*>(AC));
1015 }
1016 break;
1017 case GLO_EDGERELDATA:
1018 // check front element
1019 if (AC == frontAC) {
1020 // insert at front
1021 container.edgeRelDatas.insert(container.edgeRelDatas.begin(), dynamic_cast<GNEEdgeRelData*>(AC));
1022 } else {
1023 // insert at back
1024 container.edgeRelDatas.push_back(dynamic_cast<GNEEdgeRelData*>(AC));
1025 }
1026 break;
1027 default:
1028 break;
1029 }
1030}
1031
1032
1033void
1035 // first clear GUIGlObjects
1036 container.GUIGlObjects.clear();
1037 // reserve
1038 container.GUIGlObjects.reserve(container.attributeCarriers.size());
1039 // iterate over attribute carriers
1040 for (const auto& attributeCarrrier : container.attributeCarriers) {
1041 // add GUIGlObject in GUIGlObjects container
1042 container.GUIGlObjects.push_back(attributeCarrrier->getGUIGlObject());
1043 }
1044}
1045
1046
1047void
1049 // iterate over myGUIGlObjectLanes
1050 for (const auto& glObject : myEdgeObjects.GUIGlObjects) {
1051 // cast attribute carrier from glObject
1052 GNEAttributeCarrier* AC = dynamic_cast<GNEAttributeCarrier*>(glObject);
1053 // only continue if attributeCarrier isn't nullptr;
1054 if (AC) {
1055 // update attribute carrier
1056 updateAttributeCarriers(myEdgeObjects, AC);
1057 // cast specific network elemetns
1058 if (AC->getTagProperty().isNetworkElement()) {
1059 // update network elements
1060 updateNetworkElements(myEdgeObjects, AC);
1061 } else if (AC->getTagProperty().isAdditionalElement()) {
1062 // update additional elements
1063 updateAdditionalElements(myEdgeObjects, AC);
1064 // update shapes and TAZs
1065 if (AC->getTagProperty().isShapeElement()) {
1066 // update shape elements
1067 updateShapeElements(myEdgeObjects, AC);
1068 }
1069 if (AC->getTagProperty().isTAZElement()) {
1070 // update TAZ elements
1071 updateTAZElements(myEdgeObjects, AC);
1072 }
1073 } else if (AC->getTagProperty().isDemandElement()) {
1074 // update demand elements
1075 updateDemandElements(myEdgeObjects, AC);
1076 } else if (AC->getTagProperty().isGenericData()) {
1077 // update generic datas
1078 updateGenericDataElements(myEdgeObjects, AC);
1079 }
1080 }
1081 }
1082 // update GUIGlObjects (due front element)
1083 updateGUIGlObjects(myEdgeObjects);
1084 // iterate over myGUIGlObjectLanes
1085 for (const auto& glObject : myLaneObjects.GUIGlObjects) {
1086 // cast attribute carrier from glObject
1087 GNEAttributeCarrier* AC = dynamic_cast<GNEAttributeCarrier*>(glObject);
1088 // only continue if attributeCarrier isn't nullptr;
1089 if (AC) {
1090 // update attribute carrier
1091 updateAttributeCarriers(myLaneObjects, AC);
1092 // cast specific network elemetns
1093 if (AC->getTagProperty().isNetworkElement()) {
1094 // update network elements
1095 updateNetworkElements(myLaneObjects, AC);
1096 } else if (AC->getTagProperty().isAdditionalElement()) {
1097 // update additional elements
1098 updateAdditionalElements(myLaneObjects, AC);
1099 // update shapes and TAZs
1100 if (AC->getTagProperty().isShapeElement()) {
1101 // update shape elements
1102 updateShapeElements(myLaneObjects, AC);
1103 }
1104 if (AC->getTagProperty().isTAZElement()) {
1105 // update TAZ elements
1106 updateTAZElements(myLaneObjects, AC);
1107 }
1108 } else if (AC->getTagProperty().isDemandElement()) {
1109 // update demand elements
1110 updateDemandElements(myLaneObjects, AC);
1111 } else if (AC->getTagProperty().isGenericData()) {
1112 // update generic datas
1113 updateGenericDataElements(myLaneObjects, AC);
1114 }
1115 }
1116 }
1117 // update GUIGlObjects (due front element)
1118 updateGUIGlObjects(myLaneObjects);
1119}
1120
1121
1123 myViewNet(nullptr),
1124 mySwapLane2edge(false) {
1125}
1126
1127// ---------------------------------------------------------------------------
1128// GNEViewNetHelper::MouseButtonKeyPressed - methods
1129// ---------------------------------------------------------------------------
1130
1134
1135
1136void
1138 myEventInfo = (FXEvent*) eventData;
1139}
1140
1141
1142bool
1144 if (myEventInfo) {
1145 return (myEventInfo->state & SHIFTMASK) != 0;
1146 } else {
1147 return false;
1148 }
1149}
1150
1151
1152bool
1154 if (myEventInfo) {
1155 return (myEventInfo->state & CONTROLMASK) != 0;
1156 } else {
1157 return false;
1158 }
1159}
1160
1161
1162bool
1164 if (myEventInfo) {
1165 return (myEventInfo->state & ALTMASK) != 0;
1166 } else {
1167 return false;
1168 }
1169}
1170
1171
1172bool
1174 if (myEventInfo) {
1175 return (myEventInfo->state & LEFTBUTTONMASK) != 0;
1176 } else {
1177 return false;
1178 }
1179}
1180
1181
1182bool
1184 if (myEventInfo) {
1185 return (myEventInfo->state & RIGHTBUTTONMASK) != 0;
1186 } else {
1187 return false;
1188 }
1189}
1190
1191// ---------------------------------------------------------------------------
1192// GNEViewNetHelper::MoveSingleElementValues - methods
1193// ---------------------------------------------------------------------------
1194
1198
1199
1200bool
1202 // first obtain moving reference (common for all)
1203 myRelativeClickedPosition = myViewNet->getPositionInformation();
1204 // get edited element
1205 const GNENetworkElement* editedElement = myViewNet->myEditNetworkElementShapes.getEditedNetworkElement();
1206 // check what type of AC will be moved
1207 if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (myViewNet->myObjectsUnderCursor.getJunctionFront() == editedElement)) {
1208 // get move operation
1209 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
1210 // continue if move operation is valid
1211 if (moveOperation) {
1212 myMoveOperations.push_back(moveOperation);
1213 return true;
1214 } else {
1215 return false;
1216 }
1217 } else if (myViewNet->myObjectsUnderCursor.getLaneFront() && (myViewNet->myObjectsUnderCursor.getLaneFront() == editedElement)) {
1218 // get move operation
1219 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getLaneFront()->getMoveOperation();
1220 // continue if move operation is valid
1221 if (moveOperation) {
1222 myMoveOperations.push_back(moveOperation);
1223 return true;
1224 } else {
1225 return false;
1226 }
1227 } else if (myViewNet->myObjectsUnderCursor.getCrossingFront() && (myViewNet->myObjectsUnderCursor.getCrossingFront() == editedElement)) {
1228 // get move operation
1229 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getCrossingFront()->getMoveOperation();
1230 // continue if move operation is valid
1231 if (moveOperation) {
1232 myMoveOperations.push_back(moveOperation);
1233 return true;
1234 } else {
1235 return false;
1236 }
1237 } else if (myViewNet->myObjectsUnderCursor.getConnectionFront() && (myViewNet->myObjectsUnderCursor.getConnectionFront() == editedElement)) {
1238 // get move operation
1239 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getConnectionFront()->getMoveOperation();
1240 // continue if move operation is valid
1241 if (moveOperation) {
1242 myMoveOperations.push_back(moveOperation);
1243 return true;
1244 } else {
1245 return false;
1246 }
1247 } else if (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() && (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() == editedElement)) {
1248 // get move operation
1249 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getWalkingAreaFront()->getMoveOperation();
1250 // continue if move operation is valid
1251 if (moveOperation) {
1252 myMoveOperations.push_back(moveOperation);
1253 return true;
1254 } else {
1255 return false;
1256 }
1257 } else {
1258 // there isn't moved items, then return false
1259 return false;
1260 }
1261}
1262
1263
1264bool
1266 // first obtain moving reference (common for all)
1267 myRelativeClickedPosition = myViewNet->getPositionInformation();
1268 // get front AC
1269 const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
1270 // check what type of AC will be moved
1271 if (myViewNet->myObjectsUnderCursor.getPolyFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPolyFront())) {
1272 // get move operation
1273 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPolyFront()->getMoveOperation();
1274 // continue if move operation is valid
1275 if (moveOperation) {
1276 myMoveOperations.push_back(moveOperation);
1277 return true;
1278 } else {
1279 return false;
1280 }
1281 } else if (myViewNet->myObjectsUnderCursor.getPOIFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPOIFront())) {
1282 // get move operation
1283 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPOIFront()->getMoveOperation();
1284 // continue if move operation is valid
1285 if (moveOperation) {
1286 myMoveOperations.push_back(moveOperation);
1287 return true;
1288 } else {
1289 return false;
1290 }
1291 } else if (myViewNet->myObjectsUnderCursor.getAdditionalFront() && (frontAC == myViewNet->myObjectsUnderCursor.getAdditionalFront())) {
1292 // get move operation
1293 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getAdditionalFront()->getMoveOperation();
1294 // continue if move operation is valid
1295 if (moveOperation) {
1296 myMoveOperations.push_back(moveOperation);
1297 return true;
1298 } else {
1299 return false;
1300 }
1301 } else if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (frontAC == myViewNet->myObjectsUnderCursor.getJunctionFront())) {
1302 // check if over junction there is a geometry point
1303 if (myViewNet->myObjectsUnderCursor.getEdgeFront() && (myViewNet->myObjectsUnderCursor.getEdgeFront()->clickedOverGeometryPoint(myRelativeClickedPosition))) {
1304 // get move operation
1305 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getEdgeFront()->getMoveOperation();
1306 // continue if move operation is valid
1307 if (moveOperation) {
1308 myMoveOperations.push_back(moveOperation);
1309 return true;
1310 } else {
1311 return false;
1312 }
1313 } else {
1314 // get move operation
1315 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
1316 // continue if move operation is valid
1317 if (moveOperation) {
1318 myMoveOperations.push_back(moveOperation);
1319 return true;
1320 } else {
1321 return false;
1322 }
1323 }
1324 } else if ((myViewNet->myObjectsUnderCursor.getEdgeFront() && (frontAC == myViewNet->myObjectsUnderCursor.getEdgeFront())) ||
1325 (myViewNet->myObjectsUnderCursor.getLaneFront() && (frontAC == myViewNet->myObjectsUnderCursor.getLaneFront()))) {
1326 // calculate Edge movement values (can be entire shape, single geometry points, altitude, etc.)
1327 if (myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1328 // edit end point
1329 myViewNet->myObjectsUnderCursor.getEdgeFront()->editEndpoint(myViewNet->getPositionInformation(), myViewNet->myUndoList);
1330 // edge values wasn't calculated, then return false
1331 return false;
1332 } else {
1333 // get move operation
1334 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getEdgeFront()->getMoveOperation();
1335 // continue if move operation is valid
1336 if (moveOperation) {
1337 myMoveOperations.push_back(moveOperation);
1338 return true;
1339 } else {
1340 return false;
1341 }
1342 }
1343 } else {
1344 // there isn't moved items, then return false
1345 return false;
1346 }
1347}
1348
1349
1350bool
1352 // first obtain moving reference (common for all)
1353 myRelativeClickedPosition = myViewNet->getPositionInformation();
1354 // get front AC
1355 const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
1356 // check demand element
1357 if (myViewNet->myObjectsUnderCursor.getDemandElementFront() && (frontAC == myViewNet->myObjectsUnderCursor.getDemandElementFront())) {
1358 // get move operation
1359 GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getDemandElementFront()->getMoveOperation();
1360 // continue if move operation is valid
1361 if (moveOperation) {
1362 myMoveOperations.push_back(moveOperation);
1363 return true;
1364 } else {
1365 return false;
1366 }
1367
1368 } else {
1369 // there isn't moved items, then return false
1370 return false;
1371 }
1372}
1373
1374
1375void
1377 // calculate moveOffset
1378 const GNEMoveOffset moveOffset = calculateMoveOffset();
1379 // check if mouse button is pressed
1380 if (mouseLeftButtonPressed) {
1381 // iterate over all operations
1382 for (const auto& moveOperation : myMoveOperations) {
1383 // move elements
1384 GNEMoveElement::moveElement(myViewNet, moveOperation, moveOffset);
1385 }
1386 } else {
1387 // iterate over all operations
1388 for (const auto& moveOperation : myMoveOperations) {
1389 // commit move
1390 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1391 // don't forget delete move operation
1392 delete moveOperation;
1393 }
1394 // clear move operations
1395 myMoveOperations.clear();
1396 }
1397}
1398
1399
1400void
1402 // calculate moveOffset
1403 const GNEMoveOffset moveOffset = calculateMoveOffset();
1404 // finish all move operations
1405 for (const auto& moveOperation : myMoveOperations) {
1406 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1407 // don't forget delete move operation
1408 delete moveOperation;
1409 }
1410 // clear move operations
1411 myMoveOperations.clear();
1412}
1413
1414
1415const GNEMoveOffset
1417 // calculate moveOffset depending of current mouse position and relative clicked position
1418 // @note #3521: Add checkBox to allow moving elements... has to be implemented and used here
1419 Position moveOffset = (myViewNet->getPositionInformation() - myViewNet->myMoveSingleElementValues.myRelativeClickedPosition);
1420 // calculate Z depending of moveElevation
1421 if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
1422 // use Y as Z value and return Z move offset
1423 return GNEMoveOffset(moveOffset.y());
1424 } else {
1425 // return X-Y move offset
1426 return GNEMoveOffset(moveOffset.x(), moveOffset.y());
1427 }
1428}
1429
1430// ---------------------------------------------------------------------------
1431// GNEViewNetHelper::MoveMultipleElementValues - methods
1432// ---------------------------------------------------------------------------
1433
1435 myViewNet(viewNet),
1436 myMovingSelectedEdge(false),
1437 myEdgeOffset(0) {
1438}
1439
1440
1441void
1443 // save clicked position (to calculate offset)
1444 myClickedPosition = myViewNet->getPositionInformation();
1445 // continue depending of clicked element
1446 if (myViewNet->myObjectsUnderCursor.getJunctionFront()) {
1447 calculateJunctionSelection();
1448 } else if (myViewNet->myObjectsUnderCursor.getEdgeFront()) {
1449 calculateEdgeSelection(myViewNet->myObjectsUnderCursor.getEdgeFront());
1450 }
1451}
1452
1453
1454void
1456 // calculate moveOffset
1457 const GNEMoveOffset moveOffset = calculateMoveOffset();
1458 // check if mouse button is pressed
1459 if (mouseLeftButtonPressed) {
1460 // iterate over all operations
1461 for (const auto& moveOperation : myMoveOperations) {
1462 // move elements
1463 GNEMoveElement::moveElement(myViewNet, moveOperation, moveOffset);
1464 }
1465 } else if (myMoveOperations.size() > 0) {
1466 // begin undo list
1467 myViewNet->getUndoList()->begin(GUIIcon::MODEMOVE, TL("moving selection"));
1468 // iterate over all operations
1469 for (const auto& moveOperation : myMoveOperations) {
1470 // commit move
1471 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1472 // don't forget delete move operation
1473 delete moveOperation;
1474 }
1475 // end undo list
1476 myViewNet->getUndoList()->end();
1477 // clear move operations
1478 myMoveOperations.clear();
1479 }
1480}
1481
1482
1483void
1485 // calculate moveOffset
1486 const GNEMoveOffset moveOffset = calculateMoveOffset();
1487 // begin undo list
1488 myViewNet->getUndoList()->begin(GUIIcon::MODEMOVE, TL("moving selection"));
1489 // finish all move operations
1490 for (const auto& moveOperation : myMoveOperations) {
1491 GNEMoveElement::commitMove(myViewNet, moveOperation, moveOffset, myViewNet->getUndoList());
1492 // don't forget delete move operation
1493 delete moveOperation;
1494 }
1495 // end undo list
1496 myViewNet->getUndoList()->end();
1497 // clear move operations
1498 myMoveOperations.clear();
1499}
1500
1501
1502bool
1504 return (myMoveOperations.size() > 0);
1505}
1506
1507
1508bool
1510 return myMovingSelectedEdge;
1511}
1512
1513
1514void
1518
1519
1520double
1522 return myEdgeOffset;
1523}
1524
1525
1526const GNEMoveOffset
1528 // calculate moveOffset depending of current mouse position and relative clicked position
1529 // @note #3521: Add checkBox to allow moving elements... has to be implemented and used here
1530 Position moveOffset = (myViewNet->getPositionInformation() - myClickedPosition);
1531 // calculate Z depending of moveElevation
1532 if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
1533 // use Y for Z and return X move offset
1534 return GNEMoveOffset(moveOffset.y());
1535 } else {
1536 // return X-Y move offset
1537 return GNEMoveOffset(moveOffset.x(), moveOffset.y());
1538 }
1539}
1540
1541
1542void
1544 // declare move operation
1545 GNEMoveOperation* moveOperation = nullptr;
1546 // first move all selected junctions
1547 const auto selectedJunctions = myViewNet->getNet()->getAttributeCarriers()->getSelectedJunctions();
1548 // iterate over selected junctions
1549 for (const auto& junction : selectedJunctions) {
1550 moveOperation = junction->getMoveOperation();
1551 if (moveOperation) {
1552 myMoveOperations.push_back(moveOperation);
1553 }
1554 }
1555 // now move all selected edges
1556 const auto selectedEdges = myViewNet->getNet()->getAttributeCarriers()->getSelectedEdges();
1557 // iterate over selected edges
1558 for (const auto& edge : selectedEdges) {
1559 moveOperation = edge->getMoveOperation();
1560 if (moveOperation) {
1561 myMoveOperations.push_back(moveOperation);
1562 }
1563 }
1564}
1565
1566
1567void
1569 // first move all selected junctions
1570 const auto selectedJunctions = myViewNet->getNet()->getAttributeCarriers()->getSelectedJunctions();
1571 // iterate over selected junctions
1572 for (const auto& junction : selectedJunctions) {
1573 GNEMoveOperation* moveOperation = junction->getMoveOperation();
1574 if (moveOperation) {
1575 myMoveOperations.push_back(moveOperation);
1576 }
1577 }
1578 // enable moving selected edge flag
1579 myMovingSelectedEdge = true;
1580 // get edge shape
1581 const auto& shape = clickedEdge->getNBEdge()->getGeometry();
1582 // calculate offset based on the clicked edge shape and convex angle
1583 if (clickedEdge->isConvexAngle()) {
1584 myEdgeOffset = shape.nearest_offset_to_point2D(myViewNet->getPositionInformation());
1585 } else {
1586 myEdgeOffset = shape.length2D() - shape.nearest_offset_to_point2D(myViewNet->getPositionInformation());
1587 }
1588 // now move all selected edges
1589 const auto selectedEdges = myViewNet->getNet()->getAttributeCarriers()->getSelectedEdges();
1590 // iterate over edges betwen 0 and 180 degrees
1591 for (const auto& edge : selectedEdges) {
1592 GNEMoveOperation* moveOperation = edge->getMoveOperation();
1593 // continue if move operation is valid
1594 if (moveOperation) {
1595 myMoveOperations.push_back(moveOperation);
1596 }
1597 }
1598}
1599
1600// ---------------------------------------------------------------------------
1601// GNEViewNetHelper::VehicleOptions - methods
1602// ---------------------------------------------------------------------------
1603
1605 myViewNet(viewNet) {
1606}
1607
1608
1609void
1614
1615
1616void
1620
1621// ---------------------------------------------------------------------------
1622// GNEViewNetHelper::VehicleTypeOptions - methods
1623// ---------------------------------------------------------------------------
1624
1628
1629
1630void
1635
1636
1637void
1641
1642// ---------------------------------------------------------------------------
1643// GNEViewNetHelper::SelectingArea - methods
1644// ---------------------------------------------------------------------------
1645
1647 selectingUsingRectangle(false),
1648 startDrawing(false),
1649 myViewNet(viewNet) {
1650}
1651
1652
1653void
1655 selectingUsingRectangle = true;
1656 selectionCorner1 = myViewNet->getPositionInformation();
1657 selectionCorner2 = selectionCorner1;
1658}
1659
1660
1661void
1663 // start drawing
1664 startDrawing = true;
1665 // only update selection corner 2
1666 selectionCorner2 = myViewNet->getPositionInformation();
1667 // update status bar
1668 myViewNet->setStatusBarText(TL("Selection width:") + toString(fabs(selectionCorner1.x() - selectionCorner2.x()))
1669 + TL(" height:") + toString(fabs(selectionCorner1.y() - selectionCorner2.y()))
1670 + TL(" diagonal:") + toString(selectionCorner1.distanceTo2D(selectionCorner2)));
1671}
1672
1673
1674void
1676 // finish rectangle selection
1677 selectingUsingRectangle = false;
1678 startDrawing = false;
1679 // clear status bar
1680 myViewNet->setStatusBarText("");
1681}
1682
1683
1684void
1686 // shift held down on mouse-down and mouse-up and check that rectangle exist
1687 if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1688 (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1689 myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1690 // create boundary between two corners
1691 Boundary rectangleBoundary;
1692 rectangleBoundary.add(selectionCorner1);
1693 rectangleBoundary.add(selectionCorner2);
1694 // process selection within boundary
1695 processBoundarySelection(rectangleBoundary);
1696 }
1697}
1698
1699
1700std::vector<GNEEdge*>
1702 // declare vector for selection
1703 std::vector<GNEEdge*> result;
1704 // shift held down on mouse-down and mouse-up and check that rectangle exist
1705 if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1706 (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1707 myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
1708 // create boundary between two corners
1709 Boundary rectangleBoundary;
1710 rectangleBoundary.add(selectionCorner1);
1711 rectangleBoundary.add(selectionCorner2);
1712 if (myViewNet->makeCurrent()) {
1713 // obtain all ACs in Rectangle BOundary
1714 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(rectangleBoundary);
1715 // Filter ACs in Boundary and get only edges
1716 for (const auto& AC : ACsInBoundary) {
1717 if (AC.second->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1718 result.push_back(dynamic_cast<GNEEdge*>(AC.second));
1719 }
1720 }
1721 myViewNet->makeNonCurrent();
1722 }
1723 }
1724 return result;
1725}
1726
1727
1728void
1730 processBoundarySelection(shape.getBoxBoundary());
1731}
1732
1733
1734void
1736 if (selectingUsingRectangle) {
1738 glTranslated(0, 0, GLO_RECTANGLESELECTION);
1739 GLHelper::setColor(color);
1740 glLineWidth(2);
1741 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1742 glBegin(GL_QUADS);
1743 glVertex2d(selectionCorner1.x(), selectionCorner1.y());
1744 glVertex2d(selectionCorner1.x(), selectionCorner2.y());
1745 glVertex2d(selectionCorner2.x(), selectionCorner2.y());
1746 glVertex2d(selectionCorner2.x(), selectionCorner1.y());
1747 glEnd();
1749 }
1750}
1751
1752
1753void
1755 if (myViewNet->makeCurrent()) {
1756 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(boundary);
1757 // filter ACsInBoundary depending of current supermode
1758 std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundaryFiltered;
1759 for (const auto& AC : ACsInBoundary) {
1760 if (myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
1761 if (AC.second->getTagProperty().isNetworkElement() || AC.second->getTagProperty().isAdditionalElement()) {
1762 ACsInBoundaryFiltered.insert(AC);
1763 }
1764 } else if (myViewNet->myEditModes.isCurrentSupermodeDemand() && AC.second->getTagProperty().isDemandElement()) {
1765 ACsInBoundaryFiltered.insert(AC);
1766 } else if (myViewNet->myEditModes.isCurrentSupermodeData() && AC.second->getTagProperty().isGenericData()) {
1767 ACsInBoundaryFiltered.insert(AC);
1768 }
1769 }
1770 // declare two sets of attribute carriers, one for select and another for unselect
1771 std::vector<GNEAttributeCarrier*> ACToSelect;
1772 std::vector<GNEAttributeCarrier*> ACToUnselect;
1773 // reserve memory (we assume that in the worst case we're going to insert all elements of ACsInBoundaryFiltered
1774 ACToSelect.reserve(ACsInBoundaryFiltered.size());
1775 ACToUnselect.reserve(ACsInBoundaryFiltered.size());
1776 // in restrict AND replace mode all current selected attribute carriers will be unselected
1777 if ((myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::RESTRICT) ||
1778 (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::REPLACE)) {
1779 // obtain selected ACs depending of current supermode
1780 const auto selectedAC = myViewNet->getNet()->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1781 // add id into ACs to unselect
1782 for (const auto& AC : selectedAC) {
1783 ACToUnselect.push_back(AC);
1784 }
1785 }
1786 // iterate over AttributeCarriers obtained of boundary an place it in ACToSelect or ACToUnselect
1787 for (const auto& AC : ACsInBoundaryFiltered) {
1788 switch (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode()) {
1790 ACToUnselect.push_back(AC.second);
1791 break;
1793 if (std::find(ACToUnselect.begin(), ACToUnselect.end(), AC.second) != ACToUnselect.end()) {
1794 ACToSelect.push_back(AC.second);
1795 }
1796 break;
1797 default:
1798 ACToSelect.push_back(AC.second);
1799 break;
1800 }
1801 }
1802 // select junctions and their connections and crossings if Auto select junctions is enabled (note: only for "add mode")
1803 if (myViewNet->autoSelectNodes() && (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode() == GNESelectorFrame::ModificationMode::Operation::ADD)) {
1804 std::vector<GNEEdge*> edgesToSelect;
1805 // iterate over ACToSelect and extract edges
1806 for (const auto& AC : ACToSelect) {
1807 if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1808 edgesToSelect.push_back(dynamic_cast<GNEEdge*>(AC));
1809 }
1810 }
1811 // iterate over extracted edges
1812 for (const auto& edge : edgesToSelect) {
1813 // select junction source and all their connections and crossings
1814 ACToSelect.push_back(edge->getFromJunction());
1815 for (const auto& connection : edge->getFromJunction()->getGNEConnections()) {
1816 ACToSelect.push_back(connection);
1817 }
1818 for (const auto& crossing : edge->getFromJunction()->getGNECrossings()) {
1819 ACToSelect.push_back(crossing);
1820 }
1821 // select junction destiny and all their connections crossings
1822 ACToSelect.push_back(edge->getToJunction());
1823 for (const auto& connection : edge->getToJunction()->getGNEConnections()) {
1824 ACToSelect.push_back(connection);
1825 }
1826 for (const auto& crossing : edge->getToJunction()->getGNECrossings()) {
1827 ACToSelect.push_back(crossing);
1828 }
1829 }
1830 }
1831 // only continue if there is ACs to select or unselect
1832 if ((ACToSelect.size() + ACToUnselect.size()) > 0) {
1833 // first unselect AC of ACToUnselect and then selects AC of ACToSelect
1834 myViewNet->myUndoList->begin(GUIIcon::MODESELECT, TL("selection using rectangle"));
1835 for (const auto& AC : ACToUnselect) {
1836 AC->setAttribute(GNE_ATTR_SELECTED, "0", myViewNet->myUndoList);
1837 }
1838 for (const auto& AC : ACToSelect) {
1839 if (AC->getTagProperty().isSelectable()) {
1840 AC->setAttribute(GNE_ATTR_SELECTED, "1", myViewNet->myUndoList);
1841 }
1842 }
1843 myViewNet->myUndoList->end();
1844 }
1845 myViewNet->makeNonCurrent();
1846 }
1847}
1848
1849// ---------------------------------------------------------------------------
1850// GNEViewNetHelper::TestingMode - methods
1851// ---------------------------------------------------------------------------
1852
1854 myViewNet(viewNet) {
1855}
1856
1857
1858void
1860 // first check if testing mode is enabled and window size is correct
1861 if (OptionsCont::getOptions().getBool("gui-testing") && OptionsCont::getOptions().isSet("window-size")) {
1862 std::vector<std::string> windowSize = OptionsCont::getOptions().getStringVector("window-size");
1863 // make sure that given windows size has exactly two valid int values
1864 if ((windowSize.size() == 2) && GNEAttributeCarrier::canParse<int>(windowSize[0]) && GNEAttributeCarrier::canParse<int>(windowSize[1])) {
1865 myTestingWidth = GNEAttributeCarrier::parse<int>(windowSize[0]);
1866 myTestingHeight = GNEAttributeCarrier::parse<int>(windowSize[1]);
1867 } else {
1868 WRITE_ERRORF(TL("Invalid windows size-format: %for option 'window-size'"), toString(windowSize));
1869 }
1870 }
1871}
1872
1873
1874void
1876 // first check if testing mode is enabled
1877 if (OptionsCont::getOptions().getBool("gui-testing")) {
1878 // check if main windows has to be resized
1879 if (myTestingWidth > 0) {
1880 mainWindow->resize(myTestingWidth, myTestingHeight);
1881 }
1882 //std::cout << " fixed: view=" << getWidth() << ", " << getHeight() << " app=" << mainWindow->getWidth() << ", " << mainWindow->getHeight() << "\n";
1883 // draw pink square in the upper left corner on top of everything
1884 const double size = myViewNet->p2m(32);
1885 Position center = myViewNet->screenPos2NetPos(8, 8);
1886 // magenta
1889 glTranslated(center.x(), center.y(), GLO_TESTELEMENT);
1890 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1891 glBegin(GL_QUADS);
1892 glVertex2d(0, 0);
1893 glVertex2d(0, -size);
1894 glVertex2d(size, -size);
1895 glVertex2d(size, 0);
1896 glEnd();
1898 // blue
1901 glTranslated(center.x(), center.y(), GLO_TESTELEMENT + 1);
1902 glScaled(0.7, 0.7, 0);
1903 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1904 glBegin(GL_QUADS);
1905 glVertex2d(0, 0);
1906 glVertex2d(0, -size);
1907 glVertex2d(size, -size);
1908 glVertex2d(size, 0);
1909 glEnd();
1911 // yellow
1914 glTranslated(center.x(), center.y(), GLO_TESTELEMENT + 2);
1915 glScaled(0.4, 0.4, 0);
1916 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1917 glBegin(GL_QUADS);
1918 glVertex2d(0, 0);
1919 glVertex2d(0, -size);
1920 glVertex2d(size, -size);
1921 glVertex2d(size, 0);
1922 glEnd();
1924 }
1925}
1926
1927// ---------------------------------------------------------------------------
1928// GNEViewNetHelper::SaveElements - methods
1929// ---------------------------------------------------------------------------
1930
1932 myViewNet(viewNet) {
1933}
1934
1935
1937 delete mySaveIndividualFilesPopup;
1938}
1939
1940
1941void
1943 // create save sumo config button
1944 mySaveNeteditConfig = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1945 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1946 std::string("\t") + TL("Save NETEDITConfig") + std::string("\t") + TL("Save NETEDITConfig. (Ctrl+Shift+E)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_NETEDITCONFIG),
1947 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_E_SAVENETEDITCONFIG, GUIDesignButtonToolbar);
1948 mySaveNeteditConfig->create();
1949 // create save sumo config button
1950 mySaveSumoConfig = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1951 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1952 std::string("\t") + TL("Save SumoConfig") + std::string("\t") + TL("Save SumoConfig. (Ctrl+Shift+S)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_SUMOCONFIG),
1953 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_S_SAVESUMOCONFIG, GUIDesignButtonToolbar);
1954 mySaveSumoConfig->create();
1955 // create save network button
1956 mySaveNetwork = new MFXButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1957 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1958 std::string("\t") + TL("Save network") + std::string("\t") + TL("Save network. (Ctrl+S)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_NETWORKELEMENTS),
1959 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK, GUIDesignButtonToolbar);
1960 mySaveNetwork->create();
1961 // create popup for save individual files
1962 mySaveIndividualFilesPopup = new FXPopup(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements, POPUP_VERTICAL);
1963 mySaveIndividualFilesPopup->create();
1964 // create save individual files button
1965 mySaveIndividualFiles = new MFXMenuButtonTooltip(myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements,
1966 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(), std::string("\t") + TL("Save individual files") + std::string("\t") + TL("Save individual files."),
1967 GUIIconSubSys::getIcon(GUIIcon::SAVE_MULTIPLE), mySaveIndividualFilesPopup, nullptr, GUIDesignButtonToolbarLocator);
1968 mySaveIndividualFiles->create();
1969 // create save additional elements button
1970 mySaveAdditionalElements = new MFXButtonTooltip(mySaveIndividualFilesPopup,
1971 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1972 std::string("\t") + TL("Save additional elements") + std::string("\t") + TL("Save additional elements. (Ctrl+Shift+A)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_ADDITIONALELEMENTS),
1973 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALS, GUIDesignButtonPopup);
1974 mySaveAdditionalElements->create();
1975 // create save demand elements button
1976 mySaveDemandElements = new MFXButtonTooltip(mySaveIndividualFilesPopup,
1977 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1978 std::string("\t") + TL("Save demand elements") + std::string("\t") + TL("Save demand elements. (Ctrl+Shift+D)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_DEMANDELEMENTS),
1979 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS, GUIDesignButtonPopup);
1980 mySaveDemandElements->create();
1981 // create save data elements button
1982 mySaveDataElements = new MFXButtonTooltip(mySaveIndividualFilesPopup,
1983 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1984 std::string("\t") + TL("Save data elements") + std::string("\t") + TL("Save data elements. (Ctrl+Shift+B)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_DATAELEMENTS),
1985 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS, GUIDesignButtonPopup);
1986 mySaveDataElements->create();
1987 // create save mean datas elements button
1988 mySaveMeanDataElements = new MFXButtonTooltip(mySaveIndividualFilesPopup,
1989 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
1990 std::string("\t") + TL("Save mean data elements") + std::string("\t") + TL("Save mean data elements. (Ctrl+Shift+M)"), GUIIconSubSys::getIcon(GUIIcon::SAVE_MEANDATAELEMENTS),
1991 myViewNet->getViewParent()->getGNEAppWindows(), MID_HOTKEY_CTRL_SHIFT_M_SAVEMEANDATAS, GUIDesignButtonPopup);
1992 mySaveMeanDataElements->create();
1993 // recalc menu bar because there is new elements
1994 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements->recalc();
1995 // show menu bar modes
1996 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().saveElements->show();
1997}
1998
1999
2000void
2002 if (value) {
2003 mySaveIndividualFiles->enable();
2004 } else {
2005 mySaveIndividualFiles->disable();
2006 }
2007}
2008
2009// ---------------------------------------------------------------------------
2010// GNEViewNetHelper::EditModes - methods
2011// ---------------------------------------------------------------------------
2012
2014 currentSupermode(Supermode::NETWORK),
2015 networkEditMode(NetworkEditMode::NETWORK_INSPECT),
2016 demandEditMode(DemandEditMode::DEMAND_INSPECT),
2017 dataEditMode(DataEditMode::DATA_INSPECT),
2018 networkButton(nullptr),
2019 demandButton(nullptr),
2020 dataButton(nullptr),
2021 myViewNet(viewNet) {
2022 auto& neteditOptions = OptionsCont::getOptions();
2023 // if new option is enabled, start in create edge mode
2024 if (neteditOptions.getBool("new")) {
2026 neteditOptions.resetWritable();
2027 neteditOptions.set("new", "false");
2028 }
2029}
2030
2031
2032void
2034 // create network button
2035 networkButton = new MFXCheckableButton(false,
2036 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
2037 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2038 TL("Network") + std::string("\t") + TL("Edit network elements") + std::string("\t") + TL("Set mode for edit network elements. (F2)"),
2040 networkButton->create();
2041 // create demand button
2042 demandButton = new MFXCheckableButton(false,
2043 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
2044 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2045 TL("Demand") + std::string("\t") + TL("Edit traffic demand elements") + std::string("\t") + TL("Set mode for edit traffic demand. (F3)"),
2047 demandButton->create();
2048 // create data button
2049 dataButton = new MFXCheckableButton(false,
2050 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes,
2051 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2052 TL("Data") + std::string("\t") + TL("Edit data elements") + std::string("\t") + TL("Set mode for edit data demand. (F4)"),
2054 dataButton->create();
2055 // recalc menu bar because there is new elements
2056 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2057 // show menu bar modes
2058 myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->show();
2059}
2060
2061
2062void
2064 if (!force && (supermode == currentSupermode)) {
2065 myViewNet->setStatusBarText(TL("Mode already selected"));
2066 if (myViewNet->myCurrentFrame != nullptr) {
2067 myViewNet->myCurrentFrame->focusUpperElement();
2068 }
2069 } else {
2070 myViewNet->setStatusBarText("");
2071 // abort current operation
2072 myViewNet->abortOperation(false);
2073 // set super mode
2074 currentSupermode = supermode;
2075 // set supermodes
2076 if (supermode == Supermode::NETWORK) {
2077 // change buttons
2078 networkButton->setChecked(true);
2079 demandButton->setChecked(false);
2080 dataButton->setChecked(false);
2081 // show network buttons
2082 myViewNet->myNetworkCheckableButtons.showNetworkCheckableButtons();
2083 // hide demand buttons
2084 myViewNet->myDemandCheckableButtons.hideDemandCheckableButtons();
2085 // hide data buttons
2086 myViewNet->myDataCheckableButtons.hideDataCheckableButtons();
2087 // force update network mode
2088 setNetworkEditMode(networkEditMode, true);
2089 } else if (supermode == Supermode::DEMAND) {
2090 // change buttons
2091 networkButton->setChecked(false);
2092 demandButton->setChecked(true);
2093 dataButton->setChecked(false);
2094 // hide network buttons
2095 myViewNet->myNetworkCheckableButtons.hideNetworkCheckableButtons();
2096 // show demand buttons
2097 myViewNet->myDemandCheckableButtons.showDemandCheckableButtons();
2098 // hide data buttons
2099 myViewNet->myDataCheckableButtons.hideDataCheckableButtons();
2100 // force update demand mode
2101 setDemandEditMode(demandEditMode, true);
2102 // demand modes require ALWAYS a recomputing
2103 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2104 // check if update path calculator
2105 if (!myViewNet->myNet->getPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2106 // update DijkstraRouter of RouteCalculatorInstance
2107 myViewNet->myNet->getPathManager()->getPathCalculator()->updatePathCalculator();
2108 // compute all demand elements
2109 myViewNet->myNet->computeDemandElements(myViewNet->myViewParent->getGNEAppWindows());
2110 }
2111 } else if (supermode == Supermode::DATA) {
2112 // change buttons
2113 networkButton->setChecked(false);
2114 demandButton->setChecked(false);
2115 dataButton->setChecked(true);
2116 // hide network buttons
2117 myViewNet->myNetworkCheckableButtons.hideNetworkCheckableButtons();
2118 // hide demand buttons
2119 myViewNet->myDemandCheckableButtons.hideDemandCheckableButtons();
2120 // show data buttons
2121 myViewNet->myDataCheckableButtons.showDataCheckableButtons();
2122 // force update data mode
2123 setDataEditMode(dataEditMode, true);
2124 // check if recompute
2125 if (myViewNet->getViewParent()->getGNEAppWindows()->getProcessingMenuCommands().menuCheckRecomputeDataMode->getCheck() == TRUE) {
2126 // demand modes require ALWAYS a recomputing
2127 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2128 }
2129 // check if update path calculator
2130 if (!myViewNet->myNet->getPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2131 // update DijkstraRouter of RouteCalculatorInstance
2132 myViewNet->myNet->getPathManager()->getPathCalculator()->updatePathCalculator();
2133 // compute all demand elements
2134 myViewNet->myNet->computeDemandElements(myViewNet->myViewParent->getGNEAppWindows());
2135 }
2136 }
2137 // update buttons
2138 networkButton->update();
2139 demandButton->update();
2140 dataButton->update();
2141 // update Supermode CommandButtons in GNEAppWindows
2142 myViewNet->myViewParent->getGNEAppWindows()->updateSuperModeMenuCommands(currentSupermode);
2143 }
2144}
2145
2146
2147void
2149 if ((mode == networkEditMode) && !force) {
2150 myViewNet->setStatusBarText(TL("Network mode already selected"));
2151 if (myViewNet->myCurrentFrame != nullptr) {
2152 myViewNet->myCurrentFrame->focusUpperElement();
2153 }
2154 } else if (networkEditMode == NetworkEditMode::NETWORK_TLS && !myViewNet->myViewParent->getTLSEditorFrame()->isTLSSaved()) {
2155 myViewNet->setStatusBarText(TL("Save modifications in TLS before change mode"));
2156 myViewNet->myCurrentFrame->focusUpperElement();
2157 } else {
2158 myViewNet->setStatusBarText("");
2159 myViewNet->abortOperation(false);
2160 // stop editing of custom shapes
2161 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2162 // set new Network mode
2163 networkEditMode = mode;
2164 // for common modes (Inspect/Delete/Select/move) change also the other supermode
2165 if (networkEditMode == NetworkEditMode::NETWORK_INSPECT) {
2166 demandEditMode = DemandEditMode::DEMAND_INSPECT;
2167 dataEditMode = DataEditMode::DATA_INSPECT;
2168 } else if (networkEditMode == NetworkEditMode::NETWORK_DELETE) {
2169 demandEditMode = DemandEditMode::DEMAND_DELETE;
2170 dataEditMode = DataEditMode::DATA_DELETE;
2171 } else if (networkEditMode == NetworkEditMode::NETWORK_SELECT) {
2172 demandEditMode = DemandEditMode::DEMAND_SELECT;
2173 dataEditMode = DataEditMode::DATA_SELECT;
2174 } else if (networkEditMode == NetworkEditMode::NETWORK_MOVE) {
2175 demandEditMode = DemandEditMode::DEMAND_MOVE;
2176 }
2177 // certain modes require a recomputing
2178 switch (mode) {
2183 // modes which depend on computed data
2184 myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
2185 break;
2186 default:
2187 break;
2188 }
2189 // update cursors
2190 myViewNet->updateCursor();
2191 // update network mode specific controls
2192 myViewNet->updateNetworkModeSpecificControls();
2193 }
2194}
2195
2196
2197void
2199 if ((mode == demandEditMode) && !force) {
2200 myViewNet->setStatusBarText(TL("Demand mode already selected"));
2201 if (myViewNet->myCurrentFrame != nullptr) {
2202 myViewNet->myCurrentFrame->focusUpperElement();
2203 }
2204 } else {
2205 myViewNet->setStatusBarText("");
2206 myViewNet->abortOperation(false);
2207 // stop editing of custom shapes
2208 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2209 // set new Demand mode
2210 demandEditMode = mode;
2211 // for common modes (Inspect/Delete/Select/Move) change also the other supermode
2212 if (demandEditMode == DemandEditMode::DEMAND_INSPECT) {
2213 networkEditMode = NetworkEditMode::NETWORK_INSPECT;
2214 dataEditMode = DataEditMode::DATA_INSPECT;
2215 } else if (demandEditMode == DemandEditMode::DEMAND_DELETE) {
2216 networkEditMode = NetworkEditMode::NETWORK_DELETE;
2217 dataEditMode = DataEditMode::DATA_DELETE;
2218 } else if (demandEditMode == DemandEditMode::DEMAND_SELECT) {
2219 networkEditMode = NetworkEditMode::NETWORK_SELECT;
2220 dataEditMode = DataEditMode::DATA_SELECT;
2221 } else if (demandEditMode == DemandEditMode::DEMAND_MOVE) {
2222 networkEditMode = NetworkEditMode::NETWORK_MOVE;
2223 }
2224 // update cursors
2225 myViewNet->updateCursor();
2226 // update network mode specific controls
2227 myViewNet->updateDemandModeSpecificControls();
2228 }
2229}
2230
2231
2232void
2234 if ((mode == dataEditMode) && !force) {
2235 myViewNet->setStatusBarText(TL("Data mode already selected"));
2236 if (myViewNet->myCurrentFrame != nullptr) {
2237 myViewNet->myCurrentFrame->focusUpperElement();
2238 }
2239 } else {
2240 myViewNet->setStatusBarText("");
2241 myViewNet->abortOperation(false);
2242 // stop editing of custom shapes
2243 myViewNet->myEditNetworkElementShapes.stopEditCustomShape();
2244 // set new Data mode
2245 dataEditMode = mode;
2246 // for common modes (Inspect/Delete/Select/Move) change also the other supermode
2247 if (dataEditMode == DataEditMode::DATA_INSPECT) {
2248 networkEditMode = NetworkEditMode::NETWORK_INSPECT;
2249 demandEditMode = DemandEditMode::DEMAND_INSPECT;
2250 } else if (dataEditMode == DataEditMode::DATA_DELETE) {
2251 networkEditMode = NetworkEditMode::NETWORK_DELETE;
2252 demandEditMode = DemandEditMode::DEMAND_DELETE;
2253 } else if (dataEditMode == DataEditMode::DATA_SELECT) {
2254 networkEditMode = NetworkEditMode::NETWORK_SELECT;
2255 demandEditMode = DemandEditMode::DEMAND_SELECT;
2256 }
2257 // update all datasets
2258 for (const auto& dataSet : myViewNet->getNet()->getAttributeCarriers()->getDataSets()) {
2259 dataSet->updateAttributeColors();
2260 }
2261 // update cursors
2262 myViewNet->updateCursor();
2263 // update network mode specific controls
2264 myViewNet->updateDataModeSpecificControls();
2265 }
2266}
2267
2268
2269bool
2271 return (currentSupermode == Supermode::NETWORK);
2272}
2273
2274
2275bool
2277 return (currentSupermode == Supermode::DEMAND);
2278}
2279
2280
2281bool
2283 return (currentSupermode == Supermode::DATA);
2284}
2285
2286// ---------------------------------------------------------------------------
2287// GNEViewNetHelper::NetworkViewOptions - methods
2288// ---------------------------------------------------------------------------
2289
2291 menuCheckToggleGrid(nullptr),
2292 menuCheckToggleDrawJunctionShape(nullptr),
2293 menuCheckDrawSpreadVehicles(nullptr),
2294 menuCheckShowDemandElements(nullptr),
2295 menuCheckSelectEdges(nullptr),
2296 menuCheckShowConnections(nullptr),
2297 menuCheckHideConnections(nullptr),
2298 menuCheckShowAdditionalSubElements(nullptr),
2299 menuCheckShowTAZElements(nullptr),
2300 menuCheckExtendSelection(nullptr),
2301 menuCheckChangeAllPhases(nullptr),
2302 menuCheckWarnAboutMerge(nullptr),
2303 menuCheckShowJunctionBubble(nullptr),
2304 menuCheckMoveElevation(nullptr),
2305 menuCheckChainEdges(nullptr),
2306 menuCheckAutoOppositeEdge(nullptr),
2307 myViewNet(viewNet) {
2308}
2309
2310
2311void
2313 // create menu checks
2314 menuCheckToggleGrid = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2315 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2316 (std::string("\t") + TL("Show grid") + std::string("\t") + TL("Show grid and restrict movement to the grid - define grid size in visualization options. (Ctrl+G)")),
2319 menuCheckToggleGrid->setChecked(false);
2320 menuCheckToggleGrid->create();
2321
2322 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2323 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2324 (std::string("\t") + TL("Hide junction shape") + std::string("\t") + TL("Toggle hiding junction shape. (Ctrl+J)")),
2327 menuCheckToggleDrawJunctionShape->setChecked(false);
2328 menuCheckToggleDrawJunctionShape->create();
2329
2330 menuCheckDrawSpreadVehicles = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2331 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2332 (std::string("\t") + TL("Draw vehicles spread in lane or depart position") + std::string("\t") + TL("Draw vehicles spread in lane or in depart position.")),
2335 menuCheckDrawSpreadVehicles->setChecked(false);
2336 menuCheckDrawSpreadVehicles->create();
2337
2338 menuCheckShowDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2339 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2340 (std::string("\t") + TL("Show demand elements") + std::string("\t") + TL("Toggle show demand elements.")),
2343 menuCheckShowDemandElements->setChecked(false);
2344 menuCheckShowDemandElements->create();
2345
2346 menuCheckSelectEdges = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2347 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2348 (std::string("\t") + TL("Clicks target lanes") + std::string("\t") + TL("Toggle whether clicking should inspect/select/delete lanes instead of edges.")),
2351 menuCheckSelectEdges->create();
2352
2353 menuCheckShowConnections = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2354 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2355 (std::string("\t") + TL("Show connections over junctions") + std::string("\t") + TL("Toggle show connections over junctions.")),
2358 menuCheckShowConnections->setChecked(myViewNet->getVisualisationSettings().showLane2Lane);
2359 menuCheckShowConnections->create();
2360
2361 menuCheckHideConnections = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2362 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2363 (std::string("\t") + TL("Hide connections") + std::string("\t") + TL("Toggle hide connections.")),
2366 menuCheckHideConnections->setChecked(false);
2367 menuCheckHideConnections->create();
2368
2369 menuCheckShowAdditionalSubElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2370 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2371 (std::string("\t") + TL("Show additional sub-elements") + std::string("\t") + TL("Toggle show additional sub-elements.")),
2374 menuCheckShowAdditionalSubElements->setChecked(false);
2375 menuCheckShowAdditionalSubElements->create();
2376
2377 menuCheckShowTAZElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2378 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2379 (std::string("\t") + TL("Show TAZ elements") + std::string("\t") + TL("Toggle show TAZ elements.")),
2382 menuCheckShowTAZElements->setChecked(false);
2383 menuCheckShowTAZElements->create();
2384
2385 menuCheckExtendSelection = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2386 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2387 (std::string("\t") + TL("Automatic select junctions") + std::string("\t") + TL("Toggle whether selecting multiple edges should automatically select their junctions.")),
2390 menuCheckExtendSelection->setChecked(true);
2391 menuCheckExtendSelection->create();
2392
2393 menuCheckChangeAllPhases = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2394 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2395 (std::string("\t") + TL("Apply state to all phases") + std::string("\t") + TL("Toggle whether clicking should apply state changes to all phases of the current TLS plan.")),
2398 menuCheckChangeAllPhases->setChecked(false);
2399 menuCheckChangeAllPhases->create();
2400
2401 menuCheckWarnAboutMerge = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2402 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2403 (std::string("\t") + TL("Automatic merging junction") + std::string("\t") + TL("Toggle ask for confirmation before merging junction.")),
2406 menuCheckWarnAboutMerge->create();
2407
2408 menuCheckShowJunctionBubble = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2409 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2410 (std::string("\t") + TL("Show bubbles") + std::string("\t") + TL("Toggle show bubbles over junctions shapes.")),
2413 menuCheckShowJunctionBubble->setChecked(false);
2414 menuCheckShowJunctionBubble->create();
2415
2416 menuCheckMoveElevation = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2417 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2418 (std::string("\t") + TL("Move elevation") + std::string("\t") + TL("Apply mouse movement to elevation instead of x,y position.")),
2421 menuCheckMoveElevation->setChecked(false);
2422 menuCheckMoveElevation->create();
2423
2424 menuCheckChainEdges = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2425 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2426 (std::string("\t") + TL("Edge chain mode") + std::string("\t") + TL("Create consecutive edges with a single click (hit ESC to cancel chain).")),
2429 menuCheckChainEdges->setChecked(false);
2430 menuCheckChainEdges->create();
2431
2432 menuCheckAutoOppositeEdge = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2433 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2434 (std::string("\t") + TL("Edge opposite direction") + std::string("\t") + TL("Automatically create an edge in the opposite direction.")),
2437 menuCheckAutoOppositeEdge->setChecked(false);
2438 menuCheckAutoOppositeEdge->create();
2439
2440 // always recalc after creating new elements
2441 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2442}
2443
2444
2445void
2447 menuCheckToggleGrid->hide();
2448 menuCheckToggleDrawJunctionShape->hide();
2449 menuCheckDrawSpreadVehicles->hide();
2450 menuCheckShowDemandElements->hide();
2451 menuCheckSelectEdges->hide();
2452 menuCheckShowConnections->hide();
2453 menuCheckHideConnections->hide();
2454 menuCheckShowAdditionalSubElements->hide();
2455 menuCheckShowTAZElements->hide();
2456 menuCheckExtendSelection->hide();
2457 menuCheckChangeAllPhases->hide();
2458 menuCheckWarnAboutMerge->hide();
2459 menuCheckShowJunctionBubble->hide();
2460 menuCheckMoveElevation->hide();
2461 menuCheckChainEdges->hide();
2462 menuCheckAutoOppositeEdge->hide();
2463 // Also hide toolbar grip
2464 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2465}
2466
2467
2468void
2469GNEViewNetHelper::NetworkViewOptions::getVisibleNetworkMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2470 // save visible menu commands in commands vector
2471 if (menuCheckToggleGrid->shown()) {
2472 commands.push_back(menuCheckToggleGrid);
2473 }
2474 if (menuCheckToggleDrawJunctionShape->shown()) {
2475 commands.push_back(menuCheckToggleDrawJunctionShape);
2476 }
2477 if (menuCheckDrawSpreadVehicles->shown()) {
2478 commands.push_back(menuCheckDrawSpreadVehicles);
2479 }
2480 if (menuCheckShowDemandElements->shown()) {
2481 commands.push_back(menuCheckShowDemandElements);
2482 }
2483 if (menuCheckSelectEdges->shown()) {
2484 commands.push_back(menuCheckSelectEdges);
2485 }
2486 if (menuCheckShowConnections->shown()) {
2487 commands.push_back(menuCheckShowConnections);
2488 }
2489 if (menuCheckHideConnections->shown()) {
2490 commands.push_back(menuCheckHideConnections);
2491 }
2492 if (menuCheckShowAdditionalSubElements->shown()) {
2493 commands.push_back(menuCheckShowAdditionalSubElements);
2494 }
2495 if (menuCheckShowTAZElements->shown()) {
2496 commands.push_back(menuCheckShowTAZElements);
2497 }
2498 if (menuCheckExtendSelection->shown()) {
2499 commands.push_back(menuCheckExtendSelection);
2500 }
2501 if (menuCheckChangeAllPhases->shown()) {
2502 commands.push_back(menuCheckChangeAllPhases);
2503 }
2504 if (menuCheckWarnAboutMerge->shown()) {
2505 commands.push_back(menuCheckWarnAboutMerge);
2506 }
2507 if (menuCheckShowJunctionBubble->shown()) {
2508 commands.push_back(menuCheckShowJunctionBubble);
2509 }
2510 if (menuCheckMoveElevation->shown()) {
2511 commands.push_back(menuCheckMoveElevation);
2512 }
2513 if (menuCheckChainEdges->shown()) {
2514 commands.push_back(menuCheckChainEdges);
2515 }
2516 if (menuCheckAutoOppositeEdge->shown()) {
2517 commands.push_back(menuCheckAutoOppositeEdge);
2518 }
2519}
2520
2521
2522bool
2524 return (menuCheckDrawSpreadVehicles->amChecked() == TRUE);
2525}
2526
2527
2528bool
2530 if (menuCheckShowDemandElements->shown()) {
2531 return (menuCheckShowDemandElements->amChecked() == TRUE);
2532 } else {
2533 // by default, if menuCheckShowDemandElements isn't shown, always show demand elements
2534 return true;
2535 }
2536}
2537
2538
2539bool
2541 if (menuCheckSelectEdges->shown()) {
2542 return (menuCheckSelectEdges->amChecked() != TRUE);
2543 } else {
2544 // by default, if menuCheckSelectEdges isn't shown, always select edges
2545 return true;
2546 }
2547}
2548
2549
2550bool
2552 if (myViewNet->myEditModes.isCurrentSupermodeData()) {
2553 return false;
2554 } else if (myViewNet->myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
2555 // check if menu check hide connections ins shown
2556 return (menuCheckHideConnections->amChecked() == FALSE);
2557 } else if (myViewNet->myEditModes.networkEditMode == NetworkEditMode::NETWORK_PROHIBITION) {
2558 return true;
2559 } else if (myViewNet->myEditModes.isCurrentSupermodeNetwork() && menuCheckShowConnections->shown() == false) {
2560 return false;
2561 } else {
2562 return (myViewNet->getVisualisationSettings().showLane2Lane);
2563 }
2564}
2565
2566
2567bool
2569 if (!myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
2570 return false;
2571 } else if (menuCheckShowAdditionalSubElements->shown() == false) {
2572 return false;
2573 } else {
2574 return menuCheckShowAdditionalSubElements->amChecked();
2575 }
2576}
2577
2578
2579bool
2581 if (!myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
2582 return false;
2583 } else if (menuCheckShowTAZElements->shown() == false) {
2584 return false;
2585 } else {
2586 return menuCheckShowTAZElements->amChecked();
2587 }
2588}
2589
2590
2591bool
2593 if (menuCheckMoveElevation->shown()) {
2594 return (menuCheckMoveElevation->amChecked() == TRUE);
2595 } else {
2596 return false;
2597 }
2598}
2599
2600// ---------------------------------------------------------------------------
2601// GNEViewNetHelper::DemandViewOptions - methods
2602// ---------------------------------------------------------------------------
2603
2605 menuCheckToggleGrid(nullptr),
2606 menuCheckToggleDrawJunctionShape(nullptr),
2607 menuCheckDrawSpreadVehicles(nullptr),
2608 menuCheckHideShapes(nullptr),
2609 menuCheckShowAllTrips(nullptr),
2610 menuCheckShowAllPersonPlans(nullptr),
2611 menuCheckLockPerson(nullptr),
2612 menuCheckShowAllContainerPlans(nullptr),
2613 menuCheckLockContainer(nullptr),
2614 menuCheckHideNonInspectedDemandElements(nullptr),
2615 menuCheckShowOverlappedRoutes(nullptr),
2616 myViewNet(viewNet),
2617 myLockedPerson(nullptr),
2618 myLockedContainer(nullptr) {
2619}
2620
2621
2622void
2624 // create menu checks
2625 menuCheckToggleGrid = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2626 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2627 (std::string("\t") + TL("Show grid") + std::string("\t") + TL("Show grid and restrict movement to the grid - define grid size in visualization options. (Ctrl+G)")),
2630 menuCheckToggleGrid->setChecked(false);
2631 menuCheckToggleGrid->create();
2632
2633 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2634 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2635 (std::string("\t") + TL("Hide junction shape") + std::string("\t") + TL("Toggle hiding junction shape. (Ctrl+J)")),
2638 menuCheckToggleDrawJunctionShape->setChecked(false);
2639 menuCheckToggleDrawJunctionShape->create();
2640
2641 menuCheckDrawSpreadVehicles = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2642 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2643 (std::string("\t") + TL("Draw vehicles spread/depart position") + std::string("\t") + TL("Draw vehicles spread in lane or in depart position.")),
2646 menuCheckDrawSpreadVehicles->setChecked(false);
2647 menuCheckDrawSpreadVehicles->create();
2648
2649 menuCheckHideShapes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2650 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2651 (std::string("\t") + TL("Show shapes") + std::string("\t") + TL("Toggle show shapes (Polygons and POIs).")),
2654 menuCheckHideShapes->setChecked(false);
2655 menuCheckHideShapes->create();
2656
2657 menuCheckShowAllTrips = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2658 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2659 (std::string("\t") + TL("Show all trips") + std::string("\t") + TL("Toggle show all trips (requires updated demand - F5).")),
2662 menuCheckShowAllTrips->setChecked(false);
2663 menuCheckShowAllTrips->create();
2664
2665 menuCheckShowAllPersonPlans = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2666 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2667 (std::string("\t") + TL("Show all person plans") + std::string("\t") + TL("Toggle show all person plans.")),
2670 menuCheckShowAllPersonPlans->setChecked(false);
2671 menuCheckShowAllPersonPlans->create();
2672
2673 menuCheckLockPerson = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2674 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2675 (std::string("\t") + TL("Lock selected person") + std::string("\t") + TL("Toggle lock selected person.")),
2678 menuCheckLockPerson->setChecked(false);
2679 menuCheckLockPerson->create();
2680
2681 menuCheckShowAllContainerPlans = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2682 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2683 (std::string("\t") + TL("Show all containers plans") + std::string("\t") + TL("Toggle show all container plans.")),
2686 menuCheckShowAllContainerPlans->setChecked(false);
2687 menuCheckShowAllContainerPlans->create();
2688
2689 menuCheckLockContainer = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2690 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2691 (std::string("\t") + TL("Lock selected container") + std::string("\t") + TL("Toggle lock selected container.")),
2694 menuCheckLockContainer->setChecked(false);
2695 menuCheckLockContainer->create();
2696
2697 menuCheckHideNonInspectedDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2698 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2699 (std::string("\t") + TL("Show non-inspected demand elements") + std::string("\t") + TL("Toggle show non-inspected demand elements.")),
2702 menuCheckHideNonInspectedDemandElements->setChecked(false);
2703 menuCheckHideNonInspectedDemandElements->create();
2704
2705 menuCheckShowOverlappedRoutes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2706 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2707 (std::string("\t") + TL("Show number of overlapped routes") + std::string("\t") + TL("Toggle show number of overlapped routes.")),
2710 menuCheckShowOverlappedRoutes->setChecked(false);
2711 menuCheckShowOverlappedRoutes->create();
2712
2713 // always recalc after creating new elements
2714 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2715}
2716
2717
2718void
2720 menuCheckToggleGrid->hide();
2721 menuCheckToggleDrawJunctionShape->hide();
2722 menuCheckDrawSpreadVehicles->hide();
2723 menuCheckHideShapes->hide();
2724 menuCheckShowAllTrips->hide();
2725 menuCheckShowAllPersonPlans->hide();
2726 menuCheckLockPerson->hide();
2727 menuCheckShowAllContainerPlans->hide();
2728 menuCheckLockContainer->hide();
2729 menuCheckHideNonInspectedDemandElements->hide();
2730 menuCheckShowOverlappedRoutes->hide();
2731 // Also hide toolbar grip
2732 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2733}
2734
2735
2736void
2737GNEViewNetHelper::DemandViewOptions::getVisibleDemandMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2738 // save visible menu commands in commands vector
2739 if (menuCheckToggleGrid->shown()) {
2740 commands.push_back(menuCheckToggleGrid);
2741 }
2742 if (menuCheckToggleDrawJunctionShape->shown()) {
2743 commands.push_back(menuCheckToggleDrawJunctionShape);
2744 }
2745 if (menuCheckDrawSpreadVehicles->shown()) {
2746 commands.push_back(menuCheckDrawSpreadVehicles);
2747 }
2748 if (menuCheckHideShapes->shown()) {
2749 commands.push_back(menuCheckHideShapes);
2750 }
2751 if (menuCheckShowAllTrips->shown()) {
2752 commands.push_back(menuCheckShowAllTrips);
2753 }
2754 if (menuCheckShowAllPersonPlans->shown() && menuCheckShowAllPersonPlans->isEnabled()) {
2755 commands.push_back(menuCheckShowAllPersonPlans);
2756 }
2757 if (menuCheckLockPerson->shown() && menuCheckLockPerson->isEnabled()) {
2758 commands.push_back(menuCheckLockPerson);
2759 }
2760 if (menuCheckShowAllContainerPlans->shown() && menuCheckShowAllContainerPlans->isEnabled()) {
2761 commands.push_back(menuCheckShowAllContainerPlans);
2762 }
2763 if (menuCheckLockContainer->shown() && menuCheckLockContainer->isEnabled()) {
2764 commands.push_back(menuCheckLockContainer);
2765 }
2766 if (menuCheckHideNonInspectedDemandElements->shown()) {
2767 commands.push_back(menuCheckHideNonInspectedDemandElements);
2768 }
2769 if (menuCheckShowOverlappedRoutes->shown()) {
2770 commands.push_back(menuCheckShowOverlappedRoutes);
2771 }
2772}
2773
2774
2775bool
2777 return (menuCheckDrawSpreadVehicles->amChecked() == TRUE);
2778}
2779
2780
2781bool
2783 if (menuCheckHideNonInspectedDemandElements->shown()) {
2784 // check conditions
2785 if ((menuCheckHideNonInspectedDemandElements->amChecked() == FALSE) || (myViewNet->getInspectedAttributeCarriers().empty())) {
2786 // if checkbox is disabled or there isn't insepected element, then return true
2787 return true;
2788 } else if (myViewNet->getInspectedAttributeCarriers().front()->getTagProperty().isDemandElement()) {
2789 if (myViewNet->isAttributeCarrierInspected(demandElement)) {
2790 // if inspected element correspond to demandElement, return true
2791 return true;
2792 } else {
2793 // if demandElement is a route, check if dottedAC is one of their children (Vehicle or Stop)
2794 for (const auto& i : demandElement->getChildDemandElements()) {
2795 if (myViewNet->isAttributeCarrierInspected(i)) {
2796 return true;
2797 }
2798 }
2799 // if demandElement is a vehicle, check if dottedAC is one of his route Parent
2800 for (const auto& i : demandElement->getParentDemandElements()) {
2801 if (myViewNet->isAttributeCarrierInspected(i)) {
2802 return true;
2803 }
2804 }
2805 // dottedAC isn't one of their parent, then return false
2806 return false;
2807 }
2808 } else {
2809 // we're inspecting a demand element, then return true
2810 return true;
2811 }
2812 } else {
2813 // we're inspecting a demand element, then return true
2814 return true;
2815 }
2816}
2817
2818
2819bool
2821 if (menuCheckHideShapes->shown()) {
2822 return (menuCheckHideShapes->amChecked() == FALSE);
2823 } else {
2824 return true;
2825 }
2826}
2827
2828
2829bool
2831 return (menuCheckShowAllTrips->amChecked() == TRUE);
2832}
2833
2834
2835bool
2837 if (menuCheckShowAllPersonPlans->isEnabled()) {
2838 return (menuCheckShowAllPersonPlans->amChecked() == TRUE);
2839 } else {
2840 return false;
2841 }
2842}
2843
2844
2845void
2847 myLockedPerson = person;
2848}
2849
2850
2851void
2853 myLockedPerson = nullptr;
2854}
2855
2856
2857const GNEDemandElement*
2859 return myLockedPerson;
2860}
2861
2862
2863bool
2865 if (menuCheckShowAllContainerPlans->isEnabled()) {
2866 return (menuCheckShowAllContainerPlans->amChecked() == TRUE);
2867 } else {
2868 return false;
2869 }
2870}
2871
2872
2873void
2875 myLockedContainer = container;
2876}
2877
2878
2879void
2881 myLockedContainer = nullptr;
2882}
2883
2884
2885bool
2887 if (menuCheckShowOverlappedRoutes->isEnabled()) {
2888 return (menuCheckShowOverlappedRoutes->amChecked() == TRUE);
2889 } else {
2890 return false;
2891 }
2892}
2893
2894
2895const GNEDemandElement*
2897 return myLockedContainer;
2898}
2899
2900// ---------------------------------------------------------------------------
2901// GNEViewNetHelper::DataViewOptions - methods
2902// ---------------------------------------------------------------------------
2903
2905 menuCheckToggleDrawJunctionShape(nullptr),
2906 menuCheckShowAdditionals(nullptr),
2907 menuCheckShowShapes(nullptr),
2908 menuCheckShowDemandElements(nullptr),
2909 menuCheckToggleTAZRelDrawing(nullptr),
2910 menuCheckToggleTAZDrawFill(nullptr),
2911 menuCheckToggleTAZRelOnlyFrom(nullptr),
2912 menuCheckToggleTAZRelOnlyTo(nullptr),
2913 myViewNet(viewNet) {
2914}
2915
2916
2917void
2919 // create menu checks
2920 menuCheckToggleDrawJunctionShape = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2921 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2922 (std::string("\t") + TL("Hide junction shape") + std::string("\t") + TL("Toggle hiding junction shape. (Ctrl+J)")),
2925 menuCheckToggleDrawJunctionShape->setChecked(false);
2926 menuCheckToggleDrawJunctionShape->create();
2927
2928 menuCheckShowAdditionals = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2929 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2930 (std::string("\t") + TL("Show additionals") + std::string("\t") + TL("Toggle show additionals.")),
2933 menuCheckShowAdditionals->create();
2934
2935 menuCheckShowShapes = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2936 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2937 (std::string("\t") + TL("Show shapes") + std::string("\t") + TL("Toggle show shapes (Polygons and POIs).")),
2940 menuCheckShowShapes->create();
2941
2942 menuCheckShowDemandElements = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2943 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2944 (std::string("\t") + TL("Show demand elements") + std::string("\t") + TL("Toggle show demand elements.")),
2947 menuCheckShowDemandElements->create();
2948
2949 menuCheckToggleTAZRelDrawing = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2950 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2951 (std::string("\t") + TL("Draw TAZREL drawing mode") + std::string("\t") + TL("Toggle draw TAZREL drawing mode.")),
2954 menuCheckToggleTAZRelDrawing->create();
2955
2956 menuCheckToggleTAZDrawFill = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2957 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2958 (std::string("\t") + TL("Toggle draw TAZ fill") + std::string("\t") + TL("Toggle draw TAZ fill")),
2961 menuCheckToggleTAZDrawFill->create();
2962
2963 menuCheckToggleTAZRelOnlyFrom = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2964 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2965 (std::string("\t") + TL("Toggle draw TAZRel only from") + std::string("\t") + TL("Toggle draw TAZRel only from")),
2968 menuCheckToggleTAZRelOnlyFrom->create();
2969
2970 menuCheckToggleTAZRelOnlyTo = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
2971 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
2972 (std::string("\t") + TL("Toggle draw TAZRel only to") + std::string("\t") + TL("Toggle draw TAZRel only to")),
2975 menuCheckToggleTAZRelOnlyTo->create();
2976
2977 // always recalc after creating new elements
2978 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2979}
2980
2981
2982void
2984 menuCheckToggleDrawJunctionShape->hide();
2985 menuCheckShowAdditionals->hide();
2986 menuCheckShowShapes->hide();
2987 menuCheckShowDemandElements->hide();
2988 menuCheckToggleTAZRelDrawing->hide();
2989 menuCheckToggleTAZDrawFill->hide();
2990 menuCheckToggleTAZRelOnlyFrom->hide();
2991 menuCheckToggleTAZRelOnlyTo->hide();
2992 // Also hide toolbar grip
2993 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->show();
2994}
2995
2996
2997void
2998GNEViewNetHelper::DataViewOptions::getVisibleDataMenuCommands(std::vector<MFXCheckableButton*>& commands) const {
2999 // save visible menu commands in commands vector
3000 if (menuCheckToggleDrawJunctionShape->shown()) {
3001 commands.push_back(menuCheckToggleDrawJunctionShape);
3002 }
3003 if (menuCheckShowAdditionals->shown()) {
3004 commands.push_back(menuCheckShowAdditionals);
3005 }
3006 if (menuCheckShowShapes->shown()) {
3007 commands.push_back(menuCheckShowShapes);
3008 }
3009 if (menuCheckShowDemandElements->shown()) {
3010 commands.push_back(menuCheckShowDemandElements);
3011 }
3012 if (menuCheckToggleTAZRelDrawing->shown()) {
3013 commands.push_back(menuCheckToggleTAZRelDrawing);
3014 }
3015 if (menuCheckToggleTAZDrawFill->shown()) {
3016 commands.push_back(menuCheckToggleTAZDrawFill);
3017 }
3018 if (menuCheckToggleTAZRelOnlyFrom->shown()) {
3019 commands.push_back(menuCheckToggleTAZRelOnlyFrom);
3020 }
3021 if (menuCheckToggleTAZRelOnlyTo->shown()) {
3022 commands.push_back(menuCheckToggleTAZRelOnlyTo);
3023 }
3024}
3025
3026
3027bool
3029 if (menuCheckShowAdditionals->shown()) {
3030 return (menuCheckShowAdditionals->amChecked() == TRUE);
3031 } else {
3032 return true;
3033 }
3034}
3035
3036
3037bool
3039 if (menuCheckShowShapes->shown()) {
3040 return (menuCheckShowShapes->amChecked() == TRUE);
3041 } else {
3042 return true;
3043 }
3044}
3045
3046
3047bool
3049 if (menuCheckShowDemandElements->shown()) {
3050 return (menuCheckShowDemandElements->amChecked() == TRUE);
3051 } else {
3052 return true;
3053 }
3054}
3055
3056
3057bool
3059 return (menuCheckToggleTAZRelDrawing->amChecked() != TRUE);
3060}
3061
3062
3063bool
3065 if (menuCheckToggleTAZDrawFill->shown()) {
3066 return (menuCheckToggleTAZDrawFill->amChecked() != TRUE);
3067 } else {
3068 return false;
3069 }
3070}
3071
3072
3073bool
3075 if (menuCheckToggleTAZRelOnlyFrom->shown()) {
3076 return (menuCheckToggleTAZRelOnlyFrom->amChecked() != TRUE);
3077 } else {
3078 return false;
3079 }
3080}
3081
3082
3083bool
3085 if (menuCheckToggleTAZRelOnlyTo->shown()) {
3086 return (menuCheckToggleTAZRelOnlyTo->amChecked() != TRUE);
3087 } else {
3088 return false;
3089 }
3090}
3091
3092// ---------------------------------------------------------------------------
3093// GNEViewNetHelper::IntervalBar - methods
3094// ---------------------------------------------------------------------------
3095
3097 myViewNet(viewNet),
3098 myUpdateInterval(true),
3099 myGenericDataTypesComboBox(nullptr),
3100 myDataSetsComboBox(nullptr),
3101 myIntervalCheckBox(nullptr),
3102 myBeginTextField(nullptr),
3103 myEndTextField(nullptr),
3104 myParametersComboBox(nullptr) {
3105}
3106
3107
3108void
3110 // create interval label
3111 FXLabel* genericDataLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3112 "Data type", 0, GUIDesignLabelThickedFixed(100));
3113 genericDataLabel->create();
3114 // create combo box for generic datas
3115 myGenericDataTypesComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3117 myGenericDataTypesComboBox->create();
3118 // fill combo box
3119 myGenericDataTypesComboBox->appendItem("<all>");
3120 myGenericDataTypesComboBox->appendItem(toString(GNE_TAG_EDGEREL_SINGLE).c_str());
3121 myGenericDataTypesComboBox->appendItem(toString(SUMO_TAG_EDGEREL).c_str());
3122 myGenericDataTypesComboBox->appendItem(toString(SUMO_TAG_TAZREL).c_str());
3123 myGenericDataTypesComboBox->setNumVisible(myGenericDataTypesComboBox->getNumItems());
3124 // create dataSet label
3125 FXLabel* dataSetLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3126 "Data sets", 0, GUIDesignLabelThickedFixed(100));
3127 dataSetLabel->create();
3128 // create combo box for sets
3129 myDataSetsComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3131 myDataSetsComboBox->create();
3132 // create checkbutton for myLimitByInterval
3133 myIntervalCheckBox = new FXCheckButton(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3135 myIntervalCheckBox->create();
3136 // create textfield for begin
3137 myBeginTextField = new FXTextField(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3139 myBeginTextField->create();
3140 // create text field for end
3141 myEndTextField = new FXTextField(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3143 myEndTextField->create();
3144 // create parameter label
3145 FXLabel* parameterLabel = new FXLabel(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3146 "Parameter", 0, GUIDesignLabelThickedFixed(100));
3147 parameterLabel->create();
3148 // create combo box for attributes
3149 myParametersComboBox = new FXComboBox(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar,
3151 myParametersComboBox->create();
3152 // always recalc after creating new elements
3153 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->recalc();
3154}
3155
3156
3157void
3159 // first update interval bar
3160 updateIntervalBar();
3161 // show toolbar grip
3162 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->show();
3163}
3164
3165
3166void
3168 // hide toolbar grip
3169 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().intervalBar->hide();
3170}
3171
3172
3173void
3175 // check if intervalBar has to be updated
3176 if (myUpdateInterval && myViewNet->getNet()) {
3177 // clear data sets
3178 myDataSets.clear();
3179 // declare intervals
3180 double begin = INVALID_DOUBLE;
3181 double end = INVALID_DOUBLE;
3182 // clear parameters
3183 myParameters.clear();
3184 // iterate over all data elements
3185 for (const auto& dataSet : myViewNet->getNet()->getAttributeCarriers()->getDataSets()) {
3186 // add data set ID
3187 myDataSets.push_back(dataSet->getID());
3188 // iterate over all intervals
3189 for (const auto& interval : dataSet->getDataIntervalChildren()) {
3190 // set intervals
3191 if ((begin == INVALID_DOUBLE) || (interval.first < begin)) {
3192 begin = interval.first;
3193 }
3194 if ((end == INVALID_DOUBLE) || (interval.first > end)) {
3195 end = interval.first;
3196 }
3197 // iterate over all generic datas
3198 for (const auto& genericData : interval.second->getGenericDataChildren()) {
3199 // iterate over parameters
3200 for (const auto& parameter : genericData->getParametersMap()) {
3201 myParameters.insert(parameter.first);
3202 }
3203 }
3204 }
3205 }
3206 // get previous dataSet
3207 const std::string previousDataSet = myDataSetsComboBox->getText().text();
3208 // get previous interval
3209 const std::string previousBegin = (myIntervalCheckBox->getCheck() == TRUE) ? myBeginTextField->getText().text() : "";
3210 const std::string previousEnd = (myIntervalCheckBox->getCheck() == TRUE) ? myEndTextField->getText().text() : "";
3211 // get previous parameter
3212 const std::string previousParameter = myParametersComboBox->getText().text();
3213 // clear comboBoxes
3214 myDataSetsComboBox->clearItems();
3215 myParametersComboBox->clearItems();
3216 // add first item (all)
3217 myDataSetsComboBox->appendItem("<all>");
3218 myParametersComboBox->appendItem("<all>");
3219 // fill dataSet comboBox
3220 for (const auto& dataSet : myDataSets) {
3221 myDataSetsComboBox->appendItem(dataSet.c_str());
3222 }
3223 // set begin/end
3224 myBeginTextField->setText(toString(begin).c_str());
3225 myEndTextField->setText(toString(end).c_str());
3226 // fill parameter comboBox
3227 for (const auto& parameter : myParameters) {
3228 myParametersComboBox->appendItem(parameter.c_str());
3229 }
3230 // check previous dataSet
3231 myDataSetsComboBox->setCurrentItem(0, FALSE);
3232 for (int i = 0; i < myDataSetsComboBox->getNumItems(); i++) {
3233 if (myDataSetsComboBox->getItem(i).text() == previousDataSet) {
3234 myDataSetsComboBox->setCurrentItem(i);
3235 }
3236 }
3237 // set previous interval
3238 if (myIntervalCheckBox->getCheck() == TRUE) {
3239 myBeginTextField->setText(previousBegin.c_str());
3240 myEndTextField->setText(previousEnd.c_str());
3241 }
3242 // check previous parameter
3243 myParametersComboBox->setCurrentItem(0, FALSE);
3244 for (int i = 0; i < myParametersComboBox->getNumItems(); i++) {
3245 if (myParametersComboBox->getItem(i).text() == previousParameter) {
3246 myParametersComboBox->setCurrentItem(i);
3247 }
3248 }
3249 // set visible elements
3250 if (myDataSetsComboBox->getNumItems() < 10) {
3251 myDataSetsComboBox->setNumVisible(myDataSetsComboBox->getNumItems());
3252 } else {
3253 myDataSetsComboBox->setNumVisible(10);
3254 }
3255 if (myParametersComboBox->getNumItems() < 10) {
3256 myParametersComboBox->setNumVisible(myParametersComboBox->getNumItems());
3257 } else {
3258 myParametersComboBox->setNumVisible(10);
3259 }
3260 // check if enable or disable
3261 if ((myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_INSPECT) ||
3262 (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_SELECT) ||
3263 (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_DELETE)) {
3264 enableIntervalBar();
3265 } else {
3266 disableIntervalBar();
3267 }
3268 // intervalBar updated, then change flag
3269 myUpdateInterval = false;
3270 }
3271}
3272
3273
3274void
3276 myUpdateInterval = true;
3277}
3278
3279
3282 if (myGenericDataTypesComboBox->isEnabled() && (myGenericDataTypesComboBox->getTextColor() == FXRGB(0, 0, 0))) {
3283 if (myGenericDataTypesComboBox->getText() == toString(GNE_TAG_EDGEREL_SINGLE).c_str()) {
3285 } else if (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_EDGEREL).c_str()) {
3286 return SUMO_TAG_EDGEREL;
3287 } else if (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_TAZREL).c_str()) {
3288 return SUMO_TAG_TAZREL;
3289 }
3290 }
3291 return SUMO_TAG_NOTHING;
3292}
3293
3294
3297 if (!myDataSetsComboBox->isEnabled() ||
3298 (myDataSetsComboBox->getCurrentItem() == 0) ||
3299 (myDataSetsComboBox->getTextColor() == FXRGB(255, 0, 0))) {
3300 return nullptr;
3301 } else {
3302 return myViewNet->getNet()->getAttributeCarriers()->retrieveDataSet(myDataSetsComboBox->getText().text());
3303 }
3304}
3305
3306
3307double
3309 if (!myIntervalCheckBox->isEnabled() || (myIntervalCheckBox->getCheck() == FALSE)) {
3310 return INVALID_DOUBLE;
3311 } else {
3312 return GNEAttributeCarrier::parse<double>(myBeginTextField->getText().text());
3313 }
3314}
3315
3316
3317double
3319 if (!myIntervalCheckBox->isEnabled() || (myIntervalCheckBox->getCheck() == FALSE)) {
3320 return INVALID_DOUBLE;
3321 } else {
3322 return GNEAttributeCarrier::parse<double>(myEndTextField->getText().text());
3323 }
3324}
3325
3326
3327std::string
3329 if (!myParametersComboBox->isEnabled() ||
3330 (myParametersComboBox->getCurrentItem() == 0) ||
3331 (myParametersComboBox->getTextColor() == FXRGB(255, 0, 0))) {
3332 return "";
3333 } else {
3334 return myParametersComboBox->getText().text();
3335 }
3336}
3337
3338
3339void
3341 if ((myGenericDataTypesComboBox->getText() == "<all>") ||
3342 (myGenericDataTypesComboBox->getText() == toString(GNE_TAG_EDGEREL_SINGLE).c_str()) ||
3343 (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_EDGEREL).c_str()) ||
3344 (myGenericDataTypesComboBox->getText() == toString(SUMO_TAG_TAZREL).c_str())) {
3345 myGenericDataTypesComboBox->setTextColor(FXRGB(0, 0, 0));
3346 } else {
3347 myGenericDataTypesComboBox->setTextColor(FXRGB(255, 0, 0));
3348 }
3349 // update view net
3350 myViewNet->updateViewNet();
3351}
3352
3353
3354void
3356 // check if exist
3357 if (std::find(myDataSets.begin(), myDataSets.end(), myDataSetsComboBox->getText().text()) != myDataSets.end()) {
3358 myDataSetsComboBox->setTextColor(FXRGB(0, 0, 0));
3359 } else {
3360 myDataSetsComboBox->setTextColor(FXRGB(255, 0, 0));
3361 }
3362 // update view net
3363 myViewNet->updateViewNet();
3364}
3365
3366
3367void
3369 // enable or disable text fields
3370 if (myIntervalCheckBox->isEnabled() && (myIntervalCheckBox->getCheck() == TRUE)) {
3371 myBeginTextField->enable();
3372 myEndTextField->enable();
3373 } else {
3374 myBeginTextField->disable();
3375 myEndTextField->disable();
3376 }
3377 // update view net
3378 myViewNet->updateViewNet();
3379}
3380
3381
3382void
3384 if (myBeginTextField->getText().empty()) {
3385 myBeginTextField->setText(toString(myViewNet->getNet()->getDataSetIntervalMinimumBegin()).c_str());
3386 myBeginTextField->setTextColor(FXRGB(0, 0, 0));
3387 } else if (GNEAttributeCarrier::canParse<double>(myBeginTextField->getText().text())) {
3388 myBeginTextField->setTextColor(FXRGB(0, 0, 0));
3389 } else {
3390 myBeginTextField->setTextColor(FXRGB(255, 0, 0));
3391 }
3392 // update view net
3393 myViewNet->updateViewNet();
3394}
3395
3396
3397void
3399 if (myEndTextField->getText().empty()) {
3400 myEndTextField->setText(toString(myViewNet->getNet()->getDataSetIntervalMaximumEnd()).c_str());
3401 myEndTextField->setTextColor(FXRGB(0, 0, 0));
3402 } else if (GNEAttributeCarrier::canParse<double>(myEndTextField->getText().text())) {
3403 myEndTextField->setTextColor(FXRGB(0, 0, 0));
3404 } else {
3405 myEndTextField->setTextColor(FXRGB(255, 0, 0));
3406 }
3407 // update view net
3408 myViewNet->updateViewNet();
3409}
3410
3411
3412void
3414 // check if exist
3415 if (myParameters.count(myParametersComboBox->getText().text()) > 0) {
3416 myParametersComboBox->setTextColor(FXRGB(0, 0, 0));
3417 } else {
3418 myParametersComboBox->setTextColor(FXRGB(255, 0, 0));
3419 }
3420 // update view net
3421 myViewNet->updateViewNet();
3422}
3423
3424
3425
3426void
3428 // enable elements
3429 myGenericDataTypesComboBox->enable();
3430 myDataSetsComboBox->enable();
3431 myIntervalCheckBox->enable();
3432 if (myIntervalCheckBox->getCheck() == TRUE) {
3433 myBeginTextField->enable();
3434 myEndTextField->enable();
3435 } else {
3436 myBeginTextField->disable();
3437 myEndTextField->disable();
3438 }
3439 myParametersComboBox->enable();
3440}
3441
3442
3443void
3445 // disable all elements
3446 myGenericDataTypesComboBox->disable();
3447 myDataSetsComboBox->disable();
3448 myIntervalCheckBox->disable();
3449 myBeginTextField->disable();
3450 myEndTextField->disable();
3451 myParametersComboBox->disable();
3452}
3453
3454// ---------------------------------------------------------------------------
3455// GNEViewNetHelper::CommonCheckableButtons - methods
3456// ---------------------------------------------------------------------------
3457
3459 inspectButton(nullptr),
3460 deleteButton(nullptr),
3461 selectButton(nullptr),
3462 myViewNet(viewNet) {
3463}
3464
3465
3466void
3468 // inspect button
3469 inspectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3470 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3471 std::string("\t") + TL("Set inspect mode") + std::string("\t") + TL("Mode for inspect elements and change their attributes. (I)"),
3473 inspectButton->create();
3474 // delete button
3475 deleteButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3476 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3477 std::string("\t") + TL("Set delete mode") + std::string("\t") + TL("Mode for delete elements. (D)"),
3479 deleteButton->create();
3480 // select button
3481 selectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3482 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3483 std::string("\t") + ("Set select mode") + std::string("\t") + ("Mode for select elements. (S)"),
3485 selectButton->create();
3486 // always recalc menu bar after creating new elements
3487 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3488}
3489
3490
3491void
3493 inspectButton->show();
3494 deleteButton->show();
3495 selectButton->show();
3496}
3497
3498
3499void
3501 inspectButton->hide();
3502 deleteButton->hide();
3503 selectButton->hide();
3504}
3505
3506
3507void
3509 inspectButton->setChecked(false);
3510 deleteButton->setChecked(false);
3511 selectButton->setChecked(false);
3512}
3513
3514
3515void
3517 inspectButton->update();
3518 deleteButton->update();
3519 selectButton->update();
3520}
3521
3522// ---------------------------------------------------------------------------
3523// GNEViewNetHelper::NetworkCheckableButtons - methods
3524// ---------------------------------------------------------------------------
3525
3527 moveNetworkElementsButton(nullptr),
3528 createEdgeButton(nullptr),
3529 connectionButton(nullptr),
3530 trafficLightButton(nullptr),
3531 additionalButton(nullptr),
3532 crossingButton(nullptr),
3533 TAZButton(nullptr),
3534 shapeButton(nullptr),
3535 prohibitionButton(nullptr),
3536 wireButton(nullptr),
3537 myViewNet(viewNet) {
3538}
3539
3540
3541void
3543 // move button
3544 moveNetworkElementsButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3545 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3546 std::string("\t") + TL("Set move mode") + std::string("\t") + TL("Mode for move elements. (M)"),
3548 moveNetworkElementsButton->create();
3549 // create edge
3550 createEdgeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3551 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3552 std::string("\t") + TL("Set create edge mode") + std::string("\t") + TL("Mode for creating junction and edges. (E)"),
3554 createEdgeButton->create();
3555 // connection mode
3556 connectionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3557 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3558 std::string("\t") + TL("Set connection mode") + std::string("\t") + TL("Mode for edit connections between lanes. (C)"),
3560 connectionButton->create();
3561 // prohibition mode
3562 prohibitionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3563 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3564 std::string("\t") + TL("Set prohibition mode") + std::string("\t") + TL("Mode for editing connection prohibitions. (H)"),
3566 prohibitionButton->create();
3567 // traffic light mode
3568 trafficLightButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3569 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3570 std::string("\t") + TL("Set traffic light mode") + std::string("\t") + TL("Mode for edit traffic lights over junctions. (T)"),
3572 trafficLightButton->create();
3573 // additional mode
3574 additionalButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3575 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3576 std::string("\t") + TL("Set additional mode") + std::string("\t") + TL("Mode for adding additional elements. (A)"),
3578 additionalButton->create();
3579 // crossing mode
3580 crossingButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3581 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3582 std::string("\t") + TL("Set crossing mode") + std::string("\t") + TL("Mode for creating crossings between edges. (R)"),
3584 crossingButton->create();
3585 // TAZ Mode
3586 TAZButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3587 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3588 std::string("\t") + TL("Set TAZ mode") + std::string("\t") + TL("Mode for creating Traffic Assignment Zones. (Z)"),
3590 TAZButton->create();
3591 // shape mode
3592 shapeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3593 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3594 std::string("\t") + TL("Set polygon mode") + std::string("\t") + TL("Mode for creating polygons and POIs. (P)"),
3596 shapeButton->create();
3597 // wire mode
3598 wireButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3599 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3600 std::string("\t") + TL("Set wire mode") + std::string("\t") + TL("Mode for editing wires. (W)"),
3602 wireButton->create();
3603 // always recalc after creating new elements
3604 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3605}
3606
3607
3608void
3610 moveNetworkElementsButton->show();
3611 createEdgeButton->show();
3612 connectionButton->show();
3613 trafficLightButton->show();
3614 additionalButton->show();
3615 crossingButton->show();
3616 TAZButton->show();
3617 shapeButton->show();
3618 prohibitionButton->show();
3619 wireButton->show();
3620}
3621
3622
3623void
3625 moveNetworkElementsButton->hide();
3626 createEdgeButton->hide();
3627 connectionButton->hide();
3628 trafficLightButton->hide();
3629 additionalButton->hide();
3630 crossingButton->hide();
3631 TAZButton->hide();
3632 shapeButton->hide();
3633 prohibitionButton->hide();
3634 wireButton->hide();
3635}
3636
3637
3638void
3640 moveNetworkElementsButton->setChecked(false);
3641 createEdgeButton->setChecked(false);
3642 connectionButton->setChecked(false);
3643 trafficLightButton->setChecked(false);
3644 additionalButton->setChecked(false);
3645 crossingButton->setChecked(false);
3646 TAZButton->setChecked(false);
3647 shapeButton->setChecked(false);
3648 prohibitionButton->setChecked(false);
3649 wireButton->setChecked(false);
3650}
3651
3652
3653void
3655 moveNetworkElementsButton->update();
3656 createEdgeButton->update();
3657 connectionButton->update();
3658 trafficLightButton->update();
3659 additionalButton->update();
3660 crossingButton->update();
3661 TAZButton->update();
3662 shapeButton->update();
3663 prohibitionButton->update();
3664 wireButton->update();
3665}
3666
3667// ---------------------------------------------------------------------------
3668// GNEViewNetHelper::DemandCheckableButtons - methods
3669// ---------------------------------------------------------------------------
3670
3674
3675
3676void
3678 // move button
3679 moveDemandElementsButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3680 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3681 std::string("\t") + TL("Set move mode") + std::string("\t") + TL("Mode for move elements. (M)"),
3683 moveDemandElementsButton->create();
3684 // route mode
3685 routeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3686 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3687 std::string("\t") + TL("Create route mode") + std::string("\t") + TL("Mode for creating routes. (R)"),
3689 routeButton->create();
3690 // vehicle mode
3691 vehicleButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3692 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3693 std::string("\t") + TL("Create vehicle mode") + std::string("\t") + TL("Mode for creating vehicles. (V)"),
3695 vehicleButton->create();
3696 // type mode
3697 typeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3698 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3699 std::string("\t") + TL("Create type mode") + std::string("\t") + TL("Mode for creating types (vehicles, person and containers). (T)"),
3701 typeButton->create();
3702 // type distribution mode
3703 typeDistributionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3704 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3705 std::string("\t") + TL("Create type distribution mode") + std::string("\t") + TL("Mode for creating type distribution. (U)"),
3707 typeDistributionButton->create();
3708 // stop mode
3709 stopButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3710 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3711 std::string("\t") + TL("Create stop mode") + std::string("\t") + TL("Mode for creating stops. (A)"),
3713 stopButton->create();
3714 // person mode
3715 personButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3716 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3717 std::string("\t") + TL("Create person mode") + std::string("\t") + TL("Mode for creating persons. (P)"),
3719 personButton->create();
3720 // person plan mode
3721 personPlanButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3722 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3723 std::string("\t") + TL("Create person plan mode") + std::string("\t") + TL("Mode for creating person plans. (L)"),
3725 personPlanButton->create();
3726 // container mode
3727 containerButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3728 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3729 std::string("\t") + TL("Create container mode") + std::string("\t") + TL("Mode for creating containers. (C)"),
3731 containerButton->create();
3732 // container plan mode
3733 containerPlanButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3734 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3735 std::string("\t") + TL("Create container plan mode") + std::string("\t") + TL("Mode for creating container plans. (H)"),
3737 containerPlanButton->create();
3738 // always recalc after creating new elements
3739 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3740}
3741
3742
3743void
3745 moveDemandElementsButton->show();
3746 routeButton->show();
3747 vehicleButton->show();
3748 typeButton->show();
3749 typeDistributionButton->show();
3750 stopButton->show();
3751 personButton->show();
3752 personPlanButton->show();
3753 containerButton->show();
3754 containerPlanButton->show();
3755}
3756
3757
3758void
3760 moveDemandElementsButton->hide();
3761 routeButton->hide();
3762 vehicleButton->hide();
3763 typeButton->hide();
3764 typeDistributionButton->hide();
3765 stopButton->hide();
3766 personButton->hide();
3767 personPlanButton->hide();
3768 containerButton->hide();
3769 containerPlanButton->hide();
3770}
3771
3772
3773void
3775 moveDemandElementsButton->setChecked(false);
3776 routeButton->setChecked(false);
3777 vehicleButton->setChecked(false);
3778 typeButton->setChecked(false);
3779 typeDistributionButton->setChecked(false);
3780 stopButton->setChecked(false);
3781 personButton->setChecked(false);
3782 personPlanButton->setChecked(false);
3783 containerButton->setChecked(false);
3784 containerPlanButton->setChecked(false);
3785}
3786
3787
3788void
3790 moveDemandElementsButton->update();
3791 routeButton->update();
3792 vehicleButton->update();
3793 typeButton->update();
3794 typeDistributionButton->update();
3795 stopButton->update();
3796 personButton->update();
3797 personPlanButton->update();
3798 containerButton->update();
3799 containerPlanButton->update();
3800}
3801
3802// ---------------------------------------------------------------------------
3803// GNEViewNetHelper::DataCheckableButtons - methods
3804// ---------------------------------------------------------------------------
3805
3809
3810
3811void
3813 // edgeData mode
3814 edgeDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3815 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3816 std::string("\t") + TL("Create edge data mode") + std::string("\t") + TL("Mode for creating edge datas. (E)"),
3818 edgeDataButton->create();
3819 // edgeRelData mode
3820 edgeRelDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3821 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3822 std::string("\t") + TL("Create edge relation data mode") + std::string("\t") + TL("Mode for creating edge relation datas. (R)"),
3824 edgeRelDataButton->create();
3825 // TAZRelData mode
3826 TAZRelDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3827 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3828 std::string("\t") + TL("Create TAZ relation data mode") + std::string("\t") + TL("Mode for creating TAZ relation datas. (Z)"),
3830 TAZRelDataButton->create();
3831 // meanData button
3832 meanDataButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes,
3833 myViewNet->myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
3834 std::string("\t") + TL("MeanData mode") + std::string("\t") + TL("Mode for MeanData elements. (M)"),
3836 meanDataButton->create();
3837 // always recalc after creating new elements
3838 myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
3839}
3840
3841
3842void
3844 edgeDataButton->show();
3845 edgeRelDataButton->show();
3846 TAZRelDataButton->show();
3847 meanDataButton->show();
3848}
3849
3850
3851void
3853 edgeDataButton->hide();
3854 edgeRelDataButton->hide();
3855 TAZRelDataButton->hide();
3856 meanDataButton->hide();
3857}
3858
3859
3860void
3862 edgeDataButton->setChecked(false);
3863 edgeRelDataButton->setChecked(false);
3864 TAZRelDataButton->setChecked(false);
3865 meanDataButton->setChecked(false);
3866}
3867
3868
3869void
3871 edgeDataButton->update();
3872 edgeRelDataButton->update();
3873 TAZRelDataButton->update();
3874 meanDataButton->update();
3875}
3876
3877// ---------------------------------------------------------------------------
3878// GNEViewNetHelper::EditNetworkElementShapes - methods
3879// ---------------------------------------------------------------------------
3880
3882 myViewNet(viewNet),
3883 myEditedNetworkElement(nullptr),
3884 myPreviousNetworkEditMode(NetworkEditMode::NETWORK_NONE) {
3885}
3886
3887
3888void
3890 if (element && (myEditedNetworkElement == nullptr)) {
3891 // save current edit mode before starting
3892 myPreviousNetworkEditMode = myViewNet->myEditModes.networkEditMode;
3893 // set move mode
3894 myViewNet->myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_MOVE);
3895 //set editedNetworkElement
3896 myEditedNetworkElement = element;
3897 // enable shape edited flag
3898 myEditedNetworkElement->setShapeEdited(true);
3899 // update view net to show the new editedShapePoly
3900 myViewNet->updateViewNet();
3901 }
3902}
3903
3904
3905void
3907 // stop edit shape junction deleting editedShapePoly
3908 if (myEditedNetworkElement != nullptr) {
3909 // disable shape edited flag
3910 myEditedNetworkElement->setShapeEdited(false);
3911 // reset editedNetworkElement
3912 myEditedNetworkElement = nullptr;
3913 // restore previous edit mode
3914 if (myViewNet->myEditModes.networkEditMode != myPreviousNetworkEditMode) {
3915 myViewNet->myEditModes.setNetworkEditMode(myPreviousNetworkEditMode);
3916 }
3917 }
3918}
3919
3920
3921void
3923 // save edited junction's shape
3924 if (myEditedNetworkElement != nullptr) {
3925
3926 /* */
3927
3928 // stop edit custom shape
3929 stopEditCustomShape();
3930 }
3931}
3932
3933
3936 return myEditedNetworkElement;
3937}
3938
3939// ---------------------------------------------------------------------------
3940// GNEViewNetHelper::BlockIcon - methods
3941// ---------------------------------------------------------------------------
3942
3943void
3945 const Position viewPosition, const double exaggeration, const double size,
3946 const double offsetx, const double offsety) {
3947 // first check if icon can be drawn
3948 if (checkDrawing(AC, type, exaggeration)) {
3949 // Start pushing matrix
3951 // Traslate to position
3952 glTranslated(viewPosition.x(), viewPosition.y(), GLO_LOCKICON);
3953 // Traslate depending of the offset
3954 glTranslated(offsetx, offsety, 0);
3955 // rotate to avoid draw invert
3956 glRotated(180, 0, 0, 1);
3957 // Set draw color
3958 glColor3d(1, 1, 1);
3959 // Draw lock icon
3961 // Pop matrix
3963 }
3964}
3965
3966
3968
3969
3970bool
3972 // get view net
3973 const auto viewNet = AC->getNet()->getViewNet();
3974 // get visualization settings
3975 const auto& s = viewNet->getVisualisationSettings();
3976 // check exaggeration
3977 if (exaggeration == 0) {
3978 return false;
3979 }
3980 // check supermodes
3981 if (viewNet->getEditModes().isCurrentSupermodeNetwork() &&
3983 return false;
3984 }
3985 if (viewNet->getEditModes().isCurrentSupermodeDemand() && (!AC->getTagProperty().isDemandElement())) {
3986 return false;
3987 }
3988 if (viewNet->getEditModes().isCurrentSupermodeData() && (!AC->getTagProperty().isDataElement())) {
3989 return false;
3990 }
3991 // check if is locked
3992 if (!viewNet->getLockManager().isObjectLocked(type, AC->isAttributeCarrierSelected())) {
3993 return false;
3994 }
3995 // check visualizationSettings
3996 if (s.drawForPositionSelection || s.drawForRectangleSelection) {
3997 return false;
3998 }
3999 // check detail
4000 if (!s.drawDetail(s.detailSettings.lockIcon, exaggeration)) {
4001 return false;
4002 }
4003 // all ok, then draw
4004 return true;
4005}
4006
4007// ---------------------------------------------------------------------------
4008// GNEViewNetHelper - methods
4009// ---------------------------------------------------------------------------
4010
4011const std::vector<RGBColor>&
4013 // if is empty, fill it
4014 if (myRainbowScaledColors.empty()) {
4015 // fill scale colors (10)
4016 myRainbowScaledColors.push_back(RGBColor(232, 35, 0, 255));
4017 myRainbowScaledColors.push_back(RGBColor(255, 165, 0, 255));
4018 myRainbowScaledColors.push_back(RGBColor(255, 255, 0, 255));
4019 myRainbowScaledColors.push_back(RGBColor(28, 215, 0, 255));
4020 myRainbowScaledColors.push_back(RGBColor(0, 181, 100, 255));
4021 myRainbowScaledColors.push_back(RGBColor(0, 255, 191, 255));
4022 myRainbowScaledColors.push_back(RGBColor(178, 255, 255, 255));
4023 myRainbowScaledColors.push_back(RGBColor(0, 112, 184, 255));
4024 myRainbowScaledColors.push_back(RGBColor(56, 41, 131, 255));
4025 myRainbowScaledColors.push_back(RGBColor(127, 0, 255, 255));
4026 }
4027 return myRainbowScaledColors;
4028}
4029
4030
4031const RGBColor&
4032GNEViewNetHelper::getRainbowScaledColor(const double min, const double max, const double value) {
4033 // check extremes
4034 if (value <= min) {
4035 return getRainbowScaledColors().front();
4036 } else if (value >= max) {
4037 return getRainbowScaledColors().back();
4038 } else {
4039 // calculate value procent between [min, max]
4040 const double procent = ((value - min) * 100) / (max - min);
4041 // check if is valid
4042 if (procent <= 0) {
4043 return getRainbowScaledColors().front();
4044 } else if (procent >= 100) {
4045 return getRainbowScaledColors().back();
4046 } else {
4047 // return scaled color
4048 return getRainbowScaledColors().at((int)(procent / 10.0));
4049 }
4050 }
4051}
4052
4053
4054std::vector<GUIGlObject*>
4055GNEViewNetHelper::filterElementsByLayer(const std::vector<GUIGlObject*>& GLObjects) {
4056 std::vector<GUIGlObject*> filteredGLObjects;
4057 if (GLObjects.size() > 0) {
4058 const auto firstLayer = GLObjects.front()->getType();
4059 for (const auto& GLObject : GLObjects) {
4060 if ((GLO_RIDE <= firstLayer) && (firstLayer <= GLO_TRANSHIP) &&
4061 (GLO_RIDE <= GLObject->getType()) && (GLObject->getType() <= GLO_TRANSHIP)) {
4062 filteredGLObjects.push_back(GLObject);
4063 } else if ((GLO_STOP <= firstLayer) && (firstLayer <= GLO_STOP_CONTAINER) &&
4064 (GLO_STOP <= GLObject->getType()) && (GLObject->getType() <= GLO_STOP_CONTAINER)) {
4065 filteredGLObjects.push_back(GLObject);
4066 } else if ((GLO_VEHICLE <= firstLayer) && (firstLayer <= GLO_ROUTEFLOW) &&
4067 (GLO_VEHICLE <= GLObject->getType()) && (GLObject->getType() <= GLO_ROUTEFLOW)) {
4068 filteredGLObjects.push_back(GLObject);
4069 } else if ((GLO_PERSON <= firstLayer) && (firstLayer <= GLO_PERSONFLOW) &&
4070 (GLO_PERSON <= GLObject->getType()) && (GLObject->getType() <= GLO_PERSONFLOW)) {
4071 filteredGLObjects.push_back(GLObject);
4072 } else if ((GLO_CONTAINER <= firstLayer) && (firstLayer <= GLO_CONTAINERFLOW) &&
4073 (GLO_CONTAINER <= GLObject->getType()) && (GLObject->getType() <= GLO_CONTAINERFLOW)) {
4074 filteredGLObjects.push_back(GLObject);
4075 } else if (GLObject->getType() == firstLayer) {
4076 filteredGLObjects.push_back(GLObject);
4077 }
4078 }
4079 }
4080 return filteredGLObjects;
4081}
4082
4083/****************************************************************************/
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:815
@ MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS
save Data Elements
Definition GUIAppEnum.h:201
@ MID_HOTKEY_F3_SUPERMODE_DEMAND
select demand supermode in netedit
Definition GUIAppEnum.h:231
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
show all person plans
Definition GUIAppEnum.h:847
@ MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING
toggle TAZRel drawing
Definition GUIAppEnum.h:871
@ MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition GUIAppEnum.h:789
@ MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
move elevation instead of x,y
Definition GUIAppEnum.h:811
@ MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
hide connections
Definition GUIAppEnum.h:797
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
show connections
Definition GUIAppEnum.h:795
@ MID_GNE_INTERVALBAR_BEGIN
begin changed in InterbalBar
Definition GUIAppEnum.h:891
@ MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO
toggle draw TAZRel only to
Definition GUIAppEnum.h:877
@ MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition GUIAppEnum.h:863
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS
show TAZ elements
Definition GUIAppEnum.h:801
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
lock person
Definition GUIAppEnum.h:849
@ MID_HOTKEY_Z_MODE_TAZ_TAZREL
hotkey for mode editing TAZ and TAZRel
Definition GUIAppEnum.h:73
@ MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition GUIAppEnum.h:837
@ MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
ask before merging junctions
Definition GUIAppEnum.h:807
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID
show grid
Definition GUIAppEnum.h:835
@ MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS
Save Demand Elements.
Definition GUIAppEnum.h:205
@ MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK
Stop the simulation in SUMO and save network in netedit.
Definition GUIAppEnum.h:115
@ MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE
hotkey for perform a single simulation step in SUMO and set delete mode in netedit
Definition GUIAppEnum.h:47
@ MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
create edges in chain mode
Definition GUIAppEnum.h:813
@ MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition GUIAppEnum.h:869
@ MID_HOTKEY_C_MODE_CONNECT_CONTAINER
hotkey for mode connecting lanes AND container
Definition GUIAppEnum.h:45
@ MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN
hotkey for mode prohibition AND container plan
Definition GUIAppEnum.h:51
@ 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:843
@ MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS
show additionals
Definition GUIAppEnum.h:865
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
show junctions as bubbles
Definition GUIAppEnum.h:809
@ MID_GNE_INTERVALBAR_END
end changed in InterbalBar
Definition GUIAppEnum.h:893
@ MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
extend selection
Definition GUIAppEnum.h:803
@ MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT
hotkey for stop simulation in SUMO and set select mode in netedit
Definition GUIAppEnum.h:61
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS
show sub-additionals
Definition GUIAppEnum.h:799
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS
show all container plans
Definition GUIAppEnum.h:851
@ MID_HOTKEY_F4_SUPERMODE_DATA
select data supermode in netedit
Definition GUIAppEnum.h:233
@ MID_HOTKEY_U_MODE_TYPEDISTRIBUTION
hotkey for mode type distribution
Definition GUIAppEnum.h:67
@ MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALSTOP
hotkey for start simulation in SUMO and set editing mode additionals AND stops in netedit
Definition GUIAppEnum.h:43
@ MID_GNE_INTERVALBAR_PARAMETER
parameter changed in InterbalBar
Definition GUIAppEnum.h:895
@ 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:71
@ MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL
toggle draw TAZ fill
Definition GUIAppEnum.h:873
@ MID_HOTKEY_CTRL_SHIFT_M_SAVEMEANDATAS
save Mean Datas
Definition GUIAppEnum.h:213
@ MID_HOTKEY_L_MODE_PERSONPLAN
hotkey for mode person plan
Definition GUIAppEnum.h:55
@ MID_HOTKEY_V_MODE_VEHICLE
hotkey for mode create vehicles
Definition GUIAppEnum.h:69
@ MID_HOTKEY_I_MODE_INSPECT
hotkey for mode inspecting object attributes
Definition GUIAppEnum.h:53
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition GUIAppEnum.h:791
@ MID_HOTKEY_CTRL_SHIFT_E_SAVENETEDITCONFIG
save netedit Config
Definition GUIAppEnum.h:207
@ MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
hide non-inspected demand element
Definition GUIAppEnum.h:841
@ MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALS
Save Additional Elements.
Definition GUIAppEnum.h:199
@ MID_GNE_INTERVALBAR_GENERICDATATYPE
generic data selected
Definition GUIAppEnum.h:885
@ MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
change all phases
Definition GUIAppEnum.h:805
@ MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES
show shapes
Definition GUIAppEnum.h:867
@ 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:875
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition GUIAppEnum.h:787
@ MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition GUIAppEnum.h:839
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES
show overlapped routes
Definition GUIAppEnum.h:855
@ MID_HOTKEY_CTRL_SHIFT_S_SAVESUMOCONFIG
save SUMOConfig (SUMO AND netedit)
Definition GUIAppEnum.h:219
@ MID_GNE_INTERVALBAR_DATASET
data set selected
Definition GUIAppEnum.h:887
@ MID_HOTKEY_M_MODE_MOVE_MEANDATA
hotkey for mode moving element AND mean data
Definition GUIAppEnum.h:57
@ MID_HOTKEY_F2_SUPERMODE_NETWORK
select network supermode in netedit
Definition GUIAppEnum.h:229
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER
lock container
Definition GUIAppEnum.h:853
@ MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
select edges
Definition GUIAppEnum.h:793
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS
show all trips
Definition GUIAppEnum.h:845
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID
show grid
Definition GUIAppEnum.h:785
@ MID_GNE_INTERVALBAR_LIMITED
enable/disable show data elements by interval
Definition GUIAppEnum.h:889
@ 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:300
#define GUIDesignComboBoxNCol
number of column of every combo box
Definition GUIDesigns.h:306
#define GUIDesignButtonPopup
checkable button placed in popup (for example, locate buttons)
Definition GUIDesigns.h:107
#define GUIDesignButtonToolbar
little button with icon placed in navigation toolbar
Definition GUIDesigns.h:118
#define GUIDesignTextFieldNCol
Num of column of text field.
Definition GUIDesigns.h:66
#define GUIDesignTextFieldFixedRestricted(width, type)
text field with fixed width
Definition GUIDesigns.h:60
#define GUIDesignMFXCheckableButtonSquare
Definition GUIDesigns.h:132
#define GUIDesignButtonToolbarLocator
little checkable button with icon placed in navigation toolbar used specify for Locator
Definition GUIDesigns.h:124
#define GUIDesignMFXCheckableButtonSupermode
checkable button with icon placed in navigation toolbar for supermodes
Definition GUIDesigns.h:135
#define GUIDesignCheckButtonAttribute
checkButton without thick extended over the frame used for attributes
Definition GUIDesigns.h:196
#define GUIDesignLabelThickedFixed(width)
label thicked, icon before text, text centered and custom width
Definition GUIDesigns.h:247
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
@ SAVE_NETEDITCONFIG
@ SAVE_DATAELEMENTS
@ NETWORKMODE_CHECKBOX_BUBBLES
@ SAVE_NETWORKELEMENTS
@ DATAMODE_CHECKBOX_TAZRELONLYFROM
@ MODEPERSONPLAN
@ MODECROSSING
@ MODEMEANDATA
@ MODEADDITIONAL
@ MODEEDGERELDATA
@ SUPERMODEDEMAND
@ MODEPROHIBITION
@ SAVE_ADDITIONALELEMENTS
@ 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
@ SAVE_MEANDATAELEMENTS
@ DATAMODE_CHECKBOX_TAZRELDRAWING
@ NETWORKMODE_CHECKBOX_SHOWCONNECTIONS
@ DEMANDMODE_CHECKBOX_SHOWPERSONPLANS
@ MODECONTAINER
@ DEMANDMODE_CHECKBOX_HIDESHAPES
@ DATAMODE_CHECKBOX_TAZDRAWFILL
@ MODEEDGEDATA
@ NETWORKMODE_CHECKBOX_ELEVATION
@ SUPERMODENETWORK
@ COMMONMODE_CHECKBOX_SPREADVEHICLE
@ SAVE_DEMANDELEMENTS
@ DEMANDMODE_CHECKBOX_LOCKCONTAINER
@ NETWORKMODE_CHECKBOX_SHOWSUBADDITIONALS
@ NETWORKMODE_CHECKBOX_SHOWTAZELEMENTS
@ SUPERMODEDATA
@ MODECONNECTION
@ MODECONTAINERPLAN
@ SAVE_MULTIPLE
@ NETWORKMODE_CHECKBOX_CHAIN
@ DEMANDMODE_CHECKBOX_SHOWOVERLAPPEDROUTES
@ NETWORKMODE_CHECKBOX_ASKFORMERGE
@ SAVE_SUMOCONFIG
@ MODETYPEDISTRIBUTION
@ COMMONMODE_CHECKBOX_TOGGLEGRID
@ MODETAZRELDATA
@ DEMANDMODE_CHECKBOX_SHOWCONTAINERPLANS
@ NETWORKMODE_CHECKBOX_TWOWAY
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define TL(string)
Definition MsgHandler.h:287
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_EDGEREL
a relation between two edges
@ SUMO_TAG_NOTHING
invalid tag
@ GNE_TAG_EDGEREL_SINGLE
@ 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
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_END
weights: time range end
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
#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.
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:44
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:37
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:1504
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition GNEEdge.cpp:480
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:120
GNEViewNet * getViewNet() const
get view net
Definition GNENet.cpp:2030
void setShapeEdited(const bool value)
set shape edited
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 shortDataElements()
short data elements by begin
void filterLockedElements(const GNEViewNetHelper::LockManager &lockManager, std::vector< GUIGlObjectType > forcedIgnoredTiped={})
filter locked elements
void updateAttributeCarriers(ObjectsContainer &container, GNEAttributeCarrier *AC)
update attribute carrier elements
std::vector< GUIGlObject * > filterDuplicatedObjects(const std::vector< GUIGlObject * > &GUIGlObjects) const
filter duplicated objects
GNEEdge * getEdgeFront() const
get front edge or a pointer to nullptr
const std::vector< GNEJunction * > & getClickedJunctions() const
get vector with clicked junctions
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.
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:771
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.
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
NetworkEditMode networkEditMode
the current Network edit mode
bool isCurrentSupermodeDemand() const
@check if current supermode is Demand
void setDemandEditMode(DemandEditMode demandMode, const bool force=false)
set Demand edit mode
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
EditModes(GNEViewNet *viewNet)
default constructor
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 setSaveIndividualFiles(bool value)
enable or disable save individual files
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
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