Eclipse SUMO - Simulation of Urban MObility
GNEViewNetHelper.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
15 // A file used to reduce the size of GNEViewNet.h grouping structs and classes
16 /****************************************************************************/
17 
18 
19 // ===========================================================================
20 // included modules
21 // ===========================================================================
22 
34 #include <utils/gui/div/GLHelper.h>
38 
39 #include "GNEViewNetHelper.h"
40 #include "GNEViewNet.h"
41 #include "GNENet.h"
42 #include "GNEUndoList.h"
43 #include "GNEViewParent.h"
44 #include "GNEApplicationWindow.h"
45 
46 // ===========================================================================
47 // member method definitions
48 // ===========================================================================
49 
50 // ---------------------------------------------------------------------------
51 // GNEViewNetHelper::ObjectsUnderCursor - methods
52 // ---------------------------------------------------------------------------
53 
55 
56 
57 void
58 GNEViewNetHelper::ObjectsUnderCursor::updateObjectUnderCursor(const std::vector<GUIGlObject*>& GUIGlObjects, GNEPoly* editedPolyShape) {
59  // first clear all containers
60  myAttributeCarriers.clear();
61  myNetElements.clear();
62  myAdditionals.clear();
63  myShapes.clear();
64  myDemandElements.clear();
65  myJunctions.clear();
66  myEdges.clear();
67  myLanes.clear();
68  myCrossings.clear();
69  myConnections.clear();
70  myTAZs.clear();
71  myPOIs.clear();
72  myPolys.clear();
73  // set GUIGlObject
74  sortGUIGlObjectsByAltitude(GUIGlObjects);
75  // iterate over GUIGlObjects
76  for (const auto& i : myGUIGlObjects) {
77  // only continue if isn't GLO_NETELEMENT (0)
78  if (i->getType() != GLO_NETELEMENT) {
79  // cast attribute carrier from glObject
80  myAttributeCarriers.push_back(dynamic_cast<GNEAttributeCarrier*>(i));
81  // only continue if attributeCarrier isn't nullptr;
82  if (myAttributeCarriers.back()) {
83  // If we're editing a shape, ignore rest of elements (including other polygons)
84  if (editedPolyShape != nullptr) {
85  if (myAttributeCarriers.back() == editedPolyShape) {
86  // cast Poly from attribute carrier
87  myPolys.push_back(dynamic_cast<GNEPoly*>(myAttributeCarriers.back()));
88  }
89  } else {
90  // obtain tag property (only for improve code legibility)
91  const auto& tagValue = myAttributeCarriers.back()->getTagProperty();
92  // check if attributeCarrier can be casted into netElement, additional or shape
93  if (tagValue.isNetElement()) {
94  // cast netElement from attribute carrier
95  myNetElements.push_back(dynamic_cast<GNENetElement*>(myAttributeCarriers.back()));
96  } else if (tagValue.isDemandElement()) {
97  // cast demand element from attribute carrier
98  myDemandElements.push_back(dynamic_cast<GNEDemandElement*>(myAttributeCarriers.back()));
99  } else if (tagValue.isAdditional()) {
100  // cast additional element from attribute carrier
101  myAdditionals.push_back(dynamic_cast<GNEAdditional*>(myAttributeCarriers.back()));
102  } else if (tagValue.isShape()) {
103  // cast shape element from attribute carrier
104  myShapes.push_back(dynamic_cast<GNEShape*>(myAttributeCarriers.back()));
105  } else if (tagValue.isTAZ()) {
106  // cast TAZ element from attribute carrier
107  myTAZs.push_back(dynamic_cast<GNETAZ*>(myAttributeCarriers.back()));
108  }
109  // now set specify AC type
110  switch (i->getType()) {
111  case GLO_JUNCTION:
112  myJunctions.push_back(dynamic_cast<GNEJunction*>(myAttributeCarriers.back()));
113  break;
114  case GLO_EDGE: {
115  // fisrt obtain Edge
116  GNEEdge* edge = dynamic_cast<GNEEdge*>(myAttributeCarriers.back());
117  // check if parent edge is already inserted in myEdges (for example, due clicking over Geometry Points)
118  if (std::find(myEdges.begin(), myEdges.end(), edge) == myEdges.end()) {
119  myEdges.push_back(edge);
120  }
121  break;
122  }
123  case GLO_LANE: {
124  myLanes.push_back(dynamic_cast<GNELane*>(myAttributeCarriers.back()));
125  // check if edge's parent lane is already inserted in myEdges (for example, due clicking over Geometry Points)
126  if (std::find(myEdges.begin(), myEdges.end(), myLanes.back()->getParentEdge()) == myEdges.end()) {
127  myEdges.push_back(myLanes.back()->getParentEdge());
128  }
129  break;
130  }
131  case GLO_CROSSING:
132  myCrossings.push_back(dynamic_cast<GNECrossing*>(myAttributeCarriers.back()));
133  break;
134  case GLO_CONNECTION:
135  myConnections.push_back(dynamic_cast<GNEConnection*>(myAttributeCarriers.back()));
136  break;
137  case GLO_POI:
138  myPOIs.push_back(dynamic_cast<GNEPOI*>(myAttributeCarriers.back()));
139  break;
140  case GLO_POLYGON:
141  myPolys.push_back(dynamic_cast<GNEPoly*>(myAttributeCarriers.back()));
142  break;
143  default:
144  break;
145  }
146  }
147  } else {
148  myAttributeCarriers.pop_back();
149  }
150  }
151  }
152  // write information in debug mode
153  WRITE_DEBUG("ObjectsUnderCursor: GUIGlObjects: " + toString(GUIGlObjects.size()) +
154  ", AttributeCarriers: " + toString(myAttributeCarriers.size()) +
155  ", NetElements: " + toString(myNetElements.size()) +
156  ", Additionals: " + toString(myAdditionals.size()) +
157  ", DemandElements: " + toString(myDemandElements.size()) +
158  ", Shapes: " + toString(myShapes.size()) +
159  ", Junctions: " + toString(myJunctions.size()) +
160  ", Edges: " + toString(myEdges.size()) +
161  ", Lanes: " + toString(myLanes.size()) +
162  ", Crossings: " + toString(myCrossings.size()) +
163  ", Connections: " + toString(myConnections.size()) +
164  ", TAZs: " + toString(myTAZs.size()) +
165  ", POIs: " + toString(myPOIs.size()) +
166  ", Polys: " + toString(myPolys.size()));
167 }
168 
169 
170 void
172  // clear some containers
173  myGUIGlObjects.clear();
174  myAttributeCarriers.clear();
175  myNetElements.clear();
176  // fill containers using edges
177  for (const auto& i : myEdges) {
178  myGUIGlObjects.push_back(i);
179  myAttributeCarriers.push_back(i);
180  myNetElements.push_back(i);
181  }
182  // write information for debug
183  WRITE_DEBUG("ObjectsUnderCursor: swapped Lanes to edges")
184 }
185 
186 
187 GUIGlID
189  if (myGUIGlObjects.size() > 0) {
190  return myGUIGlObjects.front()->getGlID();
191  } else {
192  return 0;
193  }
194 }
195 
196 
199  if (myGUIGlObjects.size() > 0) {
200  return myGUIGlObjects.front()->getType();
201  } else {
202  return GLO_NETWORK;
203  }
204 }
205 
206 
209  if (myAttributeCarriers.size() > 0) {
210  return myAttributeCarriers.front();
211  } else {
212  return nullptr;
213  }
214 }
215 
216 
219  if (myNetElements.size() > 0) {
220  return myNetElements.front();
221  } else {
222  return nullptr;
223  }
224 }
225 
226 
229  if (myAdditionals.size() > 0) {
230  return myAdditionals.front();
231  } else {
232  return nullptr;
233  }
234 }
235 
236 
237 GNEShape*
239  if (myShapes.size() > 0) {
240  return myShapes.front();
241  } else {
242  return nullptr;
243  }
244 }
245 
246 
249  if (myDemandElements.size() > 0) {
250  return myDemandElements.front();
251  } else {
252  return nullptr;
253  }
254 }
255 
256 
259  if (myJunctions.size() > 0) {
260  return myJunctions.front();
261  } else {
262  return nullptr;
263  }
264 }
265 
266 
267 GNEEdge*
269  if (myEdges.size() > 0) {
270  return myEdges.front();
271  } else {
272  return nullptr;
273  }
274 }
275 
276 
277 GNELane*
279  if (myLanes.size() > 0) {
280  return myLanes.front();
281  } else {
282  return nullptr;
283  }
284 }
285 
286 
289  if (myCrossings.size() > 0) {
290  return myCrossings.front();
291  } else {
292  return nullptr;
293  }
294 }
295 
296 
299  if (myConnections.size() > 0) {
300  return myConnections.front();
301  } else {
302  return nullptr;
303  }
304 }
305 
306 
307 GNETAZ*
309  if (myTAZs.size() > 0) {
310  return myTAZs.front();
311  } else {
312  return nullptr;
313  }
314 }
315 
316 
317 GNEPOI*
319  if (myPOIs.size() > 0) {
320  return myPOIs.front();
321  } else {
322  return nullptr;
323  }
324 }
325 
326 
327 GNEPoly*
329  if (myPolys.size() > 0) {
330  return myPolys.front();
331  } else {
332  return nullptr;
333  }
334 }
335 
336 
337 const std::vector<GNEAttributeCarrier*>&
339  return myAttributeCarriers;
340 }
341 
342 
343 void
344 GNEViewNetHelper::ObjectsUnderCursor::sortGUIGlObjectsByAltitude(const std::vector<GUIGlObject*>& GUIGlObjects) {
345  // first clear myGUIGlObjects
346  myGUIGlObjects.clear();
347  // declare a map to save sorted GUIGlObjects
348  std::map<GUIGlObjectType, std::vector<GUIGlObject*> > mySortedGUIGlObjects;
349  for (const auto& i : GUIGlObjects) {
350  mySortedGUIGlObjects[i->getType()].push_back(i);
351  }
352  // move sorted GUIGlObjects into myGUIGlObjects using a reverse iterator
353  for (std::map<GUIGlObjectType, std::vector<GUIGlObject*> >::reverse_iterator i = mySortedGUIGlObjects.rbegin(); i != mySortedGUIGlObjects.rend(); i++) {
354  for (const auto& j : i->second) {
355  myGUIGlObjects.push_back(j);
356  }
357  }
358 }
359 
360 // ---------------------------------------------------------------------------
361 // GNEViewNetHelper::keyPressed - methods
362 // ---------------------------------------------------------------------------
363 
365  myEventInfo(nullptr) {
366 }
367 
368 
369 void
371  myEventInfo = (FXEvent*) eventData;
372 }
373 
374 
375 bool
377  if (myEventInfo) {
378  return (myEventInfo->state & SHIFTMASK) != 0;
379  } else {
380  return false;
381  }
382 }
383 
384 
385 bool
387  if (myEventInfo) {
388  return (myEventInfo->state & CONTROLMASK) != 0;
389  } else {
390  return false;
391  }
392 }
393 
394 // ---------------------------------------------------------------------------
395 // GNEViewNetHelper::MoveSingleElementValues - methods
396 // ---------------------------------------------------------------------------
397 
399  movingIndexShape(-1),
400  myViewNet(viewNet),
401  myMovingStartPos(false),
402  myMovingEndPos(false),
403  myJunctionToMove(nullptr),
404  myEdgeToMove(nullptr),
405  myPolyToMove(nullptr),
406  myPOIToMove(nullptr),
407  myAdditionalToMove(nullptr),
408  myDemandElementToMove(nullptr),
409  myTAZToMove(nullptr) {
410 }
411 
412 
413 bool
415  // first obtain moving reference (common for all)
416  myRelativeClickedPosition = myViewNet->getPositionInformation();
417  // check what type of AC will be moved
418  if (myViewNet->myObjectsUnderCursor.getPolyFront()) {
419  // calculate poly movement values (can be entire shape, single geometry points, altitude, etc.)
420  return calculatePolyValues();
421  } else if (myViewNet->myObjectsUnderCursor.getPOIFront()) {
422  // set POI moved object
423  myPOIToMove = myViewNet->myObjectsUnderCursor.getPOIFront();
424  // Save original Position of POI in view
425  originalPositionInView = myPOIToMove->getPositionInView();
426  // there is moved items, then return true
427  return true;
428  } else if (myViewNet->myObjectsUnderCursor.getAdditionalFront()) {
429  // set additionals moved object
430  myAdditionalToMove = myViewNet->myObjectsUnderCursor.getAdditionalFront();
431  // save current position of additional
432  originalPositionInView = myAdditionalToMove->getPositionInView();
433  // start additional geometry moving
434  myAdditionalToMove->startGeometryMoving();
435  // there is moved items, then return true
436  return true;
437  } else if (myViewNet->myObjectsUnderCursor.getTAZFront()) {
438  // calculate TAZ movement values (can be entire shape or single geometry points)
439  return calculateTAZValues();
440  } else if (myViewNet->myObjectsUnderCursor.getJunctionFront()) {
441  // set junction moved object
442  myJunctionToMove = myViewNet->myObjectsUnderCursor.getJunctionFront();
443  // Save original Position of Element in view
444  originalPositionInView = myJunctionToMove->getPositionInView();
445  // start junction geometry moving
446  myJunctionToMove->startGeometryMoving();
447  // there is moved items, then return true
448  return true;
449  } else if (myViewNet->myObjectsUnderCursor.getEdgeFront() || myViewNet->myObjectsUnderCursor.getLaneFront()) {
450  // calculate Edge movement values (can be entire shape, single geometry points, altitude, etc.)
451  return calculateEdgeValues();
452  } else {
453  // there isn't moved items, then return false
454  return false;
455  }
456 }
457 
458 
459 bool
461  // first obtain moving reference (common for all)
462  myRelativeClickedPosition = myViewNet->getPositionInformation();
463  // check what type of AC will be moved
464  if (myViewNet->myObjectsUnderCursor.getDemandElementFront()) {
465  // set additionals moved object
466  myDemandElementToMove = myViewNet->myObjectsUnderCursor.getDemandElementFront();
467  // save current position of demand element
468  originalPositionInView = myDemandElementToMove->getPositionInView();
469  // start demand element geometry moving
470  myDemandElementToMove->startGeometryMoving();
471  // there is moved items, then return true
472  return true;
473  } else {
474  // there isn't moved items, then return false
475  return false;
476  }
477 }
478 
479 
480 void
482  // calculate offsetMovement depending of current mouse position and relative clicked position
483  // @note #3521: Add checkBox to allow moving elements... has to be implemented and used here
484  Position offsetMovement = myViewNet->getPositionInformation() - myViewNet->myMoveSingleElementValues.myRelativeClickedPosition;
485  // calculate Z depending of moveElevation
486  if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->getCheck() == TRUE) {
487  // reset offset X and Y and use Y for Z
488  offsetMovement = Position(0, 0, offsetMovement.y());
489  } else {
490  // leave z empty (because in this case offset only actuates over X-Y)
491  offsetMovement.setz(0);
492  }
493  // check what element will be moved
494  if (myPolyToMove) {
495  // move shape's geometry without commiting changes depending if polygon is blocked
496  if (myPolyToMove->isPolygonBlocked()) {
497  // move entire shape
498  myPolyToMove->moveEntireShape(originalShapeBeforeMoving, offsetMovement);
499  } else {
500  // move only a certain Geometry Point
501  movingIndexShape = myPolyToMove->moveVertexShape(movingIndexShape, originalPositionInView, offsetMovement);
502  }
503  } else if (myPOIToMove) {
504  // Move POI's geometry without commiting changes
505  myPOIToMove->moveGeometry(originalPositionInView, offsetMovement);
506  } else if (myJunctionToMove) {
507  // Move Junction's geometry without commiting changes
508  myJunctionToMove->moveGeometry(originalPositionInView, offsetMovement);
509  } else if (myEdgeToMove) {
510  // check if we're moving the start or end position, or a geometry point
511  if (myMovingStartPos) {
512  myEdgeToMove->moveShapeStart(originalPositionInView, offsetMovement);
513  } else if (myMovingEndPos) {
514  myEdgeToMove->moveShapeEnd(originalPositionInView, offsetMovement);
515  } else {
516  // move edge's geometry without commiting changes
517  movingIndexShape = myEdgeToMove->moveVertexShape(movingIndexShape, originalPositionInView, offsetMovement);
518  }
519  } else if (myAdditionalToMove && (myAdditionalToMove->isAdditionalBlocked() == false)) {
520  // Move Additional geometry without commiting changes
521  myAdditionalToMove->moveGeometry(offsetMovement);
522  } else if (myDemandElementToMove/* && (myDemandElementToMove->isDemandElementBlocked() == false)*/) {
523  // Move DemandElement geometry without commiting changes
524  myDemandElementToMove->moveGeometry(offsetMovement);
525  } else if (myTAZToMove) {
527  if (myTAZToMove->isShapeBlocked()) {
528  // move entire shape
529  myTAZToMove->moveEntireShape(originalShapeBeforeMoving, offsetMovement);
530  } else {
531  // move only a certain Geometry Point
532  movingIndexShape = myTAZToMove->moveVertexShape(movingIndexShape, originalPositionInView, offsetMovement);
533  }
534  }
535  // update view (needed to see the movement)
536  myViewNet->update();
537 }
538 
539 
540 void
542  if (myPolyToMove) {
543  myPolyToMove->commitShapeChange(originalShapeBeforeMoving, myViewNet->getUndoList());
544  myPolyToMove = nullptr;
545  } else if (myPOIToMove) {
546  myPOIToMove->commitGeometryMoving(originalPositionInView, myViewNet->getUndoList());
547  myPOIToMove = nullptr;
548  } else if (myJunctionToMove) {
549  // check if in the moved position there is another Junction and it will be merged
550  if (!myViewNet->mergeJunctions(myJunctionToMove, originalPositionInView)) {
551  myJunctionToMove->commitGeometryMoving(originalPositionInView, myViewNet->getUndoList());
552  }
553  myJunctionToMove = nullptr;
554  } else if (myEdgeToMove) {
555  // commit change depending of what was moved
556  if (myMovingStartPos) {
557  myEdgeToMove->commitShapeStartChange(originalPositionInView, myViewNet->getUndoList());
558  myMovingStartPos = false;
559  } else if (myMovingEndPos) {
560  myEdgeToMove->commitShapeEndChange(originalPositionInView, myViewNet->getUndoList());
561  myMovingEndPos = false;
562  } else {
563  myEdgeToMove->commitShapeChange(originalShapeBeforeMoving, myViewNet->getUndoList());
564  }
565  myEdgeToMove = nullptr;
566  } else if (myAdditionalToMove) {
567  myAdditionalToMove->commitGeometryMoving(myViewNet->getUndoList());
568  myAdditionalToMove->endGeometryMoving();
569  myAdditionalToMove = nullptr;
570  } else if (myDemandElementToMove) {
571  myDemandElementToMove->commitGeometryMoving(myViewNet->getUndoList());
572  myDemandElementToMove->endGeometryMoving();
573  myDemandElementToMove = nullptr;
574  } else if (myTAZToMove) {
575  myTAZToMove->commitShapeChange(originalShapeBeforeMoving, myViewNet->getUndoList());
576  myTAZToMove = nullptr;
577  }
578 }
579 
580 
581 bool
583  // set Poly to move
584  myPolyToMove = myViewNet->myObjectsUnderCursor.getPolyFront();
585  // now we have two cases: if we're editing the X-Y coordenade or the altitude (z)
586  if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->getCheck() == TRUE) {
587  // check if in the clicked position a geometry point exist
588  int existentIndex = myPolyToMove->getVertexIndex(myViewNet->getPositionInformation(), false, false);
589  if (existentIndex != -1) {
590  // save original shape (needed for commit change)
591  myViewNet->myMoveSingleElementValues.originalShapeBeforeMoving = myPolyToMove->getShape();
592  // obtain existent index
593  myViewNet->myMoveSingleElementValues.movingIndexShape = existentIndex;
594  myViewNet->myMoveSingleElementValues.originalPositionInView = myPolyToMove->getShape()[existentIndex];
595  // poly values sucesfully calculated, then return true
596  return true;
597  } else {
598  // stop poly moving
599  myPolyToMove = nullptr;
600  // poly values wasn't calculated, then return false
601  return false;
602  }
603  } else {
604  // save original shape (needed for commit change)
605  myViewNet->myMoveSingleElementValues.originalShapeBeforeMoving = myPolyToMove->getShape();
606  // save clicked position as moving original position
607  myViewNet->myMoveSingleElementValues.originalPositionInView = myViewNet->getPositionInformation();
608  // obtain index of vertex to move if shape isn't blocked
609  if ((myPolyToMove->isPolygonBlocked() == false) && (myPolyToMove->isMovementBlocked() == false)) {
610  // check if we want to remove a Geometry Point
611  if (myViewNet->myKeyPressed.shiftKeyPressed()) {
612  // check if we're clicked over a Geometry Point
613  myViewNet->myMoveSingleElementValues.movingIndexShape = myPolyToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, false, false);
614  if (myViewNet->myMoveSingleElementValues.movingIndexShape != -1) {
615  myPolyToMove->deleteGeometryPoint(myViewNet->myMoveSingleElementValues.originalPositionInView);
616  // after removing Geomtery Point, reset PolyToMove
617  myPolyToMove = nullptr;
618  // poly values wasn't calculated, then return false
619  return false;
620  }
621  // poly values sucesfully calculated, then return true
622  return true;
623  } else {
624  // obtain index of vertex to move and moving reference
625  myViewNet->myMoveSingleElementValues.movingIndexShape = myPolyToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, false, false);
626  // check if a new Vertex must be created
627  if (myViewNet->myMoveSingleElementValues.movingIndexShape == -1) {
628  if (myPolyToMove->getShape().distance2D(myViewNet->myMoveSingleElementValues.originalPositionInView) <= 0.8) {
629  // create new geometry point
630  myViewNet->myMoveSingleElementValues.movingIndexShape = myPolyToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, true, true);
631  } else {
632  // nothing to move, then return false
633  return false;
634  }
635  }
636  // set Z value
637  myViewNet->myMoveSingleElementValues.originalPositionInView.setz(myPolyToMove->getShape()[myViewNet->myMoveSingleElementValues.movingIndexShape].z());
638  // poly values sucesfully calculated, then return true
639  return true;
640  }
641  } else {
642  myViewNet->myMoveSingleElementValues.movingIndexShape = -1;
643  // check if polygon has the entire movement blocked, or only the shape blocked
644  return (myPolyToMove->isMovementBlocked() == false);
645  }
646  }
647 }
648 
649 
650 bool
652  if (myViewNet->myKeyPressed.shiftKeyPressed()) {
653  // edit end point
654  myViewNet->myObjectsUnderCursor.getEdgeFront()->editEndpoint(myViewNet->getPositionInformation(), myViewNet->myUndoList);
655  // edge values wasn't calculated, then return false
656  return false;
657  } else {
658  // assign clicked edge to edgeToMove
659  myEdgeToMove = myViewNet->myObjectsUnderCursor.getEdgeFront();
660  // check if we clicked over a start or end position
661  if (myEdgeToMove->clickedOverShapeStart(myViewNet->getPositionInformation())) {
662  // save start pos
663  myViewNet->myMoveSingleElementValues.originalPositionInView = myEdgeToMove->getNBEdge()->getGeometry().front();
664  myViewNet->myMoveSingleElementValues.myMovingStartPos = true;
665  // start geometry moving
666  myEdgeToMove->startGeometryMoving();
667  // edge values sucesfully calculated, then return true
668  return true;
669  } else if (myEdgeToMove->clickedOverShapeEnd(myViewNet->getPositionInformation())) {
670  // save end pos
671  myViewNet->myMoveSingleElementValues.originalPositionInView = myEdgeToMove->getNBEdge()->getGeometry().back();
672  myViewNet->myMoveSingleElementValues.myMovingEndPos = true;
673  // start geometry moving
674  myEdgeToMove->startGeometryMoving();
675  // edge values sucesfully calculated, then return true
676  return true;
677  } else {
678  // now we have two cases: if we're editing the X-Y coordenade or the altitude (z)
679  if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->getCheck() == TRUE) {
680  // check if in the clicked position a geometry point exist
681  int existentIndex = myEdgeToMove->getVertexIndex(myViewNet->getPositionInformation(), false, false);
682  if (existentIndex != -1) {
683  myViewNet->myMoveSingleElementValues.movingIndexShape = existentIndex;
684  myViewNet->myMoveSingleElementValues.originalPositionInView = myEdgeToMove->getNBEdge()->getInnerGeometry()[existentIndex];
685  // start geometry moving
686  myEdgeToMove->startGeometryMoving();
687  // edge values sucesfully calculated, then return true
688  return true;
689  } else {
690  // stop edge moving
691  myEdgeToMove = nullptr;
692  // edge values wasn't calculated, then return false
693  return false;
694  }
695  } else {
696  // save original shape (needed for commit change)
697  myViewNet->myMoveSingleElementValues.originalShapeBeforeMoving = myEdgeToMove->getNBEdge()->getInnerGeometry();
698  // obtain index of vertex to move and moving reference
699  myViewNet->myMoveSingleElementValues.movingIndexShape = myEdgeToMove->getVertexIndex(myViewNet->getPositionInformation(), false, false);
700  // if index doesn't exist, create it snapping new edge to grid
701  if (myViewNet->myMoveSingleElementValues.movingIndexShape == -1) {
702  myViewNet->myMoveSingleElementValues.movingIndexShape = myEdgeToMove->getVertexIndex(myViewNet->getPositionInformation(), true, true);
703  }
704  // make sure that myViewNet->myMoveSingleElementValues.movingIndexShape isn't -1
705  if (myViewNet->myMoveSingleElementValues.movingIndexShape != -1) {
706  myViewNet->myMoveSingleElementValues.originalPositionInView = myEdgeToMove->getNBEdge()->getInnerGeometry()[myViewNet->myMoveSingleElementValues.movingIndexShape];
707  // start geometry moving
708  myEdgeToMove->startGeometryMoving();
709  // edge values sucesfully calculated, then return true
710  return true;
711  } else {
712  // edge values wasn't calculated, then return false
713  return false;
714  }
715  }
716  }
717  }
718 }
719 
720 
721 bool
723  // set TAZ to move
724  myTAZToMove = myViewNet->myObjectsUnderCursor.getTAZFront();
725  // save original shape (needed for commit change)
726  myViewNet->myMoveSingleElementValues.originalShapeBeforeMoving = myTAZToMove->getTAZShape();
727  // save clicked position as moving original position
728  myViewNet->myMoveSingleElementValues.originalPositionInView = myViewNet->getPositionInformation();
729  // obtain index of vertex to move if shape isn't blocked
730  if ((myTAZToMove->isShapeBlocked() == false) && (myTAZToMove->isAdditionalBlocked() == false)) {
731  // check if we want to remove a Geometry Point
732  if (myViewNet->myKeyPressed.shiftKeyPressed()) {
733  // check if we're clicked over a Geometry Point
734  myViewNet->myMoveSingleElementValues.movingIndexShape = myTAZToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, false, false);
735  if (myViewNet->myMoveSingleElementValues.movingIndexShape != -1) {
736  myTAZToMove->deleteGeometryPoint(myViewNet->myMoveSingleElementValues.originalPositionInView);
737  // after removing Geomtery Point, reset TAZToMove
738  myTAZToMove = nullptr;
739  // TAZ values wasn't calculated, then return false
740  return false;
741  }
742  // TAZ values sucesfully calculated, then return true
743  return true;
744  } else {
745  // obtain index of vertex to move and moving reference
746  myViewNet->myMoveSingleElementValues.movingIndexShape = myTAZToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, false, false);
747  if (myViewNet->myMoveSingleElementValues.movingIndexShape == -1) {
748  // create new geometry point
749  myViewNet->myMoveSingleElementValues.movingIndexShape = myTAZToMove->getVertexIndex(myViewNet->myMoveSingleElementValues.originalPositionInView, true, true);
750  }
751  // TAZ values sucesfully calculated, then return true
752  return true;
753  }
754  } else {
755  // abort moving index shape
756  myViewNet->myMoveSingleElementValues.movingIndexShape = -1;
757  // check if TAZ has the entire movement blocked, or only the shape blocked
758  return (myTAZToMove->isAdditionalBlocked() == false);
759  }
760 }
761 
762 // ---------------------------------------------------------------------------
763 // GNEViewNetHelper::MoveMultipleElementValues - methods
764 // ---------------------------------------------------------------------------
765 
767  myViewNet(viewNet),
768  myMovingSelection(false) {
769 }
770 
771 
772 void
774  // enable moving selection
775  myMovingSelection = true;
776  // save clicked position (to calculate offset)
777  myClickedPosition = myViewNet->getPositionInformation();
778  // obtain Junctions and edges selected
779  std::vector<GNEJunction*> selectedJunctions = myViewNet->getNet()->retrieveJunctions(true);
780  std::vector<GNEEdge*> selectedEdges = myViewNet->getNet()->retrieveEdges(true);
781  // Junctions are always moved, then save position of current selected junctions (Needed when mouse is released)
782  for (auto i : selectedJunctions) {
783  // save junction position
784  myMovedJunctionOriginPositions[i] = i->getPositionInView();
785  // start geometry moving
786  i->startGeometryMoving();
787  }
788  // make special movement depending of clicked AC
789  if (originAC->getTagProperty().getTag() == SUMO_TAG_JUNCTION) {
790  // if clicked element is a junction, move shapes of all selected edges
791  for (auto i : selectedEdges) {
792  // save entire edge geometry
793  myMovedEdgesOriginShape[i] = i->getNBEdge()->getInnerGeometry();
794  // start geometry moving
795  i->startGeometryMoving();
796  }
797  } else if (originAC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
798  // obtain clicked edge
799  GNEEdge* clickedEdge = dynamic_cast<GNEEdge*>(originAC);
800  // if clicked edge has origin and destiny junction selected, move shapes of all selected edges
801  if (myMovedJunctionOriginPositions.count(clickedEdge->getGNEJunctionSource()) > 0 &&
802  myMovedJunctionOriginPositions.count(clickedEdge->getGNEJunctionDestiny()) > 0) {
803  for (auto i : selectedEdges) {
804  // save entire edge geometry
805  myMovedEdgesOriginShape[i] = i->getNBEdge()->getInnerGeometry();
806  // start geometry moving
807  i->startGeometryMoving();
808  }
809  } else {
810  // declare three groups for dividing edges
811  std::vector<GNEEdge*> noJunctionsSelected;
812  std::vector<GNEEdge*> originJunctionSelected;
813  std::vector<GNEEdge*> destinyJunctionSelected;
814  // divide selected edges into four groups, depending of the selection of their junctions
815  for (auto i : selectedEdges) {
816  bool originSelected = myMovedJunctionOriginPositions.count(i->getGNEJunctionSource()) > 0;
817  bool destinySelected = myMovedJunctionOriginPositions.count(i->getGNEJunctionDestiny()) > 0;
818  // bot junctions selected
819  if (!originSelected && !destinySelected) {
820  noJunctionsSelected.push_back(i);
821  } else if (originSelected && !destinySelected) {
822  originJunctionSelected.push_back(i);
823  } else if (!originSelected && destinySelected) {
824  destinyJunctionSelected.push_back(i);
825  } else if (!originSelected && !destinySelected) {
826  // save edge geometry
827  myMovedEdgesOriginShape[i] = i->getNBEdge()->getInnerGeometry();
828  // start geometry moving
829  i->startGeometryMoving();
830  }
831  }
832  // save original shape of all noJunctionsSelected edges (needed for commit change)
833  for (auto i : noJunctionsSelected) {
834  myMovedEgdesGeometryPoints[i] = new MoveSingleElementValues(myViewNet);
835  // save edge geometry
836  myMovedEgdesGeometryPoints[i]->originalShapeBeforeMoving = i->getNBEdge()->getInnerGeometry();
837  // start geometry moving
838  i->startGeometryMoving();
839  }
840  // obtain index shape of clicked edge
841  int index = clickedEdge->getVertexIndex(myViewNet->getPositionInformation(), true, true);
842  // check that index is valid
843  if (index < 0) {
844  // end geometry moving without changes in moved junctions
845  for (auto i : myMovedJunctionOriginPositions) {
846  i.first->endGeometryMoving();
847  }
848  // end geometry moving without changes in moved edges
849  for (auto i : myMovedEdgesOriginShape) {
850  i.first->endGeometryMoving();
851  }
852  // end geometry moving without changes in moved shapes
853  for (auto i : myMovedEgdesGeometryPoints) {
854  i.first->endGeometryMoving();
855  }
856  // stop moving selection
857  myMovingSelection = false;
858  // clear containers
859  myMovedJunctionOriginPositions.clear();
860  myMovedEdgesOriginShape.clear();
861  // delete all movedEgdesGeometryPoints before clear container
862  for (const auto& i : myMovedEgdesGeometryPoints) {
863  delete i.second;
864  }
865  myMovedEgdesGeometryPoints.clear();
866  } else {
867  // save index and original position
868  myMovedEgdesGeometryPoints[clickedEdge] = new MoveSingleElementValues(myViewNet);
869  myMovedEgdesGeometryPoints[clickedEdge]->movingIndexShape = index;
870  myMovedEgdesGeometryPoints[clickedEdge]->originalPositionInView = myViewNet->getPositionInformation();
871  // start moving of clicked edge AFTER getting vertex Index
872  clickedEdge->startGeometryMoving();
873  // do the same for the rest of noJunctionsSelected edges
874  for (auto i : noJunctionsSelected) {
875  if (i != clickedEdge) {
876  myMovedEgdesGeometryPoints[i] = new MoveSingleElementValues(myViewNet);
877  // save index and original position
878  myMovedEgdesGeometryPoints[i]->movingIndexShape = i->getVertexIndex(myViewNet->getPositionInformation(), true, true);
879  // set originalPosition depending if edge is opposite to clicked edge
880  if (i->getOppositeEdge() == clickedEdge) {
881  myMovedEgdesGeometryPoints[i]->originalPositionInView = myViewNet->getPositionInformation();
882  } else {
883  myMovedEgdesGeometryPoints[i]->originalPositionInView = i->getNBEdge()->getInnerGeometry()[myMovedEgdesGeometryPoints[i]->movingIndexShape];
884  }
885  // start moving of clicked edge AFTER getting vertex Index
886  i->startGeometryMoving();
887  }
888  }
889  }
890  }
891  }
892 }
893 
894 
895 void
897  // calculate offset between current position and original position
898  Position offsetMovement = myViewNet->getPositionInformation() - myClickedPosition;
899  // calculate Z depending of Grid
900  if (myViewNet->myNetworkViewOptions.menuCheckMoveElevation->shown() && myViewNet->myNetworkViewOptions.menuCheckMoveElevation->getCheck() == TRUE) {
901  // reset offset X and Y and use Y for Z
902  offsetMovement = Position(0, 0, offsetMovement.y());
903  } else {
904  // leave z empty (because in this case offset only actuates over X-Y)
905  offsetMovement.setz(0);
906  }
907  // move selected junctions
908  for (auto i : myMovedJunctionOriginPositions) {
909  i.first->moveGeometry(i.second, offsetMovement);
910  }
911  // move entire edge shapes
912  for (auto i : myMovedEdgesOriginShape) {
913  i.first->moveEntireShape(i.second, offsetMovement);
914  }
915  // move partial shapes
916  for (auto i : myMovedEgdesGeometryPoints) {
917  i.first->moveVertexShape(i.second->movingIndexShape, i.second->originalPositionInView, offsetMovement);
918  }
919  // update view (needed to see the movement)
920  myViewNet->update();
921 }
922 
923 
924 void
926  // begin undo list
927  myViewNet->getUndoList()->p_begin("position of selected elements");
928  // commit positions of moved junctions
929  for (auto i : myMovedJunctionOriginPositions) {
930  i.first->commitGeometryMoving(i.second, myViewNet->getUndoList());
931  }
932  // commit shapes of entired moved edges
933  for (auto i : myMovedEdgesOriginShape) {
934  i.first->commitShapeChange(i.second, myViewNet->getUndoList());
935  }
936  //commit shapes of partial moved shapes
937  for (auto i : myMovedEgdesGeometryPoints) {
938  i.first->commitShapeChange(i.second->originalShapeBeforeMoving, myViewNet->getUndoList());
939  }
940  // end undo list
941  myViewNet->getUndoList()->p_end();
942  // stop moving selection
943  myMovingSelection = false;
944  // clear containers
945  myMovedJunctionOriginPositions.clear();
946  myMovedEdgesOriginShape.clear();
947  // delete all movedEgdesGeometryPoints before clear container
948  for (const auto& i : myMovedEgdesGeometryPoints) {
949  delete i.second;
950  }
951  myMovedEgdesGeometryPoints.clear();
952 }
953 
954 
955 bool
957  return myMovingSelection;
958 }
959 
960 // ---------------------------------------------------------------------------
961 // GNEViewNetHelper::VehicleOptions - methods
962 // ---------------------------------------------------------------------------
963 
965  myViewNet(viewNet) {
966 }
967 
968 
969 void
971  UNUSED_PARAMETER(myViewNet);
972  // currently unused
973 }
974 
975 
976 void
978  // currently unused
979 }
980 
981 // ---------------------------------------------------------------------------
982 // GNEViewNetHelper::VehicleTypeOptions - methods
983 // ---------------------------------------------------------------------------
984 
986  myViewNet(viewNet) {
987 }
988 
989 
990 void
992  UNUSED_PARAMETER(myViewNet);
993  // currently unused
994 }
995 
996 
997 void
999  // currently unused
1000 }
1001 
1002 // ---------------------------------------------------------------------------
1003 // GNEViewNetHelper::SelectingArea - methods
1004 // ---------------------------------------------------------------------------
1005 
1007  selectingUsingRectangle(false),
1008  startDrawing(false),
1009  myViewNet(viewNet) {
1010 }
1011 
1012 
1013 void
1015  selectingUsingRectangle = true;
1016  selectionCorner1 = myViewNet->getPositionInformation();
1017  selectionCorner2 = selectionCorner1;
1018 }
1019 
1020 
1021 void
1023  // start drawing
1024  startDrawing = true;
1025  // only update selection corner 2
1026  selectionCorner2 = myViewNet->getPositionInformation();
1027  // update status bar
1028  myViewNet->setStatusBarText("Selection width:" + toString(fabs(selectionCorner1.x() - selectionCorner2.x()))
1029  + " height:" + toString(fabs(selectionCorner1.y() - selectionCorner2.y()))
1030  + " diagonal:" + toString(selectionCorner1.distanceTo2D(selectionCorner2)));
1031  // update view (needed to update rectangle)
1032  myViewNet->update();
1033 }
1034 
1035 
1036 void
1038  // finish rectangle selection
1039  selectingUsingRectangle = false;
1040  startDrawing = false;
1041 }
1042 
1043 
1044 void
1046  // shift held down on mouse-down and mouse-up and check that rectangle exist
1047  if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1048  (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1049  myViewNet->myKeyPressed.shiftKeyPressed()) {
1050  // create boundary between two corners
1051  Boundary rectangleBoundary;
1052  rectangleBoundary.add(selectionCorner1);
1053  rectangleBoundary.add(selectionCorner2);
1054  // process selection within boundary
1055  processBoundarySelection(rectangleBoundary);
1056  }
1057 }
1058 
1059 
1060 std::vector<GNEEdge*>
1062  // declare vector for selection
1063  std::vector<GNEEdge*> result;
1064  // shift held down on mouse-down and mouse-up and check that rectangle exist
1065  if ((abs(selectionCorner1.x() - selectionCorner2.x()) > 0.01) &&
1066  (abs(selectionCorner1.y() - selectionCorner2.y()) > 0.01) &&
1067  myViewNet->myKeyPressed.shiftKeyPressed()) {
1068  // create boundary between two corners
1069  Boundary rectangleBoundary;
1070  rectangleBoundary.add(selectionCorner1);
1071  rectangleBoundary.add(selectionCorner2);
1072  if (myViewNet->makeCurrent()) {
1073  // obtain all ACs in Rectangle BOundary
1074  std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(rectangleBoundary);
1075  // Filter ACs in Boundary and get only edges
1076  for (auto i : ACsInBoundary) {
1077  if (i.second->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1078  result.push_back(dynamic_cast<GNEEdge*>(i.second));
1079  }
1080  }
1081  myViewNet->makeNonCurrent();
1082  }
1083  }
1084  return result;
1085 }
1086 
1087 
1088 void
1090  processBoundarySelection(shape.getBoxBoundary());
1091 }
1092 
1093 
1094 void
1096  if (selectingUsingRectangle) {
1097  glPushMatrix();
1098  glTranslated(0, 0, GLO_MAX - 1);
1099  GLHelper::setColor(color);
1100  glLineWidth(2);
1101  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1102  glBegin(GL_QUADS);
1103  glVertex2d(selectionCorner1.x(), selectionCorner1.y());
1104  glVertex2d(selectionCorner1.x(), selectionCorner2.y());
1105  glVertex2d(selectionCorner2.x(), selectionCorner2.y());
1106  glVertex2d(selectionCorner2.x(), selectionCorner1.y());
1107  glEnd();
1108  glPopMatrix();
1109  }
1110 }
1111 
1112 
1113 void
1115  if (myViewNet->makeCurrent()) {
1116  std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundary = myViewNet->getAttributeCarriersInBoundary(boundary);
1117  // filter ACsInBoundary depending of current supermode
1118  std::set<std::pair<std::string, GNEAttributeCarrier*> > ACsInBoundaryFiltered;
1119  for (const auto& i : ACsInBoundary) {
1120  if (((myViewNet->myEditModes.currentSupermode == GNE_SUPERMODE_NETWORK) && !i.second->getTagProperty().isDemandElement()) ||
1121  ((myViewNet->myEditModes.currentSupermode == GNE_SUPERMODE_DEMAND) && i.second->getTagProperty().isDemandElement())) {
1122  ACsInBoundaryFiltered.insert(i);
1123  }
1124  }
1125  // declare two sets of attribute carriers, one for select and another for unselect
1126  std::vector<GNEAttributeCarrier*> ACToSelect;
1127  std::vector<GNEAttributeCarrier*> ACToUnselect;
1128  // reserve memory (we assume that in the worst case we're going to insert all elements of ACsInBoundaryFiltered
1129  ACToSelect.reserve(ACsInBoundaryFiltered.size());
1130  ACToUnselect.reserve(ACsInBoundaryFiltered.size());
1131  // in restrict AND replace mode all current selected attribute carriers will be unselected
1132  if ((myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode() == GNESelectorFrame::ModificationMode::SET_RESTRICT) ||
1133  (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode() == GNESelectorFrame::ModificationMode::SET_REPLACE)) {
1134  // obtain selected ACs depending of current supermode
1135  std::vector<GNEAttributeCarrier*> selectedAC = myViewNet->getNet()->getSelectedAttributeCarriers(false);
1136  // add id into ACs to unselect
1137  for (auto i : selectedAC) {
1138  ACToUnselect.push_back(i);
1139  }
1140  }
1141  // iterate over AtributeCarriers obtained of boundary an place it in ACToSelect or ACToUnselect
1142  for (auto i : ACsInBoundaryFiltered) {
1143  switch (myViewNet->myViewParent->getSelectorFrame()->getModificationModeModul()->getModificationMode()) {
1145  ACToUnselect.push_back(i.second);
1146  break;
1148  if (std::find(ACToUnselect.begin(), ACToUnselect.end(), i.second) != ACToUnselect.end()) {
1149  ACToSelect.push_back(i.second);
1150  }
1151  break;
1152  default:
1153  ACToSelect.push_back(i.second);
1154  break;
1155  }
1156  }
1157  // select junctions and their connections and crossings if Auto select junctions is enabled (note: only for "add mode")
1158  if (myViewNet->autoSelectNodes() && GNESelectorFrame::ModificationMode::SET_ADD) {
1159  std::vector<GNEEdge*> edgesToSelect;
1160  // iterate over ACToSelect and extract edges
1161  for (auto i : ACToSelect) {
1162  if (i->getTagProperty().getTag() == SUMO_TAG_EDGE) {
1163  edgesToSelect.push_back(dynamic_cast<GNEEdge*>(i));
1164  }
1165  }
1166  // iterate over extracted edges
1167  for (auto i : edgesToSelect) {
1168  // select junction source and all their connections and crossings
1169  ACToSelect.push_back(i->getGNEJunctionSource());
1170  for (auto j : i->getGNEJunctionSource()->getGNEConnections()) {
1171  ACToSelect.push_back(j);
1172  }
1173  for (auto j : i->getGNEJunctionSource()->getGNECrossings()) {
1174  ACToSelect.push_back(j);
1175  }
1176  // select junction destiny and all their connections crossings
1177  ACToSelect.push_back(i->getGNEJunctionDestiny());
1178  for (auto j : i->getGNEJunctionDestiny()->getGNEConnections()) {
1179  ACToSelect.push_back(j);
1180  }
1181  for (auto j : i->getGNEJunctionDestiny()->getGNECrossings()) {
1182  ACToSelect.push_back(j);
1183  }
1184  }
1185  }
1186  // only continue if there is ACs to select or unselect
1187  if ((ACToSelect.size() + ACToUnselect.size()) > 0) {
1188  // first unselect AC of ACToUnselect and then selects AC of ACToSelect
1189  myViewNet->myUndoList->p_begin("selection using rectangle");
1190  for (auto i : ACToUnselect) {
1191  i->setAttribute(GNE_ATTR_SELECTED, "0", myViewNet->myUndoList);
1192  }
1193  for (auto i : ACToSelect) {
1194  if (i->getTagProperty().isSelectable()) {
1195  i->setAttribute(GNE_ATTR_SELECTED, "1", myViewNet->myUndoList);
1196  }
1197  }
1198  myViewNet->myUndoList->p_end();
1199  }
1200  myViewNet->makeNonCurrent();
1201  }
1202 }
1203 
1204 // ---------------------------------------------------------------------------
1205 // GNEViewNetHelper::TestingMode - methods
1206 // ---------------------------------------------------------------------------
1207 
1209  myViewNet(viewNet),
1210  myTestingEnabled(OptionsCont::getOptions().getBool("gui-testing")),
1211  myTestingWidth(0),
1212  myTestingHeight(0) {
1213 }
1214 
1215 
1216 void
1218  // first check if testing mode is enabled and window size is correct
1219  if (myTestingEnabled && OptionsCont::getOptions().isSet("window-size")) {
1220  std::vector<std::string> windowSize = OptionsCont::getOptions().getStringVector("window-size");
1221  // make sure that given windows size has exactly two valid int values
1222  if ((windowSize.size() == 2) && GNEAttributeCarrier::canParse<int>(windowSize[0]) && GNEAttributeCarrier::canParse<int>(windowSize[1])) {
1223  myTestingWidth = GNEAttributeCarrier::parse<int>(windowSize[0]);
1224  myTestingHeight = GNEAttributeCarrier::parse<int>(windowSize[1]);
1225  } else {
1226  WRITE_ERROR("Invalid windows size-format: " + toString(windowSize) + "for option 'window-size'");
1227  }
1228  }
1229 }
1230 
1231 
1232 void
1234  // first check if testing mode is neabled
1235  if (myTestingEnabled) {
1236  // check if main windows has to be resized
1237  if (myTestingWidth > 0 && ((myViewNet->getWidth() != myTestingWidth) || (myViewNet->getHeight() != myTestingHeight))) {
1238  // only resize once to avoid flickering
1239  //std::cout << " before resize: view=" << getWidth() << ", " << getHeight() << " app=" << mainWindow->getWidth() << ", " << mainWindow->getHeight() << "\n";
1240  mainWindow->resize(myTestingWidth + myTestingWidth - myViewNet->getWidth(), myTestingHeight + myTestingHeight - myViewNet->getHeight());
1241  //std::cout << " directly after resize: view=" << getWidth() << ", " << getHeight() << " app=" << mainWindow->getWidth() << ", " << mainWindow->getHeight() << "\n";
1242  myTestingWidth = 0;
1243  }
1244  //std::cout << " fixed: view=" << getWidth() << ", " << getHeight() << " app=" << mainWindow->getWidth() << ", " << mainWindow->getHeight() << "\n";
1245  // draw pink square in the upper left corner on top of everything
1246  glPushMatrix();
1247  const double size = myViewNet->p2m(32);
1248  Position center = myViewNet->screenPos2NetPos(8, 8);
1250  glTranslated(center.x(), center.y(), GLO_MAX - 1);
1251  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1252  glBegin(GL_QUADS);
1253  glVertex2d(0, 0);
1254  glVertex2d(0, -size);
1255  glVertex2d(size, -size);
1256  glVertex2d(size, 0);
1257  glEnd();
1258  glPopMatrix();
1259  glPushMatrix();
1260  // show box with the current position relative to pink square
1261  Position posRelative = myViewNet->screenPos2NetPos(myViewNet->getWidth() - 40, myViewNet->getHeight() - 20);
1262  // adjust cursor position (24,25) to show exactly the same position as in function netedit.leftClick(match, X, Y)
1263  GLHelper::drawTextBox(toString(myViewNet->getWindowCursorPosition().x() - 24) + " " + toString(myViewNet->getWindowCursorPosition().y() - 25), posRelative, GLO_MAX - 1, myViewNet->p2m(20), RGBColor::BLACK, RGBColor::WHITE);
1264  glPopMatrix();
1265  }
1266 }
1267 
1268 
1269 bool
1271  return myTestingEnabled;
1272 }
1273 
1274 // ---------------------------------------------------------------------------
1275 // GNEViewNetHelper::EditModes - methods
1276 // ---------------------------------------------------------------------------
1277 
1279  currentSupermode(GNE_SUPERMODE_NONE),
1280  networkEditMode(GNE_NMODE_INSPECT),
1281  demandEditMode(GNE_DMODE_INSPECT),
1282  networkButton(nullptr),
1283  demandButton(nullptr),
1284  myViewNet(viewNet) {
1285 }
1286 
1287 
1288 void
1290  // create buttons
1291  networkButton = new MFXCheckableButton(false, myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes, "Network\t\tSet mode for edit network elements.",
1293  networkButton->create();
1294 
1295  demandButton = new MFXCheckableButton(false, myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().superModes, "Demand\t\tSet mode for edit traffic demand.",
1297  demandButton->create();
1298 
1299  // recalc menu bar because there is new elements
1300  myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
1301  // show menu bar modes
1302  myViewNet->getViewParent()->getGNEAppWindows()->getToolbarsGrip().modes->show();
1303 }
1304 
1305 
1306 void
1308  if (supermode == currentSupermode) {
1309  myViewNet->setStatusBarText("Mode already selected");
1310  if (myViewNet->myCurrentFrame != nullptr) {
1311  myViewNet->myCurrentFrame->focusUpperElement();
1312  }
1313  } else {
1314  myViewNet->setStatusBarText("");
1315  // abort current operation
1316  myViewNet->abortOperation(false);
1317  // set super mode
1318  currentSupermode = supermode;
1319  // set supermodes
1320  if (supermode == GNE_SUPERMODE_NETWORK) {
1321  // change buttons
1322  networkButton->setChecked(true);
1323  demandButton->setChecked(false);
1324  // show network buttons
1325  myViewNet->myNetworkCheckableButtons.showNetworkCheckableButtons();
1326  // hide demand buttons
1327  myViewNet->myDemandCheckableButtons.hideDemandCheckableButtons();
1328  // force update network mode
1329  setNetworkEditMode(networkEditMode, true);
1330  } else if (supermode == GNE_SUPERMODE_DEMAND) {
1331  // change buttons
1332  networkButton->setChecked(false);
1333  demandButton->setChecked(true);
1334  // hide network buttons
1335  myViewNet->myNetworkCheckableButtons.hideNetworkCheckableButtons();
1336  // show demand buttons
1337  myViewNet->myDemandCheckableButtons.showDemandCheckableButtons();
1338  // force update demand mode
1339  setDemandEditMode(demandEditMode, true);
1340  }
1341  // update buttons
1342  networkButton->update();
1343  demandButton->update();
1344  // update Supermode CommandButtons in GNEAppWindows
1345  myViewNet->myViewParent->getGNEAppWindows()->updateSuperModeMenuCommands(currentSupermode);
1346  }
1347 }
1348 
1349 
1350 void
1352  if ((mode == networkEditMode) && !force) {
1353  myViewNet->setStatusBarText("Network mode already selected");
1354  if (myViewNet->myCurrentFrame != nullptr) {
1355  myViewNet->myCurrentFrame->focusUpperElement();
1356  }
1357  } else if (networkEditMode == GNE_NMODE_TLS && !myViewNet->myViewParent->getTLSEditorFrame()->isTLSSaved()) {
1358  myViewNet->setStatusBarText("save modifications in TLS before change mode");
1359  myViewNet->myCurrentFrame->focusUpperElement();
1360  } else {
1361  myViewNet->setStatusBarText("");
1362  myViewNet->abortOperation(false);
1363  // stop editing of custom shapes
1364  myViewNet->myEditShapes.stopEditCustomShape();
1365  // set new Network mode
1366  networkEditMode = mode;
1367  // for common modes (Inspect/Delete/Select/move) change also the other supermode
1368  if (networkEditMode == GNE_NMODE_INSPECT) {
1369  demandEditMode = GNE_DMODE_INSPECT;
1370  } else if (networkEditMode == GNE_NMODE_DELETE) {
1371  demandEditMode = GNE_DMODE_DELETE;
1372  } else if (networkEditMode == GNE_NMODE_SELECT) {
1373  demandEditMode = GNE_DMODE_SELECT;
1374  } else if (networkEditMode == GNE_NMODE_MOVE) {
1375  demandEditMode = GNE_DMODE_MOVE;
1376  }
1377  // certain modes require a recomputing
1378  switch (mode) {
1379  case GNE_NMODE_CONNECT:
1380  case GNE_NMODE_PROHIBITION:
1381  case GNE_NMODE_TLS:
1382  // modes which depend on computed data
1383  myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
1384  break;
1385  default:
1386  break;
1387  }
1388  // update network mode specific controls
1389  myViewNet->updateNetworkModeSpecificControls();
1390  }
1391 }
1392 
1393 
1394 void
1396  if ((mode == demandEditMode) && !force) {
1397  myViewNet->setStatusBarText("Demand mode already selected");
1398  if (myViewNet->myCurrentFrame != nullptr) {
1399  myViewNet->myCurrentFrame->focusUpperElement();
1400  }
1401  } else {
1402  myViewNet->setStatusBarText("");
1403  myViewNet->abortOperation(false);
1404  // stop editing of custom shapes
1405  myViewNet->myEditShapes.stopEditCustomShape();
1406  // set new Demand mode
1407  demandEditMode = mode;
1408  // for common modes (Inspect/Delete/Select/Move) change also the other supermode
1409  if (demandEditMode == GNE_DMODE_INSPECT) {
1410  networkEditMode = GNE_NMODE_INSPECT;
1411  } else if (demandEditMode == GNE_DMODE_DELETE) {
1412  networkEditMode = GNE_NMODE_DELETE;
1413  } else if (demandEditMode == GNE_DMODE_SELECT) {
1414  networkEditMode = GNE_NMODE_SELECT;
1415  } else if (demandEditMode == GNE_DMODE_MOVE) {
1416  networkEditMode = GNE_NMODE_MOVE;
1417  }
1418  // demand modes require ALWAYS a recomputing
1419  myViewNet->myNet->computeNetwork(myViewNet->myViewParent->getGNEAppWindows());
1420  // update DijkstraRouter of RouteCalculatorInstance
1422  // update network mode specific controls
1423  myViewNet->updateDemandModeSpecificControls();
1424  }
1425 }
1426 
1427 // ---------------------------------------------------------------------------
1428 // GNEViewNetHelper::CommonViewOptions - methods
1429 // ---------------------------------------------------------------------------
1430 
1431 
1433  menuCheckShowGrid(nullptr),
1434  myViewNet(viewNet) {
1435 }
1436 
1437 
1438 void
1440 
1441  menuCheckShowGrid = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1442  ("Grid\t\tshow grid and restrict movement to the grid (size defined in visualization options)"),
1443  myViewNet, MID_GNE_COMMONVIEWOPTIONS_SHOWGRID, LAYOUT_FIX_HEIGHT);
1444  menuCheckShowGrid->setHeight(23);
1445  menuCheckShowGrid->setCheck(false);
1446  menuCheckShowGrid->create();
1447 
1448 }
1449 
1450 
1451 void
1453  menuCheckShowGrid->hide();
1454 }
1455 
1456 
1457 void
1458 GNEViewNetHelper::CommonViewOptions::getVisibleCommonMenuCommands(std::vector<FXMenuCheck*>& commands) const {
1459  // save visible menu commands in commands vector
1460  if (menuCheckShowGrid->shown()) {
1461  commands.push_back(menuCheckShowGrid);
1462  }
1463 }
1464 
1465 // ---------------------------------------------------------------------------
1466 // GNEViewNetHelper::NetworkViewOptions - methods
1467 // ---------------------------------------------------------------------------
1468 
1470  myViewNet(viewNet) {
1471 }
1472 
1473 
1474 void
1476  menuCheckShowDemandElements = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1477  ("Show demand elements\t\tToggle show demand elements"),
1478  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS, LAYOUT_FIX_HEIGHT);
1479  menuCheckShowDemandElements->setHeight(23);
1480  menuCheckShowDemandElements->setCheck(false);
1481  menuCheckShowDemandElements->create();
1482 
1483  menuCheckSelectEdges = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1484  ("Select edges\t\tToggle whether clicking should select " + toString(SUMO_TAG_EDGE) + "s or " + toString(SUMO_TAG_LANE) + "s").c_str(),
1485  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES, LAYOUT_FIX_HEIGHT);
1486  menuCheckSelectEdges->setHeight(23);
1487  menuCheckSelectEdges->setCheck(true);
1488  menuCheckSelectEdges->create();
1489 
1490  menuCheckShowConnections = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1491  ("Show " + toString(SUMO_TAG_CONNECTION) + "s\t\tToggle show " + toString(SUMO_TAG_CONNECTION) + "s over " + toString(SUMO_TAG_JUNCTION) + "s").c_str(),
1492  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS, LAYOUT_FIX_HEIGHT);
1493  menuCheckShowConnections->setHeight(23);
1494  menuCheckShowConnections->setCheck(myViewNet->getVisualisationSettings()->showLane2Lane);
1495  menuCheckShowConnections->create();
1496 
1497  menuCheckHideConnections = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1498  ("hide " + toString(SUMO_TAG_CONNECTION) + "s\t\tHide connections").c_str(),
1499  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS, LAYOUT_FIX_HEIGHT);
1500  menuCheckHideConnections->setHeight(23);
1501  menuCheckHideConnections->setCheck(false);
1502  menuCheckHideConnections->create();
1503 
1504  menuCheckExtendSelection = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1505  ("Auto-select " + toString(SUMO_TAG_JUNCTION) + "s\t\tToggle whether selecting multiple " + toString(SUMO_TAG_EDGE) + "s should automatically select their " + toString(SUMO_TAG_JUNCTION) + "s").c_str(),
1506  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION, LAYOUT_FIX_HEIGHT);
1507  menuCheckExtendSelection->setHeight(23);
1508  menuCheckExtendSelection->setCheck(false);
1509  menuCheckExtendSelection->create();
1510 
1511  menuCheckChangeAllPhases = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1512  ("Apply change to all phases\t\tToggle whether clicking should apply state changes to all phases of the current " + toString(SUMO_TAG_TRAFFIC_LIGHT) + " plan").c_str(),
1513  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES, LAYOUT_FIX_HEIGHT);
1514  menuCheckChangeAllPhases->setHeight(23);
1515  menuCheckChangeAllPhases->setCheck(false);
1516  menuCheckChangeAllPhases->create();
1517 
1518  menuCheckWarnAboutMerge = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1519  ("Ask for merge\t\tAsk for confirmation before merging " + toString(SUMO_TAG_JUNCTION) + ".").c_str(),
1520  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE, LAYOUT_FIX_HEIGHT);
1521  menuCheckWarnAboutMerge->setHeight(23);
1522  menuCheckWarnAboutMerge->setCheck(true);
1523  menuCheckWarnAboutMerge->create();
1524 
1525  menuCheckShowJunctionBubble = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1526  ("Bubbles\t\tShow bubbles over " + toString(SUMO_TAG_JUNCTION) + "'s shapes.").c_str(),
1527  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES, LAYOUT_FIX_HEIGHT);
1528  menuCheckShowJunctionBubble->setHeight(23);
1529  menuCheckShowJunctionBubble->setCheck(false);
1530  menuCheckShowJunctionBubble->create();
1531 
1532  menuCheckMoveElevation = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1533  ("Elevation\t\tApply mouse movement to elevation instead of x,y position"),
1534  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION, LAYOUT_FIX_HEIGHT);
1535  menuCheckMoveElevation->setHeight(23);
1536  menuCheckMoveElevation->setCheck(false);
1537  menuCheckMoveElevation->create();
1538 
1539  menuCheckChainEdges = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1540  ("Chain\t\tCreate consecutive " + toString(SUMO_TAG_EDGE) + "s with a single click (hit ESC to cancel chain).").c_str(),
1541  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES, LAYOUT_FIX_HEIGHT);
1542  menuCheckChainEdges->setHeight(23);
1543  menuCheckChainEdges->setCheck(false);
1544  menuCheckChainEdges->create();
1545 
1546  menuCheckAutoOppositeEdge = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1547  ("Two-way\t\tAutomatically create an " + toString(SUMO_TAG_EDGE) + " in the opposite direction").c_str(),
1548  myViewNet, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES, LAYOUT_FIX_HEIGHT);
1549  menuCheckAutoOppositeEdge->setHeight(23);
1550  menuCheckAutoOppositeEdge->setCheck(false);
1551  menuCheckAutoOppositeEdge->create();
1552 
1553  // always recalc after creating new elements
1554  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions->recalc();
1555 }
1556 
1557 
1558 void
1560  menuCheckShowDemandElements->hide();
1561  menuCheckSelectEdges->hide();
1562  menuCheckShowConnections->hide();
1563  menuCheckHideConnections->hide();
1564  menuCheckExtendSelection->hide();
1565  menuCheckChangeAllPhases->hide();
1566  menuCheckWarnAboutMerge->hide();
1567  menuCheckShowJunctionBubble->hide();
1568  menuCheckMoveElevation->hide();
1569  menuCheckChainEdges->hide();
1570  menuCheckAutoOppositeEdge->hide();
1571  // Also hide toolbar grip
1572  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions->show();
1573 }
1574 
1575 
1576 void
1578  // save visible menu commands in commands vector
1579  if (menuCheckShowDemandElements->shown()) {
1580  commands.push_back(menuCheckShowDemandElements);
1581  }
1582  if (menuCheckSelectEdges->shown()) {
1583  commands.push_back(menuCheckSelectEdges);
1584  }
1585  if (menuCheckShowConnections->shown()) {
1586  commands.push_back(menuCheckShowConnections);
1587  }
1588  if (menuCheckHideConnections->shown()) {
1589  commands.push_back(menuCheckHideConnections);
1590  }
1591  if (menuCheckExtendSelection->shown()) {
1592  commands.push_back(menuCheckExtendSelection);
1593  }
1594  if (menuCheckChangeAllPhases->shown()) {
1595  commands.push_back(menuCheckChangeAllPhases);
1596  }
1597  if (menuCheckWarnAboutMerge->shown()) {
1598  commands.push_back(menuCheckWarnAboutMerge);
1599  }
1600  if (menuCheckShowJunctionBubble->shown()) {
1601  commands.push_back(menuCheckShowJunctionBubble);
1602  }
1603  if (menuCheckMoveElevation->shown()) {
1604  commands.push_back(menuCheckMoveElevation);
1605  }
1606  if (menuCheckChainEdges->shown()) {
1607  commands.push_back(menuCheckChainEdges);
1608  }
1609  if (menuCheckAutoOppositeEdge->shown()) {
1610  commands.push_back(menuCheckAutoOppositeEdge);
1611  }
1612 }
1613 
1614 
1615 bool
1617  if (menuCheckShowDemandElements->shown()) {
1618  return (menuCheckShowDemandElements->getCheck() == TRUE);
1619  } else {
1620  // by default, if menuCheckShowDemandElements isn't shown, always show demand elements
1621  return true;
1622  }
1623 }
1624 
1625 
1626 bool
1628  if (menuCheckSelectEdges->shown()) {
1629  return (menuCheckSelectEdges->getCheck() == TRUE);
1630  } else {
1631  // by default, if menuCheckSelectEdges isn't shown, always select edges
1632  return true;
1633  }
1634 }
1635 
1636 
1637 bool
1639  if (myViewNet->myEditModes.networkEditMode == GNE_NMODE_CONNECT) {
1640  // check if menu hceck hide connections ins shown
1641  return (menuCheckHideConnections->getCheck() == FALSE);
1642  } else if (myViewNet->myEditModes.networkEditMode == GNE_NMODE_PROHIBITION) {
1643  return true;
1644  } else if (menuCheckShowConnections->shown() == false) {
1645  return false;
1646  } else {
1647  return (myViewNet->getVisualisationSettings()->showLane2Lane);
1648  }
1649 }
1650 
1651 
1652 bool
1654  if (menuCheckMoveElevation->shown()) {
1655  return (menuCheckMoveElevation->getCheck() == TRUE);
1656  } else {
1657  return false;
1658  }
1659 }
1660 
1661 // ---------------------------------------------------------------------------
1662 // GNEViewNetHelper::DemandViewOptions - methods
1663 // ---------------------------------------------------------------------------
1664 
1666  menuCheckHideShapes(nullptr),
1667  menuCheckHideNonInspectedDemandElements(nullptr),
1668  menuCheckShowAllPersonPlans(nullptr),
1669  menuCheckLockPerson(nullptr),
1670  myViewNet(viewNet),
1671  myLockedPerson(nullptr) {
1672 }
1673 
1674 
1675 void
1677 
1678  menuCheckHideShapes = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1679  ("Hide shapes\t\tToggle show shapes (Polygons and POIs)"),
1680  myViewNet, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES, LAYOUT_FIX_HEIGHT);
1681  menuCheckHideShapes->setHeight(23);
1682  menuCheckHideShapes->setCheck(false);
1683  menuCheckHideShapes->create();
1684 
1685  menuCheckHideNonInspectedDemandElements = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1686  ("Hide non-inspected elements\t\tToggle show non-inspected demand elements"),
1687  myViewNet, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED, LAYOUT_FIX_HEIGHT);
1688  menuCheckHideNonInspectedDemandElements->setHeight(23);
1689  menuCheckHideNonInspectedDemandElements->setCheck(false);
1690  menuCheckHideNonInspectedDemandElements->create();
1691 
1692  menuCheckShowAllPersonPlans = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1693  ("Show all person plans\t\tshow all person plans"),
1694  myViewNet, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS, LAYOUT_FIX_HEIGHT);
1695  menuCheckShowAllPersonPlans->setHeight(23);
1696  menuCheckShowAllPersonPlans->setCheck(false);
1697  menuCheckShowAllPersonPlans->create();
1698 
1699  menuCheckLockPerson = new FXMenuCheck(myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions,
1700  ("Lock person\t\tLock selected person"),
1701  myViewNet, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON, LAYOUT_FIX_HEIGHT);
1702  menuCheckLockPerson->setHeight(23);
1703  menuCheckLockPerson->setCheck(false);
1704  menuCheckLockPerson->create();
1705 
1706  // always recalc after creating new elements
1707  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions->recalc();
1708 }
1709 
1710 
1711 void
1713  menuCheckHideShapes->hide();
1714  menuCheckHideNonInspectedDemandElements->hide();
1715  menuCheckShowAllPersonPlans->hide();
1716  menuCheckLockPerson->hide();
1717  // Also hide toolbar grip
1718  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modeOptions->show();
1719 }
1720 
1721 
1722 void
1723 GNEViewNetHelper::DemandViewOptions::getVisibleDemandMenuCommands(std::vector<FXMenuCheck*>& commands) const {
1724  // save visible menu commands in commands vector
1725  if (menuCheckHideShapes->shown()) {
1726  commands.push_back(menuCheckHideShapes);
1727  }
1728  if (menuCheckHideNonInspectedDemandElements->shown()) {
1729  commands.push_back(menuCheckHideNonInspectedDemandElements);
1730  }
1731  if (menuCheckShowAllPersonPlans->shown() && menuCheckShowAllPersonPlans->isEnabled()) {
1732  commands.push_back(menuCheckShowAllPersonPlans);
1733  }
1734  if (menuCheckLockPerson->shown() && menuCheckLockPerson->isEnabled()) {
1735  commands.push_back(menuCheckLockPerson);
1736  }
1737 }
1738 
1739 
1740 bool
1742  if (menuCheckHideNonInspectedDemandElements->shown()) {
1743  // check conditions
1744  if ((menuCheckHideNonInspectedDemandElements->getCheck() == FALSE) || (myViewNet->getDottedAC() == nullptr)) {
1745  // if checkbox is disabled or there isn't insepected element, then return true
1746  return true;
1747  } else if (myViewNet->getDottedAC()->getTagProperty().isDemandElement()) {
1748  if (myViewNet->getDottedAC() == demandElement) {
1749  // if inspected element correspond to demandElement, return true
1750  return true;
1751  } else {
1752  // if demandElement is a route, check if dottedAC is one of their children (Vehicle or Stop)
1753  for (const auto& i : demandElement->getChildDemandElements()) {
1754  if (i == myViewNet->getDottedAC()) {
1755  return true;
1756  }
1757  }
1758  // if demandElement is a vehicle, check if dottedAC is one of his route Parent
1759  for (const auto& i : demandElement->getParentDemandElements()) {
1760  if (i == myViewNet->getDottedAC()) {
1761  return true;
1762  }
1763  }
1764  // dottedAC isn't one of their parent, then return false
1765  return false;
1766  }
1767  } else {
1768  // we're inspecting a demand element, then return true
1769  return true;
1770  }
1771  } else {
1772  // we're inspecting a demand element, then return true
1773  return true;
1774  }
1775 }
1776 
1777 
1778 bool
1780  if (menuCheckHideShapes->shown()) {
1781  return (menuCheckHideShapes->getCheck() == FALSE);
1782  } else {
1783  return true;
1784  }
1785 }
1786 
1787 
1788 bool
1790  if (menuCheckShowAllPersonPlans->shown() && menuCheckShowAllPersonPlans->isEnabled()) {
1791  return (menuCheckShowAllPersonPlans->getCheck() == TRUE);
1792  } else {
1793  return false;
1794  }
1795 }
1796 
1797 
1798 void
1800  myLockedPerson = person;
1801 }
1802 
1803 
1804 void
1806  myLockedPerson = nullptr;
1807 }
1808 
1809 
1810 const GNEDemandElement*
1812  return myLockedPerson;
1813 }
1814 
1815 // ---------------------------------------------------------------------------
1816 // GNEViewNetHelper::CommonCheckableButtons - methods
1817 // ---------------------------------------------------------------------------
1818 
1820  inspectButton(nullptr),
1821  deleteButton(nullptr),
1822  selectButton(nullptr),
1823  moveButton(nullptr),
1824  myViewNet(viewNet) {
1825 }
1826 
1827 
1828 void
1830  // inspect button
1831  inspectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset inspect mode\tMode for inspect elements and change their attributes.",
1833  inspectButton->create();
1834  // delete button
1835  deleteButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset delete mode\tMode for delete elements.",
1837  deleteButton->create();
1838  // select button
1839  selectButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset select mode\tMode for select elements.",
1841  selectButton->create();
1842  // move button
1843  moveButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset move mode\tMode for move elements.",
1845  moveButton->create();
1846  // always recalc menu bar after creating new elements
1847  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
1848 }
1849 
1850 
1851 void
1853  inspectButton->show();
1854  deleteButton->show();
1855  selectButton->show();
1856  moveButton->show();
1857 }
1858 
1859 
1860 void
1862  inspectButton->hide();
1863  deleteButton->hide();
1864  selectButton->hide();
1865  moveButton->hide();
1866 }
1867 
1868 
1869 void
1871  inspectButton->setChecked(false);
1872  deleteButton->setChecked(false);
1873  selectButton->setChecked(false);
1874  moveButton->setChecked(false);
1875 }
1876 
1877 
1878 void
1880  inspectButton->update();
1881  deleteButton->update();
1882  selectButton->update();
1883  moveButton->update();
1884 }
1885 
1886 // ---------------------------------------------------------------------------
1887 // GNEViewNetHelper::NetworkCheckableButtons - methods
1888 // ---------------------------------------------------------------------------
1889 
1891  createEdgeButton(nullptr),
1892  connectionButton(nullptr),
1893  trafficLightButton(nullptr),
1894  additionalButton(nullptr),
1895  crossingButton(nullptr),
1896  TAZButton(nullptr),
1897  shapeButton(nullptr),
1898  prohibitionButton(nullptr),
1899  myViewNet(viewNet) {
1900 }
1901 
1902 
1903 void
1905  // create edge
1906  createEdgeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset create edge mode\tMode for creating junction and edges.",
1908  createEdgeButton->create();
1909  // connection mode
1910  connectionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset connection mode\tMode for edit connections between lanes.",
1912  connectionButton->create();
1913  // prohibition mode
1914  prohibitionButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset prohibition mode\tMode for editing connection prohibitions.",
1916  prohibitionButton->create();
1917  // traffic light mode
1918  trafficLightButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset traffic light mode\tMode for edit traffic lights over junctions.",
1920  trafficLightButton->create();
1921  // additional mode
1922  additionalButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset additional mode\tMode for adding additional elements.",
1924  additionalButton->create();
1925  // crossing mode
1926  crossingButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset crossing mode\tMode for creating crossings between edges.",
1928  crossingButton->create();
1929  // TAZ Mode
1930  TAZButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset TAZ mode\tMode for creating Traffic Assignment Zones.",
1932  TAZButton->create();
1933  // shape mode
1934  shapeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tset polygon mode\tMode for creating polygons and POIs.",
1936  shapeButton->create();
1937  // always recalc after creating new elements
1938  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
1939 }
1940 
1941 
1942 void
1944  createEdgeButton->show();
1945  connectionButton->show();
1946  trafficLightButton->show();
1947  additionalButton->show();
1948  crossingButton->show();
1949  TAZButton->show();
1950  shapeButton->show();
1951  prohibitionButton->show();
1952 }
1953 
1954 
1955 void
1957  createEdgeButton->hide();
1958  connectionButton->hide();
1959  trafficLightButton->hide();
1960  additionalButton->hide();
1961  crossingButton->hide();
1962  TAZButton->hide();
1963  shapeButton->hide();
1964  prohibitionButton->hide();
1965 }
1966 
1967 
1968 void
1970  createEdgeButton->setChecked(false);
1971  connectionButton->setChecked(false);
1972  trafficLightButton->setChecked(false);
1973  additionalButton->setChecked(false);
1974  crossingButton->setChecked(false);
1975  TAZButton->setChecked(false);
1976  shapeButton->setChecked(false);
1977  prohibitionButton->setChecked(false);
1978 }
1979 
1980 
1981 void
1983  createEdgeButton->update();
1984  connectionButton->update();
1985  trafficLightButton->update();
1986  additionalButton->update();
1987  crossingButton->update();
1988  TAZButton->update();
1989  shapeButton->update();
1990  prohibitionButton->update();
1991 }
1992 
1993 // ---------------------------------------------------------------------------
1994 // GNEViewNetHelper::DemandCheckableButtons - methods
1995 // ---------------------------------------------------------------------------
1996 
1998  routeButton(nullptr),
1999  vehicleButton(nullptr),
2000  vehicleTypeButton(nullptr),
2001  stopButton(nullptr),
2002  personTypeButton(nullptr),
2003  personButton(nullptr),
2004  personPlanButton(nullptr),
2005  myViewNet(viewNet) {
2006 }
2007 
2008 
2009 void
2011  // route mode
2012  routeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate route mode\tMode for creating routes.",
2014  routeButton->create();
2015  // vehicle mode
2016  vehicleButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate vehicle mode\tMode for creating vehicles.",
2018  vehicleButton->create();
2019  // vehicle type mode
2020  vehicleTypeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate vehicle type mode\tMode for creating vehicle types.",
2022  vehicleTypeButton->create();
2023  // stop mode
2024  stopButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate stop mode\tMode for creating stops.",
2026  stopButton->create();
2027  // person type mode
2028  personTypeButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate person type mode\tMode for creating person types.",
2030  personTypeButton->create();
2031  // person mode
2032  personButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate person mode\tMode for creating persons.",
2034  personButton->create();
2035  // person plan mode
2036  personPlanButton = new MFXCheckableButton(false, myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, "\tcreate person plan mode\tMode for creating person plans.",
2038  personPlanButton->create();
2039  // always recalc after creating new elements
2040  myViewNet->myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
2041 }
2042 
2043 
2044 void
2046  routeButton->show();
2047  vehicleButton->show();
2048  vehicleTypeButton->show();
2049  stopButton->show();
2050  personTypeButton->show();
2051  personButton->show();
2052  personPlanButton->show();
2053 }
2054 
2055 
2056 void
2058  routeButton->hide();
2059  vehicleButton->hide();
2060  vehicleTypeButton->hide();
2061  stopButton->hide();
2062  personTypeButton->hide();
2063  personButton->hide();
2064  personPlanButton->hide();
2065 }
2066 
2067 
2068 void
2070  routeButton->setChecked(false);
2071  vehicleButton->setChecked(false);
2072  vehicleTypeButton->setChecked(false);
2073  stopButton->setChecked(false);
2074  personTypeButton->setChecked(false);
2075  personButton->setChecked(false);
2076  personPlanButton->setChecked(false);
2077 }
2078 
2079 
2080 void
2082  routeButton->update();
2083  vehicleButton->update();
2084  vehicleTypeButton->update();
2085  stopButton->update();
2086  personTypeButton->update();
2087  personButton->update();
2088  personPlanButton->update();
2089 }
2090 
2091 // ---------------------------------------------------------------------------
2092 // GNEViewNetHelper::EditShapes - methods
2093 // ---------------------------------------------------------------------------
2094 
2096  editedShapePoly(nullptr),
2097  editingNetElementShapes(false),
2098  myViewNet(viewNet) {
2099 }
2100 
2101 
2102 void
2104  if ((editedShapePoly == nullptr) && (element != nullptr) && (shape.size() > 1)) {
2105  // save current edit mode before starting
2106  myPreviousNetworkEditMode = myViewNet->myEditModes.networkEditMode;
2107  if ((element->getTagProperty().getTag() == SUMO_TAG_CONNECTION) || (element->getTagProperty().getTag() == SUMO_TAG_CROSSING)) {
2108  editingNetElementShapes = true;
2109  } else {
2110  editingNetElementShapes = false;
2111  }
2112  // set move mode
2113  myViewNet->myEditModes.setNetworkEditMode(GNE_NMODE_MOVE);
2114  // add special GNEPoly fo edit shapes (color is taken from junction color settings)
2115  RGBColor col = myViewNet->getVisualisationSettings()->junctionColorer.getSchemes()[0].getColor(3);
2116  editedShapePoly = myViewNet->myNet->addPolygonForEditShapes(element, shape, fill, col);
2117  // update view net to show the new editedShapePoly
2118  myViewNet->update();
2119  }
2120 }
2121 
2122 
2123 void
2125  // stop edit shape junction deleting editedShapePoly
2126  if (editedShapePoly != nullptr) {
2127  myViewNet->myNet->removePolygonForEditShapes(editedShapePoly);
2128  editedShapePoly = nullptr;
2129  // restore previous edit mode
2130  if (myViewNet->myEditModes.networkEditMode != myPreviousNetworkEditMode) {
2131  myViewNet->myEditModes.setNetworkEditMode(myPreviousNetworkEditMode);
2132  }
2133  }
2134 }
2135 
2136 
2137 void
2139  // save edited junction's shape
2140  if (editedShapePoly != nullptr) {
2141  myViewNet->myUndoList->p_begin("custom " + editedShapePoly->getShapeEditedElement()->getTagStr() + " shape");
2143  if (editedShapePoly->getShapeEditedElement()->getTagProperty().hasAttribute(SUMO_ATTR_CUSTOMSHAPE)) {
2144  attr = SUMO_ATTR_CUSTOMSHAPE;
2145  }
2146  editedShapePoly->getShapeEditedElement()->setAttribute(attr, toString(editedShapePoly->getShape()), myViewNet->myUndoList);
2147  myViewNet->myUndoList->p_end();
2148  stopEditCustomShape();
2149  myViewNet->update();
2150  }
2151 }
2152 
2153 /****************************************************************************/
GNEViewNetHelper::CommonCheckableButtons::updateCommonCheckableButtons
void updateCommonCheckableButtons()
update Common checkable buttons
Definition: GNEViewNetHelper.cpp:1879
GNEViewNetHelper::MoveMultipleElementValues::isMovingSelection
bool isMovingSelection() const
check if currently there is element being moved
Definition: GNEViewNetHelper.cpp:956
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:31
GNEDemandElement::RouteCalculator::updateDijkstraRouter
void updateDijkstraRouter()
update DijkstraRoute (called when SuperMode Demand is selected)
Definition: GNEDemandElement.cpp:64
GLO_CONNECTION
@ GLO_CONNECTION
a connection
Definition: GUIGlObjectTypes.h:54
MID_HOTKEY_F4_SUPERMODE_DEMAND
@ MID_HOTKEY_F4_SUPERMODE_DEMAND
hot key <F4> set demand mode in NETEDIT
Definition: GUIAppEnum.h:171
GLO_MAX
@ GLO_MAX
empty max
Definition: GUIGlObjectTypes.h:165
GNEViewNetHelper::ObjectsUnderCursor::getPolyFront
GNEPoly * getPolyFront() const
get front Poly (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:328
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
GNEViewNetHelper::DemandCheckableButtons::disableDemandCheckableButtons
void disableDemandCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:2069
GNEViewNetHelper::EditShapes::EditShapes
EditShapes(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:2095
ICON_MODEPERSONPLAN
@ ICON_MODEPERSONPLAN
Definition: GUIIcons.h:242
ICON_MODEVEHICLETYPE
@ ICON_MODEVEHICLETYPE
Definition: GUIIcons.h:238
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:48
GNEViewNetHelper::KeyPressed::KeyPressed
KeyPressed()
constructor
Definition: GNEViewNetHelper.cpp:364
GNEViewNetHelper::KeyPressed::shiftKeyPressed
bool shiftKeyPressed() const
check if SHIFT key was pressed during click
Definition: GNEViewNetHelper.cpp:376
DemandEditMode
DemandEditMode
@brie enum for demand edit modes
Definition: GNEViewNetHelper.h:82
MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
lock person
Definition: GUIAppEnum.h:633
GNEViewNetHelper::MoveMultipleElementValues::moveSelection
void moveSelection()
move selection
Definition: GNEViewNetHelper.cpp:896
GNEViewNetHelper::CommonViewOptions::CommonViewOptions
CommonViewOptions(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1432
ICON_SUPERMODENETWORK
@ ICON_SUPERMODENETWORK
Definition: GUIIcons.h:214
GNEDemandElement::getRouteCalculatorInstance
static RouteCalculator * getRouteCalculatorInstance()
obtain instance of RouteCalculator
Definition: GNEDemandElement.cpp:280
ICON_MODESELECT
@ ICON_MODESELECT
Definition: GUIIcons.h:228
GNEViewNetHelper::MoveSingleElementValues::calculateTAZValues
bool calculateTAZValues()
calculate TAZ movement values (Position, Index, etc.)
Definition: GNEViewNetHelper.cpp:722
GNEViewNetHelper::SelectingArea::processShapeSelection
void processShapeSelection(const PositionVector &shape)
process shape selection
Definition: GNEViewNetHelper.cpp:1089
GNEHierarchicalChildElements::getChildDemandElements
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition: GNEHierarchicalChildElements.cpp:296
GNEViewNetHelper::ObjectsUnderCursor::getPOIFront
GNEPOI * getPOIFront() const
get front POI (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:318
GNEViewNetHelper::DemandViewOptions::lockPerson
void lockPerson(const GNEDemandElement *person)
lock person
Definition: GNEViewNetHelper.cpp:1799
GNEViewNetHelper::DemandViewOptions::getLockedPerson
const GNEDemandElement * getLockedPerson() const
get locked person
Definition: GNEViewNetHelper.cpp:1811
RGBColor::BLACK
static const RGBColor BLACK
Definition: RGBColor.h:197
GNESelectorFrame::ModificationMode::SET_RESTRICT
@ SET_RESTRICT
Definition: GNESelectorFrame.h:130
ICON_MODETAZ
@ ICON_MODETAZ
Definition: GUIIcons.h:224
OptionsCont.h
GNEPOI
Definition: GNEPOI.h:44
GNEViewNetHelper::DemandCheckableButtons::DemandCheckableButtons
DemandCheckableButtons(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1997
GNEViewNetHelper::CommonCheckableButtons::hideCommonCheckableButtons
void hideCommonCheckableButtons()
hide all Common Checkable Buttons
Definition: GNEViewNetHelper.cpp:1861
GNEViewNetHelper::KeyPressed::controlKeyPressed
bool controlKeyPressed() const
check if CONTROL key was pressed during click
Definition: GNEViewNetHelper.cpp:386
GNEViewNetHelper::DemandViewOptions::hideDemandViewOptionsMenuChecks
void hideDemandViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:1712
SUMO_ATTR_CUSTOMSHAPE
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
Definition: SUMOXMLDefinitions.h:702
GNEViewNetHelper::DemandViewOptions::getVisibleDemandMenuCommands
void getVisibleDemandMenuCommands(std::vector< FXMenuCheck * > &commands) const
get visible demand menu commands
Definition: GNEViewNetHelper.cpp:1723
GNEViewNetHelper::CommonCheckableButtons::disableCommonCheckableButtons
void disableCommonCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:1870
GNESelectorFrame::ModificationMode::SET_REPLACE
@ SET_REPLACE
Definition: GNESelectorFrame.h:131
GNEPoly
Definition: GNEPoly.h:45
GNEViewNetHelper::ObjectsUnderCursor::updateObjectUnderCursor
void updateObjectUnderCursor(const std::vector< GUIGlObject * > &GUIGlObjects, GNEPoly *editedPolyShape)
update objects under cursor (Called only in onLeftBtnPress(...) function)
Definition: GNEViewNetHelper.cpp:58
ICON_MODECREATEEDGE
@ ICON_MODECREATEEDGE
Definition: GUIIcons.h:222
SUMO_TAG_LANE
@ SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
ICON_MODEADDITIONAL
@ ICON_MODEADDITIONAL
Definition: GUIIcons.h:220
GNE_DMODE_INSPECT
@ GNE_DMODE_INSPECT
mode for inspecting demand elements
Definition: GNEViewNetHelper.h:86
GNEViewNetHelper::EditModes::setNetworkEditMode
void setNetworkEditMode(NetworkEditMode networkMode, bool force=false)
set Network edit mode
Definition: GNEViewNetHelper.cpp:1351
MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
show all person plans
Definition: GUIAppEnum.h:631
GNEViewNetHelper::TestingMode::TestingMode
TestingMode(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1208
GNEViewNetHelper::ObjectsUnderCursor::getTAZFront
GNETAZ * getTAZFront() const
get front TAZ (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:308
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
GNEViewNetHelper::CommonViewOptions::hideCommonViewOptionsMenuChecks
void hideCommonViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:1452
GNEViewNetHelper::NetworkViewOptions::showDemandElements
bool showDemandElements() const
check if show demand elements checkbox is enabled
Definition: GNEViewNetHelper.cpp:1616
GNEViewNetHelper::MoveSingleElementValues::calculateEdgeValues
bool calculateEdgeValues()
calculate Edge movement values (Position, Index, etc.)
Definition: GNEViewNetHelper.cpp:651
GNEViewNet
Definition: GNEViewNet.h:42
GNEViewNetHelper::ObjectsUnderCursor::getEdgeFront
GNEEdge * getEdgeFront() const
get front edge (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:268
GNEViewNetHelper::DemandCheckableButtons::hideDemandCheckableButtons
void hideDemandCheckableButtons()
hide all Demand Checkable Buttons
Definition: GNEViewNetHelper.cpp:2057
GLHelper.h
GNEViewNetHelper::NetworkCheckableButtons::updateNetworkCheckableButtons
void updateNetworkCheckableButtons()
update network checkable buttons
Definition: GNEViewNetHelper.cpp:1982
GNEViewNetHelper::ObjectsUnderCursor::getGlIDFront
GUIGlID getGlIDFront() const
get front GUI GL ID (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:188
GUIDesigns.h
GNEViewNetHelper::VehicleOptions::VehicleOptions
VehicleOptions(GNEViewNet *viewNet)
constructor
Definition: GNEViewNetHelper.cpp:964
GNEViewNetHelper::TestingMode::drawTestingElements
void drawTestingElements(GUIMainWindow *mainWindow)
draw testing element
Definition: GNEViewNetHelper.cpp:1233
MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
show connections
Definition: GUIAppEnum.h:609
GNE_NMODE_TLS
@ GNE_NMODE_TLS
mode for editing tls
Definition: GNEViewNetHelper.h:68
MID_HOTKEY_D_DELETEMODE
@ MID_HOTKEY_D_DELETEMODE
hotkey for mode deleting things
Definition: GUIAppEnum.h:49
GLO_CROSSING
@ GLO_CROSSING
a tl-logic
Definition: GUIGlObjectTypes.h:52
MID_HOTKEY_C_CONNECTMODE_PERSONPLANMODE
@ MID_HOTKEY_C_CONNECTMODE_PERSONPLANMODE
hotkey for mode connecting lanes
Definition: GUIAppEnum.h:47
MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
show junctions as bubbles
Definition: GUIAppEnum.h:619
PositionVector
A list of positions.
Definition: PositionVector.h:45
GUIIconSubSys::getIcon
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:609
MID_HOTKEY_Z_TAZMODE
@ MID_HOTKEY_Z_TAZMODE
hotkey for mode editing TAZ
Definition: GUIAppEnum.h:69
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:621
PositionVector::getBoxBoundary
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
Definition: PositionVector.cpp:390
GNESelectorFrame::ModificationMode::SET_SUB
@ SET_SUB
Definition: GNESelectorFrame.h:129
GNEViewNetHelper::DemandCheckableButtons::showDemandCheckableButtons
void showDemandCheckableButtons()
show all Demand Checkable Buttons
Definition: GNEViewNetHelper.cpp:2045
GUIDesignButtonToolbarSupermode
#define GUIDesignButtonToolbarSupermode
checkable button with icon placed in navigation toolbar for supermodes
Definition: GUIDesigns.h:91
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
ICON_MODEPOLYGON
@ ICON_MODEPOLYGON
Definition: GUIIcons.h:230
GNEViewNetHelper::SelectingArea::moveRectangleSelection
void moveRectangleSelection()
move rectangle selection
Definition: GNEViewNetHelper.cpp:1022
ICON_MODEMOVE
@ ICON_MODEMOVE
Definition: GUIIcons.h:227
MID_HOTKEY_S_SELECTMODE
@ MID_HOTKEY_S_SELECTMODE
hotkey for mode selecting objects
Definition: GUIAppEnum.h:59
GLO_POLYGON
@ GLO_POLYGON
a polygon
Definition: GUIGlObjectTypes.h:104
GNEEdge::getVertexIndex
int getVertexIndex(Position pos, bool createIfNoExist, bool snapToGrid)
return index of a vertex of shape, or of a new vertex if position is over an shape's edge
Definition: GNEEdge.cpp:301
GNEViewNetHelper::NetworkCheckableButtons::hideNetworkCheckableButtons
void hideNetworkCheckableButtons()
hide all Network Checkable Buttons
Definition: GNEViewNetHelper.cpp:1956
GUIAppEnum.h
OptionsCont::getStringVector
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
Definition: OptionsCont.cpp:235
GNEJunction.h
MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
@ MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
extend selection
Definition: GUIAppEnum.h:613
GNE_NMODE_DELETE
@ GNE_NMODE_DELETE
mode for deleting network elements
Definition: GNEViewNetHelper.h:58
GNEViewNetHelper::DemandViewOptions::DemandViewOptions
DemandViewOptions(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1665
GUIGlObjectType
GUIGlObjectType
Definition: GUIGlObjectTypes.h:39
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
ICON_MODESTOP
@ ICON_MODESTOP
Definition: GUIIcons.h:239
MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES
@ MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES
hide shapes
Definition: GUIAppEnum.h:629
GNEViewNetHelper::DemandViewOptions::unlockPerson
void unlockPerson()
unlock person
Definition: GNEViewNetHelper.cpp:1805
ICON_MODEDELETE
@ ICON_MODEDELETE
Definition: GUIIcons.h:225
RGBColor
Definition: RGBColor.h:39
GNEViewNetHelper::TestingMode::isTestingEnabled
bool isTestingEnabled() const
check if testing mode is enabled
Definition: GNEViewNetHelper.cpp:1270
GNEViewNetHelper::DemandViewOptions::buildDemandViewOptionsMenuChecks
void buildDemandViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:1676
RGBColor::MAGENTA
static const RGBColor MAGENTA
Definition: RGBColor.h:194
GNE_DMODE_SELECT
@ GNE_DMODE_SELECT
mode for selecting demand elements
Definition: GNEViewNetHelper.h:90
ICON_MODEVEHICLE
@ ICON_MODEVEHICLE
Definition: GUIIcons.h:237
GNEViewNetHelper::NetworkCheckableButtons::disableNetworkCheckableButtons
void disableNetworkCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:1969
GNECrossing
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNECrossing.h:44
GNETAZ.h
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1273
GNEHierarchicalParentElements::getParentDemandElements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
Definition: GNEHierarchicalParentElements.cpp:114
GNEViewNetHelper::EditModes::setSupermode
void setSupermode(Supermode supermode)
set Network edit mode
Definition: GNEViewNetHelper.cpp:1307
GNEViewNetHelper::MoveSingleElementValues::finishMoveSingleElement
void finishMoveSingleElement()
finish moving single elements in Network AND Demand mode
Definition: GNEViewNetHelper.cpp:541
GNEViewNetHelper::SelectingArea::drawRectangleSelection
void drawRectangleSelection(const RGBColor &color) const
draw rectangle selection
Definition: GNEViewNetHelper.cpp:1095
GNEViewNetHelper::SelectingArea::beginRectangleSelection
void beginRectangleSelection()
begin rectangle selection
Definition: GNEViewNetHelper.cpp:1014
GNEShape
Definition: GNEShape.h:34
ICON_MODEPERSON
@ ICON_MODEPERSON
Definition: GUIIcons.h:241
GNEViewNetHelper::CommonCheckableButtons::showCommonCheckableButtons
void showCommonCheckableButtons()
show all Common Checkable Buttons
Definition: GNEViewNetHelper.cpp:1852
GNEViewNetHelper::SelectingArea::processBoundarySelection
void processBoundarySelection(const Boundary &boundary)
Process boundary Selection.
Definition: GNEViewNetHelper.cpp:1114
GNEViewNetHelper::EditModes::buildSuperModeButtons
void buildSuperModeButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:1289
ICON_MODECROSSING
@ ICON_MODECROSSING
Definition: GUIIcons.h:223
GNEEdge::getNBEdge
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:631
GNEViewNetHelper::CommonCheckableButtons::buildCommonCheckableButtons
void buildCommonCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:1829
GNEDemandElement.h
GNEViewNetHelper::SelectingArea::SelectingArea
SelectingArea(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1006
GNEViewNetHelper::MoveSingleElementValues
struct used to group all variables related with movement of single elements
Definition: GNEViewNetHelper.h:489
MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
@ MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
hide connections
Definition: GUIAppEnum.h:611
GNEViewNet.h
GNEViewNetHelper::MoveMultipleElementValues::beginMoveSelection
void beginMoveSelection(GNEAttributeCarrier *originAC)
begin move selection
Definition: GNEViewNetHelper.cpp:773
GNEViewNetHelper::SelectingArea::processRectangleSelection
void processRectangleSelection()
process rectangle Selection
Definition: GNEViewNetHelper.cpp:1045
GNEViewNetHelper::NetworkCheckableButtons::showNetworkCheckableButtons
void showNetworkCheckableButtons()
show all Network Checkable Buttons
Definition: GNEViewNetHelper.cpp:1943
NBEdge::getInnerGeometry
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
Definition: NBEdge.cpp:552
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode
bool beginMoveSingleElementNetworkMode()
begin move single element in Network mode
Definition: GNEViewNetHelper.cpp:414
ICON_MODEPERSONTYPE
@ ICON_MODEPERSONTYPE
Definition: GUIIcons.h:240
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
@ MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
ask before merging junctions
Definition: GUIAppEnum.h:617
GNETLSEditorFrame.h
GNE_NMODE_SELECT
@ GNE_NMODE_SELECT
mode for selecting network elements
Definition: GNEViewNetHelper.h:60
GNE_SUPERMODE_NETWORK
@ GNE_SUPERMODE_NETWORK
Network mode (Edges, junctions, etc..)
Definition: GNEViewNetHelper.h:46
MID_HOTKEY_W_PROHIBITIONMODE_PERSONTYPEMODE
@ MID_HOTKEY_W_PROHIBITIONMODE_PERSONTYPEMODE
hotkey for mode editing connection prohibitions AND person types
Definition: GUIAppEnum.h:67
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
GLO_EDGE
@ GLO_EDGE
an edge
Definition: GUIGlObjectTypes.h:46
GNEApplicationWindow.h
GNE_NMODE_CONNECT
@ GNE_NMODE_CONNECT
mode for connecting lanes
Definition: GNEViewNetHelper.h:66
Position::x
double x() const
Returns the x-position.
Definition: Position.h:56
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
GNEEdge.h
GNEViewNetHelper::CommonViewOptions::getVisibleCommonMenuCommands
void getVisibleCommonMenuCommands(std::vector< FXMenuCheck * > &commands) const
get visible common menu commands
Definition: GNEViewNetHelper.cpp:1458
GNETAZ
Definition: GNETAZ.h:34
GNEViewNetHelper::NetworkViewOptions::getVisibleNetworkMenuCommands
void getVisibleNetworkMenuCommands(std::vector< FXMenuCheck * > &commands) const
get visible network menu commands
Definition: GNEViewNetHelper.cpp:1577
GNEViewNetHelper::MoveMultipleElementValues::finishMoveSelection
void finishMoveSelection()
finish moving selection
Definition: GNEViewNetHelper.cpp:925
GLO_POI
@ GLO_POI
a poi
Definition: GUIGlObjectTypes.h:106
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
GLO_LANE
@ GLO_LANE
a lane
Definition: GUIGlObjectTypes.h:48
GNEViewNetHelper::NetworkViewOptions::editingElevation
bool editingElevation() const
check if we're editing elevation
Definition: GNEViewNetHelper.cpp:1653
ICON_MODECONNECTION
@ ICON_MODECONNECTION
Definition: GUIIcons.h:221
ICON_MODEROUTE
@ ICON_MODEROUTE
Definition: GUIIcons.h:236
GNENetElement
Definition: GNENetElement.h:43
GNEViewNetHelper::ObjectsUnderCursor::getConnectionFront
GNEConnection * getConnectionFront() const
get front connection (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:298
Supermode
Supermode
@brie enum for supermodes
Definition: GNEViewNetHelper.h:42
GNEViewNetHelper::NetworkViewOptions::showConnections
bool showConnections() const
check if select show connections checkbox is enabled
Definition: GNEViewNetHelper.cpp:1638
GNEViewNetHelper::TestingMode::initTestingMode
void initTestingMode()
init testing mode
Definition: GNEViewNetHelper.cpp:1217
GNESelectorFrame::ModificationMode::SET_ADD
@ SET_ADD
Definition: GNESelectorFrame.h:128
GNEEdge::getGNEJunctionDestiny
GNEJunction * getGNEJunctionDestiny() const
returns the destination-junction
Definition: GNEEdge.cpp:493
GNECrossing.h
GNEViewNetHelper::DemandViewOptions::showShapes
bool showShapes() const
check if shapes has to be hide
Definition: GNEViewNetHelper.cpp:1779
GNEViewNetHelper::NetworkCheckableButtons::NetworkCheckableButtons
NetworkCheckableButtons(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1890
MID_HOTKEY_T_TLSMODE_VTYPEMODE
@ MID_HOTKEY_T_TLSMODE_VTYPEMODE
hotkey for mode editing TLS AND Vehicle Types
Definition: GUIAppEnum.h:63
GNEViewNetHelper::NetworkViewOptions::buildNetworkViewOptionsMenuChecks
void buildNetworkViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:1475
GNEViewNetHelper::DemandCheckableButtons::updateDemandCheckableButtons
void updateDemandCheckableButtons()
update Demand checkable buttons
Definition: GNEViewNetHelper.cpp:2081
NetworkEditMode
NetworkEditMode
@brie enum for network edit modes
Definition: GNEViewNetHelper.h:52
GNELane.h
MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
@ MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
move elevation instead of x,y
Definition: GUIAppEnum.h:621
ICON_SUPERMODEDEMAND
@ ICON_SUPERMODEDEMAND
Definition: GUIIcons.h:215
GNEViewNetHelper::EditShapes::startEditCustomShape
void startEditCustomShape(GNENetElement *element, const PositionVector &shape, bool fill)
start edit custom shape
Definition: GNEViewNetHelper.cpp:2103
GNEViewNetHelper::NetworkViewOptions::hideNetworkViewOptionsMenuChecks
void hideNetworkViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:1559
GNEViewNetHelper::ObjectsUnderCursor::getJunctionFront
GNEJunction * getJunctionFront() const
get front junction (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:258
GNEEdge::startGeometryMoving
void startGeometryMoving()
Definition: GNEEdge.cpp:240
GNEViewNetHelper::KeyPressed::update
void update(void *eventData)
update status of KeyPressed
Definition: GNEViewNetHelper.cpp:370
GNEViewNetHelper::ObjectsUnderCursor::ObjectsUnderCursor
ObjectsUnderCursor()
constructor
Definition: GNEViewNetHelper.cpp:54
GNEViewNetHelper::ObjectsUnderCursor::getGlTypeFront
GUIGlObjectType getGlTypeFront() const
get front GUI GL object type (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:198
GNEViewNetHelper::EditShapes::saveEditedShape
void saveEditedShape()
save edited shape
Definition: GNEViewNetHelper.cpp:2138
MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
select edges
Definition: GUIAppEnum.h:607
GNEViewParent.h
GNEViewNetHelper::DemandViewOptions::showNonInspectedDemandElements
bool showNonInspectedDemandElements(const GNEDemandElement *demandElement) const
check if non inspected element has to be hidden
Definition: GNEViewNetHelper.cpp:1741
GNEEdge::getGNEJunctionSource
GNEJunction * getGNEJunctionSource() const
returns the source-junction
Definition: GNEEdge.cpp:487
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNEPoly.h
GNE_NMODE_PROHIBITION
@ GNE_NMODE_PROHIBITION
Mode for editing connection prohibitions.
Definition: GNEViewNetHelper.h:78
GNESelectorFrame.h
GNEViewNetHelper::SelectingArea::processEdgeRectangleSelection
std::vector< GNEEdge * > processEdgeRectangleSelection()
process rectangle Selection (only limited to Edges)
Definition: GNEViewNetHelper.cpp:1061
MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
@ MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
hide non-inspected demand element
Definition: GUIAppEnum.h:627
MID_HOTKEY_V_VEHICLEMODE
@ MID_HOTKEY_V_VEHICLEMODE
hotkey for mode create vehicles
Definition: GUIAppEnum.h:65
GUIMainWindow
Definition: GUIMainWindow.h:46
Position::y
double y() const
Returns the y-position.
Definition: Position.h:61
SUMO_TAG_TRAFFIC_LIGHT
@ SUMO_TAG_TRAFFIC_LIGHT
a traffic light
Definition: SUMOXMLDefinitions.h:139
SUMO_TAG_CROSSING
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
Definition: SUMOXMLDefinitions.h:226
GNEViewNetHelper::VehicleTypeOptions::VehicleTypeOptions
VehicleTypeOptions(GNEViewNet *viewNet)
constructor
Definition: GNEViewNetHelper.cpp:985
GNEViewNetHelper::MoveSingleElementValues::moveSingleElement
void moveSingleElement()
move single element in Network AND Demand mode
Definition: GNEViewNetHelper.cpp:481
MFXCheckableButton
Definition: MFXCheckableButton.h:30
GNEViewNetHelper::NetworkViewOptions::NetworkViewOptions
NetworkViewOptions(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1469
GNEViewNetHelper::MoveSingleElementValues::calculatePolyValues
bool calculatePolyValues()
calculate Poly movement values (Position, Index, etc.)
Definition: GNEViewNetHelper.cpp:582
GNE_SUPERMODE_DEMAND
@ GNE_SUPERMODE_DEMAND
Demanding mode (Routes, Vehicles etc..)
Definition: GNEViewNetHelper.h:48
GUIGlID
unsigned int GUIGlID
Definition: GUIGlObject.h:42
GLO_NETELEMENT
@ GLO_NETELEMENT
reserved GLO type to pack all netElements
Definition: GUIGlObjectTypes.h:44
ICON_MODETLS
@ ICON_MODETLS
Definition: GUIIcons.h:229
GNEViewNetHelper::ObjectsUnderCursor::getDemandElementFront
GNEDemandElement * getDemandElementFront() const
get front net element element (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:248
GNEViewNetHelper::NetworkViewOptions::selectEdges
bool selectEdges() const
check if select edges checkbox is enabled
Definition: GNEViewNetHelper.cpp:1627
GNEViewNetHelper::MoveMultipleElementValues::MoveMultipleElementValues
MoveMultipleElementValues(GNEViewNet *viewNet)
constructor
Definition: GNEViewNetHelper.cpp:766
SUMO_TAG_CONNECTION
@ SUMO_TAG_CONNECTION
connectio between two lanes
Definition: SUMOXMLDefinitions.h:202
MID_HOTKEY_F3_SUPERMODE_NETWORK
@ MID_HOTKEY_F3_SUPERMODE_NETWORK
hot key <F3> set network mode in NETEDIT
Definition: GUIAppEnum.h:169
GNEViewNetHelper::ObjectsUnderCursor::getCrossingFront
GNECrossing * getCrossingFront() const
get front crossing (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:288
GNEViewNetHelper::EditModes::EditModes
EditModes(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1278
GNEViewNetHelper::VehicleOptions::hideVehicleOptionsMenuChecks
void hideVehicleOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:977
GNEConnection
Definition: GNEConnection.h:38
MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES
automatically create opposite edge
Definition: GUIAppEnum.h:625
GNEViewNetHelper::VehicleOptions::buildVehicleOptionsMenuChecks
void buildVehicleOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:970
ICON_MODEINSPECT
@ ICON_MODEINSPECT
Definition: GUIIcons.h:226
MID_HOTKEY_P_POLYGONMODE_PERSONMODE
@ MID_HOTKEY_P_POLYGONMODE_PERSONMODE
hotkey for mode creating polygons
Definition: GUIAppEnum.h:57
GNEViewNetHelper::ObjectsUnderCursor::getLaneFront
GNELane * getLaneFront() const
get front lane (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:278
GNE_SUPERMODE_NONE
@ GNE_SUPERMODE_NONE
empty super mode
Definition: GNEViewNetHelper.h:44
GLO_JUNCTION
@ GLO_JUNCTION
a junction
Definition: GUIGlObjectTypes.h:50
GNEViewNetHelper::ObjectsUnderCursor::getClickedAttributeCarriers
const std::vector< GNEAttributeCarrier * > & getClickedAttributeCarriers() const
get vector with clicked ACs
Definition: GNEViewNetHelper.cpp:338
MID_GNE_COMMONVIEWOPTIONS_SHOWGRID
@ MID_GNE_COMMONVIEWOPTIONS_SHOWGRID
show grid
Definition: GUIAppEnum.h:603
GNEViewNetHelper.h
ICON_MODEPROHIBITION
@ ICON_MODEPROHIBITION
Definition: GUIIcons.h:231
GNE_ATTR_SELECTED
@ GNE_ATTR_SELECTED
element is selected
Definition: SUMOXMLDefinitions.h:971
GNEViewNetHelper::MoveSingleElementValues::MoveSingleElementValues
MoveSingleElementValues(GNEViewNet *viewNet)
constructor
Definition: GNEViewNetHelper.cpp:398
GNEViewNetHelper::ObjectsUnderCursor::getAttributeCarrierFront
GNEAttributeCarrier * getAttributeCarrierFront() const
get front attribute carrier (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:208
GNE_DMODE_MOVE
@ GNE_DMODE_MOVE
mode for moving demand elements
Definition: GNEViewNetHelper.h:92
MID_HOTKEY_I_INSPECTMODE
@ MID_HOTKEY_I_INSPECTMODE
hotkey for mode inspecting object attributes
Definition: GUIAppEnum.h:53
GNEPOI.h
GNEViewNetHelper::EditModes::setDemandEditMode
void setDemandEditMode(DemandEditMode demandMode, bool force=false)
set Demand edit mode
Definition: GNEViewNetHelper.cpp:1395
GNEViewNetHelper::NetworkCheckableButtons::buildNetworkCheckableButtons
void buildNetworkCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:1904
GNEJunction
Definition: GNEJunction.h:47
GNEViewNetHelper::CommonCheckableButtons::CommonCheckableButtons
CommonCheckableButtons(GNEViewNet *viewNet)
default constructor
Definition: GNEViewNetHelper.cpp:1819
GNEViewNetHelper::DemandCheckableButtons::buildDemandCheckableButtons
void buildDemandCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:2010
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition: GUIAppEnum.h:605
GNEViewNetHelper::DemandViewOptions::showAllPersonPlans
bool showAllPersonPlans() const
check all person plans has to be show
Definition: GNEViewNetHelper.cpp:1789
GNE_NMODE_INSPECT
@ GNE_NMODE_INSPECT
mode for inspecting network elements
Definition: GNEViewNetHelper.h:56
GNEViewNetHelper::EditShapes::stopEditCustomShape
void stopEditCustomShape()
edit edit shape
Definition: GNEViewNetHelper.cpp:2124
SUMO_ATTR_SHAPE
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:690
MID_HOTKEY_E_EDGEMODE
@ MID_HOTKEY_E_EDGEMODE
hotkey for mode adding edges
Definition: GUIAppEnum.h:51
Position::setz
void setz(double z)
set position z
Definition: Position.h:81
MID_HOTKEY_R_CROSSINGMODE_ROUTEMODE
@ MID_HOTKEY_R_CROSSINGMODE_ROUTEMODE
hotkey for mode editing crossing AND routes
Definition: GUIAppEnum.h:61
GNEViewNetHelper::ObjectsUnderCursor::getShapeFront
GNEShape * getShapeFront() const
get front shape element (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:238
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
@ MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
change all phases
Definition: GUIAppEnum.h:615
MID_HOTKEY_M_MOVEMODE
@ MID_HOTKEY_M_MOVEMODE
hotkey for mode moving element
Definition: GUIAppEnum.h:55
GNE_DMODE_DELETE
@ GNE_DMODE_DELETE
mode for deleting demand elements
Definition: GNEViewNetHelper.h:88
GNE_NMODE_MOVE
@ GNE_NMODE_MOVE
mode for moving network elements
Definition: GNEViewNetHelper.h:62
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:284
MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
create edges in chain mode
Definition: GUIAppEnum.h:623
GNEAttributeCarrier
Definition: GNEAttributeCarrier.h:54
GNEViewNetHelper::ObjectsUnderCursor::sortGUIGlObjectsByAltitude
void sortGUIGlObjectsByAltitude(const std::vector< GUIGlObject * > &GUIGlObjects)
invert GUIGlObjects
Definition: GNEViewNetHelper.cpp:344
GLHelper::drawTextBox
static void drawTextBox(const std::string &text, const Position &pos, const double layer, const double size, const RGBColor &txtColor=RGBColor::BLACK, const RGBColor &bgColor=RGBColor::WHITE, const RGBColor &borderColor=RGBColor::BLACK, const double angle=0, const double relBorder=0.05, const double relMargin=0.5)
draw Text box with given parameters
Definition: GLHelper.cpp:722
GNEViewNetHelper::ObjectsUnderCursor::getAdditionalFront
GNEAdditional * getAdditionalFront() const
get front additional element (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:228
GNEViewNetHelper::CommonViewOptions::buildCommonViewOptionsMenuChecks
void buildCommonViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:1439
GNENet.h
GLO_NETWORK
@ GLO_NETWORK
The network - empty.
Definition: GUIGlObjectTypes.h:41
GNEViewNetHelper::VehicleTypeOptions::hideVehicleTypeOptionsMenuChecks
void hideVehicleTypeOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:998
GUIDesignButtonToolbarCheckable
#define GUIDesignButtonToolbarCheckable
little checkable button with icon placed in navigation toolbar
Definition: GUIDesigns.h:88
GNEViewNetHelper::ObjectsUnderCursor::swapLane2Edge
void swapLane2Edge()
swap lane to edge
Definition: GNEViewNetHelper.cpp:171
SUMO_TAG_JUNCTION
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
Definition: SUMOXMLDefinitions.h:59
RGBColor::WHITE
static const RGBColor WHITE
Definition: RGBColor.h:196
GNEViewNetHelper::SelectingArea::finishRectangleSelection
void finishRectangleSelection()
finish rectangle selection
Definition: GNEViewNetHelper.cpp:1037
GNEUndoList.h
GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementDemandMode
bool beginMoveSingleElementDemandMode()
begin move single element in Demand mode
Definition: GNEViewNetHelper.cpp:460
GNEConnection.h
GNEViewNetHelper::VehicleTypeOptions::buildVehicleTypeOptionsMenuChecks
void buildVehicleTypeOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:991
GNEViewNetHelper::ObjectsUnderCursor::getNetElementFront
GNENetElement * getNetElementFront() const
get front net element (or a pointer to nullptr if there isn't)
Definition: GNEViewNetHelper.cpp:218
MID_HOTKEY_A_ADDITIONALMODE_STOPMODE
@ MID_HOTKEY_A_ADDITIONALMODE_STOPMODE
hotkey for mode editing additionals AND stops
Definition: GUIAppEnum.h:45