Eclipse SUMO - Simulation of Urban MObility
GNEViewNet.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
19 // A view on the network being edited (adapted from GUIViewTraffic)
20 /****************************************************************************/
21 
22 #include <netbuild/NBEdgeCont.h>
23 #include <netedit/changes/GNEChange_Attribute.h>
24 #include <netedit/changes/GNEChange_TLS.h>
25 #include <netedit/dialogs/GNEGeometryPointDialog.h>
26 #include <netedit/elements/additional/GNEAdditionalHandler.h>
27 #include <netedit/elements/additional/GNEPOI.h>
28 #include <netedit/elements/additional/GNEPoly.h>
29 #include <netedit/elements/additional/GNETAZ.h>
30 #include <netedit/elements/demand/GNERoute.h>
31 #include <netedit/elements/network/GNEWalkingArea.h>
32 #include <netedit/elements/network/GNEConnection.h>
33 #include <netedit/elements/network/GNECrossing.h>
34 #include <netedit/frames/common/GNEDeleteFrame.h>
35 #include <netedit/frames/common/GNEInspectorFrame.h>
36 #include <netedit/frames/common/GNEMoveFrame.h>
37 #include <netedit/frames/common/GNESelectorFrame.h>
38 #include <netedit/frames/data/GNEEdgeDataFrame.h>
39 #include <netedit/frames/data/GNEEdgeRelDataFrame.h>
40 #include <netedit/frames/data/GNETAZRelDataFrame.h>
41 #include <netedit/frames/data/GNEMeanDataFrame.h>
42 #include <netedit/frames/demand/GNEContainerFrame.h>
43 #include <netedit/frames/demand/GNEContainerPlanFrame.h>
44 #include <netedit/frames/demand/GNEPersonFrame.h>
45 #include <netedit/frames/demand/GNEPersonPlanFrame.h>
46 #include <netedit/frames/demand/GNERouteFrame.h>
47 #include <netedit/frames/demand/GNERouteDistributionFrame.h>
48 #include <netedit/frames/demand/GNEStopFrame.h>
49 #include <netedit/frames/demand/GNETypeFrame.h>
50 #include <netedit/frames/demand/GNETypeDistributionFrame.h>
51 #include <netedit/frames/demand/GNEVehicleFrame.h>
52 #include <netedit/frames/network/GNEAdditionalFrame.h>
53 #include <netedit/frames/network/GNEConnectorFrame.h>
54 #include <netedit/frames/network/GNECreateEdgeFrame.h>
55 #include <netedit/frames/network/GNECrossingFrame.h>
56 #include <netedit/frames/network/GNEDecalFrame.h>
57 #include <netedit/frames/network/GNEProhibitionFrame.h>
58 #include <netedit/frames/network/GNEShapeFrame.h>
59 #include <netedit/frames/network/GNETAZFrame.h>
60 #include <netedit/frames/network/GNETLSEditorFrame.h>
61 #include <netedit/frames/network/GNEWireFrame.h>
62 #include <utils/foxtools/MFXMenuCheckIcon.h>
63 #include <utils/gui/cursors/GUICursorSubSys.h>
64 #include <utils/gui/div/GLHelper.h>
65 #include <utils/gui/div/GUIDesigns.h>
66 #include <utils/gui/div/GUIGlobalViewObjectsHandler.h>
67 #include <utils/gui/globjects/GUICursorDialog.h>
68 #include <utils/gui/globjects/GUIGlObjectStorage.h>
69 #include <utils/gui/settings/GUICompleteSchemeStorage.h>
70 #include <utils/gui/windows/GUIDanielPerspectiveChanger.h>
71 #include <utils/gui/windows/GUIDialog_ViewSettings.h>
72 #include <utils/options/OptionsCont.h>
73 
74 #include <unordered_set>
75 
76 #include "GNENet.h"
77 #include "GNEUndoList.h"
78 #include "GNEViewNet.h"
79 #include "GNEViewParent.h"
80 #include "GNEApplicationWindow.h"
81 
82 
83 // ===========================================================================
84 // FOX callback mapping
85 // ===========================================================================
86 
87 FXDEFMAP(GNEViewNet) GNEViewNetMap[] = {
88  // Super Modes
89  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F2_SUPERMODE_NETWORK, GNEViewNet::onCmdSetSupermode),
90  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F3_SUPERMODE_DEMAND, GNEViewNet::onCmdSetSupermode),
91  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F4_SUPERMODE_DATA, GNEViewNet::onCmdSetSupermode),
92  // Modes
93  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS, GNEViewNet::onCmdSetMode),
94  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_C_MODE_CONNECT_CONTAINER, GNEViewNet::onCmdSetMode),
95  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE, GNEViewNet::onCmdSetMode),
96  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_E_MODE_EDGE_EDGEDATA, GNEViewNet::onCmdSetMode),
97  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN, GNEViewNet::onCmdSetMode),
98  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_I_MODE_INSPECT, GNEViewNet::onCmdSetMode),
99  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_L_MODE_PERSONPLAN, GNEViewNet::onCmdSetMode),
100  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_M_MODE_MOVE_MEANDATA, GNEViewNet::onCmdSetMode),
101  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_P_MODE_POLYGON_PERSON, GNEViewNet::onCmdSetMode),
102  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA, GNEViewNet::onCmdSetMode),
103  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT, GNEViewNet::onCmdSetMode),
104  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_T_MODE_TLS_TYPE, GNEViewNet::onCmdSetMode),
105  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION, GNEViewNet::onCmdSetMode),
106  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_V_MODE_VEHICLE, GNEViewNet::onCmdSetMode),
107  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION, GNEViewNet::onCmdSetMode),
108  FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_Z_MODE_TAZ_TAZREL, GNEViewNet::onCmdSetMode),
109  // Network view options
110  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID, GNEViewNet::onCmdToggleShowGrid),
111  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE, GNEViewNet::onCmdToggleDrawJunctionShape),
112  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES, GNEViewNet::onCmdToggleDrawSpreadVehicles),
113  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS, GNEViewNet::onCmdToggleShowDemandElementsNetwork),
114  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES, GNEViewNet::onCmdToggleSelectEdges),
115  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS, GNEViewNet::onCmdToggleShowConnections),
116  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS, GNEViewNet::onCmdToggleHideConnections),
117  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS, GNEViewNet::onCmdToggleShowAdditionalSubElements),
118  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS, GNEViewNet::onCmdToggleShowTAZElements),
119  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION, GNEViewNet::onCmdToggleExtendSelection),
120  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES, GNEViewNet::onCmdToggleChangeAllPhases),
121  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE, GNEViewNet::onCmdToggleWarnAboutMerge),
122  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES, GNEViewNet::onCmdToggleShowJunctionBubbles),
123  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION, GNEViewNet::onCmdToggleMoveElevation),
124  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES, GNEViewNet::onCmdToggleChainEdges),
125  FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES, GNEViewNet::onCmdToggleAutoOppositeEdge),
126  // Demand view options
127  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID, GNEViewNet::onCmdToggleShowGrid),
128  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE, GNEViewNet::onCmdToggleDrawJunctionShape),
129  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES, GNEViewNet::onCmdToggleDrawSpreadVehicles),
130  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED, GNEViewNet::onCmdToggleHideNonInspecteDemandElements),
131  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES, GNEViewNet::onCmdToggleHideShapes),
132  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS, GNEViewNet::onCmdToggleShowTrips),
133  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS, GNEViewNet::onCmdToggleShowAllPersonPlans),
134  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON, GNEViewNet::onCmdToggleLockPerson),
135  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS, GNEViewNet::onCmdToggleShowAllContainerPlans),
136  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER, GNEViewNet::onCmdToggleLockContainer),
137  FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES, GNEViewNet::onCmdToggleShowOverlappedRoutes),
138  // Data view options
139  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE, GNEViewNet::onCmdToggleDrawJunctionShape),
140  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS, GNEViewNet::onCmdToggleShowAdditionals),
141  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES, GNEViewNet::onCmdToggleShowShapes),
142  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS, GNEViewNet::onCmdToggleShowDemandElementsData),
143  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING, GNEViewNet::onCmdToggleTAZRelDrawing),
144  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL, GNEViewNet::onCmdToggleTAZDrawFill),
145  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM, GNEViewNet::onCmdToggleTAZRelOnlyFrom),
146  FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO, GNEViewNet::onCmdToggleTAZRelOnlyTo),
147  // Select elements
148  FXMAPFUNC(SEL_COMMAND, MID_ADDSELECT, GNEViewNet::onCmdAddSelected),
149  FXMAPFUNC(SEL_COMMAND, MID_REMOVESELECT, GNEViewNet::onCmdRemoveSelected),
150  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADDSELECT_EDGE, GNEViewNet::onCmdAddEdgeSelected),
151  FXMAPFUNC(SEL_COMMAND, MID_GNE_REMOVESELECT_EDGE, GNEViewNet::onCmdRemoveEdgeSelected),
152  // Junctions
153  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_EDGE_ENDPOINTS, GNEViewNet::onCmdResetEdgeEndPoints),
154  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_EDIT_SHAPE, GNEViewNet::onCmdEditJunctionShape),
155  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_SHAPE, GNEViewNet::onCmdResetJunctionShape),
156  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_REPLACE, GNEViewNet::onCmdReplaceJunction),
157  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SPLIT, GNEViewNet::onCmdSplitJunction),
158  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SPLIT_RECONNECT, GNEViewNet::onCmdSplitJunctionReconnect),
159  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SELECT_ROUNDABOUT, GNEViewNet::onCmdSelectRoundabout),
160  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_CONVERT_ROUNDABOUT, GNEViewNet::onCmdConvertRoundabout),
161  FXMAPFUNC(SEL_ENTER, MID_GNE_JUNCTION_CONVERT_ROUNDABOUT, GNEViewNet::onEnterConvertRoundabout),
162  FXMAPFUNC(SEL_LEAVE, MID_GNE_JUNCTION_CONVERT_ROUNDABOUT, GNEViewNet::onLeaveConvertRoundabout),
163  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_CLEAR_CONNECTIONS, GNEViewNet::onCmdClearConnections),
164  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_CONNECTIONS, GNEViewNet::onCmdResetConnections),
165  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_ADDTLS, GNEViewNet::onCmdAddTLS),
166  FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_ADDJOINTLS, GNEViewNet::onCmdAddJoinTLS),
167  // Connections
168  FXMAPFUNC(SEL_COMMAND, MID_GNE_CONNECTION_EDIT_SHAPE, GNEViewNet::onCmdEditConnectionShape),
169  FXMAPFUNC(SEL_COMMAND, MID_GNE_CONNECTION_SMOOTH_SHAPE, GNEViewNet::onCmdSmoothConnectionShape),
170  // Crossings
171  FXMAPFUNC(SEL_COMMAND, MID_GNE_CROSSING_EDIT_SHAPE, GNEViewNet::onCmdEditCrossingShape),
172  // WalkingArea
173  FXMAPFUNC(SEL_COMMAND, MID_GNE_WALKINGAREA_EDIT_SHAPE, GNEViewNet::onCmdEditWalkingAreaShape),
174  // Edges
175  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SPLIT, GNEViewNet::onCmdSplitEdge),
176  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SPLIT_BIDI, GNEViewNet::onCmdSplitEdgeBidi),
177  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_REVERSE, GNEViewNet::onCmdReverseEdge),
178  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_ADD_REVERSE, GNEViewNet::onCmdAddReversedEdge),
179  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_ADD_REVERSE_DISCONNECTED, GNEViewNet::onCmdAddReversedEdgeDisconnected),
180  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_EDIT_ENDPOINT, GNEViewNet::onCmdEditEdgeEndpoint),
181  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_RESET_ENDPOINT, GNEViewNet::onCmdResetEdgeEndpoint),
182  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_STRAIGHTEN, GNEViewNet::onCmdStraightenEdges),
183  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SMOOTH, GNEViewNet::onCmdSmoothEdges),
184  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_STRAIGHTEN_ELEVATION, GNEViewNet::onCmdStraightenEdgesElevation),
185  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SMOOTH_ELEVATION, GNEViewNet::onCmdSmoothEdgesElevation),
186  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_RESET_LENGTH, GNEViewNet::onCmdResetLength),
187  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_USEASTEMPLATE, GNEViewNet::onCmdEdgeUseAsTemplate),
188  FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_APPLYTEMPLATE, GNEViewNet::onCmdEgeApplyTemplate),
189  // Lanes
190  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_DUPLICATE, GNEViewNet::onCmdDuplicateLane),
191  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_EDIT_SHAPE, GNEViewNet::onCmdEditLaneShape),
192  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_RESET_CUSTOMSHAPE, GNEViewNet::onCmdResetLaneCustomShape),
193  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_RESET_OPPOSITELANE, GNEViewNet::onCmdResetOppositeLane),
194  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_SIDEWALK, GNEViewNet::onCmdLaneOperation),
195  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_BIKE, GNEViewNet::onCmdLaneOperation),
196  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_BUS, GNEViewNet::onCmdLaneOperation),
197  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_GREENVERGE, GNEViewNet::onCmdLaneOperation),
198  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_SIDEWALK, GNEViewNet::onCmdLaneOperation),
199  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_BIKE, GNEViewNet::onCmdLaneOperation),
200  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_BUS, GNEViewNet::onCmdLaneOperation),
201  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_GREENVERGE_FRONT, GNEViewNet::onCmdLaneOperation),
202  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_GREENVERGE_BACK, GNEViewNet::onCmdLaneOperation),
203  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_SIDEWALK, GNEViewNet::onCmdLaneOperation),
204  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_BIKE, GNEViewNet::onCmdLaneOperation),
205  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_BUS, GNEViewNet::onCmdLaneOperation),
206  FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_GREENVERGE, GNEViewNet::onCmdLaneOperation),
207  FXMAPFUNC(SEL_COMMAND, MID_REACHABILITY, GNEViewNet::onCmdLaneReachability),
208  // Additionals
209  FXMAPFUNC(SEL_COMMAND, MID_OPEN_ADDITIONAL_DIALOG, GNEViewNet::onCmdOpenAdditionalDialog),
210  // Polygons
211  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SIMPLIFY_SHAPE, GNEViewNet::onCmdSimplifyShape),
212  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_CLOSE, GNEViewNet::onCmdClosePolygon),
213  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_OPEN, GNEViewNet::onCmdOpenPolygon),
214  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SELECT, GNEViewNet::onCmdSelectPolygonElements),
215  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SET_FIRST_POINT, GNEViewNet::onCmdSetFirstGeometryPoint),
216  FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_DELETE_GEOMETRY_POINT, GNEViewNet::onCmdDeleteGeometryPoint),
217  // edit custom shapes
218  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_SIMPLIFY, GNEViewNet::onCmdSimplifyShapeEdited),
219  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_STRAIGHTEN, GNEViewNet::onCmdStraightenShapeEdited),
220  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_CLOSE, GNEViewNet::onCmdCloseShapeEdited),
221  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_OPEN, GNEViewNet::onCmdOpenShapeEdited),
222  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_SET_FIRST_POINT, GNEViewNet::onCmdSetFirstGeometryPointShapeEdited),
223  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_DELETE_GEOMETRY_POINT, GNEViewNet::onCmdDeleteGeometryPointShapeEdited),
224  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_RESET, GNEViewNet::onCmdResetShapeEdited),
225  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_FINISH, GNEViewNet::onCmdFinishShapeEdited),
226  // POIs
227  FXMAPFUNC(SEL_COMMAND, MID_GNE_POI_TRANSFORM, GNEViewNet::onCmdTransformPOI),
228  // Demand elements
229  FXMAPFUNC(SEL_COMMAND, MID_GNE_REVERSE, GNEViewNet::onCmdReverse),
230  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADDREVERSE, GNEViewNet::onCmdAddReverse),
231  // Geometry Points
232  FXMAPFUNC(SEL_COMMAND, MID_GNE_CUSTOM_GEOMETRYPOINT, GNEViewNet::onCmdSetCustomGeometryPoint),
233  FXMAPFUNC(SEL_COMMAND, MID_GNE_RESET_GEOMETRYPOINT, GNEViewNet::onCmdResetEndPoints),
234  // toolbar views
235  FXMAPFUNC(SEL_COMMAND, MID_GNE_VIEW_DEFAULT, GNEViewNet::onCmdSetNeteditView),
236  FXMAPFUNC(SEL_COMMAND, MID_GNE_VIEW_JUPEDSIM, GNEViewNet::onCmdSetNeteditView),
237  // IntervalBar
238  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_GENERICDATATYPE, GNEViewNet::onCmdIntervalBarGenericDataType),
239  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_DATASET, GNEViewNet::onCmdIntervalBarDataSet),
240  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_LIMITED, GNEViewNet::onCmdIntervalBarLimit),
241  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_BEGIN, GNEViewNet::onCmdIntervalBarSetBegin),
242  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_END, GNEViewNet::onCmdIntervalBarSetEnd),
243  FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_PARAMETER, GNEViewNet::onCmdIntervalBarSetParameter),
244 };
245 
246 // Object implementation
247 FXIMPLEMENT(GNEViewNet, GUISUMOAbstractView, GNEViewNetMap, ARRAYNUMBER(GNEViewNetMap))
248 
249 
250 // ===========================================================================
251 // member method definitions
252 // ===========================================================================
253 GNEViewNet::GNEViewNet(FXComposite* tmpParent, FXComposite* actualParent, GUIMainWindow& app,
254  GNEViewParent* viewParent, GNENet* net, GNEUndoList* undoList,
255  FXGLVisual* glVis, FXGLCanvas* share) :
256  GUISUMOAbstractView(tmpParent, app, viewParent, net->getGrid(), glVis, share),
257  myViewObjectsSelector(this),
258  myEditModes(this),
259  myTestingMode(this),
260  myCommonCheckableButtons(this),
261  myNetworkCheckableButtons(this),
262  myDemandCheckableButtons(this),
263  myDataCheckableButtons(this),
264  myNetworkViewOptions(this),
265  myDemandViewOptions(this),
266  myDataViewOptions(this),
267  myIntervalBar(this),
268  myMoveSingleElement(this),
269  myMoveMultipleElements(this),
270  myVehicleOptions(this),
271  myVehicleTypeOptions(this),
272  mySaveElements(this),
273  myTimeFormat(this),
274  mySelectingArea(this),
275  myEditNetworkElementShapes(this),
276  myLockManager(this),
277  myViewParent(viewParent),
278  myNet(net),
279  myUndoList(undoList) {
280  // view must be the final member of actualParent
281  reparent(actualParent);
282  // Build edit modes
283  buildEditModeControls();
284  // set this net in Net
285  myNet->setViewNet(this);
286  // set drag delay
287  ((GUIDanielPerspectiveChanger*)myChanger)->setDragDelay(100000000); // 100 milliseconds
288  // Reset textures
289  GUITextureSubSys::resetTextures();
290  // init testing mode
291  myTestingMode.initTestingMode();
292  // update grid flags
293  myNetworkViewOptions.menuCheckToggleGrid->setChecked(myVisualizationSettings->showGrid);
294  myDemandViewOptions.menuCheckToggleGrid->setChecked(myVisualizationSettings->showGrid);
295  // update junction shape flags
296  const bool hide = !myVisualizationSettings->drawJunctionShape;
297  myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
298  myDemandViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
299  myDataViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
300 }
301 
302 
303 GNEViewNet::~GNEViewNet() {}
304 
305 
306 void
307 GNEViewNet::recalculateBoundaries() {
308  if (myNet && makeCurrent()) {
309  // declare boundary
310  const Boundary maxBoundary(1000000000.0, 1000000000.0, -1000000000.0, -1000000000.0);
311  // get all objects in boundary
312  const std::vector<GUIGlID> GLIDs = getObjectsInBoundary(maxBoundary);
313  // finish make OpenGL context current
314  makeNonCurrent();
315  // declare set
316  std::set<GNEAttributeCarrier*> ACs;
317  // iterate over GUIGlIDs
318  for (const auto& GLId : GLIDs) {
319  GNEAttributeCarrier* AC = myNet->getAttributeCarriers()->retrieveAttributeCarrier(GLId);
320  // Make sure that object exists
321  if (AC && AC->getTagProperty().isPlacedInRTree()) {
322  ACs.insert(AC);
323  }
324  }
325  // interate over ACs
326  for (const auto& AC : ACs) {
327  // remove object and insert again with exaggeration
328  myNet->getGrid().removeAdditionalGLObject(AC->getGUIGlObject());
329  myNet->getGrid().addAdditionalGLObject(AC->getGUIGlObject(), AC->getGUIGlObject()->getExaggeration(*myVisualizationSettings));
330  }
331  }
332 }
333 
334 
335 void
336 GNEViewNet::doInit() {}
337 
338 
339 GUIGlID
340 GNEViewNet::getToolTipID() {
341  if (myViewObjectsSelector.getGUIGlObjectFront()) {
342  return myViewObjectsSelector.getGUIGlObjectFront()->getGlID();
343  } else {
344  return 0;
345  }
346 }
347 
348 
349 void
350 GNEViewNet::buildViewToolBars(GUIGlChildWindow* v) {
351  // build coloring tools
352  {
353  for (auto it_names : gSchemeStorage.getNames()) {
354  v->getColoringSchemesCombo()->appendIconItem(it_names.c_str());
355  if (it_names == myVisualizationSettings->name) {
356  v->getColoringSchemesCombo()->setCurrentItem(v->getColoringSchemesCombo()->getNumItems() - 1);
357  }
358  }
359  }
360  // for junctions
361  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
362  std::string("\t") + TL("Locate Junctions") + std::string("\t") + TL("Locate a junction within the network. (Shift+J)"),
363  GUIIconSubSys::getIcon(GUIIcon::LOCATEJUNCTION), v, MID_HOTKEY_SHIFT_J_LOCATEJUNCTION, GUIDesignButtonPopup);
364  // for edges
365  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
366  std::string("\t") + TL("Locate Edges") + std::string("\t") + TL("Locate an edge within the network. (Shift+E)"),
367  GUIIconSubSys::getIcon(GUIIcon::LOCATEEDGE), v, MID_HOTKEY_SHIFT_E_LOCATEEDGE, GUIDesignButtonPopup);
368  // for walkingAreas
369  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
370  std::string("\t") + TL("Locate WalkingAreas") + std::string("\t") + TL("Locate a walkingArea within the network. (Shift+W)"),
371  GUIIconSubSys::getIcon(GUIIcon::LOCATEWALKINGAREA), v, MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA, GUIDesignButtonPopup);
372  // for vehicles
373  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
374  std::string("\t") + TL("Locate Vehicles") + std::string("\t") + TL("Locate a vehicle within the network. (Shift+V)"),
375  GUIIconSubSys::getIcon(GUIIcon::LOCATEVEHICLE), v, MID_HOTKEY_SHIFT_V_LOCATEVEHICLE, GUIDesignButtonPopup);
376  // for person
377  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
378  std::string("\t") + TL("Locate Persons") + std::string("\t") + TL("Locate a person within the network. (Shift+P)"),
379  GUIIconSubSys::getIcon(GUIIcon::LOCATEPERSON), v, MID_HOTKEY_SHIFT_P_LOCATEPERSON, GUIDesignButtonPopup);
380  // for container
381  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
382  std::string("\t") + TL("Locate Containers") + std::string("\t") + TL("Locate a container within the network. (Shift+C)"),
383  GUIIconSubSys::getIcon(GUIIcon::LOCATECONTAINER), v, MID_HOTKEY_SHIFT_C_LOCATECONTAINER, GUIDesignButtonPopup);
384  // for routes
385  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
386  std::string("\t") + TL("Locate Route") + std::string("\t") + TL("Locate a route within the network. (Shift+R)"),
387  GUIIconSubSys::getIcon(GUIIcon::LOCATEROUTE), v, MID_HOTKEY_SHIFT_R_LOCATEROUTE, GUIDesignButtonPopup);
388  // for routes
389  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
390  std::string("\t") + TL("Locate Stops") + std::string("\t") + TL("Locate a stop within the network. (Shift+S)"),
391  GUIIconSubSys::getIcon(GUIIcon::LOCATESTOP), v, MID_HOTKEY_SHIFT_S_LOCATESTOP, GUIDesignButtonPopup);
392  // for persons (currently unused)
393  /*
394  new MFXButtonTooltip(v->getLocatorPopup(),
395  std::string("\t") + TL("Locate Vehicle\tLocate a person within the network.",
396  GUIIconSubSys::getIcon(GUIIcon::LOCATEPERSON), &v, MID_LOCATEPERSON,
397  GUIDesignButtonPopup);
398  */
399  // for tls
400  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
401  std::string("\t") + TL("Locate TLS") + std::string("\t") + TL("Locate a tls within the network. (Shift+T)"),
402  GUIIconSubSys::getIcon(GUIIcon::LOCATETLS), v, MID_HOTKEY_SHIFT_T_LOCATETLS, GUIDesignButtonPopup);
403  // for additional stuff
404  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
405  std::string("\t") + TL("Locate Additional") + std::string("\t") + TL("Locate an additional structure within the network. (Shift+A)"),
406  GUIIconSubSys::getIcon(GUIIcon::LOCATEADD), v, MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL, GUIDesignButtonPopup);
407  // for pois
408  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
409  std::string("\t") + TL("Locate PoI") + std::string("\t") + TL("Locate a PoI within the network. (Shift+O)"),
410  GUIIconSubSys::getIcon(GUIIcon::LOCATEPOI), v, MID_HOTKEY_SHIFT_O_LOCATEPOI, GUIDesignButtonPopup);
411  // for polygons
412  new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
413  std::string("\t") + TL("Locate Polygon") + std::string("\t") + TL("Locate a Polygon within the network. (Shift+L)"),
414  GUIIconSubSys::getIcon(GUIIcon::LOCATEPOLY), v, MID_HOTKEY_SHIFT_L_LOCATEPOLY, GUIDesignButtonPopup);
415 }
416 
417 
418 void
419 GNEViewNet::updateViewNet() const {
420  // this call is only used for breakpoints (to check when view is updated)
421  GUISUMOAbstractView::update();
422 }
423 
424 
425 void
426 GNEViewNet::forceSupemodeNetwork() {
427  myEditModes.setSupermode(Supermode::NETWORK, true);
428 }
429 
430 
431 void
432 GNEViewNet::viewUpdated() {
433  if (myEditModes.isJuPedSimView()) {
434  // hide data button (and adjust width)
435  myEditModes.dataButton->hide();
436  // check network modes
437  switch (myEditModes.networkEditMode) {
438  case NetworkEditMode::NETWORK_CONNECT:
439  case NetworkEditMode::NETWORK_TLS:
440  case NetworkEditMode::NETWORK_PROHIBITION:
441  case NetworkEditMode::NETWORK_WIRE:
442  case NetworkEditMode::NETWORK_DECAL:
443  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_INSPECT);
444  break;
445  default:
446  break;
447  }
448  // check demand modes
449  switch (myEditModes.demandEditMode) {
450  case DemandEditMode::DEMAND_MOVE:
451  case DemandEditMode::DEMAND_VEHICLE:
452  case DemandEditMode::DEMAND_STOP:
453  case DemandEditMode::DEMAND_CONTAINER:
454  case DemandEditMode::DEMAND_CONTAINERPLAN:
455  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_INSPECT);
456  break;
457  default:
458  break;
459  }
460  // go to network mode if we're in data mode
461  if (myEditModes.isCurrentSupermodeData()) {
462  forceSupemodeNetwork();
463  } else {
464  // refresh current supermode
465  myEditModes.setSupermode(myEditModes.currentSupermode, true);
466  }
467  } else {
468  // show data button
469  myEditModes.dataButton->show();
470  // refresh current supermode
471  myEditModes.setSupermode(myEditModes.currentSupermode, true);
472  }
473 }
474 
475 
476 const GNEViewNetHelper::ViewObjectsSelector&
477 GNEViewNet::getViewObjectsSelector() const {
478  return myViewObjectsSelector;
479 }
480 
481 
482 void
483 GNEViewNet::updateObjectsInBoundary(const Boundary& boundary) {
484  // clear post drawing elements
485  gViewObjectsHandler.clearSelectedElements();
486  // set selection boundary in gObjectsInPosition
487  gViewObjectsHandler.setSelectionBoundary(boundary);
488  // push matrix
489  GLHelper::pushMatrix();
490  // enable draw for object under cursor
491  myVisualizationSettings->drawForViewObjectsHandler = true;
492  // draw all GL elements within the small boundary
493  drawGLElements(boundary);
494  // restore draw for object under cursor
495  myVisualizationSettings->drawForViewObjectsHandler = false;
496  // pop matrix
497  GLHelper::popMatrix();
498  // check if update front element
499  if (myFrontAttributeCarrier) {
500  gViewObjectsHandler.updateFrontElement(myFrontAttributeCarrier->getGUIGlObject());
501  }
502  // after draw elements, update objects under cursor
503  myViewObjectsSelector.updateObjects();
504 }
505 
506 
507 void
508 GNEViewNet::updateObjectsInPosition(const Position& pos) {
509  // clear post drawing elements
510  gViewObjectsHandler.clearSelectedElements();
511  // set selection position in gObjectsInPosition
512  gViewObjectsHandler.setSelectionPosition(pos);
513  // create an small boundary
514  Boundary positionBoundary;
515  positionBoundary.add(pos);
516  positionBoundary.grow(POSITION_EPS);
517  // push matrix
518  GLHelper::pushMatrix();
519  // enable draw for object under cursor
520  myVisualizationSettings->drawForViewObjectsHandler = true;
521  // draw all GL elements within the small boundary
522  drawGLElements(positionBoundary);
523  // check if filter edges that have the mouse over their geometry points
524  if (myEditModes.isCurrentSupermodeNetwork() && myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
525  gViewObjectsHandler.isolateEdgeGeometryPoints();
526  }
527  // restore draw for object under cursor
528  myVisualizationSettings->drawForViewObjectsHandler = false;
529  // pop matrix
530  GLHelper::popMatrix();
531  // check if update front element
532  if (myFrontAttributeCarrier) {
533  gViewObjectsHandler.updateFrontElement(myFrontAttributeCarrier->getGUIGlObject());
534  }
535  // after draw elements, update objects under cursor
536  myViewObjectsSelector.updateObjects();
537 }
538 
539 
540 const GNEViewNetHelper::MoveSingleElementModul&
541 GNEViewNet::getMoveSingleElementValues() const {
542  return myMoveSingleElement;
543 }
544 
545 
546 const GNEViewNetHelper::MoveMultipleElementModul&
547 GNEViewNet::getMoveMultipleElementValues() const {
548  return myMoveMultipleElements;
549 }
550 
551 
552 void
553 GNEViewNet::buildSelectionACPopupEntry(GUIGLObjectPopupMenu* ret, GNEAttributeCarrier* AC) {
554  if (AC->isAttributeCarrierSelected()) {
555  GUIDesigns::buildFXMenuCommand(ret, TL("Remove from Selected"), GUIIconSubSys::getIcon(GUIIcon::FLAG_MINUS), this, MID_REMOVESELECT);
556  } else {
557  GUIDesigns::buildFXMenuCommand(ret, TL("Add to Selected"), GUIIconSubSys::getIcon(GUIIcon::FLAG_PLUS), this, MID_ADDSELECT);
558  }
559  new FXMenuSeparator(ret);
560 }
561 
562 
563 bool
564 GNEViewNet::setColorScheme(const std::string& name) {
565  if (!gSchemeStorage.contains(name)) {
566  return false;
567  }
568  if (myGUIDialogViewSettings != nullptr) {
569  if (myGUIDialogViewSettings->getCurrentScheme() != name) {
570  myGUIDialogViewSettings->setCurrentScheme(name);
571  }
572  }
573  myVisualizationSettings = &gSchemeStorage.get(name.c_str());
574  updateViewNet();
575  return true;
576 }
577 
578 
579 void
580 GNEViewNet::openObjectDialogAtCursor(const FXEvent* /*ev*/) {
581  // reimplemented from GUISUMOAbstractView due GNEOverlappedInspection
582  ungrab();
583  // make network current
584  if (isEnabled() && myAmInitialised) {
585  // check if we're cliking while alt button is pressed
586  if (myMouseButtonKeyPressed.altKeyPressed()) {
587  // set clicked popup position
588  myClickedPopupPosition = getPositionInformation();
589  // create cursor popup dialog for mark front element
590  myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::FRONT_ELEMENT, this, myViewObjectsSelector.getGLObjects());
591  // open popup dialog
592  openPopupDialog();
593  } else if (myViewObjectsSelector.getGLObjects().empty()) {
594  openObjectDialog({myNet});
595  } else {
596  // declare filtered objects
597  std::vector<GUIGlObject*> filteredGLObjects;
598  // get GUIGLObject front
599  GUIGlObject* overlappedElement = nullptr;
600  // we need to check if we're inspecting a overlapping element
601  if (myViewParent->getInspectorFrame()->getOverlappedInspection()->overlappedInspectionShown() &&
602  myViewParent->getInspectorFrame()->getOverlappedInspection()->checkSavedPosition(getPositionInformation()) &&
603  myInspectedAttributeCarriers.size() > 0) {
604  overlappedElement = myInspectedAttributeCarriers.front()->getGUIGlObject();
605  filteredGLObjects.push_back(overlappedElement);
606  }
607  bool connections = false;
608  bool TLS = false;
609  // fill filtered objects
610  if ((myViewObjectsSelector.getGLObjects().size() == 1) && (myViewObjectsSelector.getGLObjects().back()->getType() == GLO_EDGE)) {
611  // special case for edge geometry points (because edges uses the lane pop ups)
612  filteredGLObjects.push_back(myViewObjectsSelector.getGLObjects().back());
613  } else {
614  for (const auto& glObject : myViewObjectsSelector.getGLObjects()) {
615  // always avoid edges
616  if (glObject->getType() == GLO_EDGE) {
617  continue;
618  }
619  if (glObject->getType() == GLO_CONNECTION) {
620  connections = true;
621  }
622  if (glObject->getType() == GLO_TLLOGIC) {
623  TLS = true;
624  }
625  filteredGLObjects.push_back(glObject);
626  }
627  auto it = filteredGLObjects.begin();
628  if (connections) {
629  // filter junctions if there are connections
630  while (it != filteredGLObjects.end()) {
631  if ((*it)->getType() == GLO_JUNCTION) {
632  it = filteredGLObjects.erase(it);
633  } else {
634  it++;
635  }
636  }
637  } else if (TLS) {
638  // filter all elements except TLLogic
639  while (it != filteredGLObjects.end()) {
640  if ((*it)->getType() != GLO_TLLOGIC) {
641  it = filteredGLObjects.erase(it);
642  } else {
643  it++;
644  }
645  }
646  }
647  }
648  // remove duplicated elements using an unordered set
649  auto itDuplicated = filteredGLObjects.begin();
650  std::unordered_set<GUIGlObject*> unorderedSet;
651  for (auto itElement = filteredGLObjects.begin(); itElement != filteredGLObjects.end(); itElement++) {
652  if (unorderedSet.insert(*itElement).second) {
653  *itDuplicated++ = *itElement;
654  }
655  }
656  filteredGLObjects.erase(itDuplicated, filteredGLObjects.end());
657  // open object dialog
658  openObjectDialog(filteredGLObjects);
659  }
660  }
661 }
662 
663 
664 void
665 GNEViewNet::openDeleteDialogAtCursor(const std::vector<GUIGlObject*>& GLObjects) {
666  if (myPopup) {
667  destroyPopup();
668  }
669  // set clicked popup position
670  myClickedPopupPosition = getPositionInformation();
671  // create cursor popup dialog for delete element
672  myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::DELETE_ELEMENT, this, GLObjects);
673  myCreatedPopup = true;
674  // open popup dialog
675  openPopupDialog();
676 }
677 
678 
679 void
680 GNEViewNet::openSelectDialogAtCursor(const std::vector<GUIGlObject*>& GLObjects) {
681  if (myPopup) {
682  destroyPopup();
683  }
684  // set clicked popup position
685  myClickedPopupPosition = getPositionInformation();
686  // create cursor popup dialog for select element
687  myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::SELECT_ELEMENT, this, GLObjects);
688  myCreatedPopup = true;
689  // open popup dialog
690  openPopupDialog();
691 }
692 
693 
694 void
695 GNEViewNet::saveVisualizationSettings() const {
696  // first check if we have to save gui settings in a file (only used for testing purposes)
697  const auto& neteditOptions = OptionsCont::getOptions();
698  if (neteditOptions.getString("gui-testing.setting-output").size() > 0) {
699  try {
700  // open output device
701  OutputDevice& output = OutputDevice::getDevice(neteditOptions.getString("gui-testing.setting-output"));
702  // save view settings
703  output.openTag(SUMO_TAG_VIEWSETTINGS);
704  myVisualizationSettings->save(output);
705  // save viewport (zoom, X, Y and Z)
706  output.openTag(SUMO_TAG_VIEWPORT);
707  output.writeAttr(SUMO_ATTR_ZOOM, myChanger->getZoom());
708  output.writeAttr(SUMO_ATTR_X, myChanger->getXPos());
709  output.writeAttr(SUMO_ATTR_Y, myChanger->getYPos());
710  output.writeAttr(SUMO_ATTR_ANGLE, myChanger->getRotation());
711  output.closeTag();
712  output.closeTag();
713  // close output device
714  output.close();
715  } catch (...) {
716  WRITE_ERROR(TL("GUI-Settings cannot be saved in ") + neteditOptions.getString("gui-testing.setting-output"));
717  }
718  }
719 }
720 
721 
722 const GNEViewNetHelper::EditModes&
723 GNEViewNet::getEditModes() const {
724  return myEditModes;
725 }
726 
727 
728 const GNEViewNetHelper::TestingMode&
729 GNEViewNet::getTestingMode() const {
730  return myTestingMode;
731 }
732 
733 
734 const GNEViewNetHelper::NetworkViewOptions&
735 GNEViewNet::getNetworkViewOptions() const {
736  return myNetworkViewOptions;
737 }
738 
739 
740 const GNEViewNetHelper::DemandViewOptions&
741 GNEViewNet::getDemandViewOptions() const {
742  return myDemandViewOptions;
743 }
744 
745 
746 const GNEViewNetHelper::DataViewOptions&
747 GNEViewNet::getDataViewOptions() const {
748  return myDataViewOptions;
749 }
750 
751 
752 const GNEViewNetHelper::MouseButtonKeyPressed&
753 GNEViewNet::getMouseButtonKeyPressed() const {
754  return myMouseButtonKeyPressed;
755 }
756 
757 
758 const GNEViewNetHelper::EditNetworkElementShapes&
759 GNEViewNet::getEditNetworkElementShapes() const {
760  return myEditNetworkElementShapes;
761 }
762 
763 
764 void
765 GNEViewNet::buildColorRainbow(const GUIVisualizationSettings& s, GUIColorScheme& scheme, int active, GUIGlObjectType objectType,
766  const GUIVisualizationRainbowSettings& rs) {
767  assert(!scheme.isFixed());
768  double minValue = std::numeric_limits<double>::infinity();
769  double maxValue = -std::numeric_limits<double>::infinity();
770  // retrieve range
771  bool hasMissingData = false;
772  if (objectType == GLO_LANE) {
773  // XXX (see #3409) multi-colors are not currently handled. this is a quick hack
774  if (active == 9) {
775  active = 8; // segment height, fall back to start height
776  } else if (active == 11) {
777  active = 10; // segment incline, fall back to total incline
778  }
779  for (const auto& lane : myNet->getAttributeCarriers()->getLanes()) {
780  const double val = lane.second->getColorValue(s, active);
781  if (val == s.MISSING_DATA) {
782  hasMissingData = true;
783  continue;
784  }
785  minValue = MIN2(minValue, val);
786  maxValue = MAX2(maxValue, val);
787  }
788  } else if (objectType == GLO_JUNCTION) {
789  if (active == 3) {
790  for (const auto& junction : myNet->getAttributeCarriers()->getJunctions()) {
791  minValue = MIN2(minValue, junction.second->getPositionInView().z());
792  maxValue = MAX2(maxValue, junction.second->getPositionInView().z());
793  }
794  }
795  } else if (objectType == GLO_TAZRELDATA) {
796  if (active == 4) {
797  for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_TAZREL)) {
798  const double value = genericData.second->getColorValue(s, active);
799  if (value == s.MISSING_DATA) {
800  continue;
801  }
802  minValue = MIN2(minValue, value);
803  maxValue = MAX2(maxValue, value);
804  }
805  }
806  }
807  if (scheme.getName() == GUIVisualizationSettings::SCHEME_NAME_PERMISSION_CODE) {
808  scheme.clear();
809  // add threshold for every distinct value
810  std::set<SVCPermissions> codes;
811  for (const auto& lane : myNet->getAttributeCarriers()->getLanes()) {
812  codes.insert(lane.second->getParentEdge()->getNBEdge()->getPermissions(lane.second->getIndex()));
813  }
814  int step = MAX2(1, 360 / (int)codes.size());
815  int hue = 0;
816  for (SVCPermissions p : codes) {
817  scheme.addColor(RGBColor::fromHSV(hue, 1, 1), (double)p);
818  hue = (hue + step) % 360;
819  }
820  return;
821  }
822  buildMinMaxRainbow(s, scheme, rs, minValue, maxValue, hasMissingData);
823 }
824 
825 
826 void
827 GNEViewNet::setStatusBarText(const std::string& text) {
828  myApp->setStatusBarText(text);
829 }
830 
831 
832 void
833 GNEViewNet::resetLastClickedPosition() {
834  myLastClickedPosition = Position::INVALID;
835 }
836 
837 
838 bool
839 GNEViewNet::autoSelectNodes() {
840  if (myLockManager.isObjectLocked(GLO_JUNCTION, false)) {
841  return false;
842  } else {
843  return myNetworkViewOptions.menuCheckExtendSelection->amChecked();
844  }
845 }
846 
847 
848 void
849 GNEViewNet::setSelectorFrameScale(double selectionScale) {
850  myVisualizationSettings->selectorFrameScale = selectionScale;
851 }
852 
853 
854 bool
855 GNEViewNet::changeAllPhases() const {
856  return (myNetworkViewOptions.menuCheckChangeAllPhases->amChecked() != 0);
857 }
858 
859 
860 bool
861 GNEViewNet::showJunctionAsBubbles() const {
862  return (myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) && (myNetworkViewOptions.menuCheckShowJunctionBubble->amChecked());
863 }
864 
865 
866 bool
867 GNEViewNet::checkMergeJunctions() {
868  // first check if there are junctions to merging
869  if (gViewObjectsHandler.getMergingJunctions().size() > 1) {
870  // get junctions (this call is neccesary because merging junctions are constants)
871  auto movedJunction = myNet->getAttributeCarriers()->retrieveJunction(gViewObjectsHandler.getMergingJunctions().at(0)->getID());
872  auto targetJunction = myNet->getAttributeCarriers()->retrieveJunction(gViewObjectsHandler.getMergingJunctions().at(1)->getID());
873  if (askMergeJunctions(movedJunction, targetJunction)) {
874  // merge moved and targed junctions
875  myNet->mergeJunctions(movedJunction, targetJunction, myUndoList);
876  return true;
877  }
878  }
879  return false;
880 }
881 
882 
883 bool
884 GNEViewNet::askMergeJunctions(const GNEJunction* movedJunction, const GNEJunction* targetJunction) {
885  // optionally ask for confirmation
886  if (!myNetworkViewOptions.menuCheckWarnAboutMerge->amChecked()) {
887  WRITE_DEBUG("Opening FXMessageBox 'merge junctions'");
888  // open question box
889  const std::string header = TL("Confirm Junction Merger");
890  const std::string body = (TLF("Do you wish to merge junctions '%' and '%'?\n('%' will be eliminated and its roads added to '%')", movedJunction->getMicrosimID(), targetJunction->getMicrosimID(), movedJunction->getMicrosimID(), targetJunction->getMicrosimID()));
891  const FXuint answer = FXMessageBox::question(this, MBOX_YES_NO, header.c_str(), "%s", body.c_str());
892  if (answer != 1) { //1:yes, 2:no, 4:esc
893  // write warning if netedit is running in testing mode
894  if (answer == 2) {
895  WRITE_DEBUG("Closed FXMessageBox 'merge junctions' with 'No'");
896  } else if (answer == 4) {
897  WRITE_DEBUG("Closed FXMessageBox 'merge junctions' with 'ESC'");
898  }
899  return false;
900  } else {
901  // write warning if netedit is running in testing mode
902  WRITE_DEBUG("Closed FXMessageBox 'merge junctions' with 'Yes'");
903  }
904  }
905  return true;
906 }
907 
908 
909 bool
910 GNEViewNet::aksChangeSupermode(const std::string& operation, Supermode expectedSupermode) {
911  // first check if ignore option is enabled
912  if (OptionsCont::getOptions().getBool("ignore-supermode-question")) {
913  return true;
914  }
915  std::string body;
916  if (expectedSupermode == Supermode::NETWORK) {
917  body = (operation + TL(" requires switch to network mode. Continue?"));
918  } else if (expectedSupermode == Supermode::DEMAND) {
919  body = (operation + TL(" requires switch to demand mode. Continue?"));
920  } else if (expectedSupermode == Supermode::DATA) {
921  body = (operation + TL(" requires switch to data mode. Continue?"));
922  } else {
923  throw ProcessError("invalid expected supermode");
924  }
925  // open question box
926  const auto answer = FXMessageBox::question(myApp, MBOX_YES_NO, TL("Confirm switch mode"), "%s", body.c_str());
927  // restore focus to view net
928  setFocus();
929  // return answer
930  if (answer == MBOX_CLICKED_YES) {
931  myEditModes.setSupermode(expectedSupermode, true);
932  return true;
933  } else {
934  return false;
935  }
936 }
937 
938 
939 bool
940 GNEViewNet::selectingDetectorsTLSMode() const {
941  // separate conditions for code legibly
942  const bool TLSMode = (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS));
943  const bool selectingDetectors = myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled();
944  return (TLSMode && selectingDetectors);
945 }
946 
947 
948 bool
949 GNEViewNet::selectingJunctionsTLSMode() const {
950  // separate conditions for code legibly
951  const bool TLSMode = (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS));
952  const bool selectingJunctions = myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions();
953  return (TLSMode && selectingJunctions);
954 }
955 
956 
957 GNEViewNetHelper::SaveElements&
958 GNEViewNet::getSaveElements() {
959  return mySaveElements;
960 }
961 
962 
963 GNEViewNetHelper::TimeFormat&
964 GNEViewNet::getTimeFormat() {
965  return myTimeFormat;
966 }
967 
968 
969 bool
970 GNEViewNet::restrictLane(GNELane* lane, SUMOVehicleClass vclass) {
971  // Get selected lanes
972  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
973  // Declare map of edges and lanes
974  std::map<GNEEdge*, GNELane*> mapOfEdgesAndLanes;
975  // Iterate over selected lanes
976  for (const auto& selectedLane : selectedLanes) {
977  mapOfEdgesAndLanes[myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID())] = selectedLane;
978  }
979  // Throw warning dialog if there hare multiple lanes selected in the same edge
980  if (mapOfEdgesAndLanes.size() != selectedLanes.size()) {
981  const std::string header = TL("Multiple lane in the same edge selected");
982  const std::string bodyA = TL("There are selected lanes that belong to the same edge.");
983  const std::string bodyB = TLF("Only one lane per edge will be restricted to %.", toString(vclass));
984  FXMessageBox::information(getApp(), MBOX_OK, header.c_str(), "%s", (bodyA + std::string("\n") + bodyB).c_str());
985  }
986  // If we handeln a set of lanes
987  if (mapOfEdgesAndLanes.size() > 0) {
988  // declare counter for number of Sidewalks
989  int counter = 0;
990  // iterate over selected lanes
991  for (const auto& edgeLane : mapOfEdgesAndLanes) {
992  if (edgeLane.first->hasRestrictedLane(vclass)) {
993  counter++;
994  }
995  }
996  // if all edges parent own a Sidewalk, stop function
997  if (counter == (int)mapOfEdgesAndLanes.size()) {
998  const std::string header = TLF("Set vclass to % for selected lanes", toString(vclass));
999  const std::string body = TL("All lanes own already another lane in the same edge with a restriction for ");
1000  FXMessageBox::information(getApp(), MBOX_OK, header.c_str(), "%s", (body + toString(vclass) + ".").c_str());
1001  return 0;
1002  } else {
1003  WRITE_DEBUG("Opening FXMessageBox 'restrict lanes'");
1004  // Ask confirmation to user
1005  const std::string header = TLF("Set vclass to % for selected lanes", toString(vclass));
1006  const std::string body = TLF("% lanes will be restricted to %. Continue?", toString(mapOfEdgesAndLanes.size() - counter), toString(vclass));
1007  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO, header.c_str(), "%s", body.c_str());
1008  if (answer != 1) { //1:yes, 2:no, 4:esc
1009  // write warning if netedit is running in testing mode
1010  if (answer == 2) {
1011  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'No'");
1012  } else if (answer == 4) {
1013  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'ESC'");
1014  }
1015  return 0;
1016  } else {
1017  // write warning if netedit is running in testing mode
1018  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'Yes'");
1019  }
1020  }
1021  // begin undo operation
1022  myUndoList->begin(lane, "restrict lanes to " + toString(vclass));
1023  // iterate over selected lanes
1024  for (const auto& edgeLane : mapOfEdgesAndLanes) {
1025  // Transform lane to Sidewalk
1026  myNet->restrictLane(vclass, edgeLane.second, myUndoList);
1027  }
1028  // end undo operation
1029  myUndoList->end();
1030  } else {
1031  // If only have a single lane, start undo/redo operation
1032  myUndoList->begin(lane, TL("restrict lane to ") + toString(vclass));
1033  // Transform lane to Sidewalk
1034  myNet->restrictLane(vclass, lane, myUndoList);
1035  // end undo operation
1036  myUndoList->end();
1037  }
1038  return 1;
1039 }
1040 
1041 
1042 bool
1043 GNEViewNet::addRestrictedLane(GNELane* lane, SUMOVehicleClass vclass, const bool insertAtFront) {
1044  // Get selected edges
1045  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
1046  // get selected lanes
1047  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
1048  // Declare set of edges
1049  std::set<GNEEdge*> setOfEdges;
1050  // Fill set of edges with vector of edges
1051  for (const auto& edge : selectedEdges) {
1052  setOfEdges.insert(edge);
1053  }
1054  // iterate over selected lanes
1055  for (const auto& selectedLane : selectedLanes) {
1056  // Insert pointer to edge into set of edges (To avoid duplicates)
1057  setOfEdges.insert(myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID()));
1058  }
1059  // If we handeln a set of edges
1060  if (lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) {
1061  // declare counter for number of restrictions
1062  int counter = 0;
1063  // iterate over set of edges
1064  for (const auto& edge : setOfEdges) {
1065  // update counter if edge has already a restricted lane of type "vclass"
1066  if (edge->hasRestrictedLane(vclass)) {
1067  counter++;
1068  }
1069  }
1070  // if all lanes own a Sidewalk, stop function
1071  if (counter == (int)setOfEdges.size()) {
1072  const std::string header = TLF("Add vclass % to selected lanes", toString(vclass));
1073  const std::string body = TLF("All lanes own already another lane in the same edge with a restriction to %.", toString(vclass));
1074  FXMessageBox::information(getApp(), MBOX_OK, header.c_str(), "%s", body.c_str());
1075  return 0;
1076  } else {
1077  WRITE_DEBUG("Opening FXMessageBox 'restrict lanes'");
1078  // Ask confirmation to user
1079  const std::string header = TLF("Add vclass % to selected lanes", toString(vclass));
1080  const std::string body = TLF("% restrictions to % will be added. Continue?", toString(setOfEdges.size() - counter), toString(vclass));
1081  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO, header.c_str(), "%s", body.c_str());
1082  if (answer != 1) { //1:yes, 2:no, 4:esc
1083  // write warning if netedit is running in testing mode
1084  if (answer == 2) {
1085  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'No'");
1086  } else if (answer == 4) {
1087  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'ESC'");
1088  }
1089  return 0;
1090  } else {
1091  // write warning if netedit is running in testing mode
1092  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'Yes'");
1093  }
1094  }
1095  // begin undo operation
1096  myUndoList->begin(lane, TL("add restrictions for ") + toString(vclass));
1097  // iterate over set of edges
1098  for (const auto& edge : setOfEdges) {
1099  // add restricted lane (guess target)
1100  myNet->addRestrictedLane(vclass, edge, -1, myUndoList);
1101  }
1102  // end undo operation
1103  myUndoList->end();
1104  } else {
1105  // If only have a single lane, start undo/redo operation
1106  myUndoList->begin(lane, TL("add vclass for ") + toString(vclass));
1107  // Add restricted lane
1108  if (vclass == SVC_PEDESTRIAN) {
1109  // always add pedestrian lanes on the right
1110  myNet->addRestrictedLane(vclass, lane->getParentEdge(), 0, myUndoList);
1111  } else if (vclass == SVC_IGNORING) {
1112  if (insertAtFront) {
1113  myNet->addGreenVergeLane(lane->getParentEdge(), lane->getIndex() + 1, myUndoList);
1114  } else {
1115  myNet->addGreenVergeLane(lane->getParentEdge(), lane->getIndex(), myUndoList);
1116  }
1117  } else if (lane->getParentEdge()->getLanes().size() == 1) {
1118  // guess insertion position if there is only 1 lane
1119  myNet->addRestrictedLane(vclass, lane->getParentEdge(), -1, myUndoList);
1120  } else {
1121  myNet->addRestrictedLane(vclass, lane->getParentEdge(), lane->getIndex(), myUndoList);
1122  }
1123  // end undo/redo operation
1124  myUndoList->end();
1125  }
1126  return 1;
1127 }
1128 
1129 
1130 bool
1131 GNEViewNet::removeRestrictedLane(GNELane* lane, SUMOVehicleClass vclass) {
1132  // Get selected edges
1133  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
1134  // get selected lanes
1135  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
1136  // Declare set of edges
1137  std::set<GNEEdge*> setOfEdges;
1138  // Fill set of edges with vector of edges
1139  for (const auto& edge : selectedEdges) {
1140  setOfEdges.insert(edge);
1141  }
1142  // iterate over selected lanes
1143  for (const auto& selectedLane : selectedLanes) {
1144  // Insert pointer to edge into set of edges (To avoid duplicates)
1145  setOfEdges.insert(myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID()));
1146  }
1147  // If we handeln a set of edges
1148  if (setOfEdges.size() > 0) {
1149  // declare counter for number of restrictions
1150  int counter = 0;
1151  // iterate over set of edges
1152  for (const auto& edge : setOfEdges) {
1153  // update counter if edge has already a restricted lane of type "vclass"
1154  if (edge->hasRestrictedLane(vclass)) {
1155  counter++;
1156  }
1157  }
1158  // if all lanes don't own a Sidewalk, stop function
1159  if (counter == 0) {
1160  const std::string header = TLF("Remove vclass % from selected lanes", toString(vclass));
1161  const std::string body = TLF("The selected lanes and edges don't have a restriction to %.", toString(vclass));
1162  FXMessageBox::information(getApp(), MBOX_OK, header.c_str(), "%s", body.c_str());
1163  return 0;
1164  } else {
1165  WRITE_DEBUG("Opening FXMessageBox 'restrict lanes'");
1166  // Ask confirmation to user
1167  const std::string header = TLF("Remove vclass % from selected lanes", toString(vclass));
1168  const std::string body = TLF("% restrictions to % will be removed. Continue?", toString(setOfEdges.size() - counter), toString(vclass));
1169  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO, header.c_str(), "%s", body.c_str());
1170  if (answer != 1) { //1:yes, 2:no, 4:esc
1171  // write warning if netedit is running in testing mode
1172  if (answer == 2) {
1173  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'No'");
1174  } else if (answer == 4) {
1175  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'ESC'");
1176  }
1177  return 0;
1178  } else {
1179  // write warning if netedit is running in testing mode
1180  WRITE_DEBUG("Closed FXMessageBox 'restrict lanes' with 'Yes'");
1181  }
1182  }
1183  // begin undo operation
1184  myUndoList->begin(lane, "Remove restrictions for " + toString(vclass));
1185  // iterate over set of edges
1186  for (const auto& edge : setOfEdges) {
1187  // add Sidewalk
1188  myNet->removeRestrictedLane(vclass, edge, myUndoList);
1189  }
1190  // end undo operation
1191  myUndoList->end();
1192  } else {
1193  // If only have a single lane, start undo/redo operation
1194  myUndoList->begin(lane, TL("Remove vclass for ") + toString(vclass));
1195  // Remove Sidewalk
1196  myNet->removeRestrictedLane(vclass, lane->getParentEdge(), myUndoList);
1197  // end undo/redo operation
1198  myUndoList->end();
1199  }
1200  return 1;
1201 }
1202 
1203 
1204 GNEViewNet::GNEViewNet() :
1205  myViewObjectsSelector(this),
1206  myEditModes(this),
1207  myTestingMode(this),
1208  myCommonCheckableButtons(this),
1209  myNetworkCheckableButtons(this),
1210  myDemandCheckableButtons(this),
1211  myDataCheckableButtons(this),
1212  myNetworkViewOptions(this),
1213  myDemandViewOptions(this),
1214  myDataViewOptions(this),
1215  myIntervalBar(this),
1216  myMoveSingleElement(this),
1217  myMoveMultipleElements(this),
1218  myVehicleOptions(this),
1219  myVehicleTypeOptions(this),
1220  mySaveElements(this),
1221  myTimeFormat(this),
1222  mySelectingArea(this),
1223  myEditNetworkElementShapes(this),
1224  myLockManager(this) {
1225 }
1226 
1227 
1228 std::vector<std::string>
1229 GNEViewNet::getEdgeLaneParamKeys(bool edgeKeys) const {
1230  std::set<std::string> keys;
1231  for (const NBEdge* e : myNet->getEdgeCont().getAllEdges()) {
1232  if (edgeKeys) {
1233  for (const auto& item : e->getParametersMap()) {
1234  keys.insert(item.first);
1235  }
1236  for (const auto& con : e->getConnections()) {
1237  for (const auto& item : con.getParametersMap()) {
1238  keys.insert(item.first);
1239  }
1240  }
1241  } else {
1242  for (const auto& lane : e->getLanes()) {
1243  int i = 0;
1244  for (const auto& item : lane.getParametersMap()) {
1245  keys.insert(item.first);
1246  }
1247  for (const auto& con : e->getConnectionsFromLane(i)) {
1248  for (const auto& item : con.getParametersMap()) {
1249  keys.insert(item.first);
1250  }
1251  }
1252  i++;
1253  }
1254  }
1255  }
1256  return std::vector<std::string>(keys.begin(), keys.end());
1257 }
1258 
1259 
1260 std::vector<std::string>
1261 GNEViewNet::getEdgeDataAttrs() const {
1262  std::set<std::string> keys;
1263  for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(GNE_TAG_EDGEREL_SINGLE)) {
1264  for (const auto& parameter : genericData.second->getACParametersMap()) {
1265  keys.insert(parameter.first);
1266  }
1267  }
1268  return std::vector<std::string>(keys.begin(), keys.end());
1269 }
1270 
1271 
1272 std::vector<std::string>
1273 GNEViewNet::getRelDataAttrs() const {
1274  std::set<std::string> keys;
1275  for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_TAZREL)) {
1276  for (const auto& parameter : genericData.second->getACParametersMap()) {
1277  keys.insert(parameter.first);
1278  }
1279  }
1280  for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_EDGEREL)) {
1281  for (const auto& parameter : genericData.second->getACParametersMap()) {
1282  keys.insert(parameter.first);
1283  }
1284  }
1285  return std::vector<std::string>(keys.begin(), keys.end());
1286 }
1287 
1288 
1289 bool
1290 GNEViewNet::checkSelectEdges() const {
1291  if ((myNetworkViewOptions.selectEdges() && !myMouseButtonKeyPressed.shiftKeyPressed()) ||
1292  (!myNetworkViewOptions.selectEdges() && myMouseButtonKeyPressed.shiftKeyPressed())) {
1293  return true;
1294  } else {
1295  return false;
1296  }
1297 }
1298 
1299 
1300 int
1301 GNEViewNet::getDrawingToggle() const {
1302  return myDrawingToggle;
1303 }
1304 
1305 
1306 int
1307 GNEViewNet::doPaintGL(int mode, const Boundary& bound) {
1308  // set lefthand and laneIcons
1309  myVisualizationSettings->lefthand = OptionsCont::getOptions().getBool("lefthand");
1310  myVisualizationSettings->disableLaneIcons = OptionsCont::getOptions().getBool("disable-laneIcons");
1311  // first step: update objects under cursor
1312  updateObjectsInPosition(myNet->getViewNet()->getPositionInformation());
1313  // set render modes
1314  glRenderMode(mode);
1315  glMatrixMode(GL_MODELVIEW);
1316  GLHelper::pushMatrix();
1317  glDisable(GL_TEXTURE_2D);
1318  glDisable(GL_ALPHA_TEST);
1319  glEnable(GL_BLEND);
1320  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1321  glEnable(GL_DEPTH_TEST);
1322  // visualize rectangular selection
1323  mySelectingArea.drawRectangleSelection(myVisualizationSettings->colorSettings.selectionColor);
1324  // draw certain elements only if we aren't in rectangle selection mode
1325  if (!myVisualizationSettings->drawForRectangleSelection) {
1326  // draw decals
1327  drawDecals();
1328  // draw grid (and update grid button)
1329  drawGrid();
1330  // update show connections
1331  myNetworkViewOptions.menuCheckShowConnections->setChecked(myVisualizationSettings->showLane2Lane);
1332  // draw temporal junction
1333  drawTemporalJunction();
1334  // draw temporal drawing shape
1335  drawTemporalDrawingShape();
1336  // draw testing elements
1337  myTestingMode.drawTestingElements(myApp);
1338  // draw temporal E2 multilane detectors
1339  myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->drawTemporalConsecutiveLanePath();
1340  // draw temporal overhead wires
1341  myViewParent->getWireFrame()->getConsecutiveLaneSelector()->drawTemporalConsecutiveLanePath();
1342  // draw temporal trip/flow route
1343  myViewParent->getVehicleFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1344  // draw temporal person plan route
1345  myViewParent->getPersonFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1346  myViewParent->getPersonPlanFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1347  // draw temporal container plan route
1348  myViewParent->getContainerFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1349  myViewParent->getContainerPlanFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1350  // draw temporal route
1351  myViewParent->getRouteFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1352  // draw temporal edgeRelPath
1353  myViewParent->getEdgeRelDataFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1354  }
1355  // check menu checks of supermode demand
1356  if (myEditModes.isCurrentSupermodeDemand()) {
1357  // enable or disable menuCheckShowAllPersonPlans depending of there is a locked person
1358  if (myDemandViewOptions.getLockedPerson()) {
1359  myDemandViewOptions.menuCheckShowAllPersonPlans->disable();
1360  } else {
1361  myDemandViewOptions.menuCheckShowAllPersonPlans->enable();
1362  }
1363  }
1364  // clear pathDraw
1365  myNet->getPathManager()->getPathDraw()->clearPathDraw();
1366  // draw network (boundary
1367  myNet->drawGL(*myVisualizationSettings);
1368  // draw all GL elements
1369  int hits = drawGLElements(bound);
1370  // draw temporal split junction
1371  drawTemporalSplitJunction();
1372  // draw temporal roundabout
1373  drawTemporalRoundabout();
1374  // draw temporal lines between E1 detectors and junctions in TLS Mode
1375  drawTemporalE1TLSLines();
1376  // draw temporal lines between junctions in TLS Mode
1377  drawTemporalJunctionTLSLines();
1378  // draw netedit attributes references
1379  drawNeteditAttributesReferences();
1380  // draw test circle
1381  drawTestsCircle();
1382  // pop draw matrix
1383  GLHelper::popMatrix();
1384  // update interval bar
1385  myIntervalBar.markForUpdate();
1386  // check if recopute boundaries (Deactivated, continue after 1.14 release)
1387  /*
1388  if (gObjectsInPosition.recomputeBoundaries != GLO_NETWORK) {
1389  myNet->getGrid().updateBoundaries(gObjectsInPosition.recomputeBoundaries);
1390  }
1391  */
1392  return hits;
1393 }
1394 
1395 
1396 long
1397 GNEViewNet::onLeftBtnPress(FXObject*, FXSelector, void* eventData) {
1398  // set focus in view net
1399  setFocus();
1400  // update MouseButtonKeyPressed
1401  myMouseButtonKeyPressed.update(eventData);
1402  // process left button press function depending of supermode
1403  if (myEditModes.isCurrentSupermodeNetwork()) {
1404  processLeftButtonPressNetwork(eventData);
1405  } else if (myEditModes.isCurrentSupermodeDemand()) {
1406  processLeftButtonPressDemand(eventData);
1407  } else if (myEditModes.isCurrentSupermodeData()) {
1408  processLeftButtonPressData(eventData);
1409  }
1410  // update cursor
1411  updateCursor();
1412  // update view
1413  updateViewNet();
1414  return 1;
1415 }
1416 
1417 
1418 long
1419 GNEViewNet::onLeftBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1420  // avoid closing Popup dialog in Linux
1421  if (myCreatedPopup) {
1422  myCreatedPopup = false;
1423  return 1;
1424  }
1425  // process parent function
1426  GUISUMOAbstractView::onLeftBtnRelease(obj, sel, eventData);
1427  // update MouseButtonKeyPressed
1428  myMouseButtonKeyPressed.update(eventData);
1429  // process left button release function depending of supermode
1430  if (myEditModes.isCurrentSupermodeNetwork()) {
1431  processLeftButtonReleaseNetwork();
1432  } else if (myEditModes.isCurrentSupermodeDemand()) {
1433  processLeftButtonReleaseDemand();
1434  } else if (myEditModes.isCurrentSupermodeData()) {
1435  processLeftButtonReleaseData();
1436  }
1437  // update cursor
1438  updateCursor();
1439  // update view
1440  updateViewNet();
1441  return 1;
1442 }
1443 
1444 
1445 long
1446 GNEViewNet::onMiddleBtnPress(FXObject* obj, FXSelector sel, void* eventData) {
1447  // process parent function
1448  GUISUMOAbstractView::onMiddleBtnPress(obj, sel, eventData);
1449  // update cursor
1450  updateCursor();
1451  // update view
1452  updateViewNet();
1453  return 1;
1454 }
1455 
1456 
1457 long
1458 GNEViewNet::onMiddleBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1459  // process parent function
1460  GUISUMOAbstractView::onMiddleBtnRelease(obj, sel, eventData);
1461  // update cursor
1462  updateCursor();
1463  // update view
1464  updateViewNet();
1465  return 1;
1466 }
1467 
1468 
1469 long
1470 GNEViewNet::onRightBtnPress(FXObject* obj, FXSelector sel, void* eventData) {
1471  // update MouseButtonKeyPressed
1472  myMouseButtonKeyPressed.update(eventData);
1473  // update cursor
1474  updateCursor();
1475  if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1476  // disable right button press during drawing polygon
1477  return 1;
1478  } else {
1479  return GUISUMOAbstractView::onRightBtnPress(obj, sel, eventData);
1480  }
1481 }
1482 
1483 
1484 long
1485 GNEViewNet::onRightBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1486  // update MouseButtonKeyPressed
1487  myMouseButtonKeyPressed.update(eventData);
1488  // update cursor
1489  updateCursor();
1490  // disable right button release during drawing polygon
1491  if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1492  return 1;
1493  } else {
1494  return GUISUMOAbstractView::onRightBtnRelease(obj, sel, eventData);
1495  }
1496 }
1497 
1498 
1499 long
1500 GNEViewNet::onMouseMove(FXObject* obj, FXSelector sel, void* eventData) {
1501  // process mouse move in GUISUMOAbstractView
1502  GUISUMOAbstractView::onMouseMove(obj, sel, eventData);
1503  // update MouseButtonKeyPressed
1504  myMouseButtonKeyPressed.update(eventData);
1505  // update cursor
1506  updateCursor();
1507  // process mouse move function depending of supermode
1508  if (myEditModes.isCurrentSupermodeNetwork()) {
1509  processMoveMouseNetwork(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1510  } else if (myEditModes.isCurrentSupermodeDemand()) {
1511  processMoveMouseDemand(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1512  } else if (myEditModes.isCurrentSupermodeData()) {
1513  processMoveMouseData(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1514  }
1515  // update view
1516  updateViewNet();
1517  return 1;
1518 }
1519 
1520 
1521 long
1522 GNEViewNet::onKeyPress(FXObject* o, FXSelector sel, void* eventData) {
1523  // update MouseButtonKeyPressed
1524  myMouseButtonKeyPressed.update(eventData);
1525  // update cursor
1526  updateCursor();
1527  // continue depending of current edit mode
1528  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1529  // update viewNet (for temporal junction)
1530  updateViewNet();
1531  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1532  // change "delete last created point" depending of shift key
1533  myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1534  updateViewNet();
1535  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1536  // change "delete last created point" depending of shift key
1537  myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1538  updateViewNet();
1539  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) || (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE)) {
1540  updateViewNet();
1541  }
1542  return GUISUMOAbstractView::onKeyPress(o, sel, eventData);
1543 }
1544 
1545 
1546 long
1547 GNEViewNet::onKeyRelease(FXObject* o, FXSelector sel, void* eventData) {
1548  // update MouseButtonKeyPressed
1549  myMouseButtonKeyPressed.update(eventData);
1550  // update cursor
1551  updateCursor();
1552  // continue depending of current edit mode
1553  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1554  // update viewNet (for temporal junction)
1555  updateViewNet();
1556  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1557  // change "delete last created point" depending of shift key
1558  myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1559  updateViewNet();
1560  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1561  // change "delete last created point" depending of shift key
1562  myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1563  updateViewNet();
1564  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) || (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE)) {
1565  updateViewNet();
1566  }
1567  // check if selecting using rectangle has to be disabled
1568  if (mySelectingArea.selectingUsingRectangle && !myMouseButtonKeyPressed.shiftKeyPressed()) {
1569  mySelectingArea.selectingUsingRectangle = false;
1570  updateViewNet();
1571  }
1572  return GUISUMOAbstractView::onKeyRelease(o, sel, eventData);
1573 }
1574 
1575 
1576 void
1577 GNEViewNet::abortOperation(bool clearSelection) {
1578  // steal focus from any text fields and place it over view net
1579  setFocus();
1580  // check what supermode is enabled
1581  if (myEditModes.isCurrentSupermodeNetwork()) {
1582  // abort operation depending of current mode
1583  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1584  // abort edge creation in create edge frame
1585  myViewParent->getCreateEdgeFrame()->abortEdgeCreation();
1586  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
1587  mySelectingArea.selectingUsingRectangle = false;
1588  // check if current selection has to be cleaned
1589  if (clearSelection) {
1590  myViewParent->getSelectorFrame()->clearCurrentSelection();
1591  }
1592  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
1593  // abort changes in Connector Frame
1594  myViewParent->getConnectorFrame()->getConnectionModifications()->onCmdCancelModifications(0, 0, 0);
1595  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS) {
1596  // continue depending of current TLS frame state
1597  if (myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled()) {
1598  myViewParent->getTLSEditorFrame()->getTLSAttributes()->disableE1DetectorMode();
1599  } else if (myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions()) {
1600  myViewParent->getTLSEditorFrame()->getTLSJunction()->onCmdCancelJoin(nullptr, 0, nullptr);
1601  } else {
1602  myViewParent->getTLSEditorFrame()->getTLSDefinition()->discardChanges(false);
1603  }
1604  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
1605  myEditNetworkElementShapes.stopEditCustomShape();
1606  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CROSSING) {
1607  myViewParent->getCrossingFrame()->clearEdgesHotkey();
1608  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) {
1609  // abort current drawing
1610  myViewParent->getShapeFrame()->getDrawingShapeModule()->abortDrawing();
1611  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
1612  if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1613  // abort current drawing
1614  myViewParent->getTAZFrame()->getDrawingShapeModule()->abortDrawing();
1615  } else if (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() != nullptr) {
1616  // finish current editing TAZ
1617  myViewParent->getTAZFrame()->getCurrentTAZModule()->setTAZ(nullptr);
1618  }
1619  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_PROHIBITION) {
1620  myViewParent->getProhibitionFrame()->getSelectionModul()->onCmdCancel(nullptr, 0, nullptr);
1621  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1622  // abort both network elements selections
1623  myViewParent->getAdditionalFrame()->getEdgesSelector()->clearSelection();
1624  myViewParent->getAdditionalFrame()->getLanesSelector()->clearSelection();
1625  // abort path
1626  myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->abortPathCreation();
1627  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_WIRE) {
1628  // abort path
1629  myViewParent->getWireFrame()->getConsecutiveLaneSelector()->abortPathCreation();
1630  }
1631  } else if (myEditModes.isCurrentSupermodeDemand()) {
1632  // abort operation depending of current mode
1633  if (myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) {
1634  mySelectingArea.selectingUsingRectangle = false;
1635  // check if current selection has to be cleaned
1636  if (clearSelection) {
1637  myViewParent->getSelectorFrame()->clearCurrentSelection();
1638  }
1639  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1640  myViewParent->getRouteFrame()->getPathCreator()->abortPathCreation();
1641  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1642  myViewParent->getVehicleFrame()->getPathCreator()->abortPathCreation();
1643  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1644  myViewParent->getPersonFrame()->getPlanCreator()->abortPathCreation();
1645  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1646  myViewParent->getPersonPlanFrame()->resetSelectedPerson();
1647  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1648  myViewParent->getContainerFrame()->getPlanCreator()->abortPathCreation();
1649  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1650  myViewParent->getContainerPlanFrame()->getPlanCreator()->abortPathCreation();
1651  }
1652  } else if (myEditModes.isCurrentSupermodeData()) {
1653  // abort operation depending of current mode
1654  if (myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) {
1655  mySelectingArea.selectingUsingRectangle = false;
1656  // check if current selection has to be cleaned
1657  if (clearSelection) {
1658  myViewParent->getSelectorFrame()->clearCurrentSelection();
1659  }
1660  } else if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1661  myViewParent->getEdgeRelDataFrame()->getPathCreator()->abortPathCreation();
1662  } else if (myEditModes.dataEditMode == DataEditMode::DATA_TAZRELDATA) {
1663  myViewParent->getTAZRelDataFrame()->clearTAZSelection();
1664  }
1665  }
1666  // abort undo list
1667  myUndoList->abortAllChangeGroups();
1668  // update view
1669  updateViewNet();
1670 }
1671 
1672 
1673 void
1674 GNEViewNet::hotkeyDel() {
1675  // delete elements depending of current supermode
1676  if (myEditModes.isCurrentSupermodeNetwork()) {
1677  if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) || (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS)) {
1678  setStatusBarText(TL("Cannot delete in this mode"));
1679  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT) && (myInspectedAttributeCarriers.size() > 0)) {
1680  // delete inspected elements
1681  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete network inspected elements"));
1682  deleteNetworkAttributeCarriers(myInspectedAttributeCarriers);
1683  myUndoList->end();
1684  } else {
1685  // get selected ACs
1686  const auto selectedACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1687  // delete selected elements
1688  if (selectedACs.size() > 0) {
1689  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete network selection"));
1690  deleteNetworkAttributeCarriers(selectedACs);
1691  myUndoList->end();
1692  }
1693  }
1694  } else if (myEditModes.isCurrentSupermodeDemand()) {
1695  if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) && (myInspectedAttributeCarriers.size() > 0)) {
1696  // delete inspected elements
1697  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete demand inspected elements"));
1698  deleteDemandAttributeCarriers(myInspectedAttributeCarriers);
1699  myUndoList->end();
1700  } else {
1701  // get selected ACs
1702  const auto selectedACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1703  // delete selected elements
1704  if (selectedACs.size() > 0) {
1705  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete demand selection"));
1706  deleteDemandAttributeCarriers(selectedACs);
1707  myUndoList->end();
1708  }
1709  }
1710  } else if (myEditModes.isCurrentSupermodeData()) {
1711  if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) && (myInspectedAttributeCarriers.size() > 0)) {
1712  // delete inspected elements
1713  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete data inspected elements"));
1714  deleteDataAttributeCarriers(myInspectedAttributeCarriers);
1715  myUndoList->end();
1716  } else {
1717  // get selected ACs
1718  const auto selectedACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1719  // delete selected elements
1720  if (selectedACs.size() > 0) {
1721  myUndoList->begin(GUIIcon::MODEDELETE, TL("delete data selection"));
1722  deleteDataAttributeCarriers(selectedACs);
1723  myUndoList->end();
1724  }
1725  }
1726  }
1727  // update view
1728  updateViewNet();
1729 }
1730 
1731 
1732 void
1733 GNEViewNet::hotkeyEnter() {
1734  // check what supermode is enabled
1735  if (myEditModes.isCurrentSupermodeNetwork()) {
1736  // abort operation depending of current mode
1737  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
1738  // Accept changes in Connector Frame
1739  myViewParent->getConnectorFrame()->getConnectionModifications()->onCmdSaveModifications(0, 0, 0);
1740  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS) {
1741  // continue depending of current TLS frame state
1742  if (myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled()) {
1743  myViewParent->getTLSEditorFrame()->getTLSAttributes()->disableE1DetectorMode();
1744  } else if (myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions()) {
1745  myViewParent->getTLSEditorFrame()->getTLSJunction()->onCmdAcceptJoin(nullptr, 0, nullptr);
1746  } else if (myViewParent->getTLSEditorFrame()->getTLSDefinition()->checkHaveModifications()) {
1747  myViewParent->getTLSEditorFrame()->getTLSDefinition()->onCmdSaveChanges(nullptr, 0, nullptr);
1748  }
1749  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) && (myEditNetworkElementShapes.getEditedNetworkElement() != nullptr)) {
1750  myEditNetworkElementShapes.commitShapeEdited();
1751  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) {
1752  if (myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1753  // stop current drawing
1754  myViewParent->getShapeFrame()->getDrawingShapeModule()->stopDrawing();
1755  } else {
1756  // start drawing
1757  myViewParent->getShapeFrame()->getDrawingShapeModule()->startDrawing();
1758  }
1759  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CROSSING) {
1760  myViewParent->getCrossingFrame()->createCrossingHotkey();
1761  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
1762  if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1763  // stop current drawing
1764  myViewParent->getTAZFrame()->getDrawingShapeModule()->stopDrawing();
1765  } else if (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() == nullptr) {
1766  // start drawing
1767  myViewParent->getTAZFrame()->getDrawingShapeModule()->startDrawing();
1768  } else if (myViewParent->getTAZFrame()->getTAZSaveChangesModule()->isChangesPending()) {
1769  // save pending changes
1770  myViewParent->getTAZFrame()->getTAZSaveChangesModule()->onCmdSaveChanges(0, 0, 0);
1771  }
1772  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1773  // create path element
1774  myViewParent->getAdditionalFrame()->createPath(false);
1775  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_WIRE) {
1776  // create path element
1777  myViewParent->getWireFrame()->createPath(false);
1778  }
1779  } else if (myEditModes.isCurrentSupermodeDemand()) {
1780  if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1781  myViewParent->getRouteFrame()->getPathCreator()->createPath(false);
1782  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1783  myViewParent->getVehicleFrame()->getPathCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1784  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1785  myViewParent->getPersonFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1786  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1787  myViewParent->getPersonPlanFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1788  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1789  myViewParent->getContainerFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1790  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1791  myViewParent->getContainerPlanFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1792  }
1793  } else if (myEditModes.isCurrentSupermodeData()) {
1794  if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1795  myViewParent->getEdgeRelDataFrame()->getPathCreator()->createPath(false);
1796  } else if (myEditModes.dataEditMode == DataEditMode::DATA_TAZRELDATA) {
1797  myViewParent->getTAZRelDataFrame()->buildTAZRelationData();
1798  }
1799  }
1800 }
1801 
1802 
1803 void
1804 GNEViewNet::hotkeyBackSpace() {
1805  // check what supermode is enabled
1806  if (myEditModes.isCurrentSupermodeNetwork()) {
1807  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1808  myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->removeLastElement();
1809  }
1810  } else if (myEditModes.isCurrentSupermodeDemand()) {
1811  if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1812  myViewParent->getRouteFrame()->getPathCreator()->removeLastElement();
1813  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1814  myViewParent->getVehicleFrame()->getPathCreator()->removeLastElement();
1815  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1816  myViewParent->getPersonFrame()->getPlanCreator()->removeLastElement();
1817  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1818  myViewParent->getPersonPlanFrame()->getPlanCreator()->removeLastElement();
1819  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1820  myViewParent->getContainerFrame()->getPlanCreator()->removeLastElement();
1821  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1822  myViewParent->getContainerPlanFrame()->getPlanCreator()->removeLastElement();
1823  }
1824  } else if (myEditModes.isCurrentSupermodeData()) {
1825  if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1826  myViewParent->getEdgeRelDataFrame()->getPathCreator()->removeLastElement();
1827  }
1828  }
1829 }
1830 
1831 void
1832 GNEViewNet::hotkeyFocusFrame() {
1833  // if there is a visible frame, set focus over it. In other case, set focus over ViewNet
1834  if (myCurrentFrame != nullptr) {
1835  myCurrentFrame->focusUpperElement();
1836  } else {
1837  setFocus();
1838  }
1839 }
1840 
1841 
1842 GNEViewParent*
1843 GNEViewNet::getViewParent() const {
1844  return myViewParent;
1845 }
1846 
1847 
1848 GNENet*
1849 GNEViewNet::getNet() const {
1850  return myNet;
1851 }
1852 
1853 
1854 GNEUndoList*
1855 GNEViewNet::getUndoList() const {
1856  return myUndoList;
1857 }
1858 
1859 
1860 GNEViewNetHelper::IntervalBar&
1861 GNEViewNet::getIntervalBar() {
1862  return myIntervalBar;
1863 }
1864 
1865 
1866 const std::vector<GNEAttributeCarrier*>&
1867 GNEViewNet::getInspectedAttributeCarriers() const {
1868  return myInspectedAttributeCarriers;
1869 }
1870 
1871 
1872 GNEViewNetHelper::LockManager&
1873 GNEViewNet::getLockManager() {
1874  return myLockManager;
1875 }
1876 
1877 
1878 void
1879 GNEViewNet::setInspectedAttributeCarriers(const std::vector<GNEAttributeCarrier*> ACs) {
1880  myInspectedAttributeCarriers = ACs;
1881 }
1882 
1883 
1884 bool
1885 GNEViewNet::isAttributeCarrierInspected(const GNEAttributeCarrier* AC) const {
1886  if (myInspectedAttributeCarriers.empty()) {
1887  return false;
1888  } else {
1889  // search AC in myInspectedAttributeCarriers
1890  const auto it = std::find(myInspectedAttributeCarriers.begin(), myInspectedAttributeCarriers.end(), AC);
1891  if (it == myInspectedAttributeCarriers.end()) {
1892  return false;
1893  } else {
1894  return true;
1895  }
1896  }
1897 }
1898 
1899 
1900 void
1901 GNEViewNet::removeFromAttributeCarrierInspected(const GNEAttributeCarrier* AC) {
1902  // search AC in myInspectedAttributeCarriers
1903  const auto it = std::find(myInspectedAttributeCarriers.begin(), myInspectedAttributeCarriers.end(), AC);
1904  if (it != myInspectedAttributeCarriers.end()) {
1905  myInspectedAttributeCarriers.erase(it);
1906  myViewParent->getInspectorFrame()->inspectMultisection(myInspectedAttributeCarriers);
1907  }
1908 }
1909 
1910 
1911 const GNEAttributeCarrier*
1912 GNEViewNet::getFrontAttributeCarrier() const {
1913  return myFrontAttributeCarrier;
1914 }
1915 
1916 
1917 const GUIGlObject*
1918 GNEViewNet::getFrontGLObject() const {
1919  if (myFrontAttributeCarrier) {
1920  return myFrontAttributeCarrier->getGUIGlObject();
1921  } else {
1922  return nullptr;
1923  }
1924 }
1925 
1926 
1927 void
1928 GNEViewNet::setFrontAttributeCarrier(GNEAttributeCarrier* AC) {
1929  myFrontAttributeCarrier = AC;
1930  update();
1931 }
1932 
1933 
1934 void
1935 GNEViewNet::drawTranslateFrontAttributeCarrier(const GNEAttributeCarrier* AC, double typeOrLayer, const double extraOffset) {
1936  if (myFrontAttributeCarrier == AC) {
1937  glTranslated(0, 0, GLO_FRONTELEMENT + extraOffset);
1938  } else {
1939  glTranslated(0, 0, typeOrLayer + extraOffset);
1940  }
1941 }
1942 
1943 
1944 bool
1945 GNEViewNet::isCurrentlyMovingElements() const {
1946  return myMoveSingleElement.isCurrentlyMovingSingleElement() || myMoveMultipleElements.isCurrentlyMovingMultipleElements();
1947 }
1948 
1949 
1950 bool
1951 GNEViewNet::checkOverLockedElement(const GUIGlObject* GLObject, const bool isSelected) const {
1952  // check if elemet is blocked
1953  if (myLockManager.isObjectLocked(GLObject->getType(), isSelected)) {
1954  return false;
1955  }
1956  // get front GLObject
1957  const auto glObjectFront = myViewObjectsSelector.getGUIGlObjectFront();
1958  // check if element is under cursor
1959  if (glObjectFront) {
1960  if (glObjectFront == GLObject) {
1961  return true;
1962  } else if (glObjectFront->getType() == GLObject->getType()) {
1963  for (const auto& glObjectUnderCursor : myViewObjectsSelector.getGLObjects()) {
1964  if (glObjectUnderCursor == GLObject) {
1965  return true;
1966  }
1967  }
1968  }
1969  }
1970  return false;
1971 }
1972 
1973 
1974 GNEDemandElement*
1975 GNEViewNet::getLastCreatedRoute() const {
1976  return myLastCreatedRoute;
1977 }
1978 
1979 
1980 void
1981 GNEViewNet::setLastCreatedRoute(GNEDemandElement* lastCreatedRoute) {
1982  myLastCreatedRoute = lastCreatedRoute;
1983 }
1984 
1985 
1986 GNEJunction*
1987 GNEViewNet::getJunctionAtPopupPosition() {
1988  // get first object that can be found in their container
1989  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
1990  for (const auto& glObject : glObjectLayer.second) {
1991  auto junction = myNet->getAttributeCarriers()->retrieveJunction(glObject.object->getMicrosimID(), false);
1992  if (junction) {
1993  return junction;
1994  }
1995  }
1996  }
1997  return nullptr;
1998 }
1999 
2000 
2001 GNEConnection*
2002 GNEViewNet::getConnectionAtPopupPosition() {
2003  // get first object that can be found in their container
2004  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2005  for (const auto& glObject : glObjectLayer.second) {
2006  auto connection = myNet->getAttributeCarriers()->retrieveConnection(glObject.object, false);
2007  if (connection) {
2008  return connection;
2009  }
2010  }
2011  }
2012  return nullptr;
2013 }
2014 
2015 
2016 GNECrossing*
2017 GNEViewNet::getCrossingAtPopupPosition() {
2018  // get first object that can be found in their container
2019  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2020  for (const auto& glObject : glObjectLayer.second) {
2021  auto crossing = myNet->getAttributeCarriers()->retrieveCrossing(glObject.object, false);
2022  if (crossing) {
2023  return crossing;
2024  }
2025  }
2026  }
2027  return nullptr;
2028 }
2029 
2030 
2031 GNEWalkingArea*
2032 GNEViewNet::getWalkingAreaAtPopupPosition() {
2033  // get first object that can be found in their container
2034  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2035  for (const auto& glObject : glObjectLayer.second) {
2036  auto walkingArea = myNet->getAttributeCarriers()->retrieveWalkingArea(glObject.object, false);
2037  if (walkingArea) {
2038  return walkingArea;
2039  }
2040  }
2041  }
2042  return nullptr;
2043 }
2044 
2045 
2046 GNEEdge*
2047 GNEViewNet::getEdgeAtPopupPosition() {
2048  // get first object that can be found in their container
2049  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2050  for (const auto& glObject : glObjectLayer.second) {
2051  auto edge = myNet->getAttributeCarriers()->retrieveEdge(glObject.object->getMicrosimID(), false);
2052  if (edge) {
2053  return edge;
2054  }
2055  }
2056  }
2057  return nullptr;
2058 }
2059 
2060 
2061 GNELane*
2062 GNEViewNet::getLaneAtPopupPosition() {
2063  // get first object that can be found in their container
2064  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2065  for (const auto& glObject : glObjectLayer.second) {
2066  auto lane = myNet->getAttributeCarriers()->retrieveLane(glObject.object, false);
2067  if (lane) {
2068  return lane;
2069  }
2070  }
2071  }
2072  return nullptr;
2073 }
2074 
2075 
2076 GNEAdditional*
2077 GNEViewNet::getAdditionalAtPopupPosition() {
2078  // get first object that can be found in their container
2079  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2080  for (const auto& glObject : glObjectLayer.second) {
2081  auto additionalElement = myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false);
2082  if (additionalElement) {
2083  return additionalElement;
2084  }
2085  }
2086  }
2087  return nullptr;
2088 }
2089 
2090 
2091 GNEDemandElement*
2092 GNEViewNet::getDemandElementAtPopupPosition() {
2093  // get first object that can be found in their container
2094  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2095  for (const auto& glObject : glObjectLayer.second) {
2096  auto demandElement = myNet->getAttributeCarriers()->retrieveDemandElement(glObject.object, false);
2097  if (demandElement) {
2098  return demandElement;
2099  }
2100  }
2101  }
2102  return nullptr;
2103 }
2104 
2105 
2106 GNEPoly*
2107 GNEViewNet::getPolygonAtPopupPosition() {
2108  // get first object that can be parsed to poly element
2109  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2110  for (const auto& glObject : glObjectLayer.second) {
2111  auto polygon = dynamic_cast<GNEPoly*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2112  if (polygon) {
2113  return polygon;
2114  }
2115  }
2116  }
2117  return nullptr;
2118 }
2119 
2120 
2121 GNEPOI*
2122 GNEViewNet::getPOIAtPopupPosition() {
2123  // get first object that can be parsed to POI element
2124  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2125  for (const auto& glObject : glObjectLayer.second) {
2126  auto POI = dynamic_cast<GNEPOI*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2127  if (POI) {
2128  return POI;
2129  }
2130  }
2131  }
2132  return nullptr;
2133 }
2134 
2135 
2136 GNETAZ*
2137 GNEViewNet::getTAZAtPopupPosition() {
2138  // get first object that can be parsed to TAZ element
2139  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2140  for (const auto& glObject : glObjectLayer.second) {
2141  auto TAZ = dynamic_cast<GNETAZ*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2142  if (TAZ) {
2143  return TAZ;
2144  }
2145  }
2146  }
2147  return nullptr;
2148 }
2149 
2150 
2151 GNENetworkElement*
2152 GNEViewNet::getShapeEditedAtPopupPosition() {
2153  // get first object that can be parsed to TAZ element
2154  for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2155  for (const auto& glObject : glObjectLayer.second) {
2156  if (glObject.object->getType() == GLO_JUNCTION) {
2157  auto junction = myNet->getAttributeCarriers()->retrieveJunction(glObject.object->getMicrosimID());
2158  if (junction->isShapeEdited()) {
2159  return junction;
2160  }
2161  } else if (glObject.object->getType() == GLO_CROSSING) {
2162  auto crossing = myNet->getAttributeCarriers()->retrieveCrossing(glObject.object);
2163  if (crossing->isShapeEdited()) {
2164  return crossing;
2165  }
2166  } else if (glObject.object->getType() == GLO_CONNECTION) {
2167  auto connection = myNet->getAttributeCarriers()->retrieveConnection(glObject.object);
2168  if (connection->isShapeEdited()) {
2169  return connection;
2170  }
2171  }
2172  }
2173  }
2174  return nullptr;
2175 }
2176 
2177 
2178 long
2179 GNEViewNet::onCmdSetSupermode(FXObject*, FXSelector sel, void*) {
2180  // check what network mode will be set
2181  switch (FXSELID(sel)) {
2182  case MID_HOTKEY_F2_SUPERMODE_NETWORK:
2183  if (myEditModes.networkButton->shown()) {
2184  myEditModes.setSupermode(Supermode::NETWORK, false);
2185  }
2186  break;
2187  case MID_HOTKEY_F3_SUPERMODE_DEMAND:
2188  if (myEditModes.demandButton->shown()) {
2189  myEditModes.setSupermode(Supermode::DEMAND, false);
2190  }
2191  break;
2192  case MID_HOTKEY_F4_SUPERMODE_DATA:
2193  if (myEditModes.dataButton->shown()) {
2194  myEditModes.setSupermode(Supermode::DATA, false);
2195  }
2196  break;
2197  default:
2198  break;
2199  }
2200  return 1;
2201 }
2202 
2203 
2204 long
2205 GNEViewNet::onCmdSetMode(FXObject*, FXSelector sel, void*) {
2206  // first filter modes depending of view
2207  if (myEditModes.isJuPedSimView()) {
2208  // network
2209  if (myEditModes.isCurrentSupermodeNetwork()) {
2210  switch (FXSELID(sel)) {
2211  // common
2212  case MID_HOTKEY_I_MODE_INSPECT:
2213  case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2214  case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2215  // infrastructure
2216  case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2217  case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2218  case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2219  case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2220  // shapes
2221  case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2222  case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2223  break;
2224  default:
2225  return 0;
2226  }
2227  }
2228  // demand
2229  if (myEditModes.isCurrentSupermodeDemand()) {
2230  switch (FXSELID(sel)) {
2231  // common
2232  case MID_HOTKEY_I_MODE_INSPECT:
2233  case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2234  case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2235  // persons
2236  case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2237  case MID_HOTKEY_L_MODE_PERSONPLAN:
2238  // routes
2239  case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2240  case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2241  // types
2242  case MID_HOTKEY_T_MODE_TLS_TYPE:
2243  case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2244  break;
2245  default:
2246  return 0;
2247  }
2248  }
2249  // data
2250  if (myEditModes.isCurrentSupermodeData()) {
2251  // all modes disabled
2252  return 0;
2253  }
2254  }
2255  // continue depending of supermode
2256  if (myEditModes.isCurrentSupermodeNetwork()) {
2257  // check what network mode will be set
2258  switch (FXSELID(sel)) {
2259  case MID_HOTKEY_I_MODE_INSPECT:
2260  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_INSPECT);
2261  break;
2262  case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2263  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_DELETE);
2264  break;
2265  case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2266  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_SELECT);
2267  break;
2268  case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2269  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_MOVE);
2270  break;
2271  case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2272  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CREATE_EDGE);
2273  break;
2274  case MID_HOTKEY_C_MODE_CONNECT_CONTAINER:
2275  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CONNECT);
2276  break;
2277  case MID_HOTKEY_T_MODE_TLS_TYPE:
2278  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS);
2279  break;
2280  case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2281  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_ADDITIONAL);
2282  break;
2283  case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2284  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CROSSING);
2285  break;
2286  case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2287  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TAZ);
2288  break;
2289  case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2290  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_SHAPE);
2291  break;
2292  case MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN:
2293  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_PROHIBITION);
2294  break;
2295  case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2296  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_WIRE);
2297  break;
2298  case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2299  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_DECAL);
2300  break;
2301  default:
2302  break;
2303  }
2304  } else if (myEditModes.isCurrentSupermodeDemand()) {
2305  // check what demand mode will be set
2306  switch (FXSELID(sel)) {
2307  case MID_HOTKEY_L_MODE_PERSONPLAN:
2308  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_PERSONPLAN);
2309  break;
2310  case MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN:
2311  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_CONTAINERPLAN);
2312  break;
2313  case MID_HOTKEY_I_MODE_INSPECT:
2314  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_INSPECT);
2315  break;
2316  case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2317  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_DELETE);
2318  break;
2319  case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2320  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_SELECT);
2321  break;
2322  case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2323  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_MOVE);
2324  break;
2325  case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2326  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_ROUTE);
2327  break;
2328  case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2329  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_ROUTEDISTRIBUTION);
2330  break;
2331  case MID_HOTKEY_V_MODE_VEHICLE:
2332  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_VEHICLE);
2333  break;
2334  case MID_HOTKEY_T_MODE_TLS_TYPE:
2335  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_TYPE);
2336  break;
2337  case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2338  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_TYPEDISTRIBUTION);
2339  break;
2340  case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2341  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_STOP);
2342  break;
2343  case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2344  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_PERSON);
2345  break;
2346  case MID_HOTKEY_C_MODE_CONNECT_CONTAINER:
2347  myEditModes.setDemandEditMode(DemandEditMode::DEMAND_CONTAINER);
2348  break;
2349  default:
2350  break;
2351  }
2352  } else if (myEditModes.isCurrentSupermodeData()) {
2353  // check what demand mode will be set
2354  switch (FXSELID(sel)) {
2355  case MID_HOTKEY_I_MODE_INSPECT:
2356  myEditModes.setDataEditMode(DataEditMode::DATA_INSPECT);
2357  break;
2358  case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2359  myEditModes.setDataEditMode(DataEditMode::DATA_DELETE);
2360  break;
2361  case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2362  myEditModes.setDataEditMode(DataEditMode::DATA_SELECT);
2363  break;
2364  case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2365  myEditModes.setDataEditMode(DataEditMode::DATA_EDGEDATA);
2366  break;
2367  case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2368  myEditModes.setDataEditMode(DataEditMode::DATA_EDGERELDATA);
2369  break;
2370  case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2371  myEditModes.setDataEditMode(DataEditMode::DATA_TAZRELDATA);
2372  break;
2373  case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2374  myEditModes.setDataEditMode(DataEditMode::DATA_MEANDATA);
2375  break;
2376  default:
2377  break;
2378  }
2379  }
2380  return 1;
2381 }
2382 
2383 
2384 long
2385 GNEViewNet::onCmdSplitEdge(FXObject*, FXSelector, void*) {
2386  GNEEdge* edge = getEdgeAtPopupPosition();
2387  if (edge != nullptr) {
2388  myNet->splitEdge(edge, edge->getSplitPos(getPopupPosition()), myUndoList);
2389  }
2390  return 1;
2391 }
2392 
2393 
2394 long
2395 GNEViewNet::onCmdSplitEdgeBidi(FXObject*, FXSelector, void*) {
2396  GNEEdge* edge = getEdgeAtPopupPosition();
2397  if (edge != nullptr) {
2398  // obtain reverse edge
2399  const auto oppositeEdges = edge->getOppositeEdges();
2400  // check that reverse edge works
2401  if (oppositeEdges.size() > 0) {
2402  for (const auto& oppositeEdge : oppositeEdges) {
2403  // get reverse inner geometry
2404  const auto reverseGeometry = oppositeEdge->getNBEdge()->getInnerGeometry().reverse();
2405  if (reverseGeometry == edge->getNBEdge()->getInnerGeometry()) {
2406  myNet->splitEdgesBidi(edge, oppositeEdge, edge->getSplitPos(getPopupPosition()), myUndoList);
2407  return 1;
2408  }
2409  }
2410  }
2411  }
2412  return 1;
2413 }
2414 
2415 
2416 long
2417 GNEViewNet::onCmdReverseEdge(FXObject*, FXSelector, void*) {
2418  GNEEdge* edge = getEdgeAtPopupPosition();
2419  if (edge != nullptr) {
2420  if (edge->isAttributeCarrierSelected()) {
2421  myUndoList->begin(edge, TL("Reverse selected edges"));
2422  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2423  for (const auto& selectedEdge : selectedEdges) {
2424  myNet->reverseEdge(selectedEdge, myUndoList);
2425  }
2426  myUndoList->end();
2427  } else {
2428  myUndoList->begin(edge, TL("Reverse edge"));
2429  myNet->reverseEdge(edge, myUndoList);
2430  myUndoList->end();
2431  }
2432  }
2433  return 1;
2434 }
2435 
2436 
2437 long
2438 GNEViewNet::onCmdAddReversedEdge(FXObject*, FXSelector, void*) {
2439  GNEEdge* edge = getEdgeAtPopupPosition();
2440  if (edge != nullptr) {
2441  if (edge->isAttributeCarrierSelected()) {
2442  myUndoList->begin(edge, TL("Add Reverse edge for selected edges"));
2443  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2444  for (const auto& selectedEdge : selectedEdges) {
2445  myNet->addReversedEdge(selectedEdge, false, myUndoList);
2446  }
2447  myUndoList->end();
2448  } else {
2449  myUndoList->begin(edge, TL("Add reverse edge"));
2450  myNet->addReversedEdge(edge, false, myUndoList);
2451  myUndoList->end();
2452  }
2453  }
2454  return 1;
2455 }
2456 
2457 
2458 long
2459 GNEViewNet::onCmdAddReversedEdgeDisconnected(FXObject*, FXSelector, void*) {
2460  GNEEdge* edge = getEdgeAtPopupPosition();
2461  if (edge != nullptr) {
2462  if (edge->isAttributeCarrierSelected()) {
2463  myUndoList->begin(edge, TL("Add Reverse disconnected edge for selected edges"));
2464  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2465  for (const auto& selectedEdge : selectedEdges) {
2466  myNet->addReversedEdge(selectedEdge, true, myUndoList);
2467  }
2468  myUndoList->end();
2469  } else {
2470  myUndoList->begin(edge, TL("Add reverse disconnected edge"));
2471  myNet->addReversedEdge(edge, true, myUndoList);
2472  myUndoList->end();
2473  }
2474  }
2475  return 1;
2476 }
2477 
2478 
2479 long
2480 GNEViewNet::onCmdEditEdgeEndpoint(FXObject*, FXSelector, void*) {
2481  GNEEdge* edge = getEdgeAtPopupPosition();
2482  if (edge != nullptr) {
2483  // snap to active grid the Popup position
2484  edge->editEndpoint(getPopupPosition(), myUndoList);
2485  }
2486  return 1;
2487 }
2488 
2489 
2490 long
2491 GNEViewNet::onCmdResetEdgeEndpoint(FXObject*, FXSelector, void*) {
2492  GNEEdge* edge = getEdgeAtPopupPosition();
2493  if (edge != nullptr) {
2494  // check if edge is selected
2495  if (edge->isAttributeCarrierSelected()) {
2496  // get all selected edges
2497  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2498  // begin operation
2499  myUndoList->begin(edge, TL("reset geometry points"));
2500  // iterate over selected edges
2501  for (const auto& selectedEdge : selectedEdges) {
2502  // reset both end points
2503  selectedEdge->resetBothEndpoint(myUndoList);
2504  }
2505  // end operation
2506  myUndoList->end();
2507  } else {
2508  edge->resetEndpoint(getPopupPosition(), myUndoList);
2509  }
2510  }
2511  return 1;
2512 }
2513 
2514 
2515 long
2516 GNEViewNet::onCmdStraightenEdges(FXObject*, FXSelector, void*) {
2517  GNEEdge* edge = getEdgeAtPopupPosition();
2518  if (edge != nullptr) {
2519  if (edge->isAttributeCarrierSelected()) {
2520  myUndoList->begin(edge, TL("straighten selected edges"));
2521  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2522  for (const auto& selectedEdge : selectedEdges) {
2523  selectedEdge->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
2524  }
2525  myUndoList->end();
2526  } else {
2527 
2528  myUndoList->begin(edge, TL("straighten edge"));
2529  edge->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
2530  myUndoList->end();
2531  }
2532  }
2533  return 1;
2534 }
2535 
2536 
2537 long
2538 GNEViewNet::onCmdSmoothEdges(FXObject*, FXSelector, void*) {
2539  GNEEdge* edge = getEdgeAtPopupPosition();
2540  if (edge != nullptr) {
2541  if (edge->isAttributeCarrierSelected()) {
2542  myUndoList->begin(edge, TL("smooth selected edges"));
2543  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2544  for (const auto& selectedEdge : selectedEdges) {
2545  selectedEdge->smooth(myUndoList);
2546  }
2547  myUndoList->end();
2548  } else {
2549  myUndoList->begin(edge, TL("smooth edge"));
2550  edge->smooth(myUndoList);
2551  myUndoList->end();
2552  }
2553  }
2554  return 1;
2555 }
2556 
2557 
2558 long
2559 GNEViewNet::onCmdStraightenEdgesElevation(FXObject*, FXSelector, void*) {
2560  GNEEdge* edge = getEdgeAtPopupPosition();
2561  if (edge != nullptr) {
2562  if (edge->isAttributeCarrierSelected()) {
2563  myUndoList->begin(edge, TL("straighten elevation of selected edges"));
2564  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2565  for (const auto& selectedEdge : selectedEdges) {
2566  selectedEdge->straightenElevation(myUndoList);
2567  }
2568  myUndoList->end();
2569  } else {
2570  myUndoList->begin(edge, TL("straighten edge elevation"));
2571  edge->straightenElevation(myUndoList);
2572  myUndoList->end();
2573  }
2574  }
2575  return 1;
2576 }
2577 
2578 
2579 long
2580 GNEViewNet::onCmdSmoothEdgesElevation(FXObject*, FXSelector, void*) {
2581  GNEEdge* edge = getEdgeAtPopupPosition();
2582  if (edge != nullptr) {
2583  if (edge->isAttributeCarrierSelected()) {
2584  myUndoList->begin(edge, TL("smooth elevation of selected edges"));
2585  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2586  for (const auto& selectedEdge : selectedEdges) {
2587  selectedEdge->smoothElevation(myUndoList);
2588  }
2589  myUndoList->end();
2590  } else {
2591  myUndoList->begin(edge, TL("smooth edge elevation"));
2592  edge->smoothElevation(myUndoList);
2593  myUndoList->end();
2594  }
2595  }
2596  return 1;
2597 }
2598 
2599 
2600 long
2601 GNEViewNet::onCmdResetLength(FXObject*, FXSelector, void*) {
2602  GNEEdge* edge = getEdgeAtPopupPosition();
2603  if (edge != nullptr) {
2604  if (edge->isAttributeCarrierSelected()) {
2605  myUndoList->begin(edge, TL("reset edge lengths"));
2606  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2607  for (const auto& selectedEdge : selectedEdges) {
2608  selectedEdge->setAttribute(SUMO_ATTR_LENGTH, "-1", myUndoList);
2609  }
2610  myUndoList->end();
2611  } else {
2612  edge->setAttribute(SUMO_ATTR_LENGTH, "-1", myUndoList);
2613  }
2614  }
2615  return 1;
2616 }
2617 
2618 
2619 long
2620 GNEViewNet::onCmdEdgeUseAsTemplate(FXObject*, FXSelector, void*) {
2621  GNEEdge* edge = getEdgeAtPopupPosition();
2622  if (edge != nullptr) {
2623  myViewParent->getInspectorFrame()->getTemplateEditor()->setEdgeTemplate(edge);
2624  }
2625  return 1;
2626 }
2627 
2628 
2629 long
2630 GNEViewNet::onCmdEgeApplyTemplate(FXObject*, FXSelector, void*) {
2631  GNEEdge* edgeAtPosition = getEdgeAtPopupPosition();
2632  if ((edgeAtPosition != nullptr) && myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate()) {
2633  // begin copy template
2634  myUndoList->begin(edgeAtPosition, TL("copy edge template"));
2635  if (edgeAtPosition->isAttributeCarrierSelected()) {
2636  // copy template in all selected edges
2637  for (const auto& edge : myNet->getAttributeCarriers()->getEdges()) {
2638  if (edge.second->isAttributeCarrierSelected()) {
2639  edge.second->copyTemplate(myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate(), myUndoList);
2640  }
2641  }
2642  } else {
2643  // copy template
2644  edgeAtPosition->copyTemplate(myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate(), myUndoList);
2645  }
2646  // end copy template
2647  myUndoList->end();
2648  // update view (to see visual changes)
2649  updateViewNet();
2650  }
2651  return 1;
2652 }
2653 
2654 
2655 long
2656 GNEViewNet::onCmdSimplifyShape(FXObject*, FXSelector, void*) {
2657  // get polygon under mouse
2658  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2659  // check polygon
2660  if (polygonUnderMouse) {
2661  // check if shape is selected
2662  if (polygonUnderMouse->isAttributeCarrierSelected()) {
2663  // begin undo-list
2664  myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("simplify shapes"));
2665  // get shapes
2666  const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2667  // iterate over shapes
2668  for (const auto& selectedShape : selectedShapes) {
2669  // check if shape is a poly
2670  if ((selectedShape->getTagProperty().getTag() == SUMO_TAG_POLY) ||
2671  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2672  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_OBSTACLE)) {
2673  // simplify shape
2674  dynamic_cast<GNEPoly*>(selectedShape)->simplifyShape();
2675  }
2676  }
2677  // end undo-list
2678  myNet->getViewNet()->getUndoList()->end();
2679  } else {
2680  polygonUnderMouse->simplifyShape();
2681  }
2682  }
2683  updateViewNet();
2684  return 1;
2685 }
2686 
2687 
2688 long
2689 GNEViewNet::onCmdDeleteGeometryPoint(FXObject*, FXSelector, void*) {
2690  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2691  if (polygonUnderMouse) {
2692  polygonUnderMouse->deleteGeometryPoint(getPopupPosition());
2693  }
2694  updateViewNet();
2695  return 1;
2696 }
2697 
2698 
2699 long
2700 GNEViewNet::onCmdClosePolygon(FXObject*, FXSelector, void*) {
2701  // get polygon under mouse
2702  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2703  // check polygon
2704  if (polygonUnderMouse) {
2705  // check if shape is selected
2706  if (polygonUnderMouse->isAttributeCarrierSelected()) {
2707  // begin undo-list
2708  myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("close polygon shapes"));
2709  // get selectedshapes
2710  const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2711  // iterate over shapes
2712  for (const auto& selectedShape : selectedShapes) {
2713  // check if shape is a poly
2714  if ((selectedShape->getTagProperty().getTag() == SUMO_TAG_POLY) ||
2715  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2716  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_OBSTACLE)) {
2717  // close polygon
2718  dynamic_cast<GNEPoly*>(selectedShape)->closePolygon();
2719  }
2720  }
2721  // end undo-list
2722  myNet->getViewNet()->getUndoList()->end();
2723  } else {
2724  polygonUnderMouse->closePolygon();
2725  }
2726  }
2727  updateViewNet();
2728  return 1;
2729 }
2730 
2731 
2732 long
2733 GNEViewNet::onCmdOpenPolygon(FXObject*, FXSelector, void*) {
2734  // get polygon under mouse
2735  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2736  // check polygon
2737  if (polygonUnderMouse) {
2738  // check if shape is selected
2739  if (polygonUnderMouse->isAttributeCarrierSelected()) {
2740  // begin undo-list
2741  myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("open polygon shapes"));
2742  // get shapes
2743  const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2744  // iterate over shapes
2745  for (const auto& selectedShape : selectedShapes) {
2746  // check if shape is a poly
2747  if ((selectedShape->getTagProperty().getTag() == SUMO_TAG_POLY) ||
2748  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2749  (selectedShape->getTagProperty().getTag() == GNE_TAG_JPS_OBSTACLE)) {
2750  // open polygon
2751  dynamic_cast<GNEPoly*>(selectedShape)->openPolygon();
2752  }
2753  }
2754  // end undo-list
2755  myNet->getViewNet()->getUndoList()->end();
2756  } else {
2757  polygonUnderMouse->openPolygon();
2758  }
2759  }
2760  updateViewNet();
2761  return 1;
2762 }
2763 
2764 
2765 long
2766 GNEViewNet::onCmdSelectPolygonElements(FXObject*, FXSelector, void*) {
2767  // get polygon under mouse
2768  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2769  // check polygon
2770  if (polygonUnderMouse) {
2771  // get ACs in boundary
2772  updateObjectsInBoundary(polygonUnderMouse->getShape().getBoxBoundary());
2773  // declare filtered ACs
2774  std::vector<GNEAttributeCarrier*> filteredACs;
2775  // iterate over obtained GUIGlIDs
2776  for (const auto& AC : myViewObjectsSelector.getAttributeCarriers()) {
2777  if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
2778  if (checkSelectEdges() && myNet->getAttributeCarriers()->isNetworkElementAroundShape(AC, polygonUnderMouse->getShape())) {
2779  filteredACs.push_back(AC);
2780  }
2781  } else if (AC->getTagProperty().getTag() == SUMO_TAG_LANE) {
2782  if (!checkSelectEdges() && myNet->getAttributeCarriers()->isNetworkElementAroundShape(AC, polygonUnderMouse->getShape())) {
2783  filteredACs.push_back(AC);
2784  }
2785  } else if ((AC != polygonUnderMouse) && myNet->getAttributeCarriers()->isNetworkElementAroundShape(AC, polygonUnderMouse->getShape())) {
2786  filteredACs.push_back(AC);
2787  }
2788  }
2789  // continue if there are ACs
2790  if (filteredACs.size() > 0) {
2791  // begin undo-list
2792  myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODESELECT, TL("select within polygon boundary"));
2793  // iterate over shapes
2794  for (const auto& AC : filteredACs) {
2795  AC->setAttribute(GNE_ATTR_SELECTED, "true", myUndoList);
2796  }
2797  // end undo-list
2798  myNet->getViewNet()->getUndoList()->end();
2799  }
2800  }
2801  updateViewNet();
2802  return 1;
2803 }
2804 
2805 
2806 long
2807 GNEViewNet::onCmdSetFirstGeometryPoint(FXObject*, FXSelector, void*) {
2808  GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2809  if (polygonUnderMouse) {
2810  polygonUnderMouse->changeFirstGeometryPoint(polygonUnderMouse->getVertexIndex(getPopupPosition(), false));
2811  updateViewNet();
2812  }
2813 
2814  return 1;
2815 }
2816 
2817 
2818 long
2819 GNEViewNet::onCmdSimplifyShapeEdited(FXObject*, FXSelector, void*) {
2820  auto undoList = myNet->getViewNet()->getUndoList();
2821  // get shape edited under mouse
2822  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2823  if (shapeEdited) {
2824  // simplify edited shape using undo-redo
2825  undoList->begin(shapeEdited, TL("simplify edited shape"));
2826  shapeEdited->simplifyShapeEdited(undoList);
2827  undoList->end();
2828  }
2829  return 1;
2830 }
2831 
2832 
2833 long
2834 GNEViewNet::onCmdStraightenShapeEdited(FXObject*, FXSelector, void*) {
2835  auto undoList = myNet->getViewNet()->getUndoList();
2836  // get shape edited under mouse
2837  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2838  if (shapeEdited) {
2839  // simplify edited shape using undo-redo
2840  undoList->begin(shapeEdited, TL("straigthen edited shape"));
2841  shapeEdited->straigthenShapeEdited(undoList);
2842  undoList->end();
2843  }
2844  return 1;
2845 }
2846 
2847 
2848 long
2849 GNEViewNet::onCmdCloseShapeEdited(FXObject*, FXSelector, void*) {
2850  auto undoList = myNet->getViewNet()->getUndoList();
2851  // get shape edited under mouse
2852  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2853  if (shapeEdited) {
2854  // close edited shape using undo-redo
2855  undoList->begin(shapeEdited, TL("simplify edited shape"));
2856  shapeEdited->closeShapeEdited(undoList);
2857  undoList->end();
2858  }
2859  return 1;
2860 }
2861 
2862 
2863 long
2864 GNEViewNet::onCmdOpenShapeEdited(FXObject*, FXSelector, void*) {
2865  auto undoList = myNet->getViewNet()->getUndoList();
2866  // get shape edited under mouse
2867  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2868  if (shapeEdited) {
2869  // open edited shape using undo-redo
2870  undoList->begin(shapeEdited, TL("simplify edited shape"));
2871  shapeEdited->openShapeEdited(undoList);
2872  undoList->end();
2873  }
2874  return 1;
2875 }
2876 
2877 
2878 long
2879 GNEViewNet::onCmdSetFirstGeometryPointShapeEdited(FXObject*, FXSelector, void*) {
2880  auto undoList = myNet->getViewNet()->getUndoList();
2881  // get shape edited under mouse
2882  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2883  if (shapeEdited) {
2884  // get geometry point index under cursor
2885  const auto geometryPointIndex = shapeEdited->getGeometryPointUnderCursorShapeEdited();
2886  // set first geometry point in edited shape using undo-redo
2887  undoList->begin(shapeEdited, TL("simplify edited shape"));
2888  shapeEdited->setFirstGeometryPointShapeEdited(geometryPointIndex, undoList);
2889  undoList->end();
2890  }
2891  return 1;
2892 }
2893 
2894 
2895 long
2896 GNEViewNet::onCmdDeleteGeometryPointShapeEdited(FXObject*, FXSelector, void*) {
2897  auto undoList = myNet->getViewNet()->getUndoList();
2898  // get shape edited under mouse
2899  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2900  if (shapeEdited) {
2901  // get geometry point index under cursor
2902  const auto geometryPointIndex = shapeEdited->getGeometryPointUnderCursorShapeEdited();
2903  // delete geometry point edited shape using undo-redo
2904  undoList->begin(shapeEdited, TL("simplify edited shape"));
2905  shapeEdited->deleteGeometryPointShapeEdited(geometryPointIndex, undoList);
2906  undoList->end();
2907  }
2908  return 1;
2909 }
2910 
2911 
2912 long
2913 GNEViewNet::onCmdResetShapeEdited(FXObject*, FXSelector, void*) {
2914  auto undoList = myNet->getViewNet()->getUndoList();
2915  // get shape edited under mouse
2916  GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2917  if (shapeEdited) {
2918  // simplify edited shape using undo-redo
2919  undoList->begin(shapeEdited, TL("simplify edited shape"));
2920  shapeEdited->resetShapeEdited(undoList);
2921  undoList->end();
2922  }
2923  return 1;
2924 }
2925 
2926 
2927 long
2928 GNEViewNet::onCmdFinishShapeEdited(FXObject*, FXSelector, void*) {
2929  // the same behavior as when we press enter
2930  hotkeyEnter();
2931  return 1;
2932 }
2933 
2934 
2935 long
2936 GNEViewNet::onCmdTransformPOI(FXObject*, FXSelector, void*) {
2937  // declare additional handler
2938  GNEAdditionalHandler additionalHanlder(myNet, true, false);
2939  // obtain POI at popup position
2940  GNEPOI* POI = getPOIAtPopupPosition();
2941  if (POI) {
2942  // check what type of POI will be transformed
2943  if (POI->getTagProperty().getTag() == SUMO_TAG_POI) {
2944  // obtain lanes around POI boundary
2945  std::vector<GUIGlID> GLIDs = getObjectsInBoundary(POI->getCenteringBoundary());
2946  std::vector<GNELane*> lanes;
2947  for (const auto& GLID : GLIDs) {
2948  GNELane* lane = dynamic_cast<GNELane*>(GUIGlObjectStorage::gIDStorage.getObjectBlocking(GLID));
2949  if (lane) {
2950  lanes.push_back(lane);
2951  }
2952  }
2953  if (lanes.empty()) {
2954  WRITE_WARNINGF(TL("No lanes around % to attach it"), toString(SUMO_TAG_POI));
2955  } else {
2956  // obtain nearest lane to POI
2957  GNELane* nearestLane = lanes.front();
2958  double minorPosOverLane = nearestLane->getLaneShape().nearest_offset_to_point2D(POI->getPositionInView());
2959  double minorLateralOffset = nearestLane->getLaneShape().positionAtOffset(minorPosOverLane).distanceTo(POI->getPositionInView());
2960  for (const auto& lane : lanes) {
2961  double posOverLane = lane->getLaneShape().nearest_offset_to_point2D(POI->getPositionInView());
2962  double lateralOffset = lane->getLaneShape().positionAtOffset(posOverLane).distanceTo(POI->getPositionInView());
2963  if (lateralOffset < minorLateralOffset) {
2964  minorPosOverLane = posOverLane;
2965  minorLateralOffset = lateralOffset;
2966  nearestLane = lane;
2967  }
2968  }
2969  // get sumo base object of POI (And all common attributes)
2970  CommonXMLStructure::SumoBaseObject* POIBaseObject = POI->getSumoBaseObject();
2971  // add specific attributes
2972  POIBaseObject->addStringAttribute(SUMO_ATTR_LANE, nearestLane->getID());
2973  POIBaseObject->addDoubleAttribute(SUMO_ATTR_POSITION, minorPosOverLane);
2974  POIBaseObject->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, POI->getFriendlyPos());
2975  POIBaseObject->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, 0);
2976  // remove POI
2977  myUndoList->begin(POI, TL("attach POI into lane"));
2978  myNet->deleteAdditional(POI, myUndoList);
2979  // add new POI use route handler
2980  additionalHanlder.parseSumoBaseObject(POIBaseObject);
2981  myUndoList->end();
2982  }
2983  } else {
2984  // get sumo base object of POI (And all common attributes)
2985  CommonXMLStructure::SumoBaseObject* POIBaseObject = POI->getSumoBaseObject();
2986  // add specific attributes
2987  POIBaseObject->addDoubleAttribute(SUMO_ATTR_X, POI->x());
2988  POIBaseObject->addDoubleAttribute(SUMO_ATTR_Y, POI->y());
2989  // remove POI
2990  myUndoList->begin(POI, TL("release POI from lane"));
2991  myNet->deleteAdditional(POI, myUndoList);
2992  // add new POI use route handler
2993  additionalHanlder.parseSumoBaseObject(POIBaseObject);
2994  myUndoList->end();
2995  }
2996  // update view after transform
2997  updateViewNet();
2998  }
2999  return 1;
3000 }
3001 
3002 
3003 long
3004 GNEViewNet::onCmdReverse(FXObject*, FXSelector, void*) {
3005  // obtain demand element at popup position
3006  GNEDemandElement* demandElement = getDemandElementAtPopupPosition();
3007  if (demandElement) {
3008  // begin undo list
3009  myUndoList->begin(demandElement, TLF("reverse % '%'", demandElement->getTagStr(), demandElement->getID()));
3010  GNERouteHandler::reverse(demandElement);
3011  myUndoList->end();
3012  }
3013  return 1;
3014 }
3015 
3016 
3017 long
3018 GNEViewNet::onCmdAddReverse(FXObject*, FXSelector, void*) {
3019  // obtain demand element at popup position
3020  GNEDemandElement* demandElement = getDemandElementAtPopupPosition();
3021  if (demandElement) {
3022  // begin undo list
3023  myUndoList->begin(demandElement, TLF("add reverse '%'", demandElement->getTagStr()));
3024  GNERouteHandler::addReverse(demandElement);
3025  myUndoList->end();
3026  }
3027  return 1;
3028 }
3029 
3030 
3031 long
3032 GNEViewNet::onCmdSetCustomGeometryPoint(FXObject*, FXSelector, void*) {
3033  // get element at popup position
3034  GNELane* lane = getLaneAtPopupPosition();
3035  GNEPoly* poly = getPolygonAtPopupPosition();
3036  GNETAZ* TAZ = getTAZAtPopupPosition();
3037  // check element
3038  if (lane != nullptr) {
3039  // make a copy of edge geometry
3040  PositionVector edgeGeometry = lane->getParentEdge()->getNBEdge()->getGeometry();
3041  // get index position
3042  const int index = edgeGeometry.indexOfClosest(getPositionInformation(), true);
3043  // get new position
3044  Position newPosition = edgeGeometry[index];
3045  // edit using modal GNEGeometryPointDialog
3046  GNEGeometryPointDialog(this, &newPosition); // NOSONAR, constructor returns after dialog has been closed
3047  // now check position
3048  if (newPosition != edgeGeometry[index]) {
3049  // update new position
3050  edgeGeometry[index] = newPosition;
3051  // begin undo list
3052  myUndoList->begin(lane->getParentEdge(), TL("change edge Geometry Point position"));
3053  // continue depending of index
3054  if (index == 0) {
3055  // change shape start
3056  GNEChange_Attribute::changeAttribute(lane->getParentEdge(), GNE_ATTR_SHAPE_START, toString(edgeGeometry.front()), myUndoList);
3057  } else if (index == ((int)edgeGeometry.size() - 1)) {
3058  // change shape end
3059  GNEChange_Attribute::changeAttribute(lane->getParentEdge(), GNE_ATTR_SHAPE_END, toString(edgeGeometry.back()), myUndoList);
3060  } else {
3061  // remove front and back geometry points
3062  edgeGeometry.pop_front();
3063  edgeGeometry.pop_back();
3064  // change shape
3065  GNEChange_Attribute::changeAttribute(lane->getParentEdge(), SUMO_ATTR_SHAPE, toString(edgeGeometry), myUndoList);
3066  }
3067  // end undo list
3068  myUndoList->end();
3069  }
3070  } else if (poly != nullptr) {
3071  // make a copy of polygon geometry
3072  PositionVector polygonGeometry = poly->getShape();
3073  // get index position
3074  const int index = polygonGeometry.indexOfClosest(getPositionInformation(), true);
3075  // get new position
3076  Position newPosition = polygonGeometry[index];
3077  // edit using modal GNEGeometryPointDialog
3078  GNEGeometryPointDialog(this, &newPosition); // NOSONAR, constructor returns after dialog has been closed
3079  // now check position
3080  if (newPosition != polygonGeometry[index]) {
3081  // update new position
3082  polygonGeometry[index] = newPosition;
3083  // begin undo list
3084  myUndoList->begin(poly, TL("change polygon Geometry Point position"));
3085  // change shape
3086  GNEChange_Attribute::changeAttribute(poly, SUMO_ATTR_SHAPE, toString(polygonGeometry), myUndoList);
3087  // end undo list
3088  myUndoList->end();
3089  }
3090  } else if (TAZ != nullptr) {
3091  // make a copy of TAZ geometry
3092  PositionVector TAZGeometry = TAZ->getAdditionalGeometry().getShape();
3093  // get index position
3094  const int index = TAZGeometry.indexOfClosest(getPositionInformation(), true);
3095  // get new position
3096  Position newPosition = TAZGeometry[index];
3097  // edit using modal GNEGeometryPointDialog
3098  GNEGeometryPointDialog(this, &newPosition); // NOSONAR, constructor returns after dialog has been closed
3099  // now check position
3100  if (newPosition != TAZGeometry[index]) {
3101  // update new position
3102  TAZGeometry[index] = newPosition;
3103  // begin undo list
3104  myUndoList->begin(TAZ, TL("change TAZ Geometry Point position"));
3105  // change shape
3106  GNEChange_Attribute::changeAttribute(TAZ, SUMO_ATTR_SHAPE, toString(TAZGeometry), myUndoList);
3107  // end undo list
3108  myUndoList->end();
3109  }
3110  }
3111  return 1;
3112 }
3113 
3114 
3115 long
3116 GNEViewNet::onCmdResetEndPoints(FXObject*, FXSelector, void*) {
3117  // get lane at popup position
3118  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3119  // check element
3120  if (laneAtPopupPosition != nullptr) {
3121  // get parent edge
3122  GNEEdge* edge = laneAtPopupPosition->getParentEdge();
3123  // check if edge is selected
3124  if (edge->isAttributeCarrierSelected()) {
3125  // get selected edges
3126  const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
3127  // begin undo list
3128  myUndoList->begin(edge, TL("reset end points of selected edges"));
3129  // iterate over edges
3130  for (const auto& selectedEdge : selectedEdges) {
3131  // reset both end points
3132  selectedEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3133  selectedEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3134  }
3135  // end undo list
3136  myUndoList->end();
3137  } else {
3138  // begin undo list
3139  myUndoList->begin(edge, TL("reset end points of edge '") + edge->getID());
3140  // reset both end points
3141  edge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3142  edge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3143  // end undo list
3144  myUndoList->end();
3145  }
3146  }
3147  return 1;
3148 }
3149 
3150 
3151 long
3152 GNEViewNet::onCmdDuplicateLane(FXObject*, FXSelector, void*) {
3153  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3154  if (laneAtPopupPosition != nullptr) {
3155  // when duplicating an unselected lane, keep all connections as they
3156  // are, otherwise recompute them
3157  if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3158  myUndoList->begin(laneAtPopupPosition, TL("duplicate selected lanes"));
3159  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3160  for (const auto& lane : selectedLanes) {
3161  myNet->duplicateLane(lane, myUndoList, true);
3162  }
3163  myUndoList->end();
3164  } else {
3165  myUndoList->begin(laneAtPopupPosition, TL("duplicate lane"));
3166  myNet->duplicateLane(laneAtPopupPosition, myUndoList, false);
3167  myUndoList->end();
3168  }
3169  }
3170  return 1;
3171 }
3172 
3173 
3174 long
3175 GNEViewNet::onCmdEditLaneShape(FXObject*, FXSelector, void*) {
3176  // Obtain lane under mouse
3177  GNELane* lane = getLaneAtPopupPosition();
3178  if (lane) {
3179  myEditNetworkElementShapes.startEditCustomShape(lane);
3180  }
3181  // destroy pop-up and update view Net
3182  destroyPopup();
3183  setFocus();
3184  return 1;
3185 }
3186 
3187 
3188 long
3189 GNEViewNet::onCmdResetLaneCustomShape(FXObject*, FXSelector, void*) {
3190  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3191  if (laneAtPopupPosition != nullptr) {
3192  // when duplicating an unselected lane, keep all connections as they
3193  // are, otherwise recompute them
3194  if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3195  myUndoList->begin(laneAtPopupPosition, TL("reset custom lane shapes"));
3196  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3197  for (const auto& lane : selectedLanes) {
3198  lane->setAttribute(SUMO_ATTR_CUSTOMSHAPE, "", myUndoList);
3199  }
3200  myUndoList->end();
3201  } else {
3202  myUndoList->begin(laneAtPopupPosition, TL("reset custom lane shape"));
3203  laneAtPopupPosition->setAttribute(SUMO_ATTR_CUSTOMSHAPE, "", myUndoList);
3204  myUndoList->end();
3205  }
3206  }
3207  return 1;
3208 }
3209 
3210 
3211 long
3212 GNEViewNet::onCmdResetOppositeLane(FXObject*, FXSelector, void*) {
3213  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3214  if (laneAtPopupPosition != nullptr) {
3215  // when duplicating an unselected lane, keep all connections as they
3216  // are, otherwise recompute them
3217  if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3218  myUndoList->begin(laneAtPopupPosition, TL("reset opposite lanes"));
3219  const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3220  for (const auto& lane : selectedLanes) {
3221  lane->setAttribute(GNE_ATTR_OPPOSITE, "", myUndoList);
3222  }
3223  myUndoList->end();
3224  } else {
3225  myUndoList->begin(laneAtPopupPosition, TL("reset opposite lane"));
3226  laneAtPopupPosition->setAttribute(GNE_ATTR_OPPOSITE, "", myUndoList);
3227  myUndoList->end();
3228  }
3229  }
3230  return 1;
3231 }
3232 
3233 
3234 long
3235 GNEViewNet::onCmdLaneOperation(FXObject*, FXSelector sel, void*) {
3236  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3237  if (laneAtPopupPosition) {
3238  // check lane operation
3239  switch (FXSELID(sel)) {
3240  case MID_GNE_LANE_TRANSFORM_SIDEWALK:
3241  return restrictLane(laneAtPopupPosition, SVC_PEDESTRIAN);
3242  case MID_GNE_LANE_TRANSFORM_BIKE:
3243  return restrictLane(laneAtPopupPosition, SVC_BICYCLE);
3244  case MID_GNE_LANE_TRANSFORM_BUS:
3245  return restrictLane(laneAtPopupPosition, SVC_BUS);
3246  case MID_GNE_LANE_TRANSFORM_GREENVERGE:
3247  return restrictLane(laneAtPopupPosition, SVC_IGNORING);
3248  case MID_GNE_LANE_ADD_SIDEWALK:
3249  return addRestrictedLane(laneAtPopupPosition, SVC_PEDESTRIAN, false);
3250  case MID_GNE_LANE_ADD_BIKE:
3251  return addRestrictedLane(laneAtPopupPosition, SVC_BICYCLE, false);
3252  case MID_GNE_LANE_ADD_BUS:
3253  return addRestrictedLane(laneAtPopupPosition, SVC_BUS, false);
3254  case MID_GNE_LANE_ADD_GREENVERGE_FRONT:
3255  return addRestrictedLane(laneAtPopupPosition, SVC_IGNORING, true);
3256  case MID_GNE_LANE_ADD_GREENVERGE_BACK:
3257  return addRestrictedLane(laneAtPopupPosition, SVC_IGNORING, false);
3258  case MID_GNE_LANE_REMOVE_SIDEWALK:
3259  return removeRestrictedLane(laneAtPopupPosition, SVC_PEDESTRIAN);
3260  case MID_GNE_LANE_REMOVE_BIKE:
3261  return removeRestrictedLane(laneAtPopupPosition, SVC_BICYCLE);
3262  case MID_GNE_LANE_REMOVE_BUS:
3263  return removeRestrictedLane(laneAtPopupPosition, SVC_BUS);
3264  case MID_GNE_LANE_REMOVE_GREENVERGE:
3265  return removeRestrictedLane(laneAtPopupPosition, SVC_IGNORING);
3266  default:
3267  return 0;
3268  }
3269  } else {
3270  return 0;
3271  }
3272 }
3273 
3274 
3275 long
3276 GNEViewNet::onCmdLaneReachability(FXObject* menu, FXSelector, void*) {
3277  GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3278  if (laneAtPopupPosition != nullptr) {
3279  // obtain vClass
3280  const SUMOVehicleClass vClass = SumoVehicleClassStrings.get(dynamic_cast<FXMenuCommand*>(menu)->getText().text());
3281  // calculate reachability
3282  myNet->getPathManager()->getPathCalculator()->calculateReachability(vClass, laneAtPopupPosition->getParentEdge());
3283  // select all lanes with reachability greater than 0
3284  myUndoList->begin(laneAtPopupPosition, TL("select lane reachability"));
3285  for (const auto& edge : myNet->getAttributeCarriers()->getEdges()) {
3286  for (const auto& lane : edge.second->getLanes()) {
3287  if (lane->getReachability() >= 0) {
3288  lane->setAttribute(GNE_ATTR_SELECTED, "true", myUndoList);
3289  }
3290  }
3291  }
3292  myUndoList->end();
3293  }
3294  // update viewNet
3295  updateViewNet();
3296  return 1;
3297 }
3298 
3299 
3300 long
3301 GNEViewNet::onCmdOpenAdditionalDialog(FXObject*, FXSelector, void*) {
3302  // retrieve additional under cursor
3303  GNEAdditional* addtional = getAdditionalAtPopupPosition();
3304  // check if additional can open dialog
3305  if (addtional && addtional->getTagProperty().hasDialog()) {
3306  addtional->openAdditionalDialog();
3307  }
3308  return 1;
3309 }
3310 
3311 
3312 void
3313 GNEViewNet::processClick(void* eventData) {
3314  FXEvent* evt = (FXEvent*)eventData;
3315  // process click
3316  destroyPopup();
3317  setFocus();
3318  myChanger->onLeftBtnPress(eventData);
3319  grab();
3320  // Check there are double click
3321  if (evt->click_count == 2) {
3322  handle(this, FXSEL(SEL_DOUBLECLICKED, 0), eventData);
3323  }
3324 }
3325 
3326 
3327 void
3328 GNEViewNet::updateCursor() {
3329  // first check if we're panning
3330  if (myPanning) {
3331  // move view
3332  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3333  setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3334  } else {
3335  // declare flags
3336  bool cursorMoveView = false;
3337  bool cursorInspect = false;
3338  bool cursorSelect = false;
3339  bool cursorMoveElement = false;
3340  bool cursorDelete = false;
3341  // continue depending of supermode
3342  if (myEditModes.isCurrentSupermodeNetwork()) {
3343  // move view
3344  if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) ||
3345  (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) ||
3346  (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) ||
3347  (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) ||
3348  (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ)) {
3349  cursorMoveView = true;
3350  }
3351  // specific mode
3352  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT) {
3353  cursorInspect = true;
3354  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
3355  cursorSelect = true;
3356  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
3357  cursorMoveElement = true;
3358  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_DELETE) {
3359  cursorDelete = true;
3360  }
3361  } else if (myEditModes.isCurrentSupermodeDemand()) {
3362  // move view
3363  if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) ||
3364  (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) ||
3365  (myEditModes.demandEditMode == DemandEditMode::DEMAND_STOP)) {
3366  cursorMoveView = true;
3367  }
3368  // specific mode
3369  if (myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) {
3370  cursorInspect = true;
3371  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) {
3372  cursorSelect = true;
3373  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE) {
3374  cursorMoveElement = true;
3375  } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_DELETE) {
3376  cursorDelete = true;
3377  }
3378  } else if (myEditModes.isCurrentSupermodeData()) {
3379  // move view
3380  if (myEditModes.dataEditMode == DataEditMode::DATA_SELECT) {
3381  cursorMoveView = true;
3382  }
3383  // specific mode
3384  if (myEditModes.dataEditMode == DataEditMode::DATA_INSPECT) {
3385  cursorInspect = true;
3386  } else if (myEditModes.dataEditMode == DataEditMode::DATA_SELECT) {
3387  cursorSelect = true;
3388  } else if (myEditModes.dataEditMode == DataEditMode::DATA_DELETE) {
3389  cursorDelete = true;
3390  }
3391  }
3392  // set cursor
3393  if (myMouseButtonKeyPressed.controlKeyPressed() && cursorMoveView) {
3394  // move view cursor if control key is pressed
3395  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3396  setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3397  } else if (cursorInspect) {
3398  // special case for inspect lanes
3399  if (!checkSelectEdges() && myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT)) {
3400  // inspect lane cursor
3401  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT_LANE));
3402  setDragCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT_LANE));
3403  } else {
3404  // inspect cursor
3405  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT));
3406  setDragCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT));
3407  }
3408  } else if (cursorSelect) {
3409  // special case for select lanes
3410  if (!checkSelectEdges() && myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT)) {
3411  // select lane cursor
3412  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::SELECT_LANE));
3413  setDragCursor(GUICursorSubSys::getCursor(GUICursor::SELECT_LANE));
3414  } else {
3415  // select cursor
3416  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::SELECT));
3417  setDragCursor(GUICursorSubSys::getCursor(GUICursor::SELECT));
3418  }
3419  } else if (cursorMoveElement) {
3420  // move cursor
3421  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEELEMENT));
3422  setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEELEMENT));
3423  } else if (cursorDelete) {
3424  // delete cursor
3425  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::DELETE_CURSOR));
3426  setDragCursor(GUICursorSubSys::getCursor(GUICursor::DELETE_CURSOR));
3427  } else {
3428  // default cursor
3429  setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::DEFAULT));
3430  setDragCursor(GUICursorSubSys::getCursor(GUICursor::DEFAULT));
3431  }
3432  }
3433 }
3434 
3435 
3436 int
3437 GNEViewNet::drawGLElements(const Boundary& bound) {
3438  // udpdate drawing toggle
3439  if (myDrawingToggle > 10000) {
3440  myDrawingToggle = 0;
3441  } else {
3442  myDrawingToggle++;
3443  }
3444  // set default scale
3445  myVisualizationSettings->scale = m2p(SUMO_const_laneWidth);
3446  // calculate boundary extremes
3447  const float minB[2] = { (float)bound.xmin(), (float)bound.ymin() };
3448  const float maxB[2] = { (float)bound.xmax(), (float)bound.ymax() };
3449  // reset gl line to 1
3450  glLineWidth(1);
3451  // set drawing modes
3452  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
3453  glEnable(GL_POLYGON_OFFSET_FILL);
3454  glEnable(GL_POLYGON_OFFSET_LINE);
3455  // draw all elements between minB and maxB, obtain objects included in minB and maxB
3456  return myGrid->Search(minB, maxB, *myVisualizationSettings);
3457 }
3458 
3459 
3460 void
3461 GNEViewNet::drawGrid() const {
3462  // depending of the visualizationSettings, enable or disable check box show grid
3463  if (myVisualizationSettings->showGrid) {
3464  // change show grid
3465  if (!myNetworkViewOptions.menuCheckToggleGrid->amChecked() ||
3466  !myDemandViewOptions.menuCheckToggleGrid->amChecked()) {
3467  // change to true
3468  myNetworkViewOptions.menuCheckToggleGrid->setChecked(true);
3469  myDemandViewOptions.menuCheckToggleGrid->setChecked(true);
3470  // update show grid buttons
3471  myNetworkViewOptions.menuCheckToggleGrid->update();
3472  myNetworkViewOptions.menuCheckToggleGrid->update();
3473  }
3474  // draw grid only in network and demand mode
3475  if (myEditModes.isCurrentSupermodeNetwork() || myEditModes.isCurrentSupermodeDemand()) {
3476  paintGLGrid();
3477  }
3478  } else {
3479  // change show grid
3480  if (myNetworkViewOptions.menuCheckToggleGrid->amChecked() ||
3481  myDemandViewOptions.menuCheckToggleGrid->amChecked()) {
3482  // change to false
3483  myNetworkViewOptions.menuCheckToggleGrid->setChecked(false);
3484  myDemandViewOptions.menuCheckToggleGrid->setChecked(false);
3485  // update show grid buttons
3486  myNetworkViewOptions.menuCheckToggleGrid->update();
3487  myNetworkViewOptions.menuCheckToggleGrid->update();
3488  }
3489  }
3490 }
3491 
3492 
3493 long
3494 GNEViewNet::onCmdResetEdgeEndPoints(FXObject*, FXSelector, void*) {
3495  // Obtain junction under mouse
3496  GNEJunction* junction = getJunctionAtPopupPosition();
3497  if (junction) {
3498  myUndoList->begin(GUIIcon::EDGE, TL("reset edge endpoints"));
3499  // are, otherwise recompute them
3500  if (junction->isAttributeCarrierSelected()) {
3501  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3502  for (const auto& selectedJunction : selectedJunctions) {
3503  // reset shape end from incoming edges
3504  for (const auto& incomingEdge : selectedJunction->getGNEIncomingEdges()) {
3505  incomingEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3506  }
3507  // reset shape start from outgoing edges
3508  for (const auto& outgoingEdge : selectedJunction->getGNEOutgoingEdges()) {
3509  outgoingEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3510  }
3511  }
3512  } else {
3513  // reset shape end from incoming edges
3514  for (const auto& incomingEdge : junction->getGNEIncomingEdges()) {
3515  incomingEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3516  }
3517  // reset shape start from outgoing edges
3518  for (const auto& outgoingEdge : junction->getGNEOutgoingEdges()) {
3519  outgoingEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3520  }
3521  }
3522  myUndoList->end();
3523  }
3524  // destroy pop-up and set focus in view net
3525  destroyPopup();
3526  setFocus();
3527  return 1;
3528 }
3529 
3530 
3531 long
3532 GNEViewNet::onCmdEditJunctionShape(FXObject*, FXSelector, void*) {
3533  // Obtain junction under mouse
3534  GNEJunction* junction = getJunctionAtPopupPosition();
3535  if (junction) {
3536  // check if network has to be updated
3537  if (junction->getNBNode()->getShape().size() == 0) {
3538  // recompute the whole network
3539  myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3540  }
3541  // if grid is enabled, show warning
3542  if (myVisualizationSettings->showGrid) {
3543  WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3544  }
3545  // start edit custom shape
3546  myEditNetworkElementShapes.startEditCustomShape(junction);
3547  }
3548  // destroy pop-up and set focus in view net
3549  destroyPopup();
3550  setFocus();
3551  return 1;
3552 }
3553 
3554 
3555 long
3556 GNEViewNet::onCmdResetJunctionShape(FXObject*, FXSelector, void*) {
3557  // Obtain junction under mouse
3558  GNEJunction* junction = getJunctionAtPopupPosition();
3559  if (junction) {
3560  // are, otherwise recompute them
3561  if (junction->isAttributeCarrierSelected()) {
3562  myUndoList->begin(junction, TL("reset custom junction shapes"));
3563  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3564  for (const auto& selectedJunction : selectedJunctions) {
3565  selectedJunction->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
3566  }
3567  myUndoList->end();
3568  } else {
3569  myUndoList->begin(junction, TL("reset custom junction shape"));
3570  junction->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
3571  myUndoList->end();
3572  }
3573  }
3574  // destroy pop-up and set focus in view net
3575  destroyPopup();
3576  setFocus();
3577  return 1;
3578 }
3579 
3580 
3581 long
3582 GNEViewNet::onCmdReplaceJunction(FXObject*, FXSelector, void*) {
3583  GNEJunction* junction = getJunctionAtPopupPosition();
3584  if (junction != nullptr) {
3585  myNet->replaceJunctionByGeometry(junction, myUndoList);
3586  updateViewNet();
3587  }
3588  // destroy pop-up and set focus in view net
3589  destroyPopup();
3590  setFocus();
3591  return 1;
3592 }
3593 
3594 
3595 long
3596 GNEViewNet::onCmdSplitJunction(FXObject*, FXSelector, void*) {
3597  GNEJunction* junction = getJunctionAtPopupPosition();
3598  if (junction != nullptr) {
3599  myNet->splitJunction(junction, false, myUndoList);
3600  updateViewNet();
3601  }
3602  // destroy pop-up and set focus in view net
3603  destroyPopup();
3604  setFocus();
3605  return 1;
3606 }
3607 
3608 
3609 long
3610 GNEViewNet::onCmdSplitJunctionReconnect(FXObject*, FXSelector, void*) {
3611  GNEJunction* junction = getJunctionAtPopupPosition();
3612  if (junction != nullptr) {
3613  myNet->splitJunction(junction, true, myUndoList);
3614  updateViewNet();
3615  }
3616  // destroy pop-up and set focus in view net
3617  destroyPopup();
3618  setFocus();
3619  return 1;
3620 }
3621 
3622 long
3623 GNEViewNet::onCmdSelectRoundabout(FXObject*, FXSelector, void*) {
3624  GNEJunction* junction = getJunctionAtPopupPosition();
3625  if (junction != nullptr) {
3626  myNet->selectRoundabout(junction, myUndoList);
3627  updateViewNet();
3628  }
3629  // destroy pop-up and set focus in view net
3630  destroyPopup();
3631  setFocus();
3632  return 1;
3633 }
3634 
3635 long
3636 GNEViewNet::onCmdConvertRoundabout(FXObject*, FXSelector, void*) {
3637  GNEJunction* junction = getJunctionAtPopupPosition();
3638  if (junction != nullptr) {
3639  myNet->createRoundabout(junction, myUndoList);
3640  updateViewNet();
3641  }
3642  // destroy pop-up and set focus in view net
3643  destroyPopup();
3644  setFocus();
3645  return 1;
3646 }
3647 
3648 
3649 long
3650 GNEViewNet::onEnterConvertRoundabout(FXObject*, FXSelector, void*) {
3651  myDrawPreviewRoundabout = true;
3652  update();
3653  return 1;
3654 }
3655 
3656 
3657 long
3658 GNEViewNet::onLeaveConvertRoundabout(FXObject*, FXSelector, void*) {
3659  myDrawPreviewRoundabout = false;
3660  update();
3661  return 1;
3662 }
3663 
3664 
3665 long
3666 GNEViewNet::onCmdClearConnections(FXObject*, FXSelector, void*) {
3667  GNEJunction* junction = getJunctionAtPopupPosition();
3668  if (junction != nullptr) {
3669  // make sure we do not inspect the connection will it is being deleted
3670  if ((myInspectedAttributeCarriers.size() > 0) && (myInspectedAttributeCarriers.front()->getTagProperty().getTag() == SUMO_TAG_CONNECTION)) {
3671  myViewParent->getInspectorFrame()->clearInspectedAC();
3672  }
3673  // make sure that connections isn't the front attribute
3674  if (myFrontAttributeCarrier != nullptr && (myFrontAttributeCarrier->getTagProperty().getTag() == SUMO_TAG_CONNECTION)) {
3675  myFrontAttributeCarrier = nullptr;
3676  }
3677  // check if we're handling a selection
3678  if (junction->isAttributeCarrierSelected()) {
3679  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3680  myUndoList->begin(GUIIcon::CONNECTION, TL("clear connections of selected junctions"));
3681  for (const auto& selectedJunction : selectedJunctions) {
3682  myNet->clearJunctionConnections(selectedJunction, myUndoList);
3683  }
3684  myUndoList->end();
3685  } else {
3686  myNet->clearJunctionConnections(junction, myUndoList);
3687  }
3688  updateViewNet();
3689  }
3690  // destroy pop-up and set focus in view net
3691  destroyPopup();
3692  setFocus();
3693  return 1;
3694 }
3695 
3696 
3697 long
3698 GNEViewNet::onCmdResetConnections(FXObject*, FXSelector, void*) {
3699  GNEJunction* junction = getJunctionAtPopupPosition();
3700  if (junction != nullptr) {
3701  // make sure we do not inspect the connection will it is being deleted
3702  if ((myInspectedAttributeCarriers.size() > 0) && myInspectedAttributeCarriers.front()->getTagProperty().getTag() == SUMO_TAG_CONNECTION) {
3703  myViewParent->getInspectorFrame()->clearInspectedAC();
3704  }
3705  // make sure that connections isn't the front attribute
3706  if (myFrontAttributeCarrier != nullptr && (myFrontAttributeCarrier->getTagProperty().getTag() == SUMO_TAG_CONNECTION)) {
3707  myFrontAttributeCarrier = nullptr;
3708  }
3709  // check if we're handling a selection
3710  if (junction->isAttributeCarrierSelected()) {
3711  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3712  myUndoList->begin(GUIIcon::CONNECTION, TL("reset connections of selected junctions"));
3713  for (const auto& selectedJunction : selectedJunctions) {
3714  myNet->resetJunctionConnections(selectedJunction, myUndoList);
3715  }
3716  myUndoList->end();
3717  } else {
3718  myNet->resetJunctionConnections(junction, myUndoList);
3719  }
3720  updateViewNet();
3721  }
3722  // destroy pop-up and set focus in view net
3723  destroyPopup();
3724  setFocus();
3725  return 1;
3726 }
3727 
3728 
3729 long
3730 GNEViewNet::onCmdAddTLS(FXObject*, FXSelector, void*) {
3731  GNEJunction* junction = getJunctionAtPopupPosition();
3732  if (junction != nullptr) {
3733  // check if we're adding TLS in multiple junctions
3734  if (junction->isAttributeCarrierSelected()) {
3735  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3736  myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODETLS, TL("add TLS in multiple junctions"));
3737  for (const auto& selectedJunction : selectedJunctions) {
3738  selectedJunction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3739  }
3740  myNet->getViewNet()->getUndoList()->end();
3741  } else {
3742  // change junction type
3743  junction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3744  // change to TLS Mode
3745  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS, true);
3746  // set junction in TLS mode
3747  myViewParent->getTLSEditorFrame()->editJunction(junction);
3748  }
3749  }
3750  // destroy pop-up and set focus in view net
3751  destroyPopup();
3752  setFocus();
3753  return 1;
3754 }
3755 
3756 
3757 long
3758 GNEViewNet::onCmdAddJoinTLS(FXObject*, FXSelector, void*) {
3759  GNEJunction* junction = getJunctionAtPopupPosition();
3760  if (junction != nullptr) {
3761  // check if we're adding TLS in multiple junctions
3762  if (junction->isAttributeCarrierSelected()) {
3763  myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODETLS, TL("add TLS in multiple junctions"));
3764  }
3765  // change junction type
3766  junction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3767  // if TLS was sucesfully created, apply the same TLID to other selected junctions
3768  if (junction->getAttribute(SUMO_ATTR_TLID).size() > 0) {
3769  const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3770  // iterate over all selected junctions
3771  for (const auto& selectedJunction : selectedJunctions) {
3772  // check that doesn't have a TL
3773  if (selectedJunction->getNBNode()->getControllingTLS().empty()) {
3774  selectedJunction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3775  selectedJunction->setAttribute(SUMO_ATTR_TLID, junction->getAttribute(SUMO_ATTR_TLID), myUndoList);
3776  }
3777  }
3778  }
3779  // rename traffic light
3780  if (junction->getNBNode()->getControllingTLS().size() > 0) {
3781  const auto TLSDef = (*junction->getNBNode()->getControllingTLS().begin());
3782  if (!myNet->getTLLogicCont().exist(TLSDef->getID() + "_joined")) {
3783  myUndoList->add(new GNEChange_TLS(junction, TLSDef, TLSDef->getID() + "_joined"), true);
3784  }
3785  }
3786  // end undoList
3787  if (junction->isAttributeCarrierSelected()) {
3788  myNet->getViewNet()->getUndoList()->end();
3789  }
3790  // change to TLS Mode
3791  myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS, true);
3792  // set junction in TLS mode
3793  myViewParent->getTLSEditorFrame()->editJunction(junction);
3794  }
3795  // destroy pop-up and set focus in view net
3796  destroyPopup();
3797  setFocus();
3798  return 1;
3799 }
3800 
3801 long
3802 GNEViewNet::onCmdEditConnectionShape(FXObject*, FXSelector, void*) {
3803  // Obtain connection under mouse
3804  GNEConnection* connection = getConnectionAtPopupPosition();
3805  if (connection) {
3806  myEditNetworkElementShapes.startEditCustomShape(connection);
3807  }
3808  // if grid is enabled, show warning
3809  if (myVisualizationSettings->showGrid) {
3810  WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3811  }
3812  // destroy pop-up and update view Net
3813  destroyPopup();
3814  setFocus();
3815  return 1;
3816 }
3817 
3818 
3819 long
3820 GNEViewNet::onCmdSmoothConnectionShape(FXObject*, FXSelector, void*) {
3821  // Obtain connection under mouse
3822  GNEConnection* connection = getConnectionAtPopupPosition();
3823  if (connection) {
3824  connection->smootShape();
3825  }
3826  // destroy pop-up and update view Net
3827  destroyPopup();
3828  setFocus();
3829  return 1;
3830 }
3831 
3832 
3833 long
3834 GNEViewNet::onCmdEditCrossingShape(FXObject*, FXSelector, void*) {
3835  // Obtain crossing under mouse
3836  GNECrossing* crossing = getCrossingAtPopupPosition();
3837  if (crossing) {
3838  // check if network has to be updated
3839  if (crossing->getParentJunction()->getNBNode()->getShape().size() == 0) {
3840  // recompute the whole network
3841  myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3842  }
3843  // if grid is enabled, show warning
3844  if (myVisualizationSettings->showGrid) {
3845  WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3846  }
3847  // start edit custom shape
3848  myEditNetworkElementShapes.startEditCustomShape(crossing);
3849  }
3850  // destroy pop-up and update view Net
3851  destroyPopup();
3852  setFocus();
3853  return 1;
3854 }
3855 
3856 
3857 long
3858 GNEViewNet::onCmdEditWalkingAreaShape(FXObject*, FXSelector, void*) {
3859  // Obtain walkingArea under mouse
3860  GNEWalkingArea* walkingArea = getWalkingAreaAtPopupPosition();
3861  if (walkingArea) {
3862  // check if network has to be updated
3863  if (walkingArea->getParentJunction()->getNBNode()->getShape().size() == 0) {
3864  // recompute the whole network
3865  myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3866  // if grid is enabled, show warning
3867  if (myVisualizationSettings->showGrid) {
3868  WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3869  }
3870  }
3871  // start edit custom shape
3872  myEditNetworkElementShapes.startEditCustomShape(walkingArea);
3873  }
3874  // destroy pop-up and update view Net
3875  destroyPopup();
3876  setFocus();
3877  return 1;
3878 }
3879 
3880 
3881 long
3882 GNEViewNet::onCmdToggleSelectEdges(FXObject*, FXSelector sel, void*) {
3883  // Toggle menuCheckSelectEdges
3884  if (myNetworkViewOptions.menuCheckSelectEdges->amChecked() == TRUE) {
3885  myNetworkViewOptions.menuCheckSelectEdges->setChecked(FALSE);
3886  } else {
3887  myNetworkViewOptions.menuCheckSelectEdges->setChecked(TRUE);
3888  }
3889  myNetworkViewOptions.menuCheckSelectEdges->update();
3890  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3891  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES)) {
3892  myNetworkViewOptions.menuCheckSelectEdges->setFocus();
3893  }
3894  return 1;
3895 }
3896 
3897 
3898 long
3899 GNEViewNet::onCmdToggleShowConnections(FXObject*, FXSelector sel, void*) {
3900  // Toggle menuCheckShowConnections
3901  if (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE) {
3902  myNetworkViewOptions.menuCheckShowConnections->setChecked(FALSE);
3903  } else {
3904  myNetworkViewOptions.menuCheckShowConnections->setChecked(TRUE);
3905  }
3906  myNetworkViewOptions.menuCheckShowConnections->update();
3907  // if show was enabled, init GNEConnections
3908  if (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE) {
3909  getNet()->initGNEConnections();
3910  }
3911  // change flag "showLane2Lane" in myVisualizationSettings
3912  myVisualizationSettings->showLane2Lane = (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE);
3913  // Hide/show connections require recompute
3914  getNet()->requireRecompute();
3915  // Update viewNet to show/hide connections
3916  updateViewNet();
3917  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3918  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS)) {
3919  myNetworkViewOptions.menuCheckShowConnections->setFocus();
3920  }
3921  return 1;
3922 }
3923 
3924 
3925 long
3926 GNEViewNet::onCmdToggleHideConnections(FXObject*, FXSelector sel, void*) {
3927  // Toggle menuCheckHideConnections
3928  if (myNetworkViewOptions.menuCheckHideConnections->amChecked() == TRUE) {
3929  myNetworkViewOptions.menuCheckHideConnections->setChecked(FALSE);
3930  } else {
3931  myNetworkViewOptions.menuCheckHideConnections->setChecked(TRUE);
3932  }
3933  myNetworkViewOptions.menuCheckHideConnections->update();
3934  // Update viewNet to show/hide connections
3935  updateViewNet();
3936  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3937  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS)) {
3938  myNetworkViewOptions.menuCheckHideConnections->setFocus();
3939  }
3940  return 1;
3941 }
3942 
3943 
3944 long
3945 GNEViewNet::onCmdToggleShowAdditionalSubElements(FXObject*, FXSelector sel, void*) {
3946  // Toggle menuCheckShowAdditionalSubElements
3947  if (myNetworkViewOptions.menuCheckShowAdditionalSubElements->amChecked() == TRUE) {
3948  myNetworkViewOptions.menuCheckShowAdditionalSubElements->setChecked(FALSE);
3949  } else {
3950  myNetworkViewOptions.menuCheckShowAdditionalSubElements->setChecked(TRUE);
3951  }
3952  myNetworkViewOptions.menuCheckShowAdditionalSubElements->update();
3953  // Update viewNet to show/hide sub elements
3954  updateViewNet();
3955  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3956  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS)) {
3957  myNetworkViewOptions.menuCheckShowAdditionalSubElements->setFocus();
3958  }
3959  return 1;
3960 }
3961 
3962 
3963 long
3964 GNEViewNet::onCmdToggleShowTAZElements(FXObject*, FXSelector sel, void*) {
3965  // Toggle menuCheckShowAdditionalSubElements
3966  if (myNetworkViewOptions.menuCheckShowTAZElements->amChecked() == TRUE) {
3967  myNetworkViewOptions.menuCheckShowTAZElements->setChecked(FALSE);
3968  } else {
3969  myNetworkViewOptions.menuCheckShowTAZElements->setChecked(TRUE);
3970  }
3971  myNetworkViewOptions.menuCheckShowTAZElements->update();
3972  // Update viewNet to show/hide TAZ elements
3973  updateViewNet();
3974  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3975  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS)) {
3976  myNetworkViewOptions.menuCheckShowTAZElements->setFocus();
3977  }
3978  return 1;
3979 }
3980 
3981 
3982 long
3983 GNEViewNet::onCmdToggleExtendSelection(FXObject*, FXSelector sel, void*) {
3984  // Toggle menuCheckExtendSelection
3985  if (myNetworkViewOptions.menuCheckExtendSelection->amChecked() == TRUE) {
3986  myNetworkViewOptions.menuCheckExtendSelection->setChecked(FALSE);
3987  } else {
3988  myNetworkViewOptions.menuCheckExtendSelection->setChecked(TRUE);
3989  }
3990  myNetworkViewOptions.menuCheckExtendSelection->update();
3991  // Only update view
3992  updateViewNet();
3993  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3994  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION)) {
3995  myNetworkViewOptions.menuCheckExtendSelection->setFocus();
3996  }
3997  return 1;
3998 }
3999 
4000 
4001 long
4002 GNEViewNet::onCmdToggleChangeAllPhases(FXObject*, FXSelector sel, void*) {
4003  // Toggle menuCheckChangeAllPhases
4004  if (myNetworkViewOptions.menuCheckChangeAllPhases->amChecked() == TRUE) {
4005  myNetworkViewOptions.menuCheckChangeAllPhases->setChecked(FALSE);
4006  } else {
4007  myNetworkViewOptions.menuCheckChangeAllPhases->setChecked(TRUE);
4008  }
4009  myNetworkViewOptions.menuCheckChangeAllPhases->update();
4010  // Only update view
4011  updateViewNet();
4012  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4013  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES)) {
4014  myNetworkViewOptions.menuCheckChangeAllPhases->setFocus();
4015  }
4016  return 1;
4017 }
4018 
4019 
4020 long
4021 GNEViewNet::onCmdToggleShowGrid(FXObject*, FXSelector sel, void*) {
4022  // show or hide grid depending of myNetworkViewOptions.menuCheckToggleGrid
4023  if (myVisualizationSettings->showGrid) {
4024  myVisualizationSettings->showGrid = false;
4025  myNetworkViewOptions.menuCheckToggleGrid->setChecked(false);
4026  myDemandViewOptions.menuCheckToggleGrid->setChecked(false);
4027  } else {
4028  myVisualizationSettings->showGrid = true;
4029  myNetworkViewOptions.menuCheckToggleGrid->setChecked(true);
4030  myDemandViewOptions.menuCheckToggleGrid->setChecked(true);
4031  }
4032  myNetworkViewOptions.menuCheckToggleGrid->update();
4033  myDemandViewOptions.menuCheckToggleGrid->update();
4034  // update view to show grid
4035  updateViewNet();
4036  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4037  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID)) {
4038  myNetworkViewOptions.menuCheckToggleGrid->setFocus();
4039  } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID)) {
4040  myDemandViewOptions.menuCheckToggleGrid->setFocus();
4041  }
4042  return 1;
4043 }
4044 
4045 
4046 long
4047 GNEViewNet::onCmdToggleDrawJunctionShape(FXObject*, FXSelector sel, void*) {
4048  // toggle state
4049  myVisualizationSettings->drawJunctionShape = !myVisualizationSettings->drawJunctionShape;
4050  // gui button has 'hide' semantics
4051  const bool hide = !myVisualizationSettings->drawJunctionShape;
4052  myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4053  myDemandViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4054  myDataViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4055 
4056  myNetworkViewOptions.menuCheckToggleDrawJunctionShape->update();
4057  myDemandViewOptions.menuCheckToggleDrawJunctionShape->update();
4058  myDataViewOptions.menuCheckToggleDrawJunctionShape->update();
4059  // update view to show DrawJunctionShape
4060  updateViewNet();
4061  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4062  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4063  myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4064  } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4065  myDemandViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4066  } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4067  myDataViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4068  }
4069  return 1;
4070 }
4071 
4072 long
4073 GNEViewNet::onCmdToggleDrawSpreadVehicles(FXObject*, FXSelector sel, void*) {
4074  // Toggle menuCheckShowDemandElements
4075  if ((myNetworkViewOptions.menuCheckDrawSpreadVehicles->amChecked() == TRUE) ||
4076  (myDemandViewOptions.menuCheckDrawSpreadVehicles->amChecked() == TRUE)) {
4077  myNetworkViewOptions.menuCheckDrawSpreadVehicles->setChecked(FALSE);
4078  myDemandViewOptions.menuCheckDrawSpreadVehicles->setChecked(FALSE);
4079  } else {
4080  myNetworkViewOptions.menuCheckDrawSpreadVehicles->setChecked(TRUE);
4081  myDemandViewOptions.menuCheckDrawSpreadVehicles->setChecked(TRUE);
4082  }
4083  myNetworkViewOptions.menuCheckDrawSpreadVehicles->update();
4084  myDemandViewOptions.menuCheckDrawSpreadVehicles->update();
4085  // declare edge set
4086  std::set<GNEEdge*> edgesToUpdate;
4087  // compute vehicle geometry
4088  for (const auto& vehicle : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_VEHICLE)) {
4089  if (vehicle.second->getParentEdges().size() > 0) {
4090  edgesToUpdate.insert(vehicle.second->getParentEdges().front());
4091  } else if (vehicle.second->getChildDemandElements().size() > 0 && (vehicle.second->getChildDemandElements().front()->getTagProperty().getTag() == GNE_TAG_ROUTE_EMBEDDED)) {
4092  edgesToUpdate.insert(vehicle.second->getChildDemandElements().front()->getParentEdges().front());
4093  }
4094  }
4095  for (const auto& routeFlow : myNet->getAttributeCarriers()->getDemandElements().at(GNE_TAG_FLOW_ROUTE)) {
4096  if (routeFlow.second->getParentEdges().size() > 0) {
4097  edgesToUpdate.insert(routeFlow.second->getParentEdges().front());
4098  } else if (routeFlow.second->getChildDemandElements().size() > 0 && (routeFlow.second->getChildDemandElements().front()->getTagProperty().getTag() == GNE_TAG_ROUTE_EMBEDDED)) {
4099  edgesToUpdate.insert(routeFlow.second->getChildDemandElements().front()->getParentEdges().front());
4100  }
4101  }
4102  for (const auto& trip : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_TRIP)) {
4103  if (trip.second->getParentEdges().size() > 0) {
4104  edgesToUpdate.insert(trip.second->getParentEdges().front());
4105  }
4106  }
4107  for (const auto& flow : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_FLOW)) {
4108  if (flow.second->getParentEdges().size() > 0) {
4109  edgesToUpdate.insert(flow.second->getParentEdges().front());
4110  }
4111  }
4112  // update spread geometries of all edges
4113  for (const auto& edge : edgesToUpdate) {
4114  edge->updateVehicleSpreadGeometries();
4115  }
4116  // update view to show new vehicles positions
4117  updateViewNet();
4118  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4119  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES)) {
4120  myNetworkViewOptions.menuCheckDrawSpreadVehicles->setFocus();
4121  } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES)) {
4122  myDemandViewOptions.menuCheckDrawSpreadVehicles->setFocus();
4123  }
4124  return 1;
4125 }
4126 
4127 
4128 long
4129 GNEViewNet::onCmdToggleWarnAboutMerge(FXObject*, FXSelector sel, void*) {
4130  // Toggle menuCheckWarnAboutMerge
4131  if (myNetworkViewOptions.menuCheckWarnAboutMerge->amChecked() == TRUE) {
4132  myNetworkViewOptions.menuCheckWarnAboutMerge->setChecked(FALSE);
4133  } else {
4134  myNetworkViewOptions.menuCheckWarnAboutMerge->setChecked(TRUE);
4135  }
4136  myNetworkViewOptions.menuCheckWarnAboutMerge->update();
4137  // Only update view
4138  updateViewNet();
4139  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4140  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE)) {
4141  myNetworkViewOptions.menuCheckWarnAboutMerge->setFocus();
4142  }
4143  return 1;
4144 }
4145 
4146 
4147 long
4148 GNEViewNet::onCmdToggleShowJunctionBubbles(FXObject*, FXSelector sel, void*) {
4149  // Toggle menuCheckShowJunctionBubble
4150  if (myNetworkViewOptions.menuCheckShowJunctionBubble->amChecked() == TRUE) {
4151  myNetworkViewOptions.menuCheckShowJunctionBubble->setChecked(FALSE);
4152  } else {
4153  myNetworkViewOptions.menuCheckShowJunctionBubble->setChecked(TRUE);
4154  }
4155  myNetworkViewOptions.menuCheckShowJunctionBubble->update();
4156  // Only update view
4157  updateViewNet();
4158  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4159  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES)) {
4160  myNetworkViewOptions.menuCheckShowJunctionBubble->setFocus();
4161  }
4162  return 1;
4163 }
4164 
4165 
4166 long
4167 GNEViewNet::onCmdToggleMoveElevation(FXObject*, FXSelector sel, void*) {
4168  // Toggle menuCheckMoveElevation
4169  if (myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
4170  myNetworkViewOptions.menuCheckMoveElevation->setChecked(FALSE);
4171  } else {
4172  myNetworkViewOptions.menuCheckMoveElevation->setChecked(TRUE);
4173  }
4174  myNetworkViewOptions.menuCheckMoveElevation->update();
4175  // Only update view
4176  updateViewNet();
4177  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4178  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION)) {
4179  myNetworkViewOptions.menuCheckMoveElevation->setFocus();
4180  }
4181  return 1;
4182 }
4183 
4184 
4185 long
4186 GNEViewNet::onCmdToggleChainEdges(FXObject*, FXSelector sel, void*) {
4187  // Toggle menuCheckMoveElevation
4188  if (myNetworkViewOptions.menuCheckChainEdges->amChecked() == TRUE) {
4189  myNetworkViewOptions.menuCheckChainEdges->setChecked(FALSE);
4190  } else {
4191  myNetworkViewOptions.menuCheckChainEdges->setChecked(TRUE);
4192  }
4193  myNetworkViewOptions.menuCheckChainEdges->update();
4194  // Only update view
4195  updateViewNet();
4196  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4197  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES)) {
4198  myNetworkViewOptions.menuCheckChainEdges->setFocus();
4199  }
4200  return 1;
4201 }
4202 
4203 
4204 long
4205 GNEViewNet::onCmdToggleAutoOppositeEdge(FXObject*, FXSelector sel, void*) {
4206  // Toggle menuCheckAutoOppositeEdge
4207  if (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE) {
4208  myNetworkViewOptions.menuCheckAutoOppositeEdge->setChecked(FALSE);
4209  } else {
4210  myNetworkViewOptions.menuCheckAutoOppositeEdge->setChecked(TRUE);
4211  }
4212  myNetworkViewOptions.menuCheckAutoOppositeEdge->update();
4213  // Only update view
4214  updateViewNet();
4215  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4216  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES)) {
4217  myNetworkViewOptions.menuCheckAutoOppositeEdge->setFocus();
4218  }
4219  return 1;
4220 }
4221 
4222 
4223 long
4224 GNEViewNet::onCmdToggleHideNonInspecteDemandElements(FXObject*, FXSelector sel, void*) {
4225  // Toggle menuCheckHideNonInspectedDemandElements
4226  if (myDemandViewOptions.menuCheckHideNonInspectedDemandElements->amChecked() == TRUE) {
4227  myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setChecked(FALSE);
4228  } else {
4229  myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setChecked(TRUE);
4230  }
4231  myDemandViewOptions.menuCheckHideNonInspectedDemandElements->update();
4232  // Only update view
4233  updateViewNet();
4234  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4235  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED)) {
4236  myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setFocus();
4237  }
4238  return 1;
4239 }
4240 
4241 
4242 long
4243 GNEViewNet::onCmdToggleShowOverlappedRoutes(FXObject*, FXSelector sel, void*) {
4244  // Toggle menuCheckShowOverlappedRoutes
4245  if (myDemandViewOptions.menuCheckShowOverlappedRoutes->amChecked() == TRUE) {
4246  myDemandViewOptions.menuCheckShowOverlappedRoutes->setChecked(FALSE);
4247  } else {
4248  myDemandViewOptions.menuCheckShowOverlappedRoutes->setChecked(TRUE);
4249  }
4250  myDemandViewOptions.menuCheckShowOverlappedRoutes->update();
4251  // Only update view
4252  updateViewNet();
4253  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4254  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES)) {
4255  myDemandViewOptions.menuCheckShowOverlappedRoutes->setFocus();
4256  }
4257  return 1;
4258 }
4259 
4260 
4261 long
4262 GNEViewNet::onCmdToggleHideShapes(FXObject*, FXSelector sel, void*) {
4263  // Toggle menuCheckHideShapes
4264  if (myDemandViewOptions.menuCheckHideShapes->amChecked() == TRUE) {
4265  myDemandViewOptions.menuCheckHideShapes->setChecked(FALSE);
4266  } else {
4267  myDemandViewOptions.menuCheckHideShapes->setChecked(TRUE);
4268  }
4269  myDemandViewOptions.menuCheckHideShapes->update();
4270  // Only update view
4271  updateViewNet();
4272  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4273  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES)) {
4274  myDemandViewOptions.menuCheckHideShapes->setFocus();
4275  }
4276  return 1;
4277 }
4278 
4279 
4280 long
4281 GNEViewNet::onCmdToggleShowTrips(FXObject*, FXSelector sel, void*) {
4282  // Toggle menuCheckHideShapes
4283  if (myDemandViewOptions.menuCheckShowAllTrips->amChecked() == TRUE) {
4284  myDemandViewOptions.menuCheckShowAllTrips->setChecked(FALSE);
4285  } else {
4286  myDemandViewOptions.menuCheckShowAllTrips->setChecked(TRUE);
4287  }
4288  myDemandViewOptions.menuCheckShowAllTrips->update();
4289  // Only update view
4290  updateViewNet();
4291  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4292  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS)) {
4293  myDemandViewOptions.menuCheckShowAllTrips->setFocus();
4294  }
4295  return 1;
4296 }
4297 
4298 
4299 long
4300 GNEViewNet::onCmdToggleShowAllPersonPlans(FXObject*, FXSelector sel, void*) {
4301  // Toggle menuCheckShowAllPersonPlans
4302  if (myDemandViewOptions.menuCheckShowAllPersonPlans->amChecked() == TRUE) {
4303  myDemandViewOptions.menuCheckShowAllPersonPlans->setChecked(FALSE);
4304  } else {
4305  myDemandViewOptions.menuCheckShowAllPersonPlans->setChecked(TRUE);
4306  }
4307  myDemandViewOptions.menuCheckShowAllPersonPlans->update();
4308  // Only update view
4309  updateViewNet();
4310  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4311  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS)) {
4312  myDemandViewOptions.menuCheckShowAllPersonPlans->setFocus();
4313  }
4314  return 1;
4315 }
4316 
4317 
4318 long
4319 GNEViewNet::onCmdToggleLockPerson(FXObject*, FXSelector sel, void*) {
4320  // Toggle menuCheckLockPerson
4321  if (myDemandViewOptions.menuCheckLockPerson->amChecked() == TRUE) {
4322  myDemandViewOptions.menuCheckLockPerson->setChecked(FALSE);
4323  } else if ((myInspectedAttributeCarriers.size() > 0) && myInspectedAttributeCarriers.front()->getTagProperty().isPerson()) {
4324  myDemandViewOptions.menuCheckLockPerson->setChecked(TRUE);
4325  }
4326  myDemandViewOptions.menuCheckLockPerson->update();
4327  // lock or unlock current inspected person depending of menuCheckLockPerson value
4328  if (myDemandViewOptions.menuCheckLockPerson->amChecked()) {
4329  // obtain locked person or person plan
4330  const GNEDemandElement* personOrPersonPlan = dynamic_cast<const GNEDemandElement*>(myInspectedAttributeCarriers.front());
4331  if (personOrPersonPlan) {
4332  // lock person depending if casted demand element is either a person or a person plan
4333  if (personOrPersonPlan->getTagProperty().isPerson()) {
4334  myDemandViewOptions.lockPerson(personOrPersonPlan);
4335  } else {
4336  myDemandViewOptions.lockPerson(personOrPersonPlan->getParentDemandElements().front());
4337  }
4338  }
4339  } else {
4340  // unlock current person
4341  myDemandViewOptions.unlockPerson();
4342  }
4343  // update view
4344  updateViewNet();
4345  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4346  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON)) {
4347  myDemandViewOptions.menuCheckLockPerson->setFocus();
4348  }
4349  return 1;
4350 }
4351 
4352 
4353 long
4354 GNEViewNet::onCmdToggleShowAllContainerPlans(FXObject*, FXSelector sel, void*) {
4355  // Toggle menuCheckShowAllContainerPlans
4356  if (myDemandViewOptions.menuCheckShowAllContainerPlans->amChecked() == TRUE) {
4357  myDemandViewOptions.menuCheckShowAllContainerPlans->setChecked(FALSE);
4358  } else {
4359  myDemandViewOptions.menuCheckShowAllContainerPlans->setChecked(TRUE);
4360  }
4361  myDemandViewOptions.menuCheckShowAllContainerPlans->update();
4362  // Only update view
4363  updateViewNet();
4364  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4365  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS)) {
4366  myDemandViewOptions.menuCheckShowAllContainerPlans->setFocus();
4367  }
4368  return 1;
4369 }
4370 
4371 
4372 long
4373 GNEViewNet::onCmdToggleLockContainer(FXObject*, FXSelector sel, void*) {
4374  // Toggle menuCheckLockContainer
4375  if (myDemandViewOptions.menuCheckLockContainer->amChecked() == TRUE) {
4376  myDemandViewOptions.menuCheckLockContainer->setChecked(FALSE);
4377  } else if ((myInspectedAttributeCarriers.size() > 0) && myInspectedAttributeCarriers.front()->getTagProperty().isContainer()) {
4378  myDemandViewOptions.menuCheckLockContainer->setChecked(TRUE);
4379  }
4380  myDemandViewOptions.menuCheckLockContainer->update();
4381  // lock or unlock current inspected container depending of menuCheckLockContainer value
4382  if (myDemandViewOptions.menuCheckLockContainer->amChecked()) {
4383  // obtain locked container or container plan
4384  const GNEDemandElement* containerOrContainerPlan = dynamic_cast<const GNEDemandElement*>(myInspectedAttributeCarriers.front());
4385  if (containerOrContainerPlan) {
4386  // lock container depending if casted demand element is either a container or a container plan
4387  if (containerOrContainerPlan->getTagProperty().isContainer()) {
4388  myDemandViewOptions.lockContainer(containerOrContainerPlan);
4389  } else {
4390  myDemandViewOptions.lockContainer(containerOrContainerPlan->getParentDemandElements().front());
4391  }
4392  }
4393  } else {
4394  // unlock current container
4395  myDemandViewOptions.unlockContainer();
4396  }
4397  // update view
4398  updateViewNet();
4399  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4400  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER)) {
4401  myDemandViewOptions.menuCheckLockContainer->setFocus();
4402  }
4403  return 1;
4404 }
4405 
4406 
4407 long
4408 GNEViewNet::onCmdToggleShowAdditionals(FXObject*, FXSelector sel, void*) {
4409  // Toggle menuCheckShowAdditionals
4410  if (myDataViewOptions.menuCheckShowAdditionals->amChecked() == TRUE) {
4411  myDataViewOptions.menuCheckShowAdditionals->setChecked(FALSE);
4412  } else {
4413  myDataViewOptions.menuCheckShowAdditionals->setChecked(TRUE);
4414  }
4415  myDataViewOptions.menuCheckShowAdditionals->update();
4416  // Only update view
4417  updateViewNet();
4418  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4419  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS)) {
4420  myDataViewOptions.menuCheckShowAdditionals->setFocus();
4421  }
4422  return 1;
4423 }
4424 
4425 
4426 long
4427 GNEViewNet::onCmdToggleShowShapes(FXObject*, FXSelector sel, void*) {
4428  // Toggle menuCheckShowShapes
4429  if (myDataViewOptions.menuCheckShowShapes->amChecked() == TRUE) {
4430  myDataViewOptions.menuCheckShowShapes->setChecked(FALSE);
4431  } else {
4432  myDataViewOptions.menuCheckShowShapes->setChecked(TRUE);
4433  }
4434  myDataViewOptions.menuCheckShowShapes->update();
4435  // Only update view
4436  updateViewNet();
4437  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4438  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES)) {
4439  myDataViewOptions.menuCheckShowShapes->setFocus();
4440  }
4441  return 1;
4442 }
4443 
4444 
4445 long
4446 GNEViewNet::onCmdToggleShowDemandElementsNetwork(FXObject*, FXSelector sel, void*) {
4447  // Toggle menuCheckShowDemandElements
4448  if (myNetworkViewOptions.menuCheckShowDemandElements->amChecked() == TRUE) {
4449  myNetworkViewOptions.menuCheckShowDemandElements->setChecked(FALSE);
4450  } else {
4451  myNetworkViewOptions.menuCheckShowDemandElements->setChecked(TRUE);
4452  }
4453  myNetworkViewOptions.menuCheckShowDemandElements->update();
4454  // compute demand elements
4455  myNet->computeDemandElements(myViewParent->getGNEAppWindows());
4456  // update view to show demand elements
4457  updateViewNet();
4458  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4459  if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS)) {
4460  myNetworkViewOptions.menuCheckShowDemandElements->setFocus();
4461  }
4462  return 1;
4463 }
4464 
4465 
4466 long
4467 GNEViewNet::onCmdToggleShowDemandElementsData(FXObject*, FXSelector sel, void*) {
4468  // Toggle menuCheckShowDemandElements
4469  if (myDataViewOptions.menuCheckShowDemandElements->amChecked() == TRUE) {
4470  myDataViewOptions.menuCheckShowDemandElements->setChecked(FALSE);
4471  } else {
4472  myDataViewOptions.menuCheckShowDemandElements->setChecked(TRUE);
4473  }
4474  myDataViewOptions.menuCheckShowDemandElements->update();
4475  // compute demand elements
4476  myNet->computeDemandElements(myViewParent->getGNEAppWindows());
4477  // update view to show demand elements
4478  updateViewNet();
4479  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4480  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS)) {
4481  myDataViewOptions.menuCheckShowDemandElements->setFocus();
4482  }
4483  return 1;
4484 }
4485 
4486 
4487 long
4488 GNEViewNet::onCmdToggleTAZRelDrawing(FXObject*, FXSelector sel, void*) {
4489  // Toggle menuCheckShowDemandElements
4490  if (myDataViewOptions.menuCheckToggleTAZRelDrawing->amChecked() == TRUE) {
4491  myDataViewOptions.menuCheckToggleTAZRelDrawing->setChecked(FALSE);
4492  } else {
4493  myDataViewOptions.menuCheckToggleTAZRelDrawing->setChecked(TRUE);
4494  }
4495  myDataViewOptions.menuCheckToggleTAZRelDrawing->update();
4496  // update view to show demand elements
4497  updateViewNet();
4498  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4499  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING)) {
4500  myDataViewOptions.menuCheckToggleTAZRelDrawing->setFocus();
4501  }
4502  return 1;
4503 }
4504 
4505 
4506 long
4507 GNEViewNet::onCmdToggleTAZDrawFill(FXObject*, FXSelector sel, void*) {
4508  // Toggle menuCheckShowDemandElements
4509  if (myDataViewOptions.menuCheckToggleTAZDrawFill->amChecked() == TRUE) {
4510  myDataViewOptions.menuCheckToggleTAZDrawFill->setChecked(FALSE);
4511  } else {
4512  myDataViewOptions.menuCheckToggleTAZDrawFill->setChecked(TRUE);
4513  }
4514  myDataViewOptions.menuCheckToggleTAZDrawFill->update();
4515  // update view to show demand elements
4516  updateViewNet();
4517  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4518  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL)) {
4519  myDataViewOptions.menuCheckToggleTAZDrawFill->setFocus();
4520  }
4521  return 1;
4522 }
4523 
4524 
4525 long
4526 GNEViewNet::onCmdToggleTAZRelOnlyFrom(FXObject*, FXSelector sel, void*) {
4527  // Toggle menuCheckShowDemandElements
4528  if (myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->amChecked() == TRUE) {
4529  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setChecked(FALSE);
4530  } else {
4531  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setChecked(TRUE);
4532  }
4533  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->update();
4534  // update view to show demand elements
4535  updateViewNet();
4536  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4537  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM)) {
4538  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setFocus();
4539  }
4540  return 1;
4541 }
4542 
4543 
4544 long
4545 GNEViewNet::onCmdToggleTAZRelOnlyTo(FXObject*, FXSelector sel, void*) {
4546  // Toggle menuCheckShowDemandElements
4547  if (myDataViewOptions.menuCheckToggleTAZRelOnlyTo->amChecked() == TRUE) {
4548  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setChecked(FALSE);
4549  } else {
4550  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setChecked(TRUE);
4551  }
4552  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->update();
4553  // update view to show demand elements
4554  updateViewNet();
4555  // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4556  if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO)) {
4557  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setFocus();
4558  }
4559  return 1;
4560 }
4561 
4562 
4563 long
4564 GNEViewNet::onCmdIntervalBarGenericDataType(FXObject*, FXSelector, void*) {
4565  myIntervalBar.setGenericDataType();
4566  return 1;
4567 }
4568 
4569 
4570 long
4571 GNEViewNet::onCmdIntervalBarDataSet(FXObject*, FXSelector, void*) {
4572  myIntervalBar.setDataSet();
4573  return 1;
4574 }
4575 
4576 
4577 long
4578 GNEViewNet::onCmdIntervalBarLimit(FXObject*, FXSelector, void*) {
4579  myIntervalBar.setInterval();
4580  return 1;
4581 }
4582 
4583 
4584 long
4585 GNEViewNet::onCmdIntervalBarSetBegin(FXObject*, FXSelector, void*) {
4586  myIntervalBar.setBegin();
4587  return 1;
4588 }
4589 
4590 
4591 long
4592 GNEViewNet::onCmdIntervalBarSetEnd(FXObject*, FXSelector, void*) {
4593  myIntervalBar.setEnd();
4594  return 1;
4595 }
4596 
4597 
4598 long
4599 GNEViewNet::onCmdIntervalBarSetParameter(FXObject*, FXSelector, void*) {
4600  myIntervalBar.setParameter();
4601  return 1;
4602 }
4603 
4604 
4605 long
4606 GNEViewNet::onCmdAddSelected(FXObject*, FXSelector, void*) {
4607  // only select if AC under cursor isn't previously selected
4608  auto AC = myViewObjectsSelector.getAttributeCarrierFront();
4609  if (AC && !AC->isAttributeCarrierSelected()) {
4610  AC->selectAttributeCarrier();
4611  }
4612  return 1;
4613 }
4614 
4615 
4616 long
4617 GNEViewNet::onCmdRemoveSelected(FXObject*, FXSelector, void*) {
4618  // only unselect if AC under cursor isn't previously selected
4619  auto AC = myViewObjectsSelector.getAttributeCarrierFront();
4620  if (AC && AC->isAttributeCarrierSelected()) {
4621  AC->unselectAttributeCarrier();
4622  }
4623  return 1;
4624 }
4625 
4626 
4627 long
4628 GNEViewNet::onCmdAddEdgeSelected(FXObject*, FXSelector, void*) {
4629  // only select if edge under cursor isn't previously selected
4630  auto edge = myViewObjectsSelector.getEdgeFront();
4631  if (edge && !edge->isAttributeCarrierSelected()) {
4632  edge->selectAttributeCarrier();
4633  }
4634  return 1;
4635 }
4636 
4637 
4638 long
4639 GNEViewNet::onCmdRemoveEdgeSelected(FXObject*, FXSelector, void*) {
4640  // only unselect if edge under cursor isn't previously selected
4641  auto edge = myViewObjectsSelector.getEdgeFront();
4642  if (edge && edge->isAttributeCarrierSelected()) {
4643  edge->unselectAttributeCarrier();
4644  }
4645  return 1;
4646 }
4647 
4648 
4649 long
4650 GNEViewNet::onCmdSetNeteditView(FXObject*, FXSelector sel, void*) {
4651  myEditModes.setView(FXSELID(sel));
4652  update();
4653  return 1;
4654 }
4655 
4656 // ===========================================================================
4657 // private
4658 // ===========================================================================
4659 
4660 void
4661 GNEViewNet::buildEditModeControls() {
4662  // build supermode buttons
4663  myEditModes.buildSuperModeButtons();
4664 
4665  // build save elements buttons
4666  mySaveElements.buildSaveElementsButtons();
4667 
4668  // build time switch buttons
4669  myTimeFormat.buildTimeFormatButtons();
4670 
4671  // build menu checks for Common checkable buttons
4672  myCommonCheckableButtons.buildCommonCheckableButtons();
4673 
4674  // build menu checks for Network checkable buttons
4675  myNetworkCheckableButtons.buildNetworkCheckableButtons();
4676 
4677  // build menu checks for Demand checkable buttons
4678  myDemandCheckableButtons.buildDemandCheckableButtons();
4679 
4680  // build menu checks of view options Data
4681  myDataCheckableButtons.buildDataCheckableButtons();
4682 
4683  // Create Vertical separator
4684  new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4685  // XXX for some reason the vertical groove is not visible. adding more spacing to emphasize the separation
4686  new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4687  new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4688 
4689  // build menu checks of view options Network
4690  myNetworkViewOptions.buildNetworkViewOptionsMenuChecks();
4691 
4692  // build menu checks of view options Demand
4693  myDemandViewOptions.buildDemandViewOptionsMenuChecks();
4694 
4695  // build menu checks of view options Data
4696  myDataViewOptions.buildDataViewOptionsMenuChecks();
4697 
4698  // build interval bar
4699  myIntervalBar.buildIntervalBarElements();
4700 }
4701 
4702 
4703 void
4704 GNEViewNet::updateNetworkModeSpecificControls() {
4705  // get menu checks
4706  auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions;
4707  // hide all checkbox of view options Network
4708  myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
4709  // hide all checkbox of view options Demand
4710  myDemandViewOptions.hideDemandViewOptionsMenuChecks();
4711  // hide all checkbox of view options Data
4712  myDataViewOptions.hideDataViewOptionsMenuChecks();
4713  // disable all common edit modes
4714  myCommonCheckableButtons.disableCommonCheckableButtons();
4715  // disable all network edit modes
4716  myNetworkCheckableButtons.disableNetworkCheckableButtons();
4717  // disable all network edit modes
4718  myDataCheckableButtons.disableDataCheckableButtons();
4719  // hide interval bar
4720  myIntervalBar.hideIntervalBar();
4721  // hide all frames
4722  myViewParent->hideAllFrames();
4723  // hide all menuchecks
4724  myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
4725  myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
4726  myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
4727  // In network mode, always show option "show grid", "draw spread vehicles" and "show demand elements"
4728  myNetworkViewOptions.menuCheckToggleGrid->show();
4729  myNetworkViewOptions.menuCheckToggleDrawJunctionShape->show();
4730  myNetworkViewOptions.menuCheckDrawSpreadVehicles->show();
4731  myNetworkViewOptions.menuCheckShowDemandElements->show();
4732  menuChecks.menuCheckToggleGrid->show();
4733  menuChecks.menuCheckToggleDrawJunctionShape->show();
4734  menuChecks.menuCheckDrawSpreadVehicles->show();
4735  menuChecks.menuCheckShowDemandElements->show();
4736  // show separator
4737  menuChecks.separator->show();
4738  // enable selected controls
4739  switch (myEditModes.networkEditMode) {
4740  // common modes
4741  case NetworkEditMode::NETWORK_INSPECT:
4742  myViewParent->getInspectorFrame()->show();
4743  myViewParent->getInspectorFrame()->focusUpperElement();
4744  myCurrentFrame = myViewParent->getInspectorFrame();
4745  myCommonCheckableButtons.inspectButton->setChecked(true);
4746  // show view options
4747  myNetworkViewOptions.menuCheckSelectEdges->show();
4748  myNetworkViewOptions.menuCheckShowConnections->show();
4749  myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4750  myNetworkViewOptions.menuCheckShowTAZElements->show();
4751  // show menu checks
4752  menuChecks.menuCheckSelectEdges->show();
4753  menuChecks.menuCheckShowConnections->show();
4754  menuChecks.menuCheckShowAdditionalSubElements->show();
4755  menuChecks.menuCheckShowTAZElements->show();
4756  // update lock menu bar
4757  myLockManager.updateLockMenuBar();
4758  // show
4759  break;
4760  case NetworkEditMode::NETWORK_DELETE:
4761  myViewParent->getDeleteFrame()->show();
4762  myViewParent->getDeleteFrame()->focusUpperElement();
4763  myCurrentFrame = myViewParent->getDeleteFrame();
4764  myCommonCheckableButtons.deleteButton->setChecked(true);
4765  myNetworkViewOptions.menuCheckShowConnections->show();
4766  myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4767  myNetworkViewOptions.menuCheckShowTAZElements->show();
4768  // show view options
4769  myNetworkViewOptions.menuCheckSelectEdges->show();
4770  myNetworkViewOptions.menuCheckShowConnections->show();
4771  menuChecks.menuCheckShowAdditionalSubElements->show();
4772  menuChecks.menuCheckShowTAZElements->show();
4773  // show menu checks
4774  menuChecks.menuCheckSelectEdges->show();
4775  menuChecks.menuCheckShowConnections->show();
4776  break;
4777  case NetworkEditMode::NETWORK_SELECT:
4778  myViewParent->getSelectorFrame()->show();
4779  myViewParent->getSelectorFrame()->focusUpperElement();
4780  myCurrentFrame = myViewParent->getSelectorFrame();
4781  myCommonCheckableButtons.selectButton->setChecked(true);
4782  // show view options
4783  myNetworkViewOptions.menuCheckSelectEdges->show();
4784  myNetworkViewOptions.menuCheckShowConnections->show();
4785  myNetworkViewOptions.menuCheckExtendSelection->show();
4786  myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4787  myNetworkViewOptions.menuCheckShowTAZElements->show();
4788  // show menu checks
4789  menuChecks.menuCheckSelectEdges->show();
4790  menuChecks.menuCheckShowConnections->show();
4791  menuChecks.menuCheckExtendSelection->show();
4792  menuChecks.menuCheckShowAdditionalSubElements->show();
4793  menuChecks.menuCheckShowTAZElements->show();
4794  break;
4795  // specific modes
4796  case NetworkEditMode::NETWORK_CREATE_EDGE:
4797  myViewParent->getCreateEdgeFrame()->show();
4798  myViewParent->getCreateEdgeFrame()->focusUpperElement();
4799  myCurrentFrame = myViewParent->getCreateEdgeFrame();
4800  myNetworkCheckableButtons.createEdgeButton->setChecked(true);
4801  // show view options
4802  myNetworkViewOptions.menuCheckChainEdges->show();
4803  myNetworkViewOptions.menuCheckAutoOppositeEdge->show();
4804  // show menu checks
4805  menuChecks.menuCheckChainEdges->show();
4806  menuChecks.menuCheckAutoOppositeEdge->show();
4807  break;
4808  case NetworkEditMode::NETWORK_MOVE:
4809  myViewParent->getMoveFrame()->show();
4810  myViewParent->getMoveFrame()->focusUpperElement();
4811  myCurrentFrame = myViewParent->getMoveFrame();
4812  myNetworkCheckableButtons.moveNetworkElementsButton->setChecked(true);
4813  // show view options
4814  myNetworkViewOptions.menuCheckWarnAboutMerge->show();
4815  myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4816  myNetworkViewOptions.menuCheckMoveElevation->show();
4817  // show menu checks
4818  menuChecks.menuCheckWarnAboutMerge->show();
4819  menuChecks.menuCheckShowJunctionBubble->show();
4820  menuChecks.menuCheckMoveElevation->show();
4821  break;
4822  case NetworkEditMode::NETWORK_CONNECT:
4823  myViewParent->getConnectorFrame()->show();
4824  myViewParent->getConnectorFrame()->focusUpperElement();
4825  myCurrentFrame = myViewParent->getConnectorFrame();
4826  myNetworkCheckableButtons.connectionButton->setChecked(true);
4827  break;
4828  case NetworkEditMode::NETWORK_TLS:
4829  myViewParent->getTLSEditorFrame()->show();
4830  myViewParent->getTLSEditorFrame()->focusUpperElement();
4831  myCurrentFrame = myViewParent->getTLSEditorFrame();
4832  myNetworkCheckableButtons.trafficLightButton->setChecked(true);
4833  // show view options
4834  myNetworkViewOptions.menuCheckChangeAllPhases->show();
4835  // show menu checks
4836  menuChecks.menuCheckChangeAllPhases->show();
4837  break;
4838  case NetworkEditMode::NETWORK_ADDITIONAL:
4839  myViewParent->getAdditionalFrame()->show();
4840  myViewParent->getAdditionalFrame()->focusUpperElement();
4841  myCurrentFrame = myViewParent->getAdditionalFrame();
4842  myNetworkCheckableButtons.additionalButton->setChecked(true);
4843  // show view options
4844  myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4845  // show menu checks
4846  menuChecks.menuCheckShowAdditionalSubElements->show();
4847  break;
4848  case NetworkEditMode::NETWORK_CROSSING:
4849  myViewParent->getCrossingFrame()->show();
4850  myViewParent->getCrossingFrame()->focusUpperElement();
4851  myCurrentFrame = myViewParent->getCrossingFrame();
4852  myNetworkCheckableButtons.crossingButton->setChecked(true);
4853  break;
4854  case NetworkEditMode::NETWORK_TAZ:
4855  myViewParent->getTAZFrame()->show();
4856  myViewParent->getTAZFrame()->focusUpperElement();
4857  myCurrentFrame = myViewParent->getTAZFrame();
4858  myNetworkCheckableButtons.TAZButton->setChecked(true);
4859  break;
4860  case NetworkEditMode::NETWORK_SHAPE:
4861  myViewParent->getShapeFrame()->show();
4862  myViewParent->getShapeFrame()->focusUpperElement();
4863  myCurrentFrame = myViewParent->getShapeFrame();
4864  myNetworkCheckableButtons.shapeButton->setChecked(true);
4865  break;
4866  case NetworkEditMode::NETWORK_PROHIBITION:
4867  myViewParent->getProhibitionFrame()->show();
4868  myViewParent->getProhibitionFrame()->focusUpperElement();
4869  myCurrentFrame = myViewParent->getProhibitionFrame();
4870  myNetworkCheckableButtons.prohibitionButton->setChecked(true);
4871  break;
4872  case NetworkEditMode::NETWORK_WIRE:
4873  myViewParent->getWireFrame()->show();
4874  myViewParent->getWireFrame()->focusUpperElement();
4875  myCurrentFrame = myViewParent->getWireFrame();
4876  myNetworkCheckableButtons.wireButton->setChecked(true);
4877  break;
4878  case NetworkEditMode::NETWORK_DECAL:
4879  myViewParent->getDecalFrame()->show();
4880  myViewParent->getDecalFrame()->focusUpperElement();
4881  myCurrentFrame = myViewParent->getDecalFrame();
4882  myNetworkCheckableButtons.decalButton->setChecked(true);
4883  break;
4884  default:
4885  break;
4886  }
4887  // update menuChecks shorcuts
4888  menuChecks.updateShortcuts();
4889  // update common Network buttons
4890  myCommonCheckableButtons.updateCommonCheckableButtons();
4891  // Update Network buttons
4892  myNetworkCheckableButtons.updateNetworkCheckableButtons();
4893  // recalc toolbar
4894  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
4895  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
4896  // force repaint because different modes draw different things
4897  onPaint(nullptr, 0, nullptr);
4898  // finally update view
4899  updateViewNet();
4900 }
4901 
4902 
4903 void
4904 GNEViewNet::updateDemandModeSpecificControls() {
4905  // get menu checks
4906  auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions;
4907  // hide all checkbox of view options Network
4908  myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
4909  // hide all checkbox of view options Demand
4910  myDemandViewOptions.hideDemandViewOptionsMenuChecks();
4911  // hide all checkbox of view options Data
4912  myDataViewOptions.hideDataViewOptionsMenuChecks();
4913  // disable all common edit modes
4914  myCommonCheckableButtons.disableCommonCheckableButtons();
4915  // disable all Demand edit modes
4916  myDemandCheckableButtons.disableDemandCheckableButtons();
4917  // disable all network edit modes
4918  myDataCheckableButtons.disableDataCheckableButtons();
4919  // hide interval bar
4920  myIntervalBar.hideIntervalBar();
4921  // hide all frames
4922  myViewParent->hideAllFrames();
4923  // hide all menuchecks
4924  myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
4925  myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
4926  myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
4927  // always show "hide shapes", "show grid", "draw spread vehicles", "show overlapped routes" and show/lock persons and containers
4928  myDemandViewOptions.menuCheckToggleGrid->show();
4929  myDemandViewOptions.menuCheckToggleDrawJunctionShape->show();
4930  myDemandViewOptions.menuCheckDrawSpreadVehicles->show();
4931  myDemandViewOptions.menuCheckHideShapes->show();
4932  myDemandViewOptions.menuCheckShowAllTrips->show();
4933  myDemandViewOptions.menuCheckShowAllPersonPlans->show();
4934  myDemandViewOptions.menuCheckLockPerson->show();
4935  myDemandViewOptions.menuCheckShowAllContainerPlans->show();
4936  myDemandViewOptions.menuCheckLockContainer->show();
4937  myDemandViewOptions.menuCheckShowOverlappedRoutes->show();
4938  menuChecks.menuCheckToggleGrid->show();
4939  menuChecks.menuCheckToggleDrawJunctionShape->show();
4940  menuChecks.menuCheckDrawSpreadVehicles->show();
4941  menuChecks.menuCheckHideShapes->show();
4942  menuChecks.menuCheckShowAllTrips->show();
4943  menuChecks.menuCheckShowAllPersonPlans->show();
4944  menuChecks.menuCheckLockPerson->show();
4945  menuChecks.menuCheckShowAllContainerPlans->show();
4946  menuChecks.menuCheckLockContainer->show();
4947  menuChecks.menuCheckShowOverlappedRoutes->show();
4948  // show separator
4949  menuChecks.separator->show();
4950  // enable selected controls
4951  switch (myEditModes.demandEditMode) {
4952  // common modes
4953  case DemandEditMode::DEMAND_INSPECT:
4954  myViewParent->getInspectorFrame()->show();
4955  myViewParent->getInspectorFrame()->focusUpperElement();
4956  myCurrentFrame = myViewParent->getInspectorFrame();
4957  // set checkable button
4958  myCommonCheckableButtons.inspectButton->setChecked(true);
4959  // show view options
4960  myDemandViewOptions.menuCheckHideNonInspectedDemandElements->show();
4961  // show menu checks
4962  menuChecks.menuCheckHideNonInspectedDemandElements->show();
4963  break;
4964  case DemandEditMode::DEMAND_DELETE:
4965  myViewParent->getDeleteFrame()->show();
4966  myViewParent->getDeleteFrame()->focusUpperElement();
4967  myCurrentFrame = myViewParent->getDeleteFrame();
4968  // set checkable button
4969  myCommonCheckableButtons.deleteButton->setChecked(true);
4970  break;
4971  case DemandEditMode::DEMAND_SELECT:
4972  myViewParent->getSelectorFrame()->show();
4973  myViewParent->getSelectorFrame()->focusUpperElement();
4974  myCurrentFrame = myViewParent->getSelectorFrame();
4975  // set checkable button
4976  myCommonCheckableButtons.selectButton->setChecked(true);
4977  break;
4978  case DemandEditMode::DEMAND_MOVE:
4979  myViewParent->getMoveFrame()->show();
4980  myViewParent->getMoveFrame()->focusUpperElement();
4981  myCurrentFrame = myViewParent->getMoveFrame();
4982  // set checkable button
4983  myDemandCheckableButtons.moveDemandElementsButton->setChecked(true);
4984  break;
4985  // specific modes
4986  case DemandEditMode::DEMAND_ROUTE:
4987  myViewParent->getRouteFrame()->show();
4988  myViewParent->getRouteFrame()->focusUpperElement();
4989  myCurrentFrame = myViewParent->getRouteFrame();
4990  // set checkable button
4991  myDemandCheckableButtons.routeButton->setChecked(true);
4992  break;
4993  case DemandEditMode::DEMAND_ROUTEDISTRIBUTION:
4994  myViewParent->getRouteDistributionFrame()->show();
4995  myViewParent->getRouteDistributionFrame()->focusUpperElement();
4996  myCurrentFrame = myViewParent->getRouteDistributionFrame();
4997  // set checkable button
4998  myDemandCheckableButtons.routeDistributionButton->setChecked(true);
4999  break;
5000  case DemandEditMode::DEMAND_VEHICLE:
5001  myViewParent->getVehicleFrame()->show();
5002  myViewParent->getVehicleFrame()->focusUpperElement();
5003  myCurrentFrame = myViewParent->getVehicleFrame();
5004  // set checkable button
5005  myDemandCheckableButtons.vehicleButton->setChecked(true);
5006  break;
5007  case DemandEditMode::DEMAND_TYPE:
5008  myViewParent->getTypeFrame()->show();
5009  myViewParent->getTypeFrame()->focusUpperElement();
5010  myCurrentFrame = myViewParent->getTypeFrame();
5011  // set checkable button
5012  myDemandCheckableButtons.typeButton->setChecked(true);
5013  break;
5014  case DemandEditMode::DEMAND_TYPEDISTRIBUTION:
5015  myViewParent->getTypeDistributionFrame()->show();
5016  myViewParent->getTypeDistributionFrame()->focusUpperElement();
5017  myCurrentFrame = myViewParent->getTypeDistributionFrame();
5018  // set checkable button
5019  myDemandCheckableButtons.typeDistributionButton->setChecked(true);
5020  break;
5021  case DemandEditMode::DEMAND_STOP:
5022  myViewParent->getStopFrame()->show();
5023  myViewParent->getStopFrame()->focusUpperElement();
5024  myCurrentFrame = myViewParent->getStopFrame();
5025  // set checkable button
5026  myDemandCheckableButtons.stopButton->setChecked(true);
5027  break;
5028  case DemandEditMode::DEMAND_PERSON:
5029  myViewParent->getPersonFrame()->show();
5030  myViewParent->getPersonFrame()->focusUpperElement();
5031  myCurrentFrame = myViewParent->getPersonFrame();
5032  // set checkable button
5033  myDemandCheckableButtons.personButton->setChecked(true);
5034  break;
5035  case DemandEditMode::DEMAND_PERSONPLAN:
5036  myViewParent->getPersonPlanFrame()->show();
5037  myViewParent->getPersonPlanFrame()->focusUpperElement();
5038  myCurrentFrame = myViewParent->getPersonPlanFrame();
5039  // set checkable button
5040  myDemandCheckableButtons.personPlanButton->setChecked(true);
5041  break;
5042  case DemandEditMode::DEMAND_CONTAINER:
5043  myViewParent->getContainerFrame()->show();
5044  myViewParent->getContainerFrame()->focusUpperElement();
5045  myCurrentFrame = myViewParent->getContainerFrame();
5046  // set checkable button
5047  myDemandCheckableButtons.containerButton->setChecked(true);
5048  break;
5049  case DemandEditMode::DEMAND_CONTAINERPLAN:
5050  myViewParent->getContainerPlanFrame()->show();
5051  myViewParent->getContainerPlanFrame()->focusUpperElement();
5052  myCurrentFrame = myViewParent->getContainerPlanFrame();
5053  // set checkable button
5054  myDemandCheckableButtons.containerPlanButton->setChecked(true);
5055  break;
5056  default:
5057  break;
5058  }
5059  // update menuChecks shorcuts
5060  menuChecks.updateShortcuts();
5061  // update common Network buttons
5062  myCommonCheckableButtons.updateCommonCheckableButtons();
5063  // Update Demand buttons
5064  myDemandCheckableButtons.updateDemandCheckableButtons();
5065  // recalc toolbar
5066  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
5067  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
5068  // force repaint because different modes draw different things
5069  onPaint(nullptr, 0, nullptr);
5070  // finally update view
5071  updateViewNet();
5072 }
5073 
5074 
5075 void
5076 GNEViewNet::updateDataModeSpecificControls() {
5077  // get menu checks
5078  auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions;
5079  // hide all checkbox of view options Network
5080  myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
5081  // hide all checkbox of view options Demand
5082  myDemandViewOptions.hideDemandViewOptionsMenuChecks();
5083  // hide all checkbox of view options Data
5084  myDataViewOptions.hideDataViewOptionsMenuChecks();
5085  // disable all common edit modes
5086  myCommonCheckableButtons.disableCommonCheckableButtons();
5087  // disable all Data edit modes
5088  myDataCheckableButtons.disableDataCheckableButtons();
5089  // show interval bar
5090  myIntervalBar.showIntervalBar();
5091  // hide all frames
5092  myViewParent->hideAllFrames();
5093  // hide all menuchecks
5094  myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
5095  myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
5096  myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
5097  // In data mode, always show options for show elements
5098  myDataViewOptions.menuCheckToggleDrawJunctionShape->show();
5099  myDataViewOptions.menuCheckShowAdditionals->show();
5100  myDataViewOptions.menuCheckShowShapes->show();
5101  myDataViewOptions.menuCheckShowDemandElements->show();
5102  menuChecks.menuCheckToggleDrawJunctionShape->show();
5103  menuChecks.menuCheckShowAdditionals->show();
5104  menuChecks.menuCheckShowShapes->show();
5105  menuChecks.menuCheckShowDemandElements->show();
5106  // show separator
5107  menuChecks.separator->show();
5108  // enable selected controls
5109  switch (myEditModes.dataEditMode) {
5110  // common modes
5111  case DataEditMode::DATA_INSPECT:
5112  myViewParent->getInspectorFrame()->show();
5113  myViewParent->getInspectorFrame()->focusUpperElement();
5114  myCurrentFrame = myViewParent->getInspectorFrame();
5115  // set checkable button
5116  myCommonCheckableButtons.inspectButton->setChecked(true);
5117  // show view option
5118  myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5119  myDataViewOptions.menuCheckToggleTAZDrawFill->show();
5120  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5121  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5122  // show menu check
5123  menuChecks.menuCheckToggleTAZRelDrawing->show();
5124  menuChecks.menuCheckToggleTAZDrawFill->show();
5125  menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5126  menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5127  break;
5128  case DataEditMode::DATA_DELETE:
5129  myViewParent->getDeleteFrame()->show();
5130  myViewParent->getDeleteFrame()->focusUpperElement();
5131  myCurrentFrame = myViewParent->getDeleteFrame();
5132  // set checkable button
5133  myCommonCheckableButtons.deleteButton->setChecked(true);
5134  // show toggle TAZRel drawing view option
5135  myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5136  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5137  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5138  // show toggle TAZRel drawing menu check
5139  menuChecks.menuCheckToggleTAZRelDrawing->show();
5140  menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5141  menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5142  break;
5143  case DataEditMode::DATA_SELECT:
5144  myViewParent->getSelectorFrame()->show();
5145  myViewParent->getSelectorFrame()->focusUpperElement();
5146  myCurrentFrame = myViewParent->getSelectorFrame();
5147  // set checkable button
5148  myCommonCheckableButtons.selectButton->setChecked(true);
5149  // show toggle TAZRel drawing view option
5150  myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5151  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5152  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5153  // show toggle TAZRel drawing menu check
5154  menuChecks.menuCheckToggleTAZRelDrawing->show();
5155  menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5156  menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5157  break;
5158  case DataEditMode::DATA_EDGEDATA:
5159  myViewParent->getEdgeDataFrame()->show();
5160  myViewParent->getEdgeDataFrame()->focusUpperElement();
5161  myCurrentFrame = myViewParent->getEdgeDataFrame();
5162  // set checkable button
5163  myDataCheckableButtons.edgeDataButton->setChecked(true);
5164  break;
5165  case DataEditMode::DATA_EDGERELDATA:
5166  myViewParent->getEdgeRelDataFrame()->show();
5167  myViewParent->getEdgeRelDataFrame()->focusUpperElement();
5168  myCurrentFrame = myViewParent->getEdgeRelDataFrame();
5169  // set checkable button
5170  myDataCheckableButtons.edgeRelDataButton->setChecked(true);
5171  break;
5172  case DataEditMode::DATA_TAZRELDATA:
5173  myViewParent->getTAZRelDataFrame()->show();
5174  myViewParent->getTAZRelDataFrame()->focusUpperElement();
5175  myCurrentFrame = myViewParent->getTAZRelDataFrame();
5176  // set checkable button
5177  myDataCheckableButtons.TAZRelDataButton->setChecked(true);
5178  // show view option
5179  myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5180  myDataViewOptions.menuCheckToggleTAZDrawFill->show();
5181  myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5182  myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5183  // show menu check
5184  menuChecks.menuCheckToggleTAZRelDrawing->show();
5185  menuChecks.menuCheckToggleTAZDrawFill->show();
5186  menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5187  menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5188  break;
5189  case DataEditMode::DATA_MEANDATA:
5190  myViewParent->getMeanDataFrame()->show();
5191  myViewParent->getMeanDataFrame()->focusUpperElement();
5192  myCurrentFrame = myViewParent->getMeanDataFrame();
5193  // set checkable button
5194  myDataCheckableButtons.meanDataButton->setChecked(true);
5195  break;
5196  default:
5197  break;
5198  }
5199  // update menuChecks shorcuts
5200  menuChecks.updateShortcuts();
5201  // update common Network buttons
5202  myCommonCheckableButtons.updateCommonCheckableButtons();
5203  // Update Data buttons
5204  myDataCheckableButtons.updateDataCheckableButtons();
5205  // recalc toolbar
5206  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
5207  myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
5208  // force repaint because different modes draw different things
5209  onPaint(nullptr, 0, nullptr);
5210  // finally update view
5211  updateViewNet();
5212 }
5213 
5214 
5215 void
5216 GNEViewNet::deleteNetworkAttributeCarriers(const std::vector<GNEAttributeCarrier*> ACs) {
5217  // iterate over ACs and delete it
5218  for (const auto& AC : ACs) {
5219  if (AC->getTagProperty().getTag() == SUMO_TAG_JUNCTION) {
5220  // get junction (note: could be already removed if is a child, then hardfail=false)
5221  GNEJunction* junction = myNet->getAttributeCarriers()->retrieveJunction(AC->getID(), false);
5222  // if exist, remove it
5223  if (junction) {
5224  myNet->deleteJunction(junction, myUndoList);
5225  }
5226  } else if (AC->getTagProperty().getTag() == SUMO_TAG_CROSSING) {
5227  // get crossing (note: could be already removed if is a child, then hardfail=false)
5228  GNECrossing* crossing = myNet->getAttributeCarriers()->retrieveCrossing(AC->getGUIGlObject(), false);
5229  // if exist, remove it
5230  if (crossing) {
5231  myNet->deleteCrossing(crossing, myUndoList);
5232  }
5233  } else if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
5234  // get edge (note: could be already removed if is a child, then hardfail=false)
5235  GNEEdge* edge = myNet->getAttributeCarriers()->retrieveEdge(AC->getID(), false);
5236  // if exist, remove it
5237  if (edge) {
5238  myNet->deleteEdge(edge, myUndoList, false);
5239  }
5240  } else if (AC->getTagProperty().getTag() == SUMO_TAG_LANE) {
5241  // get lane (note: could be already removed if is a child, then hardfail=false)
5242  GNELane* lane = myNet->getAttributeCarriers()->retrieveLane(AC->getGUIGlObject(), false);
5243  // if exist, remove it
5244  if (lane) {
5245  myNet->deleteLane(lane, myUndoList, false);
5246  }
5247  } else if (AC->getTagProperty().getTag() == SUMO_TAG_CONNECTION) {
5248  // get connection (note: could be already removed if is a child, then hardfail=false)
5249  GNEConnection* connection = myNet->getAttributeCarriers()->retrieveConnection(AC->getGUIGlObject(), false);
5250  // if exist, remove it
5251  if (connection) {
5252  myNet->deleteConnection(connection, myUndoList);
5253  }
5254  } else if (AC->getTagProperty().isAdditionalElement()) {
5255  // get additional Element (note: could be already removed if is a child, then hardfail=false)
5256  GNEAdditional* additionalElement = myNet->getAttributeCarriers()->retrieveAdditional(AC->getGUIGlObject(), false);
5257  // if exist, remove it
5258  if (additionalElement) {
5259  myNet->deleteAdditional(additionalElement, myUndoList);
5260  }
5261  }
5262  }
5263 }
5264 
5265 
5266 void
5267 GNEViewNet::deleteDemandAttributeCarriers(const std::vector<GNEAttributeCarrier*> ACs) {
5268  // iterate over ACs and delete it
5269  for (const auto& AC : ACs) {
5270  // get demand Element (note: could be already removed if is a child, then hardfail=false)
5271  GNEDemandElement* demandElement = myNet->getAttributeCarriers()->retrieveDemandElement(AC->getGUIGlObject(), false);
5272  // if exist, remove it
5273  if (demandElement) {
5274  myNet->deleteDemandElement(demandElement, myUndoList);
5275  }
5276  }
5277 }
5278 
5279 
5280 void
5281 GNEViewNet::deleteDataAttributeCarriers(const std::vector<GNEAttributeCarrier*> ACs) {
5282  // iterate over ACs and delete it
5283  for (const auto& AC : ACs) {
5284  if (AC->getTagProperty().getTag() == SUMO_TAG_DATASET) {
5285  // get data set (note: could be already removed if is a child, then hardfail=false)
5286  GNEDataSet* dataSet = myNet->getAttributeCarriers()->retrieveDataSet(AC->getID(), false);
5287  // if exist, remove it
5288  if (dataSet) {
5289  myNet->deleteDataSet(dataSet, myUndoList);
5290  }
5291  } else if (AC->getTagProperty().getTag() == SUMO_TAG_DATAINTERVAL) {
5292  // get data interval (note: could be already removed if is a child, then hardfail=false)
5293  GNEDataInterval* dataInterval = myNet->getAttributeCarriers()->retrieveDataInterval(AC, false);
5294  // if exist, remove it
5295  if (dataInterval) {
5296  myNet->deleteDataInterval(dataInterval, myUndoList);
5297  }
5298  } else {
5299  // get generic data (note: could be already removed if is a child, then hardfail=false)
5300  GNEGenericData* genericData = myNet->getAttributeCarriers()->retrieveGenericData(AC->getGUIGlObject(), false);
5301  // if exist, remove it
5302  if (genericData) {
5303  myNet->deleteGenericData(genericData, myUndoList);
5304  }
5305  }
5306  }
5307 }
5308 
5309 
5310 void
5311 GNEViewNet::updateControls() {
5312  if (myEditModes.isCurrentSupermodeNetwork()) {
5313  switch (myEditModes.networkEditMode) {
5314  case NetworkEditMode::NETWORK_INSPECT:
5315  myViewParent->getInspectorFrame()->update();
5316  break;
5317  default:
5318  break;
5319  }
5320  }
5321  if (myEditModes.isCurrentSupermodeDemand()) {
5322  switch (myEditModes.demandEditMode) {
5323  case DemandEditMode::DEMAND_INSPECT:
5324  myViewParent->getInspectorFrame()->update();
5325  break;
5326  case DemandEditMode::DEMAND_VEHICLE:
5327  myViewParent->getVehicleFrame()->show();
5328  break;
5329  case DemandEditMode::DEMAND_TYPE:
5330  myViewParent->getTypeFrame()->show();
5331  break;
5332  case DemandEditMode::DEMAND_TYPEDISTRIBUTION:
5333  myViewParent->getTypeDistributionFrame()->getDistributionSelector()->refreshDistributionSelector();
5334  break;
5335  case DemandEditMode::DEMAND_ROUTEDISTRIBUTION:
5336  myViewParent->getRouteDistributionFrame()->getDistributionSelector()->refreshDistributionSelector();
5337  break;
5338  case DemandEditMode::DEMAND_PERSON:
5339  myViewParent->getPersonFrame()->show();
5340  break;
5341  case DemandEditMode::DEMAND_PERSONPLAN:
5342  myViewParent->getPersonPlanFrame()->show();
5343  break;
5344  case DemandEditMode::DEMAND_CONTAINER:
5345  myViewParent->getContainerFrame()->show();
5346  break;
5347  case DemandEditMode::DEMAND_CONTAINERPLAN:
5348  myViewParent->getContainerPlanFrame()->show();
5349  break;
5350  case DemandEditMode::DEMAND_STOP:
5351  myViewParent->getStopFrame()->show();
5352  break;
5353  default:
5354  break;
5355  }
5356  }
5357  if (myEditModes.isCurrentSupermodeData()) {
5358  switch (myEditModes.dataEditMode) {
5359  case DataEditMode::DATA_INSPECT:
5360  myViewParent->getInspectorFrame()->update();
5361  break;
5362  default:
5363  break;
5364  }
5365  // update data interval
5366  myIntervalBar.markForUpdate();
5367  }
5368  // update view
5369  updateViewNet();
5370 }
5371 
5372 // ---------------------------------------------------------------------------
5373 // Private methods
5374 // ---------------------------------------------------------------------------
5375 
5376 void
5377 GNEViewNet::drawTemporalDrawingShape() const {
5378  PositionVector temporalShape;
5379  bool deleteLastCreatedPoint = false;
5380  // obtain temporal shape and delete last created point flag
5381  if (myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
5382  temporalShape = myViewParent->getShapeFrame()->getDrawingShapeModule()->getTemporalShape();
5383  deleteLastCreatedPoint = myViewParent->getShapeFrame()->getDrawingShapeModule()->getDeleteLastCreatedPoint();
5384  } else if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
5385  temporalShape = myViewParent->getTAZFrame()->getDrawingShapeModule()->getTemporalShape();
5386  deleteLastCreatedPoint = myViewParent->getTAZFrame()->getDrawingShapeModule()->getDeleteLastCreatedPoint();
5387  }
5388  // check if we're in drawing mode
5389  if (temporalShape.size() > 0) {
5390  // draw blue line with the current drawed shape
5391  GLHelper::pushMatrix();
5392  glLineWidth(2);
5393  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5394  GLHelper::setColor(RGBColor::BLUE);
5395  GLHelper::drawLine(temporalShape);
5396  GLHelper::popMatrix();
5397  // draw red line from the last point of shape to the current mouse position
5398  GLHelper::pushMatrix();
5399  glLineWidth(2);
5400  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5401  // draw last line depending if shift key (delete last created point) is pressed
5402  if (deleteLastCreatedPoint) {
5403  GLHelper::setColor(RGBColor::RED);
5404  } else {
5405  GLHelper::setColor(RGBColor::GREEN);
5406  }
5407  GLHelper::drawLine(temporalShape.back(), snapToActiveGrid(getPositionInformation()));
5408  GLHelper::popMatrix();
5409  }
5410 }
5411 
5412 
5413 void
5414 GNEViewNet::drawTemporalJunction() const {
5415  // first check if we're in correct mode
5416  if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) &&
5417  !myMouseButtonKeyPressed.controlKeyPressed() &&
5418  !myMouseButtonKeyPressed.shiftKeyPressed() &&
5419  !myMouseButtonKeyPressed.altKeyPressed()) {
5420  // get mouse position
5421  const Position mousePosition = snapToActiveGrid(getPositionInformation());
5422  // get junction exaggeration
5423  const double junctionExaggeration = myVisualizationSettings->junctionSize.getExaggeration(*myVisualizationSettings, nullptr, 4);
5424  // get bubble color
5425  RGBColor bubbleColor = myVisualizationSettings->junctionColorer.getScheme().getColor(1);
5426  // change alpha
5427  bubbleColor.setAlpha(200);
5428  // push layer matrix
5429  GLHelper::pushMatrix();
5430  // translate to temporal shape layer
5431  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5432  // push junction matrix
5433  GLHelper::pushMatrix();
5434  // move matrix junction center
5435  glTranslated(mousePosition.x(), mousePosition.y(), 0.1);
5436  // set color
5437  GLHelper::setColor(bubbleColor);
5438  // draw outline circle
5439  const double circleWidth = myVisualizationSettings->neteditSizeSettings.junctionBubbleRadius * junctionExaggeration;
5440  GLHelper::drawOutlineCircle(circleWidth, circleWidth * 0.75, 32);
5441  // pop junction matrix
5442  GLHelper::popMatrix();
5443  // draw temporal edge
5444  if (myViewParent->getCreateEdgeFrame()->getJunctionSource() && (mousePosition.distanceSquaredTo(myViewParent->getCreateEdgeFrame()->getJunctionSource()->getPositionInView()) > 1)) {
5445  // set temporal edge color
5446  RGBColor temporalEdgeColor = RGBColor::BLACK;
5447  temporalEdgeColor.setAlpha(200);
5448  // declare temporal edge geometry
5449  GUIGeometry temporalEdgeGeometry;
5450  // calculate geometry between source junction and mouse position
5451  PositionVector temporalEdge = {mousePosition, myViewParent->getCreateEdgeFrame()->getJunctionSource()->getPositionInView()};
5452  // move temporal edge 2 side
5453  temporalEdge.move2side(-1);
5454  // update geometry
5455  temporalEdgeGeometry.updateGeometry(temporalEdge);
5456  // push temporal edge matrix
5457  GLHelper::pushMatrix();
5458  // set color
5459  GLHelper::setColor(temporalEdgeColor);
5460  // draw temporal edge
5461  GUIGeometry::drawGeometry(GUIVisualizationSettings::Detail::Level0, temporalEdgeGeometry, 0.75);
5462  // check if we have to draw opposite edge
5463  if (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE) {
5464  // move temporal edge to opposite edge
5465  temporalEdge.move2side(2);
5466  // update geometry
5467  temporalEdgeGeometry.updateGeometry(temporalEdge);
5468  // draw temporal edge
5469  GUIGeometry::drawGeometry(GUIVisualizationSettings::Detail::Level0, temporalEdgeGeometry, 0.75);
5470  }
5471  // pop temporal edge matrix
5472  GLHelper::popMatrix();
5473  }
5474  // pop layer matrix
5475  GLHelper::popMatrix();
5476  }
5477 }
5478 
5479 
5480 void
5481 GNEViewNet::drawTemporalSplitJunction() const {
5482  // first check if we're in correct mode
5483  if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) &&
5484  !myMouseButtonKeyPressed.controlKeyPressed() &&
5485  myMouseButtonKeyPressed.shiftKeyPressed() &&
5486  !myMouseButtonKeyPressed.altKeyPressed() &&
5487  (gViewObjectsHandler.markedEdge != nullptr)) {
5488  // calculate split position
5489  const auto lane = gViewObjectsHandler.markedEdge->getLanes().back();
5490  auto shape = lane->getLaneShape();
5491  // move shape to side
5492  shape.move2side(lane->getDrawingConstants()->getDrawingWidth() * -1);
5493  const auto offset = shape.nearest_offset_to_point2D(snapToActiveGrid(getPositionInformation()));
5494  const auto splitPosition = shape.positionAtOffset2D(offset);
5495  // get junction exaggeration
5496  const double junctionExaggeration = myVisualizationSettings->junctionSize.getExaggeration(*myVisualizationSettings, nullptr, 4);
5497  // get bubble color
5498  RGBColor bubbleColor = myVisualizationSettings->junctionColorer.getScheme().getColor(1);
5499  // push layer matrix
5500  GLHelper::pushMatrix();
5501  // translate to temporal shape layer
5502  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5503  // push junction matrix
5504  GLHelper::pushMatrix();
5505  // move matrix junction center
5506  glTranslated(splitPosition.x(), splitPosition.y(), 0.1);
5507  // set color
5508  GLHelper::setColor(bubbleColor);
5509  // draw outline circle
5510  const double circleWidth = myVisualizationSettings->neteditSizeSettings.junctionBubbleRadius * junctionExaggeration;
5511  GLHelper::drawOutlineCircle(circleWidth, circleWidth * 0.75, 32);
5512  // draw filled circle
5513  GLHelper::drawFilledCircle(0.5, 32);
5514  // pop junction matrix
5515  GLHelper::popMatrix();
5516  // pop layer matrix
5517  GLHelper::popMatrix();
5518  }
5519 }
5520 
5521 
5522 void
5523 GNEViewNet::drawTemporalRoundabout() const {
5524  // check conditions
5525  if ((myCurrentObjectsDialog.size() > 0) && (myCurrentObjectsDialog.front()->getType() == GLO_JUNCTION) && myDrawPreviewRoundabout) {
5526  // get junction
5527  const auto junction = myNet->getAttributeCarriers()->retrieveJunction(myCurrentObjectsDialog.front()->getMicrosimID());
5528  // push layer matrix
5529  GLHelper::pushMatrix();
5530  // translate to temporal shape layer
5531  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5532  // push junction matrix
5533  GLHelper::pushMatrix();
5534  // move matrix junction center
5535  glTranslated(junction->getNBNode()->getPosition().x(), junction->getNBNode()->getPosition().y(), 0.1);
5536  // set color
5537  GLHelper::setColor(RGBColor::GREEN);
5538  // draw outline circle
5539  const double circleWidth = (junction->getNBNode()->getRadius() < 0) ? 4.0 : junction->getNBNode()->getRadius();
5540  GLHelper::drawOutlineCircle(circleWidth * 1.30, circleWidth, 32);
5541  // pop junction matrix
5542  GLHelper::popMatrix();
5543  // pop layer matrix
5544  GLHelper::popMatrix();
5545  }
5546 }
5547 
5548 
5549 void
5550 GNEViewNet::drawTemporalE1TLSLines() const {
5551  // check conditions
5552  if (selectingDetectorsTLSMode() && (myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction() != nullptr)) {
5553  // get junction
5554  const auto junctionPos = myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction()->getNBNode()->getPosition();
5555  // push layer matrix
5556  GLHelper::pushMatrix();
5557  // translate to TLLogic
5558  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5559  // iterate over all E1 detectors
5560  for (const auto& E1ID : myViewParent->getTLSEditorFrame()->getTLSAttributes()->getE1Detectors()) {
5561  // first check if E1 exists
5562  const auto E1 = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_INDUCTION_LOOP, E1ID.second, false);
5563  if (E1) {
5564  // push line matrix
5565  GLHelper::pushMatrix();
5566  // draw line between junction and E1
5567  GUIGeometry::drawChildLine(*myVisualizationSettings, junctionPos, E1->getPositionInView(),
5568  myVisualizationSettings->additionalSettings.TLSConnectionColor, true, 0.25);
5569  // pop line matrix
5570  GLHelper::popMatrix();
5571  }
5572  }
5573  // pop layer matrix
5574  GLHelper::popMatrix();
5575  }
5576 }
5577 
5578 
5579 void
5580 GNEViewNet::drawTemporalJunctionTLSLines() const {
5581  // check conditions
5582  if (selectingJunctionsTLSMode() && (myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction() != nullptr)) {
5583  // get junction
5584  const auto junctionPos = myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction()->getNBNode()->getPosition();
5585  // push layer matrix
5586  GLHelper::pushMatrix();
5587  // translate to TLLogic
5588  glTranslated(0, 0, GLO_TEMPORALSHAPE);
5589  // iterate over all Junction detectors
5590  for (const auto& selectedJunctionID : myViewParent->getTLSEditorFrame()->getTLSJunction()->getSelectedJunctionIDs()) {
5591  // get junction
5592  const auto selectedJunction = myNet->getAttributeCarriers()->retrieveJunction(selectedJunctionID);
5593  // push line matrix
5594  GLHelper::pushMatrix();
5595  // draw line between junction and Junction
5596  GUIGeometry::drawChildLine(*myVisualizationSettings, junctionPos, selectedJunction->getPositionInView(),
5597  myVisualizationSettings->additionalSettings.TLSConnectionColor, true, 0.25);
5598  // pop line matrix
5599  GLHelper::popMatrix();
5600  }
5601  // pop layer matrix
5602  GLHelper::popMatrix();
5603  }
5604 }
5605 
5606 
5607 void
5608 GNEViewNet::drawNeteditAttributesReferences() {
5609  if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL)) {
5610  myViewParent->getAdditionalFrame()->getNeteditAttributes()->drawLaneReference(gViewObjectsHandler.markedLane);
5611  }
5612 }
5613 
5614 
5615 void
5616 GNEViewNet::drawTestsCircle() const {
5617  if (myVisualizationSettings->showGrid && OptionsCont::getOptions().getBool("gui-testing")) {
5618  // get mouse position
5619  const Position mousePosition = snapToActiveGrid(getPositionInformation());
5620  // push layer matrix
5621  GLHelper::pushMatrix();
5622  // translate to test layer, but under magenta square
5623  glTranslated(mousePosition.x(), mousePosition.y(), GLO_TESTELEMENT - 1);
5624  // set color
5625  GLHelper::setColor(RGBColor::ORANGE);
5626  // draw circle
5627  GLHelper::drawFilledCircle(1, 8);
5628  // pop layer matrix
5629  GLHelper::popMatrix();
5630  }
5631 }
5632 
5633 
5634 void
5635 GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
5636  // reset moving selected edge
5637  myMoveMultipleElements.resetMovingSelectedEdge();
5638  // decide what to do based on mode
5639  switch (myEditModes.networkEditMode) {
5640  case NetworkEditMode::NETWORK_INSPECT: {
5641  // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5642  if (checkSelectEdges()) {
5643  myViewObjectsSelector.filterLanes();
5644  } else {
5645  myViewObjectsSelector.filterEdges();
5646  }
5647  // now filter locked elements
5648  myViewObjectsSelector.filterLockedElements();
5649  // check if we're selecting a new parent for the current inspected element
5650  if (myViewParent->getInspectorFrame()->getNeteditAttributesEditor()->isSelectingParent()) {
5651  myViewParent->getInspectorFrame()->getNeteditAttributesEditor()->setNewParent(myViewObjectsSelector.getAttributeCarrierFront());
5652  } else {
5653  // process left click in Inspector Frame
5654  myViewParent->getInspectorFrame()->processNetworkSupermodeClick(getPositionInformation(), myViewObjectsSelector);
5655  }
5656  // process click
5657  processClick(eventData);
5658  break;
5659  }
5660  case NetworkEditMode::NETWORK_DELETE: {
5661  // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5662  if (checkSelectEdges()) {
5663  myViewObjectsSelector.filterLanes();
5664  } else {
5665  myViewObjectsSelector.filterEdges();
5666  }
5667  // now filter locked elements forcing excluding walkingAreas
5668  myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
5669  // continue depending of AC
5670  if (myViewObjectsSelector.getAttributeCarrierFront()) {
5671  // now check if we want only delete geometry points
5672  if (myViewParent->getDeleteFrame()->getDeleteOptions()->deleteOnlyGeometryPoints()) {
5673  // only remove geometry point
5674  myViewParent->getDeleteFrame()->removeGeometryPoint(myViewObjectsSelector);
5675  } else if (myViewObjectsSelector.getAttributeCarrierFront()->isAttributeCarrierSelected()) {
5676  // remove all selected attribute carriers
5677  if (!myViewObjectsSelector.getAttributeCarrierFront()->getGUIGlObject()->isGLObjectLocked()) {
5678  myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
5679  }
5680  } else {
5681  // remove attribute carrier under cursor
5682  myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
5683  }
5684  } else {
5685  // process click
5686  processClick(eventData);
5687  }
5688  break;
5689  }
5690  case NetworkEditMode::NETWORK_SELECT:
5691  // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5692  if (checkSelectEdges()) {
5693  myViewObjectsSelector.filterLanes();
5694  } else {
5695  myViewObjectsSelector.filterEdges();
5696  }
5697  // now filter locked elements
5698  myViewObjectsSelector.filterLockedElements();
5699  // avoid to select if control key is pressed
5700  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5701  // check if a rect for selecting is being created
5702  if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5703  // begin rectangle selection
5704  mySelectingArea.beginRectangleSelection();
5705  } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
5706  // process click
5707  processClick(eventData);
5708  }
5709  } else {
5710  // process click
5711  processClick(eventData);
5712  }
5713  break;
5714  case NetworkEditMode::NETWORK_CREATE_EDGE: {
5715  // check what buttons are pressed
5716  if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5717  // get edge under cursor
5718  GNEEdge* edge = myViewObjectsSelector.getEdgeFront();
5719  if (edge) {
5720  // obtain reverse edge
5721  const auto oppositeEdges = edge->getOppositeEdges();
5722  // check if we're split one or both edges
5723  if (myMouseButtonKeyPressed.altKeyPressed()) {
5724  myNet->splitEdge(edge, edge->getSplitPos(getPositionInformation()), myUndoList);
5725  } else if (oppositeEdges.size() > 0) {
5726  myNet->splitEdgesBidi(edge, oppositeEdges.front(), edge->getSplitPos(getPositionInformation()), myUndoList);
5727  } else {
5728  myNet->splitEdge(edge, edge->getSplitPos(getPositionInformation()), myUndoList);
5729  }
5730  }
5731  } else if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5732  // process left click in create edge frame Frame
5733  myViewParent->getCreateEdgeFrame()->processClick(getPositionInformation(),
5734  myViewObjectsSelector,
5735  (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE),
5736  (myNetworkViewOptions.menuCheckChainEdges->amChecked() == TRUE));
5737  }
5738  // process click
5739  processClick(eventData);
5740  break;
5741  }
5742  case NetworkEditMode::NETWORK_MOVE: {
5743  // editing lane shapes in move mode isn't finished, then always filter lanes
5744  myViewObjectsSelector.filterLanes();
5745  // filter locked elements
5746  myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
5747  // check if we're editing a shape
5748  if (myEditNetworkElementShapes.getEditedNetworkElement()) {
5749  // check if we're removing a geometry point
5750  if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5751  // remove geometry point
5752  if (myViewObjectsSelector.getNetworkElementFront() == myEditNetworkElementShapes.getEditedNetworkElement()) {
5753  myViewObjectsSelector.getNetworkElementFront()->removeGeometryPoint(getPositionInformation(), myUndoList);
5754  }
5755  } else if (!myMoveSingleElement.beginMoveNetworkElementShape()) {
5756  // process click if there isn't movable elements (to move camera using drag an drop)
5757  processClick(eventData);
5758  }
5759  } else {
5760  // get AC under cursor
5761  auto AC = myViewObjectsSelector.getAttributeCarrierFront();
5762  // check that AC is an network or additional element
5763  if (AC && (AC->getTagProperty().isNetworkElement() || AC->getTagProperty().isAdditionalElement())) {
5764  // check if we're moving a set of selected items
5765  if (AC->isAttributeCarrierSelected()) {
5766  // move selected ACs
5767  myMoveMultipleElements.beginMoveSelection();
5768  // update view
5769  updateViewNet();
5770  } else if (!myMoveSingleElement.beginMoveSingleElementNetworkMode()) {
5771  // process click if there isn't movable elements (to move camera using drag an drop)
5772  processClick(eventData);
5773  }
5774  } else {
5775  // process click if there isn't movable elements (to move camera using drag an drop)
5776  processClick(eventData);
5777  }
5778  }
5779  break;
5780  }
5781  case NetworkEditMode::NETWORK_CONNECT: {
5782  // check if we're clicked over a non locked lane
5783  if (myViewObjectsSelector.getLaneFrontNonLocked()) {
5784  // Handle laneclick (shift key may pass connections, Control key allow conflicts)
5785  myViewParent->getConnectorFrame()->handleLaneClick(myViewObjectsSelector);
5786  updateViewNet();
5787  }
5788  // process click
5789  processClick(eventData);
5790  break;
5791  }
5792  case NetworkEditMode::NETWORK_TLS: {
5793  if (myViewObjectsSelector.getJunctionFront() || myViewObjectsSelector.getAdditionalFront()) {
5794  // edit TLS in TLSEditor frame
5795  myViewParent->getTLSEditorFrame()->editTLS(getPositionInformation(), myViewObjectsSelector);
5796  updateViewNet();
5797  }
5798  // process click
5799  processClick(eventData);
5800  break;
5801  }
5802  case NetworkEditMode::NETWORK_ADDITIONAL: {
5803  // avoid create additionals if control key is pressed
5804  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5805  if ((getPositionInformation() == myLastClickedPosition) && !myMouseButtonKeyPressed.shiftKeyPressed()) {
5806  WRITE_WARNING(TL("Shift + click to create two additionals in the same position"));
5807  } else if (myViewParent->getAdditionalFrame()->addAdditional(myViewObjectsSelector)) {
5808  // save last mouse position
5809  myLastClickedPosition = getPositionInformation();
5810  // update view to show the new additional
5811  updateViewNet();
5812  }
5813  }
5814  // process click
5815  processClick(eventData);
5816  break;
5817  }
5818  case NetworkEditMode::NETWORK_CROSSING: {
5819  // call function addCrossing from crossing frame
5820  myViewParent->getCrossingFrame()->addCrossing(myViewObjectsSelector);
5821  // process click
5822  processClick(eventData);
5823  break;
5824  }
5825  case NetworkEditMode::NETWORK_TAZ: {
5826  // avoid create TAZs if control key is pressed
5827  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5828  // check if we want to create a rect for selecting edges
5829  if (myMouseButtonKeyPressed.shiftKeyPressed() && (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() != nullptr)) {
5830  // begin rectangle selection
5831  mySelectingArea.beginRectangleSelection();
5832  } else {
5833  // check if process click was successfully
5834  if (myViewParent->getTAZFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector)) {
5835  // view net must be always update
5836  updateViewNet();
5837  }
5838  // process click
5839  processClick(eventData);
5840  }
5841  } else {
5842  // process click
5843  processClick(eventData);
5844  }
5845  break;
5846  }
5847  case NetworkEditMode::NETWORK_SHAPE: {
5848  // avoid create shapes if control key is pressed
5849  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5850  if (!myViewObjectsSelector.getPOIFront()) {
5851  // declare processClick flag
5852  bool updateTemporalShape = false;
5853  // process click
5854  myViewParent->getShapeFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector, updateTemporalShape);
5855  // view net must be always update
5856  updateViewNet();
5857  // process click depending of the result of "process click"
5858  if (!updateTemporalShape) {
5859  // process click
5860  processClick(eventData);
5861  }
5862  }
5863  } else {
5864  // process click
5865  processClick(eventData);
5866  }
5867  break;
5868  }
5869  case NetworkEditMode::NETWORK_PROHIBITION: {
5870  if (myViewObjectsSelector.getConnectionFront()) {
5871  // shift key may pass connections, Control key allow conflicts.
5872  myViewParent->getProhibitionFrame()->handleProhibitionClick(myViewObjectsSelector);
5873  updateViewNet();
5874  }
5875  // process click
5876  processClick(eventData);
5877  break;
5878  }
5879  case NetworkEditMode::NETWORK_WIRE: {
5880  // avoid create wires if control key is pressed
5881  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5882  myViewParent->getWireFrame()->addWire(myViewObjectsSelector);
5883  // update view to show the new wire
5884  updateViewNet();
5885  }
5886  // process click
5887  processClick(eventData);
5888  break;
5889  }
5890  case NetworkEditMode::NETWORK_DECAL: {
5891  // process click
5892  processClick(eventData);
5893  break;
5894  }
5895  default: {
5896  // process click
5897  processClick(eventData);
5898  }
5899  }
5900 }
5901 
5902 
5903 void
5904 GNEViewNet::processLeftButtonReleaseNetwork() {
5905  // check moved items
5906  if (myMoveMultipleElements.isMovingSelection()) {
5907  myMoveMultipleElements.finishMoveSelection();
5908  } else if (mySelectingArea.selectingUsingRectangle) {
5909  // check if we're creating a rectangle selection or we want only to select a lane
5910  if (mySelectingArea.startDrawing) {
5911  // check if we're selecting all type of elements o we only want a set of edges for TAZ
5912  if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
5913  mySelectingArea.processRectangleSelection();
5914  } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
5915  // process edge selection
5916  myViewParent->getTAZFrame()->processEdgeSelection(mySelectingArea.processEdgeRectangleSelection());
5917  }
5918  } else if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5919  // check if there is a lane in objects under cursor
5920  if (myViewObjectsSelector.getLaneFront()) {
5921  // if we clicked over an lane with shift key pressed, select or unselect it
5922  if (myViewObjectsSelector.getLaneFront()->isAttributeCarrierSelected()) {
5923  myViewObjectsSelector.getLaneFront()->unselectAttributeCarrier();
5924  } else {
5925  myViewObjectsSelector.getLaneFront()->selectAttributeCarrier();
5926  }
5927  }
5928  }
5929  // finish selection
5930  mySelectingArea.finishRectangleSelection();
5931  } else {
5932  // finish moving of single elements
5933  myMoveSingleElement.finishMoveSingleElement();
5934  }
5935 }
5936 
5937 
5938 void
5939 GNEViewNet::processMoveMouseNetwork(const bool mouseLeftButtonPressed) {
5940  // change "delete last created point" depending if during movement shift key is pressed
5941  if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
5942  myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
5943  } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
5944  myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
5945  }
5946  // check what type of additional is moved
5947  if (myMoveMultipleElements.isMovingSelection()) {
5948  // move entire selection
5949  myMoveMultipleElements.moveSelection(mouseLeftButtonPressed);
5950  } else if (mySelectingArea.selectingUsingRectangle) {
5951  // update selection corner of selecting area
5952  mySelectingArea.moveRectangleSelection();
5953  } else {
5954  // move single elements
5955  myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
5956  }
5957 }
5958 
5959 
5960 void
5961 GNEViewNet::processLeftButtonPressDemand(void* eventData) {
5962  // filter shapes (because POIs and polygons doesn't interact in demand mode)
5963  myViewObjectsSelector.filterShapes();
5964  // decide what to do based on mode
5965  switch (myEditModes.demandEditMode) {
5966  case DemandEditMode::DEMAND_INSPECT: {
5967  // filter locked elements
5968  myViewObjectsSelector.filterLockedElements();
5969  // process left click in Inspector Frame
5970  myViewParent->getInspectorFrame()->processDemandSupermodeClick(getPositionInformation(), myViewObjectsSelector);
5971  // process click
5972  processClick(eventData);
5973  break;
5974  }
5975  case DemandEditMode::DEMAND_DELETE: {
5976  // filter locked elements
5977  myViewObjectsSelector.filterLockedElements();
5978  // get front AC
5979  const auto frontAC = myViewObjectsSelector.getAttributeCarrierFront();
5980  // check conditions
5981  if (frontAC) {
5982  // check if we are deleting a selection or an single attribute carrier
5983  if (frontAC->isAttributeCarrierSelected()) {
5984  myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
5985  } else {
5986  myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
5987  }
5988  } else {
5989  // process click
5990  processClick(eventData);
5991  }
5992  break;
5993  }
5994  case DemandEditMode::DEMAND_SELECT:
5995  // filter locked elements
5996  myViewObjectsSelector.filterLockedElements();
5997  // avoid to select if control key is pressed
5998  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5999  // check if a rect for selecting is being created
6000  if (myMouseButtonKeyPressed.shiftKeyPressed()) {
6001  // begin rectangle selection
6002  mySelectingArea.beginRectangleSelection();
6003  } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
6004  // process click
6005  processClick(eventData);
6006  }
6007  } else {
6008  // process click
6009  processClick(eventData);
6010  }
6011  break;
6012  case DemandEditMode::DEMAND_MOVE: {
6013  // filter locked elements
6014  myViewObjectsSelector.filterLockedElements();
6015  // get front AC
6016  const auto frontAC = myViewObjectsSelector.getAttributeCarrierFront();
6017  // check that AC under cursor is a demand element
6018  if (frontAC) {
6019  // check if we're moving a set of selected items
6020  if (frontAC->isAttributeCarrierSelected()) {
6021  // move selected ACs
6022  myMoveMultipleElements.beginMoveSelection();
6023  // update view
6024  updateViewNet();
6025  } else if (!myMoveSingleElement.beginMoveSingleElementDemandMode()) {
6026  // process click if there isn't movable elements (to move camera using drag an drop)
6027  processClick(eventData);
6028  }
6029  } else {
6030  // process click if there isn't movable elements (to move camera using drag an drop)
6031  processClick(eventData);
6032  }
6033  break;
6034  }
6035  case DemandEditMode::DEMAND_ROUTE: {
6036  // check if we clicked over a lane
6037  if (myViewObjectsSelector.getLaneFront()) {
6038  // Handle edge click
6039  myViewParent->getRouteFrame()->addEdgeRoute(myViewObjectsSelector.getLaneFront()->getParentEdge(), myMouseButtonKeyPressed);
6040  }
6041  // process click
6042  processClick(eventData);
6043  break;
6044  }
6045  case DemandEditMode::DEMAND_VEHICLE: {
6046  // filter additionals (except TAZs) and demands (except routes)
6047  myViewObjectsSelector.filterAdditionals(true, false);
6048  myViewObjectsSelector.filterDemandElements(false);
6049  // Handle click
6050  myViewParent->getVehicleFrame()->addVehicle(myViewObjectsSelector, myMouseButtonKeyPressed);
6051  // process click
6052  processClick(eventData);
6053  break;
6054  }
6055  case DemandEditMode::DEMAND_STOP: {
6056  // filter additionals (except stoppingPlaces) and demands
6057  myViewObjectsSelector.filterAdditionals(false, true);
6058  myViewObjectsSelector.filterDemandElements(true);
6059  // Handle click
6060  if ((getPositionInformation() == myLastClickedPosition) && !myMouseButtonKeyPressed.controlKeyPressed()) {
6061  WRITE_WARNING(TL("Control + click to create two stop in the same position"));
6062  } else if (myViewParent->getStopFrame()->addStop(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6063  // save last mouse position
6064  myLastClickedPosition = getPositionInformation();
6065  // update view to show the new additional
6066  updateViewNet();
6067  }
6068  // process click
6069  processClick(eventData);
6070  break;
6071  }
6072  case DemandEditMode::DEMAND_PERSON: {
6073  // filter additionals (except stoppingPlaces and TAZs)
6074  myViewObjectsSelector.filterAdditionals(false, false);
6075  // special case if we're creating person over walk routes
6076  if (myViewParent->getPersonFrame()->getPlanSelector()->getCurrentPlanTagProperties().planRoute()) {
6077  myViewObjectsSelector.filterDemandElements(false);
6078  } else {
6079  myViewObjectsSelector.filterDemandElements(true);
6080  }
6081  // Handle click
6082  myViewParent->getPersonFrame()->addPerson(myViewObjectsSelector);
6083  // process click
6084  processClick(eventData);
6085  break;
6086  }
6087  case DemandEditMode::DEMAND_PERSONPLAN: {
6088  // filter additionals (except stoppingPlaces and TAZs)
6089  myViewObjectsSelector.filterAdditionals(false, false);
6090  // special case if we're creating person over walk routes
6091  if (myViewParent->getPersonPlanFrame()->getPlanSelector()->getCurrentPlanTagProperties().planRoute()) {
6092  myViewObjectsSelector.filterDemandElements(false);
6093  } else {
6094  myViewObjectsSelector.filterDemandElements(true);
6095  }
6096  // Handle person plan click
6097  myViewParent->getPersonPlanFrame()->addPersonPlanElement(myViewObjectsSelector);
6098  // process click
6099  processClick(eventData);
6100  break;
6101  }
6102  case DemandEditMode::DEMAND_CONTAINER: {
6103  // filter additionals (except stoppingPlaces and TAZs) and demands
6104  myViewObjectsSelector.filterAdditionals(false, false);
6105  myViewObjectsSelector.filterDemandElements(true);
6106  // Handle click
6107  myViewParent->getContainerFrame()->addContainer(myViewObjectsSelector);
6108  // process click
6109  processClick(eventData);
6110  break;
6111  }
6112  case DemandEditMode::DEMAND_CONTAINERPLAN: {
6113  // filter additionals (except stoppingPlaces and TAZs) and demands
6114  myViewObjectsSelector.filterAdditionals(false, false);
6115  myViewObjectsSelector.filterDemandElements(true);
6116  // Handle container plan click
6117  myViewParent->getContainerPlanFrame()->addContainerPlanElement(myViewObjectsSelector);
6118  // process click
6119  processClick(eventData);
6120  break;
6121  }
6122  default: {
6123  // process click
6124  processClick(eventData);
6125  }
6126  }
6127 }
6128 
6129 
6130 void
6131 GNEViewNet::processLeftButtonReleaseDemand() {
6132  // check moved items
6133  if (myMoveMultipleElements.isMovingSelection()) {
6134  myMoveMultipleElements.finishMoveSelection();
6135  } else if (mySelectingArea.selectingUsingRectangle) {
6136  // check if we're creating a rectangle selection or we want only to select a lane
6137  if (mySelectingArea.startDrawing) {
6138  mySelectingArea.processRectangleSelection();
6139  }
6140  // finish selection
6141  mySelectingArea.finishRectangleSelection();
6142  } else {
6143  // finish moving of single elements
6144  myMoveSingleElement.finishMoveSingleElement();
6145  }
6146 }
6147 
6148 
6149 void
6150 GNEViewNet::processMoveMouseDemand(const bool mouseLeftButtonPressed) {
6151  if (mySelectingArea.selectingUsingRectangle) {
6152  // update selection corner of selecting area
6153  mySelectingArea.moveRectangleSelection();
6154  } else {
6155  // move single elements
6156  myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
6157  }
6158 }
6159 
6160 
6161 void
6162 GNEViewNet::processLeftButtonPressData(void* eventData) {
6163  // get AC
6164  const auto AC = myViewObjectsSelector.getAttributeCarrierFront();
6165  // decide what to do based on mode
6166  switch (myEditModes.dataEditMode) {
6167  case DataEditMode::DATA_INSPECT: {
6168  // filter locked elements
6169  myViewObjectsSelector.filterLockedElements();
6170  // process left click in Inspector Frame
6171  if (AC && AC->getTagProperty().getTag() == SUMO_TAG_TAZ) {
6172  myViewParent->getInspectorFrame()->inspectSingleElement(AC);
6173  } else {
6174  myViewParent->getInspectorFrame()->processDataSupermodeClick(getPositionInformation(), myViewObjectsSelector);
6175  }
6176  // process click
6177  processClick(eventData);
6178  break;
6179  }
6180  case DataEditMode::DATA_DELETE: {
6181  // check conditions
6182  if (AC) {
6183  // check if we are deleting a selection or an single attribute carrier
6184  if (AC->isAttributeCarrierSelected()) {
6185  if (!AC->getGUIGlObject()->isGLObjectLocked()) {
6186  myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
6187  }
6188  } else {
6189  myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
6190  }
6191  } else {
6192  // process click
6193  processClick(eventData);
6194  }
6195  break;
6196  }
6197  case DataEditMode::DATA_SELECT:
6198  // filter locked elements
6199  myViewObjectsSelector.filterLockedElements();
6200  // avoid to select if control key is pressed
6201  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6202  // check if a rect for selecting is being created
6203  if (myMouseButtonKeyPressed.shiftKeyPressed()) {
6204  // begin rectangle selection
6205  mySelectingArea.beginRectangleSelection();
6206  } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
6207  // process click
6208  processClick(eventData);
6209  }
6210  } else {
6211  // process click
6212  processClick(eventData);
6213  }
6214  break;
6215  case DataEditMode::DATA_EDGEDATA:
6216  // avoid create edgeData if control key is pressed
6217  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6218  if (myViewParent->getEdgeDataFrame()->addEdgeData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6219  // update view to show the new edge data
6220  updateViewNet();
6221  }
6222  }
6223  // process click
6224  processClick(eventData);
6225  break;
6226  case DataEditMode::DATA_EDGERELDATA:
6227  // avoid create edgeData if control key is pressed
6228  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6229  if (myViewParent->getEdgeRelDataFrame()->addEdgeRelationData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6230  // update view to show the new edge data
6231  updateViewNet();
6232  }
6233  }
6234  // process click
6235  processClick(eventData);
6236  break;
6237  case DataEditMode::DATA_TAZRELDATA:
6238  // avoid create TAZData if control key is pressed
6239  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6240  if (myViewParent->getTAZRelDataFrame()->setTAZ(myViewObjectsSelector)) {
6241  // update view to show the new TAZ data
6242  updateViewNet();
6243  }
6244  }
6245  // process click
6246  processClick(eventData);
6247  break;
6248  case DataEditMode::DATA_MEANDATA:
6249  // avoid create TAZData if control key is pressed
6250  if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6251  //
6252  }
6253  // process click
6254  processClick(eventData);
6255  break;
6256  default: {
6257  // process click
6258  processClick(eventData);
6259  }
6260  }
6261 }
6262 
6263 
6264 void
6265 GNEViewNet::processLeftButtonReleaseData() {
6266  // check moved items
6267  if (myMoveMultipleElements.isMovingSelection()) {
6268  myMoveMultipleElements.finishMoveSelection();
6269  } else if (mySelectingArea.selectingUsingRectangle) {
6270  // check if we're creating a rectangle selection or we want only to select a lane
6271  if (mySelectingArea.startDrawing) {
6272  mySelectingArea.processRectangleSelection();
6273  }
6274  // finish selection
6275  mySelectingArea.finishRectangleSelection();
6276  } else {
6277  // finish moving of single elements
6278  myMoveSingleElement.finishMoveSingleElement();
6279  }
6280 }
6281 
6282 
6283 void
6284 GNEViewNet::processMoveMouseData(const bool mouseLeftButtonPressed) {
6285  if (mySelectingArea.selectingUsingRectangle) {
6286  // update selection corner of selecting area
6287  mySelectingArea.moveRectangleSelection();
6288  } else {
6289  // move single elements
6290  myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
6291  }
6292 }
6293 
6294 
6295 /****************************************************************************/
GNEChange_Attribute.h
GNEChange_TLS.h
FXDEFMAP
FXDEFMAP(GNEViewNet) GNEViewNetMap[]
DataEditMode::DATA_MEANDATA
@ DATA_MEANDATA
mode for create meanData elements
DataEditMode::DATA_EDGERELDATA
@ DATA_EDGERELDATA
mode for create edgeRelData elements
DataEditMode::DATA_SELECT
@ DATA_SELECT
mode for selecting data elements
DataEditMode::DATA_TAZRELDATA
@ DATA_TAZRELDATA
mode for create TAZRelData elements
DataEditMode::DATA_INSPECT
@ DATA_INSPECT
mode for inspecting data elements
DataEditMode::DATA_EDGEDATA
@ DATA_EDGEDATA
mode for create edgeData elements
DataEditMode::DATA_DELETE
@ DATA_DELETE
mode for deleting data elements
Supermode
Supermode
@brie enum for supermodes
Definition: GNEViewNetHelper.h:38
Supermode::NETWORK
@ NETWORK
Network mode (Edges, junctions, etc..)
Supermode::DATA
@ DATA
Data mode (edgeData, LaneData etc..)
Supermode::DEMAND
@ DEMAND
Demand mode (Routes, Vehicles etc..)
NetworkEditMode::NETWORK_SHAPE
@ NETWORK_SHAPE
Mode for editing Polygons.
NetworkEditMode::NETWORK_DELETE
@ NETWORK_DELETE
mode for deleting network elements
NetworkEditMode::NETWORK_MOVE
@ NETWORK_MOVE
mode for moving network elements
NetworkEditMode::NETWORK_WIRE
@ NETWORK_WIRE
Mode for editing wires.
NetworkEditMode::NETWORK_ADDITIONAL
@ NETWORK_ADDITIONAL
Mode for editing additionals.
NetworkEditMode::NETWORK_TAZ
@ NETWORK_TAZ
Mode for editing TAZ.
NetworkEditMode::NETWORK_CREATE_EDGE
@ NETWORK_CREATE_EDGE
mode for creating new edges
NetworkEditMode::NETWORK_TLS
@ NETWORK_TLS
mode for editing tls
NetworkEditMode::NETWORK_CROSSING
@ NETWORK_CROSSING
Mode for editing crossing.
NetworkEditMode::NETWORK_SELECT
@ NETWORK_SELECT
mode for selecting network elements
NetworkEditMode::NETWORK_INSPECT
@ NETWORK_INSPECT
mode for inspecting network elements
NetworkEditMode::NETWORK_PROHIBITION
@ NETWORK_PROHIBITION
Mode for editing connection prohibitions.
NetworkEditMode::NETWORK_CONNECT
@ NETWORK_CONNECT
mode for connecting lanes
NetworkEditMode::NETWORK_DECAL
@ NETWORK_DECAL
Mode for editing decals.
DemandEditMode::DEMAND_PERSONPLAN
@ DEMAND_PERSONPLAN
Mode for editing person plan.
DemandEditMode::DEMAND_INSPECT
@ DEMAND_INSPECT
mode for inspecting demand elements
DemandEditMode::DEMAND_CONTAINER
@ DEMAND_CONTAINER
Mode for editing container.
DemandEditMode::DEMAND_DELETE
@ DEMAND_DELETE
mode for deleting demand elements
DemandEditMode::DEMAND_ROUTEDISTRIBUTION
@ DEMAND_ROUTEDISTRIBUTION
Mode for editing route distributions.
DemandEditMode::DEMAND_PERSON
@ DEMAND_PERSON
Mode for editing person.
DemandEditMode::DEMAND_TYPEDISTRIBUTION
@ DEMAND_TYPEDISTRIBUTION
Mode for editing type distributions.
DemandEditMode::DEMAND_SELECT
@ DEMAND_SELECT
mode for selecting demand elements
DemandEditMode::DEMAND_ROUTE
@ DEMAND_ROUTE
Mode for editing routes.
DemandEditMode::DEMAND_VEHICLE
@ DEMAND_VEHICLE
Mode for editing vehicles.
DemandEditMode::DEMAND_MOVE
@ DEMAND_MOVE
mode for moving demand elements
DemandEditMode::DEMAND_STOP
@ DEMAND_STOP
Mode for editing stops.
DemandEditMode::DEMAND_CONTAINERPLAN
@ DEMAND_CONTAINERPLAN
Mode for editing container plan.
DemandEditMode::DEMAND_TYPE
@ DEMAND_TYPE
Mode for editing types.
MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES
automatically create opposite edge
Definition: GUIAppEnum.h:843
MID_GNE_ADDSELECT_EDGE
@ MID_GNE_ADDSELECT_EDGE
Add edge to selected items - menu entry.
Definition: GUIAppEnum.h:845
MID_HOTKEY_F3_SUPERMODE_DEMAND
@ MID_HOTKEY_F3_SUPERMODE_DEMAND
select demand supermode in netedit
Definition: GUIAppEnum.h:234
MID_GNE_LANE_EDIT_SHAPE
@ MID_GNE_LANE_EDIT_SHAPE
edit lane shape
Definition: GUIAppEnum.h:1346
MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS
show all person plans
Definition: GUIAppEnum.h:875
MID_HOTKEY_SHIFT_S_LOCATESTOP
@ MID_HOTKEY_SHIFT_S_LOCATESTOP
Locate stop - button.
Definition: GUIAppEnum.h:188
MID_GNE_LANE_TRANSFORM_BIKE
@ MID_GNE_LANE_TRANSFORM_BIKE
transform lane to bikelane
Definition: GUIAppEnum.h:1354
MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING
@ MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING
toggle TAZRel drawing
Definition: GUIAppEnum.h:899
MID_GNE_EDGE_REVERSE
@ MID_GNE_EDGE_REVERSE
reverse an edge
Definition: GUIAppEnum.h:1234
MID_GNE_JUNCTION_ADDTLS
@ MID_GNE_JUNCTION_ADDTLS
Add TLS into junction.
Definition: GUIAppEnum.h:1272
MID_ADDSELECT
@ MID_ADDSELECT
Add to selected items - menu entry.
Definition: GUIAppEnum.h:485
MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION
@ MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION
hotkey for mode decal AND type distribution
Definition: GUIAppEnum.h:69
MID_GNE_LANE_ADD_BUS
@ MID_GNE_LANE_ADD_BUS
add busLane
Definition: GUIAppEnum.h:1364
MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES
@ MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition: GUIAppEnum.h:817
MID_GNE_JUNCTION_RESET_EDGE_ENDPOINTS
@ MID_GNE_JUNCTION_RESET_EDGE_ENDPOINTS
reset edge endpoints
Definition: GUIAppEnum.h:1266
MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
@ MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION
move elevation instead of x,y
Definition: GUIAppEnum.h:839
MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
@ MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS
hide connections
Definition: GUIAppEnum.h:825
MID_GNE_REMOVESELECT_EDGE
@ MID_GNE_REMOVESELECT_EDGE
Remove edge from selected items - Menu Entry.
Definition: GUIAppEnum.h:847
MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS
show connections
Definition: GUIAppEnum.h:823
MID_GNE_INTERVALBAR_BEGIN
@ MID_GNE_INTERVALBAR_BEGIN
begin changed in InterbalBar
Definition: GUIAppEnum.h:919
MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO
@ MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO
toggle draw TAZRel only to
Definition: GUIAppEnum.h:905
MID_GNE_ADDREVERSE
@ MID_GNE_ADDREVERSE
add reverse element
Definition: GUIAppEnum.h:1412
MID_GNE_CONNECTION_SMOOTH_SHAPE
@ MID_GNE_CONNECTION_SMOOTH_SHAPE
@ brief smooth connection shape
Definition: GUIAppEnum.h:1284
MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
@ MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:891
MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS
show TAZ elements
Definition: GUIAppEnum.h:829
MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON
lock person
Definition: GUIAppEnum.h:877
MID_HOTKEY_Z_MODE_TAZ_TAZREL
@ MID_HOTKEY_Z_MODE_TAZ_TAZREL
hotkey for mode editing TAZ and TAZRel
Definition: GUIAppEnum.h:75
MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
@ MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:865
MID_GNE_JUNCTION_CLEAR_CONNECTIONS
@ MID_GNE_JUNCTION_CLEAR_CONNECTIONS
clear junction's connections
Definition: GUIAppEnum.h:1252
MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS
@ MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS
hotkey for start simulation in SUMO and set editing mode additionals AND stops in netedit
Definition: GUIAppEnum.h:43
MID_GNE_JUNCTION_SELECT_ROUNDABOUT
@ MID_GNE_JUNCTION_SELECT_ROUNDABOUT
select all roundabout nodes and edges of the current roundabout
Definition: GUIAppEnum.h:1268
MID_GNE_JUNCTION_RESET_SHAPE
@ MID_GNE_JUNCTION_RESET_SHAPE
reset junction shape
Definition: GUIAppEnum.h:1264
MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
@ MID_GNE_NETWORKVIEWOPTIONS_ASKFORMERGE
ask before merging junctions
Definition: GUIAppEnum.h:835
MID_GNE_JUNCTION_RESET_CONNECTIONS
@ MID_GNE_JUNCTION_RESET_CONNECTIONS
reset junction's connections
Definition: GUIAppEnum.h:1254
MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID
show grid
Definition: GUIAppEnum.h:863
MID_GNE_JUNCTION_SPLIT
@ MID_GNE_JUNCTION_SPLIT
turn junction into multiple junctions
Definition: GUIAppEnum.h:1258
MID_GNE_EDGE_STRAIGHTEN_ELEVATION
@ MID_GNE_EDGE_STRAIGHTEN_ELEVATION
interpolate z values linear between junctions
Definition: GUIAppEnum.h:1226
MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE
@ MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE
hotkey for perform a single simulation step in SUMO and set delete mode in netedit
Definition: GUIAppEnum.h:49
MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES
create edges in chain mode
Definition: GUIAppEnum.h:841
MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS
@ MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition: GUIAppEnum.h:897
MID_GNE_POLYGON_CLOSE
@ MID_GNE_POLYGON_CLOSE
close opened polygon
Definition: GUIAppEnum.h:1298
MID_GNE_EDGE_SMOOTH
@ MID_GNE_EDGE_SMOOTH
smooth geometry
Definition: GUIAppEnum.h:1224
MID_HOTKEY_C_MODE_CONNECT_CONTAINER
@ MID_HOTKEY_C_MODE_CONNECT_CONTAINER
hotkey for mode connecting lanes AND container
Definition: GUIAppEnum.h:45
MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN
@ MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN
hotkey for mode prohibition AND container plan
Definition: GUIAppEnum.h:53
MID_HOTKEY_SHIFT_O_LOCATEPOI
@ MID_HOTKEY_SHIFT_O_LOCATEPOI
Locate poi - button.
Definition: GUIAppEnum.h:182
MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION
@ MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION
hotkey for mode editing overhead wires AND route distributions
Definition: GUIAppEnum.h:73
MID_HOTKEY_T_MODE_TLS_TYPE
@ MID_HOTKEY_T_MODE_TLS_TYPE
hotkey for mode editing TLS AND Vehicle Types
Definition: GUIAppEnum.h:67
MID_GNE_LANE_RESET_CUSTOMSHAPE
@ MID_GNE_LANE_RESET_CUSTOMSHAPE
reset custom shape
Definition: GUIAppEnum.h:1348
MID_GNE_EDGE_STRAIGHTEN
@ MID_GNE_EDGE_STRAIGHTEN
remove inner geometry
Definition: GUIAppEnum.h:1222
MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES
@ MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES
hide shapes
Definition: GUIAppEnum.h:871
MID_GNE_LANE_TRANSFORM_BUS
@ MID_GNE_LANE_TRANSFORM_BUS
transform lane to busLane
Definition: GUIAppEnum.h:1356
MID_GNE_POLYGON_SET_FIRST_POINT
@ MID_GNE_POLYGON_SET_FIRST_POINT
Set a vertex of polygon as first vertex.
Definition: GUIAppEnum.h:1302
MID_GNE_SHAPEEDITED_DELETE_GEOMETRY_POINT
@ MID_GNE_SHAPEEDITED_DELETE_GEOMETRY_POINT
delete geometry point in shape edited
Definition: GUIAppEnum.h:1324
MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL
@ MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL
Locate additional structure - button.
Definition: GUIAppEnum.h:172
MID_GNE_LANE_DUPLICATE
@ MID_GNE_LANE_DUPLICATE
duplicate a lane
Definition: GUIAppEnum.h:1344
MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS
@ MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS
show additionals
Definition: GUIAppEnum.h:893
MID_HOTKEY_SHIFT_R_LOCATEROUTE
@ MID_HOTKEY_SHIFT_R_LOCATEROUTE
Locate route - button.
Definition: GUIAppEnum.h:186
MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES
show junctions as bubbles
Definition: GUIAppEnum.h:837
MID_GNE_LANE_ADD_GREENVERGE_FRONT
@ MID_GNE_LANE_ADD_GREENVERGE_FRONT
add greenVerge front of current lane
Definition: GUIAppEnum.h:1366
MID_GNE_INTERVALBAR_END
@ MID_GNE_INTERVALBAR_END
end changed in InterbalBar
Definition: GUIAppEnum.h:921
MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA
@ MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA
Locate edge - button.
Definition: GUIAppEnum.h:194
MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
@ MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION
extend selection
Definition: GUIAppEnum.h:831
MID_GNE_LANE_REMOVE_GREENVERGE
@ MID_GNE_LANE_REMOVE_GREENVERGE
remove greenVerge
Definition: GUIAppEnum.h:1376
MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT
@ MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT
hotkey for stop simulation in SUMO and set select mode in netedit
Definition: GUIAppEnum.h:63
MID_GNE_EDGE_ADD_REVERSE_DISCONNECTED
@ MID_GNE_EDGE_ADD_REVERSE_DISCONNECTED
add reverse edge disconnected (used for for spreadtype center)
Definition: GUIAppEnum.h:1238
MID_GNE_EDGE_SPLIT_BIDI
@ MID_GNE_EDGE_SPLIT_BIDI
split an edge
Definition: GUIAppEnum.h:1232
MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS
show sub-additionals
Definition: GUIAppEnum.h:827
MID_GNE_JUNCTION_REPLACE
@ MID_GNE_JUNCTION_REPLACE
turn junction into geometry node
Definition: GUIAppEnum.h:1256
MID_HOTKEY_SHIFT_C_LOCATECONTAINER
@ MID_HOTKEY_SHIFT_C_LOCATECONTAINER
Locate container - button.
Definition: GUIAppEnum.h:174
MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS
show all container plans
Definition: GUIAppEnum.h:879
MID_HOTKEY_SHIFT_V_LOCATEVEHICLE
@ MID_HOTKEY_SHIFT_V_LOCATEVEHICLE
Locate vehicle - button.
Definition: GUIAppEnum.h:192
MID_GNE_VIEW_DEFAULT
@ MID_GNE_VIEW_DEFAULT
set default view
Definition: GUIAppEnum.h:783
MID_HOTKEY_F4_SUPERMODE_DATA
@ MID_HOTKEY_F4_SUPERMODE_DATA
select data supermode in netedit
Definition: GUIAppEnum.h:236
MID_HOTKEY_SHIFT_L_LOCATEPOLY
@ MID_HOTKEY_SHIFT_L_LOCATEPOLY
Locate polygons - button.
Definition: GUIAppEnum.h:180
MID_GNE_LANE_REMOVE_BIKE
@ MID_GNE_LANE_REMOVE_BIKE
remove bikelane
Definition: GUIAppEnum.h:1372
MID_GNE_SHAPEEDITED_RESET
@ MID_GNE_SHAPEEDITED_RESET
reset shape
Definition: GUIAppEnum.h:1326
MID_HOTKEY_SHIFT_E_LOCATEEDGE
@ MID_HOTKEY_SHIFT_E_LOCATEEDGE
Locate edge - button.
Definition: GUIAppEnum.h:176
MID_GNE_VIEW_JUPEDSIM
@ MID_GNE_VIEW_JUPEDSIM
set juPedSim view
Definition: GUIAppEnum.h:785
MID_GNE_SHAPEEDITED_STRAIGHTEN
@ MID_GNE_SHAPEEDITED_STRAIGHTEN
straighten shape edited geometry
Definition: GUIAppEnum.h:1316
MID_GNE_POI_TRANSFORM
@ MID_GNE_POI_TRANSFORM
Transform POI to POILane, and viceversa.
Definition: GUIAppEnum.h:1336
MID_GNE_LANE_RESET_OPPOSITELANE
@ MID_GNE_LANE_RESET_OPPOSITELANE
reset opposite lane
Definition: GUIAppEnum.h:1350
MID_GNE_INTERVALBAR_PARAMETER
@ MID_GNE_INTERVALBAR_PARAMETER
parameter changed in InterbalBar
Definition: GUIAppEnum.h:923
MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA
@ MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA
hotkey for mode editing crossing, routes and edge rel datas
Definition: GUIAppEnum.h:65
MID_GNE_JUNCTION_CONVERT_ROUNDABOUT
@ MID_GNE_JUNCTION_CONVERT_ROUNDABOUT
convert junction to roundabout
Definition: GUIAppEnum.h:1270
MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL
@ MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL
toggle draw TAZ fill
Definition: GUIAppEnum.h:901
MID_REACHABILITY
@ MID_REACHABILITY
show reachability from a given lane
Definition: GUIAppEnum.h:531
MID_HOTKEY_L_MODE_PERSONPLAN
@ MID_HOTKEY_L_MODE_PERSONPLAN
hotkey for mode person plan
Definition: GUIAppEnum.h:57
MID_GNE_EDGE_RESET_LENGTH
@ MID_GNE_EDGE_RESET_LENGTH
reset custom lengths
Definition: GUIAppEnum.h:1240
MID_HOTKEY_V_MODE_VEHICLE
@ MID_HOTKEY_V_MODE_VEHICLE
hotkey for mode create vehicles
Definition: GUIAppEnum.h:71
MID_HOTKEY_SHIFT_P_LOCATEPERSON
@ MID_HOTKEY_SHIFT_P_LOCATEPERSON
Locate person - button.
Definition: GUIAppEnum.h:184
MID_HOTKEY_I_MODE_INSPECT
@ MID_HOTKEY_I_MODE_INSPECT
hotkey for mode inspecting object attributes
Definition: GUIAppEnum.h:55
MID_GNE_LANE_REMOVE_BUS
@ MID_GNE_LANE_REMOVE_BUS
remove busLane
Definition: GUIAppEnum.h:1374
MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
@ MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS
show demand elements
Definition: GUIAppEnum.h:819
MID_HOTKEY_SHIFT_J_LOCATEJUNCTION
@ MID_HOTKEY_SHIFT_J_LOCATEJUNCTION
Locate junction - button.
Definition: GUIAppEnum.h:178
MID_GNE_POLYGON_SELECT
@ MID_GNE_POLYGON_SELECT
select elements within polygon boundary
Definition: GUIAppEnum.h:1306
MID_GNE_JUNCTION_SPLIT_RECONNECT
@ MID_GNE_JUNCTION_SPLIT_RECONNECT
turn junction into multiple junctions and reconnect them heuristically
Definition: GUIAppEnum.h:1260
MID_GNE_REVERSE
@ MID_GNE_REVERSE
reverse current element
Definition: GUIAppEnum.h:1410
MID_OPEN_ADDITIONAL_DIALOG
@ MID_OPEN_ADDITIONAL_DIALOG
open additional dialog (used in netedit)
Definition: GUIAppEnum.h:469
MID_GNE_WALKINGAREA_EDIT_SHAPE
@ MID_GNE_WALKINGAREA_EDIT_SHAPE
edit crossing shape
Definition: GUIAppEnum.h:1288
MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
@ MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED
hide non-inspected demand element
Definition: GUIAppEnum.h:869
MID_GNE_JUNCTION_EDIT_SHAPE
@ MID_GNE_JUNCTION_EDIT_SHAPE
edit junction shape
Definition: GUIAppEnum.h:1262
MID_GNE_LANE_REMOVE_SIDEWALK
@ MID_GNE_LANE_REMOVE_SIDEWALK
remove sidewalk
Definition: GUIAppEnum.h:1370
MID_GNE_SHAPEEDITED_OPEN
@ MID_GNE_SHAPEEDITED_OPEN
open closed shape edited
Definition: GUIAppEnum.h:1320
MID_GNE_EDGE_RESET_ENDPOINT
@ MID_GNE_EDGE_RESET_ENDPOINT
reset default geometry endpoints
Definition: GUIAppEnum.h:1220
MID_GNE_INTERVALBAR_GENERICDATATYPE
@ MID_GNE_INTERVALBAR_GENERICDATATYPE
generic data selected
Definition: GUIAppEnum.h:913
MID_GNE_LANE_ADD_GREENVERGE_BACK
@ MID_GNE_LANE_ADD_GREENVERGE_BACK
add greenVerge back of current lane
Definition: GUIAppEnum.h:1368
MID_GNE_EDGE_SMOOTH_ELEVATION
@ MID_GNE_EDGE_SMOOTH_ELEVATION
smooth elevation with regard to adjoining edges
Definition: GUIAppEnum.h:1228
MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
@ MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES
change all phases
Definition: GUIAppEnum.h:833
MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES
@ MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES
show shapes
Definition: GUIAppEnum.h:895
MID_HOTKEY_E_MODE_EDGE_EDGEDATA
@ MID_HOTKEY_E_MODE_EDGE_EDGEDATA
hotkey for mode adding edges AND edgeDatas
Definition: GUIAppEnum.h:51
MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM
@ MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM
toggle draw TAZRel only from
Definition: GUIAppEnum.h:903
MID_GNE_EDGE_ADD_REVERSE
@ MID_GNE_EDGE_ADD_REVERSE
add reverse edge
Definition: GUIAppEnum.h:1236
MID_GNE_EDGE_APPLYTEMPLATE
@ MID_GNE_EDGE_APPLYTEMPLATE
apply template
Definition: GUIAppEnum.h:1244
MID_GNE_EDGE_USEASTEMPLATE
@ MID_GNE_EDGE_USEASTEMPLATE
use edge as tempalte
Definition: GUIAppEnum.h:1242
MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE
toggle draw junction shape
Definition: GUIAppEnum.h:815
MID_GNE_SHAPEEDITED_SIMPLIFY
@ MID_GNE_SHAPEEDITED_SIMPLIFY
simplify shape edited geometry
Definition: GUIAppEnum.h:1314
MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES
@ MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES
Draw vehicles in begin position or spread in lane.
Definition: GUIAppEnum.h:867
MID_GNE_LANE_ADD_SIDEWALK
@ MID_GNE_LANE_ADD_SIDEWALK
add sidewalk
Definition: GUIAppEnum.h:1360
MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES
show overlapped routes
Definition: GUIAppEnum.h:883
MID_GNE_SHAPEEDITED_FINISH
@ MID_GNE_SHAPEEDITED_FINISH
finish editing shape edited
Definition: GUIAppEnum.h:1328
MID_GNE_RESET_GEOMETRYPOINT
@ MID_GNE_RESET_GEOMETRYPOINT
reset geometry point
Definition: GUIAppEnum.h:1025
MID_GNE_CONNECTION_EDIT_SHAPE
@ MID_GNE_CONNECTION_EDIT_SHAPE
edit connection shape
Definition: GUIAppEnum.h:1282
MID_GNE_SHAPEEDITED_CLOSE
@ MID_GNE_SHAPEEDITED_CLOSE
close opened shape edited
Definition: GUIAppEnum.h:1318
MID_GNE_INTERVALBAR_DATASET
@ MID_GNE_INTERVALBAR_DATASET
data set selected
Definition: GUIAppEnum.h:915
MID_HOTKEY_SHIFT_T_LOCATETLS
@ MID_HOTKEY_SHIFT_T_LOCATETLS
Locate TLS - button.
Definition: GUIAppEnum.h:190
MID_GNE_LANE_TRANSFORM_SIDEWALK
@ MID_GNE_LANE_TRANSFORM_SIDEWALK
transform lane to sidewalk
Definition: GUIAppEnum.h:1352
MID_GNE_SHAPEEDITED_SET_FIRST_POINT
@ MID_GNE_SHAPEEDITED_SET_FIRST_POINT
Set a vertex of shape edited as first vertex.
Definition: GUIAppEnum.h:1322
MID_GNE_LANE_ADD_BIKE
@ MID_GNE_LANE_ADD_BIKE
add bikelane
Definition: GUIAppEnum.h:1362
MID_HOTKEY_M_MODE_MOVE_MEANDATA
@ MID_HOTKEY_M_MODE_MOVE_MEANDATA
hotkey for mode moving element AND mean data
Definition: GUIAppEnum.h:59
MID_HOTKEY_F2_SUPERMODE_NETWORK
@ MID_HOTKEY_F2_SUPERMODE_NETWORK
select network supermode in netedit
Definition: GUIAppEnum.h:232
MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER
@ MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER
lock container
Definition: GUIAppEnum.h:881
MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
@ MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES
select edges
Definition: GUIAppEnum.h:821
MID_GNE_EDGE_SPLIT
@ MID_GNE_EDGE_SPLIT
split an edge
Definition: GUIAppEnum.h:1230
MID_GNE_LANE_TRANSFORM_GREENVERGE
@ MID_GNE_LANE_TRANSFORM_GREENVERGE
transform lane to greenVerge
Definition: GUIAppEnum.h:1358
MID_GNE_CUSTOM_GEOMETRYPOINT
@ MID_GNE_CUSTOM_GEOMETRYPOINT
set custom geometry point
Definition: GUIAppEnum.h:1023
MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS
@ MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS
show all trips
Definition: GUIAppEnum.h:873
MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID
@ MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID
show grid
Definition: GUIAppEnum.h:813
MID_GNE_INTERVALBAR_LIMITED
@ MID_GNE_INTERVALBAR_LIMITED
enable/disable show data elements by interval
Definition: GUIAppEnum.h:917
MID_GNE_EDGE_EDIT_ENDPOINT
@ MID_GNE_EDGE_EDIT_ENDPOINT
change default geometry endpoints
Definition: GUIAppEnum.h:1218
MID_GNE_POLYGON_DELETE_GEOMETRY_POINT
@ MID_GNE_POLYGON_DELETE_GEOMETRY_POINT
delete geometry point
Definition: GUIAppEnum.h:1304
MID_HOTKEY_P_MODE_POLYGON_PERSON
@ MID_HOTKEY_P_MODE_POLYGON_PERSON
hotkey for mode creating polygons
Definition: GUIAppEnum.h:61
MID_GNE_JUNCTION_ADDJOINTLS
@ MID_GNE_JUNCTION_ADDJOINTLS
Add join TLS into junctions.
Definition: GUIAppEnum.h:1274
MID_GNE_CROSSING_EDIT_SHAPE
@ MID_GNE_CROSSING_EDIT_SHAPE
edit crossing shape
Definition: GUIAppEnum.h:1286
MID_GNE_POLYGON_OPEN
@ MID_GNE_POLYGON_OPEN
open closed polygon
Definition: GUIAppEnum.h:1300
MID_GNE_POLYGON_SIMPLIFY_SHAPE
@ MID_GNE_POLYGON_SIMPLIFY_SHAPE
simplify polygon geometry
Definition: GUIAppEnum.h:1296
MID_REMOVESELECT
@ MID_REMOVESELECT
Remove from selected items - Menu Entry.
Definition: GUIAppEnum.h:487
gSchemeStorage
GUICompleteSchemeStorage gSchemeStorage
Definition: GUICompleteSchemeStorage.cpp:37
GUICursor::MOVEELEMENT
@ MOVEELEMENT
move element cursor
GUICursor::MOVEVIEW
@ MOVEVIEW
move view cursor
GUICursor::SELECT_LANE
@ SELECT_LANE
select lanecursor
GUICursor::DEFAULT
@ DEFAULT
default cursor
GUICursor::SELECT
@ SELECT
select cursor
GUICursor::DELETE_CURSOR
@ DELETE_CURSOR
delete cursor
GUICursor::INSPECT_LANE
@ INSPECT_LANE
inspect lane cursor
GUICursor::INSPECT
@ INSPECT
inspect cursor
GUIDesignButtonPopup
#define GUIDesignButtonPopup
checkable button placed in popup (for example, locate buttons)
Definition: GUIDesigns.h:118
GUIDesignVerticalSeparator
#define GUIDesignVerticalSeparator
vertical separator
Definition: GUIDesigns.h:469
GUIDialog_ViewSettings.h
GUIGlID
unsigned int GUIGlID
Definition: GUIGlObject.h:43
GUIGlObjectType
GUIGlObjectType
Definition: GUIGlObjectTypes.h:37
GLO_TAZRELDATA
@ GLO_TAZRELDATA
TAZ relation data.
Definition: GUIGlObjectTypes.h:254
GLO_WALKINGAREA
@ GLO_WALKINGAREA
a walkingArea
Definition: GUIGlObjectTypes.h:53
GLO_TEMPORALSHAPE
@ GLO_TEMPORALSHAPE
temporal shape (used in netedit)
Definition: GUIGlObjectTypes.h:274
GLO_TESTELEMENT
@ GLO_TESTELEMENT
test element (used in netedit)
Definition: GUIGlObjectTypes.h:283
GLO_JUNCTION
@ GLO_JUNCTION
a junction
Definition: GUIGlObjectTypes.h:51
GLO_FRONTELEMENT
@ GLO_FRONTELEMENT
front element (used in netedit)
Definition: GUIGlObjectTypes.h:268
GLO_LANE
@ GLO_LANE
a lane
Definition: GUIGlObjectTypes.h:49
GLO_CONNECTION
@ GLO_CONNECTION
a connection
Definition: GUIGlObjectTypes.h:55
GLO_EDGE
@ GLO_EDGE
an edge
Definition: GUIGlObjectTypes.h:47
GLO_TLLOGIC
@ GLO_TLLOGIC
a tl-logic
Definition: GUIGlObjectTypes.h:59
GLO_CROSSING
@ GLO_CROSSING
a tl-logic
Definition: GUIGlObjectTypes.h:57
gViewObjectsHandler
GUIViewObjectsHandler gViewObjectsHandler
Definition: GUIGlobalViewObjectsHandler.cpp:28
GUIIcon::LOCATEVEHICLE
@ LOCATEVEHICLE
GUIIcon::LOCATEWALKINGAREA
@ LOCATEWALKINGAREA
GUIIcon::LOCATEPERSON
@ LOCATEPERSON
GUIIcon::LOCATECONTAINER
@ LOCATECONTAINER
GUIIcon::LOCATEJUNCTION
@ LOCATEJUNCTION
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:306
WRITE_WARNINGF
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:296
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:304
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:295
TL
#define TL(string)
Definition: MsgHandler.h:315
TLF
#define TLF(string,...)
Definition: MsgHandler.h:317
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SVCPermissions
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:237
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:140
SVC_IGNORING
@ SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:142
SVC_BICYCLE
@ SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:186
SVC_BUS
@ SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:172
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:163
SUMO_TAG_EDGEREL
@ SUMO_TAG_EDGEREL
a relation between two edges
Definition: SUMOXMLDefinitions.h:201
SUMO_TAG_DATAINTERVAL
@ SUMO_TAG_DATAINTERVAL
Definition: SUMOXMLDefinitions.h:365
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:181
GNE_TAG_EDGEREL_SINGLE
@ GNE_TAG_EDGEREL_SINGLE
Definition: SUMOXMLDefinitions.h:425
SUMO_TAG_POI
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:55
SUMO_TAG_VEHICLE
@ SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:159
GNE_TAG_FLOW_ROUTE
@ GNE_TAG_FLOW_ROUTE
a flow definition using a route instead of a from-to edges route
Definition: SUMOXMLDefinitions.h:439
SUMO_TAG_FLOW
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
Definition: SUMOXMLDefinitions.h:163
SUMO_TAG_CONNECTION
@ SUMO_TAG_CONNECTION
connectioon between two lanes
Definition: SUMOXMLDefinitions.h:240
SUMO_TAG_JUNCTION
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
Definition: SUMOXMLDefinitions.h:57
SUMO_TAG_CROSSING
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
Definition: SUMOXMLDefinitions.h:266
SUMO_TAG_POLY
@ SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:53
SUMO_TAG_LANE
@ SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
SUMO_TAG_DATASET
@ SUMO_TAG_DATASET
Definition: SUMOXMLDefinitions.h:364
GNE_TAG_JPS_OBSTACLE
@ GNE_TAG_JPS_OBSTACLE
polygon used for draw juPedSim obstacles
Definition: SUMOXMLDefinitions.h:435
SUMO_TAG_TAZREL
@ SUMO_TAG_TAZREL
a relation between two TAZs
Definition: SUMOXMLDefinitions.h:203
GNE_TAG_ROUTE_EMBEDDED
@ GNE_TAG_ROUTE_EMBEDDED
embedded route
Definition: SUMOXMLDefinitions.h:175
SUMO_TAG_INDUCTION_LOOP
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
Definition: SUMOXMLDefinitions.h:83
GNE_TAG_JPS_WALKABLEAREA
@ GNE_TAG_JPS_WALKABLEAREA
polygon used for draw juPedSim walkable areas
Definition: SUMOXMLDefinitions.h:433
SUMO_TAG_VIEWSETTINGS
@ SUMO_TAG_VIEWSETTINGS
Definition: SUMOXMLDefinitions.h:298
SUMO_TAG_VIEWPORT
@ SUMO_TAG_VIEWPORT
Definition: SUMOXMLDefinitions.h:318
SUMO_TAG_TRIP
@ SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:153
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
SUMO_ATTR_LANE
@ SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:867
GNE_ATTR_OPPOSITE
@ GNE_ATTR_OPPOSITE
to busStop (used by personPlans)
Definition: SUMOXMLDefinitions.h:1788
SUMO_ATTR_Y
@ SUMO_ATTR_Y
Definition: SUMOXMLDefinitions.h:861
SUMO_ATTR_X
@ SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:860
GNE_ATTR_SELECTED
@ GNE_ATTR_SELECTED
element is selected
Definition: SUMOXMLDefinitions.h:1748
SUMO_ATTR_CUSTOMSHAPE
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
Definition: SUMOXMLDefinitions.h:1410
SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:878
SUMO_ATTR_ZOOM
@ SUMO_ATTR_ZOOM
Definition: SUMOXMLDefinitions.h:1580
SUMO_ATTR_SHAPE
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:1394
SUMO_ATTR_ANGLE
@ SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:863
GNE_ATTR_SHAPE_END
@ GNE_ATTR_SHAPE_END
last coordinate of edge shape
Definition: SUMOXMLDefinitions.h:1754
SUMO_ATTR_TLID
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
Definition: SUMOXMLDefinitions.h:1384
SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:1503
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:864
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:915
GNE_ATTR_SHAPE_START
@ GNE_ATTR_SHAPE_START
first coordinate of edge shape
Definition: SUMOXMLDefinitions.h:1752
SUMO_ATTR_POSITION
@ SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:865
SUMO_const_laneWidth
const double SUMO_const_laneWidth
Definition: StdDefs.h:48
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:76
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:82
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
AdditionalHandler::parseSumoBaseObject
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
Definition: AdditionalHandler.cpp:247
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
Boundary::ymin
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
Boundary::xmin
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
Boundary::grow
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:319
Boundary::ymax
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
Boundary::xmax
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
CommonXMLStructure::SumoBaseObject::addBoolAttribute
void addBoolAttribute(const SumoXMLAttr attr, const bool value)
add bool attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:634
CommonXMLStructure::SumoBaseObject::addDoubleAttribute
void addDoubleAttribute(const SumoXMLAttr attr, const double value)
add double attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:628
CommonXMLStructure::SumoBaseObject::addStringAttribute
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
add string attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:616
GLHelper::drawLine
static void drawLine(const Position &beg, double rot, double visLength)
Draws a thin line.
Definition: GLHelper.cpp:438
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:654
GLHelper::drawOutlineCircle
static void drawOutlineCircle(double radius, double iRadius, int steps=8)
Draws an unfilled circle around (0,0)
Definition: GLHelper.cpp:596
GLHelper::drawFilledCircle
static void drawFilledCircle(const double widradiusth, const int steps=8)
Draws a filled circle around (0,0)
Definition: GLHelper.cpp:569
GLHelper::popMatrix
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:130
GLHelper::pushMatrix
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
GNEAdditionalFrame::getConsecutiveLaneSelector
GNEConsecutiveSelector * getConsecutiveLaneSelector() const
get consecutive lane selector
Definition: GNEAdditionalFrame.cpp:246
GNEAdditionalFrame::getLanesSelector
GNENetworkSelector * getLanesSelector() const
get edges selector
Definition: GNEAdditionalFrame.cpp:240
GNEAdditionalFrame::createPath
bool createPath(const bool useLastRoute)
create path
Definition: GNEAdditionalFrame.cpp:258
GNEAdditionalFrame::addAdditional
bool addAdditional(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add additional element
Definition: GNEAdditionalFrame.cpp:187
GNEAdditionalFrame::getEdgesSelector
GNENetworkSelector * getEdgesSelector() const
get edges selector
Definition: GNEAdditionalFrame.cpp:234
GNEAdditionalFrame::getNeteditAttributes
GNENeteditAttributes * getNeteditAttributes() const
get Netedit parameter
Definition: GNEAdditionalFrame.cpp:252
GNEAdditionalHandler
Builds additional objects for GNENet (busStops, chargingStations, detectors, etc.....
Definition: GNEAdditionalHandler.h:41
GNEAdditional
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEAdditional.h:49
GNEAdditional::openAdditionalDialog
virtual void openAdditionalDialog()
open Additional Dialog
Definition: GNEAdditional.cpp:138
GNEApplicationWindow::getEditMenuCommands
GNEApplicationWindowHelper::EditMenuCommands & getEditMenuCommands()
get Edit Menu Commands (needed for show/hide menu commands)
Definition: GNEApplicationWindow.cpp:4753
GNEApplicationWindow::getToolbarsGrip
GNEApplicationWindowHelper::ToolbarsGrip & getToolbarsGrip()
get ToolbarsGrip
Definition: GNEApplicationWindow.cpp:1525
GNEAttributeCarrier::getID
const std::string getID() const
get ID (all Attribute Carriers have one)
Definition: GNEAttributeCarrier.cpp:65
GNEAttributeCarrier::isAttributeCarrierSelected
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
Definition: GNEAttributeCarrier.cpp:99
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:619
GNEAttributeCarrier::getGUIGlObject
virtual GUIGlObject * getGUIGlObject()=0
GNEAttributeCarrier::getTagProperty
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
Definition: GNEAttributeCarrier.cpp:646
GNEAttributeCarrier::unselectAttributeCarrier
void unselectAttributeCarrier(const bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEAttributeCarrier.cpp:88
GNEAttributeCarrier::selectAttributeCarrier
void selectAttributeCarrier(const bool changeFlag=true)
select attribute carrier using GUIGlobalSelection
Definition: GNEAttributeCarrier.cpp:77
GNEChange_Attribute::changeAttribute
static void changeAttribute(GNEAttributeCarrier *AC, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList, const bool force=false)
change attribute
Definition: GNEChange_Attribute.cpp:38
GNEChange_TLS
Definition: GNEChange_TLS.h:34
GNEConnection::smootShape
void smootShape()
smoothShape
Definition: GNEConnection.cpp:347
GNEConnectorFrame::ConnectionModifications::onCmdSaveModifications
long onCmdSaveModifications(FXObject *, FXSelector, void *)
Called when the user presses the OK-Button saves any connection modifications.
Definition: GNEConnectorFrame.cpp:123
GNEConnectorFrame::ConnectionModifications::onCmdCancelModifications
long onCmdCancelModifications(FXObject *, FXSelector, void *)
Called when the user presses the Cancel-button discards any connection modifications.
Definition: GNEConnectorFrame.cpp:109
GNEConnectorFrame::getConnectionModifications
ConnectionModifications * getConnectionModifications() const
get pointer to ConnectionModifications modul
Definition: GNEConnectorFrame.cpp:398
GNEConnectorFrame::handleLaneClick
void handleLaneClick(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
either sets the current lane or toggles the connection of the
Definition: GNEConnectorFrame.cpp:382
GNEConsecutiveSelector::drawTemporalConsecutiveLanePath
void drawTemporalConsecutiveLanePath() const
draw temporal consecutive lane path
Definition: GNEConsecutiveSelector.cpp:235
GNEConsecutiveSelector::abortPathCreation
void abortPathCreation()
abort path creation
Definition: GNEConsecutiveSelector.cpp:309
GNEConsecutiveSelector::removeLastElement
void removeLastElement()
remove path element
Definition: GNEConsecutiveSelector.cpp:331
GNEContainerFrame::getPlanCreator
GNEPlanCreator * getPlanCreator() const
get plan creator module
Definition: GNEContainerFrame.cpp:144
GNEContainerFrame::addContainer
bool addContainer(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add vehicle element
Definition: GNEContainerFrame.cpp:98
GNEContainerFrame::show
void show()
show Frame
Definition: GNEContainerFrame.cpp:76
GNEContainerPlanFrame::getPlanCreator
GNEPlanCreator * getPlanCreator() const
get plan creator module
Definition: GNEContainerPlanFrame.cpp:158
GNEContainerPlanFrame::addContainerPlanElement
bool addContainerPlanElement(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add container plan element
Definition: GNEContainerPlanFrame.cpp:105
GNECreateEdgeFrame::processClick
void processClick(const Position &clickedPosition, const GNEViewNetHelper::ViewObjectsSelector &viewObjects, const bool oppositeEdge, const bool chainEdge)
handle processClick and set the relative coloring
Definition: GNECreateEdgeFrame.cpp:687
GNECreateEdgeFrame::abortEdgeCreation
void abortEdgeCreation()
abort current edge creation
Definition: GNECreateEdgeFrame.cpp:826
GNECreateEdgeFrame::show
void show()
show create edge frame
Definition: GNECreateEdgeFrame.cpp:843
GNECreateEdgeFrame::getJunctionSource
const GNEJunction * getJunctionSource() const
get junction source for new edge
Definition: GNECreateEdgeFrame.cpp:837
GNECrossingFrame::clearEdgesHotkey
void clearEdgesHotkey()
clear edges (used when user press ESC key in Crossing mode)
Definition: GNECrossingFrame.cpp:634
GNECrossingFrame::createCrossingHotkey
void createCrossingHotkey()
create crossing (used when user press ENTER key in Crossing mode)
Definition: GNECrossingFrame.cpp:625
GNECrossingFrame::addCrossing
void addCrossing(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add Crossing element
Definition: GNECrossingFrame.cpp:596
GNECrossing
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNECrossing.h:44
GNECrossing::getParentJunction
GNEJunction * getParentJunction() const
get parent Junction
Definition: GNECrossing.cpp:210
GNEDataInterval
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEDataInterval.h:48
GNEDeleteFrame::DeleteOptions::deleteOnlyGeometryPoints
bool deleteOnlyGeometryPoints() const
check if only delete geometry points checkbox is enabled
Definition: GNEDeleteFrame.cpp:73
GNEDeleteFrame::removeGeometryPoint
bool removeGeometryPoint(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
remove geometry point
Definition: GNEDeleteFrame.cpp:451
GNEDeleteFrame::getDeleteOptions
DeleteOptions * getDeleteOptions() const
get delete options modul
Definition: GNEDeleteFrame.cpp:472
GNEDeleteFrame::removeSelectedAttributeCarriers
void removeSelectedAttributeCarriers()
remove selected attribute carriers (element)
Definition: GNEDeleteFrame.cpp:356
GNEDeleteFrame::removeAttributeCarrier
void removeAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
remove attribute carrier (element)
Definition: GNEDeleteFrame.cpp:417
GNEDeleteFrame::show
void show()
show delete frame
Definition: GNEDeleteFrame.cpp:344
GNEDrawingShape::startDrawing
void startDrawing()
start drawing
Definition: GNEDrawingShape.cpp:90
GNEDrawingShape::isDrawing
bool isDrawing() const
return true if currently a shape is drawed
Definition: GNEDrawingShape.cpp:154
GNEDrawingShape::getDeleteLastCreatedPoint
bool getDeleteLastCreatedPoint()
get flag delete last created point
Definition: GNEDrawingShape.cpp:166
GNEDrawingShape::abortDrawing
void abortDrawing()
abort drawing
Definition: GNEDrawingShape.cpp:119
GNEDrawingShape::setDeleteLastCreatedPoint
void setDeleteLastCreatedPoint(bool value)
enable or disable delete last created point
Definition: GNEDrawingShape.cpp:160
GNEDrawingShape::stopDrawing
void stopDrawing()
stop drawing and check if shape can be created
Definition: GNEDrawingShape.cpp:102
GNEDrawingShape::getTemporalShape
const PositionVector & getTemporalShape() const
get Temporal shape
Definition: GNEDrawingShape.cpp:148
GNEEdgeDataFrame::addEdgeData
bool addEdgeData(const GNEViewNetHelper::ViewObjectsSelector &viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add additional element
Definition: GNEEdgeDataFrame.cpp:44
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
GNEEdge::smooth
void smooth(GNEUndoList *undoList)
make geometry smooth
Definition: GNEEdge.cpp:2409
GNEEdge::getNBEdge
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:753
GNEEdge::smoothElevation
void smoothElevation(GNEUndoList *undoList)
smooth elevation with regard to adjoining edges
Definition: GNEEdge.cpp:2421
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:1090
GNEEdge::getOppositeEdges
std::vector< GNEEdge * > getOppositeEdges() const
get opposite edges
Definition: GNEEdge.cpp:694
GNEEdge::copyTemplate
void copyTemplate(const GNEEdgeTemplate *edgeTemplate, GNEUndoList *undoList)
copy edge attributes from edgetemplate
Definition: GNEEdge.cpp:1027
GNEEdge::editEndpoint
void editEndpoint(Position pos, GNEUndoList *undoList)
makes pos the new geometry endpoint at the appropriate end, or remove current existent endpoint
Definition: GNEEdge.cpp:775
GNEEdge::getSplitPos
Position getSplitPos(const Position &clickPos)
Definition: GNEEdge.cpp:759
GNEEdge::straightenElevation
void straightenElevation(GNEUndoList *undoList)
interpolate z values linear between junctions
Definition: GNEEdge.cpp:2326
GNEEdge::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNEEdge.cpp:1223
GNEEdge::resetEndpoint
void resetEndpoint(const Position &pos, GNEUndoList *undoList)
restores the endpoint to the junction position at the appropriate end
Definition: GNEEdge.cpp:827
GNEEdgeRelDataFrame::addEdgeRelationData
bool addEdgeRelationData(const GNEViewNetHelper::ViewObjectsSelector &viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add additional element
Definition: GNEEdgeRelDataFrame.cpp:43
GNEFrame::focusUpperElement
void focusUpperElement()
focus upper element of frame
Definition: GNEFrame.cpp:109
GNEFrame::show
virtual void show()
show Frame
Definition: GNEFrame.cpp:115
GNEGenericDataFrame::getPathCreator
GNEPathCreator * getPathCreator() const
get GNEPathCreator modul
Definition: GNEGenericDataFrame.cpp:520
GNEGenericData
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEGenericData.h:52
GNEGeometryPointDialog
Dialog to edit geometry points.
Definition: GNEGeometryPointDialog.h:44
GNEHierarchicalElement::getParentDemandElements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
Definition: GNEHierarchicalElement.cpp:159
GNEInspectorFrame::NeteditAttributesEditor::isSelectingParent
bool isSelectingParent() const
check if we're selecting a new parent
Definition: GNEInspectorFrame.cpp:248
GNEInspectorFrame::NeteditAttributesEditor::setNewParent
void setNewParent(GNEAttributeCarrier *clickedAC)
set new parent
Definition: GNEInspectorFrame.cpp:258
GNEInspectorFrame::TemplateEditor::setEdgeTemplate
void setEdgeTemplate(const GNEEdge *edge)
set edge template
Definition: GNEInspectorFrame.cpp:613
GNEInspectorFrame::TemplateEditor::getEdgeTemplate
GNEEdgeTemplate * getEdgeTemplate() const
get edge template (to copy attributes from)
Definition: GNEInspectorFrame.cpp:607
GNEInspectorFrame::inspectSingleElement
void inspectSingleElement(GNEAttributeCarrier *AC)
Inspect a single element.
Definition: GNEInspectorFrame.cpp:994
GNEInspectorFrame::getTemplateEditor
TemplateEditor * getTemplateEditor() const
get template editor
Definition: GNEInspectorFrame.cpp:1159
GNEInspectorFrame::processDemandSupermodeClick
bool processDemandSupermodeClick(const Position &clickedPosition, GNEViewNetHelper::ViewObjectsSelector &viewObjects)
process click over Viewnet in Supermode Demand
Definition: GNEInspectorFrame.cpp:924
GNEInspectorFrame::clearInspectedAC
void clearInspectedAC()
Clear all current inspected ACs.
Definition: GNEInspectorFrame.cpp:1136
GNEInspectorFrame::show
void show()
show inspector frame
Definition: GNEInspectorFrame.cpp:871
GNEInspectorFrame::getOverlappedInspection
GNEOverlappedInspection * getOverlappedInspection() const
get GNEOverlappedInspection modul
Definition: GNEInspectorFrame.cpp:1165
GNEInspectorFrame::getNeteditAttributesEditor
GNEInspectorFrame::NeteditAttributesEditor * getNeteditAttributesEditor() const
get Netedit Attributes editor
Definition: GNEInspectorFrame.cpp:1153
GNEInspectorFrame::processNetworkSupermodeClick
bool processNetworkSupermodeClick(const Position &clickedPosition, GNEViewNetHelper::ViewObjectsSelector &viewObjects)
process click over Viewnet in Supermode Network
Definition: GNEInspectorFrame.cpp:889
GNEInspectorFrame::inspectMultisection
void inspectMultisection(const std::vector< GNEAttributeCarrier * > &ACs)
Inspect the given multi-selection.
Definition: GNEInspectorFrame.cpp:1018
GNEInspectorFrame::processDataSupermodeClick
bool processDataSupermodeClick(const Position &clickedPosition, GNEViewNetHelper::ViewObjectsSelector &viewObjects)
process click over Viewnet in Supermode Data
Definition: GNEInspectorFrame.cpp:959
GNEJunction::getGNEIncomingEdges
const std::vector< GNEEdge * > & getGNEIncomingEdges() const
Returns incoming GNEEdges.
Definition: GNEJunction.cpp:805
GNEJunction::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEJunction.cpp:1314
GNEJunction::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNEJunction.cpp:1393
GNEJunction::getPositionInView
Position getPositionInView() const
Returns position of hierarchical element in view.
Definition: GNEJunction.cpp:140
GNEJunction::getGNEOutgoingEdges
const std::vector< GNEEdge * > & getGNEOutgoingEdges() const
Returns incoming GNEEdges.
Definition: GNEJunction.cpp:811
GNEJunction::getNBNode
NBNode * getNBNode() const
Return net build node.
Definition: GNEJunction.cpp:732
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
GNELane::getLaneShape
const PositionVector & getLaneShape() const
get elements shape
Definition: GNELane.cpp:214
GNELane::getIndex
int getIndex() const
returns the index of the lane
Definition: GNELane.cpp:615
GNELane::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNELane.cpp:746
GNELane::getParentEdge
GNEEdge * getParentEdge() const
get parent edge
Definition: GNELane.cpp:196
GNEMeanDataFrame::show
void show()
show Frame
Definition: GNEMeanDataFrame.cpp:456
GNEMoveElement::removeGeometryPoint
virtual void removeGeometryPoint(const Position clickedPosition, GNEUndoList *undoList)=0
remove geometry point in the clicked position
GNEMoveFrame::show
void show()
show prohibition frame
Definition: GNEMoveFrame.cpp:690
GNENetHelper::AttributeCarriers::retrieveAttributeCarrier
GNEAttributeCarrier * retrieveAttributeCarrier(const GUIGlID id, bool hardFail=true) const
get a single attribute carrier based on a GLID
Definition: GNENetHelper.cpp:224
GNENetHelper::AttributeCarriers::getSelectedShapes
std::vector< GNEAdditional * > getSelectedShapes() const
get selected shapes
Definition: GNENetHelper.cpp:1070
GNENetHelper::AttributeCarriers::retrieveLane
GNELane * retrieveLane(const std::string &id, bool hardFail=true, bool checkVolatileChange=false) const
get lane by id
Definition: GNENetHelper.cpp:821
GNENetHelper::AttributeCarriers::retrieveCrossing
GNECrossing * retrieveCrossing(const GUIGlObject *glObject, bool hardFail=true) const
get Crossing by AC
Definition: GNENetHelper.cpp:529
GNENetHelper::AttributeCarriers::retrieveAdditional
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENetHelper.cpp:979
GNENetHelper::AttributeCarriers::retrieveWalkingArea
GNEWalkingArea * retrieveWalkingArea(const GUIGlObject *glObject, bool hardFail=true) const
get WalkingArea by GlObject
Definition: GNENetHelper.cpp:575
GNENetHelper::AttributeCarriers::isNetworkElementAroundShape
bool isNetworkElementAroundShape(GNEAttributeCarrier *AC, const PositionVector &shape) const
check if shape of given AC (network element) is around the given shape
Definition: GNENetHelper.cpp:182
GNENetHelper::AttributeCarriers::retrieveJunction
GNEJunction * retrieveJunction(const std::string &id, bool hardFail=true) const
get junction by id
Definition: GNENetHelper.cpp:420
GNENetHelper::AttributeCarriers::retrieveDataSet
GNEDataSet * retrieveDataSet(const std::string &id, bool hardFail=true) const
Returns the named data set.
Definition: GNENetHelper.cpp:1888
GNENetHelper::AttributeCarriers::getSelectedLanes
std::vector< GNELane * > getSelectedLanes() const
get selected lanes
Definition: GNENetHelper.cpp:876
GNENetHelper::AttributeCarriers::getEdges
const std::map< std::string, GNEEdge * > & getEdges() const
map with the ID and pointer to edges of net
Definition: GNENetHelper.cpp:717
GNENetHelper::AttributeCarriers::getSelectedJunctions
std::vector< GNEJunction * > getSelectedJunctions() const
return selected junctions
Definition: GNENetHelper.cpp:441
GNENetHelper::AttributeCarriers::getGenericDatas
const std::map< SumoXMLTag, std::map< const GUIGlObject *, GNEGenericData * > > & getGenericDatas() const
get all generic datas
Definition: GNENetHelper.cpp:1998
GNENetHelper::AttributeCarriers::getLanes
const std::map< const GUIGlObject *, GNELane * > & getLanes() const
get lanes
Definition: GNENetHelper.cpp:870
GNENetHelper::AttributeCarriers::retrieveDataInterval
GNEDataInterval * retrieveDataInterval(const GNEAttributeCarrier *AC, bool hardFail=true) const
Returns the data interval.
Definition: GNENetHelper.cpp:1920
GNENetHelper::AttributeCarriers::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool hardFail=true) const
get edge by id
Definition: GNENetHelper.cpp:686
GNENetHelper::AttributeCarriers::getSelectedEdges
std::vector< GNEEdge * > getSelectedEdges() const
return all edges
Definition: GNENetHelper.cpp:723
GNENetHelper::AttributeCarriers::getJunctions
const std::map< std::string, GNEJunction * > & getJunctions() const
get junctions
Definition: GNENetHelper.cpp:435
GNENetHelper::AttributeCarriers::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENetHelper.cpp:1344
GNENetHelper::AttributeCarriers::getDemandElements
const std::map< SumoXMLTag, std::map< const GUIGlObject *, GNEDemandElement * > > & getDemandElements() const
get demand elements
Definition: GNENetHelper.cpp:1406
GNENetHelper::AttributeCarriers::retrieveGenericData
GNEGenericData * retrieveGenericData(const GUIGlObject *glObject, bool hardFail=true) const
Returns the generic data.
Definition: GNENetHelper.cpp:1966
GNENetHelper::AttributeCarriers::getSelectedAttributeCarriers
std::vector< GNEAttributeCarrier * > getSelectedAttributeCarriers(const bool ignoreCurrentSupermode)
get all selected attribute carriers (or only relative to current supermode
Definition: GNENetHelper.cpp:388
GNENetHelper::AttributeCarriers::retrieveConnection
GNEConnection * retrieveConnection(const std::string &id, bool hardFail=true) const
get Connection by id
Definition: GNENetHelper.cpp:901
GNENet
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:42
GNENet::deleteEdge
void deleteEdge(GNEEdge *edge, GNEUndoList *undoList, bool recomputeConnections)
removes edge
Definition: GNENet.cpp:415
GNENet::deleteLane
void deleteLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
removes lane
Definition: GNENet.cpp:581
GNENet::deleteCrossing
void deleteCrossing(GNECrossing *crossing, GNEUndoList *undoList)
remove crossing
Definition: GNENet.cpp:636
GNENet::getGrid
SUMORTree & getGrid()
Returns the RTree used for visualisation speed-up.
Definition: GNENet.cpp:148
GNENet::deleteAdditional
void deleteAdditional(GNEAdditional *additional, GNEUndoList *undoList)
remove additional
Definition: GNENet.cpp:654
GNENet::computeAndUpdate
void computeAndUpdate(OptionsCont &neteditOptions, bool volatileOptions)
recompute the network and update lane geometries
Definition: GNENet.cpp:2873
GNENet::reverseEdge
void reverseEdge(GNEEdge *edge, GNEUndoList *undoList)
reverse edge
Definition: GNENet.cpp:1047
GNENet::getTLLogicCont
NBTrafficLightLogicCont & getTLLogicCont()
returns the tllcont of the underlying netbuilder
Definition: GNENet.cpp:2142
GNENet::restrictLane
bool restrictLane(SUMOVehicleClass vclass, GNELane *lane, GNEUndoList *undoList)
transform lane to restricted lane
Definition: GNENet.cpp:786
GNENet::deleteDemandElement
void deleteDemandElement(GNEDemandElement *demandElement, GNEUndoList *undoList)
remove demand element
Definition: GNENet.cpp:675
GNENet::duplicateLane
void duplicateLane(GNELane *lane, GNEUndoList *undoList, bool recomputeConnections)
duplicates lane
Definition: GNENet.cpp:770
GNENet::deleteDataInterval
void deleteDataInterval(GNEDataInterval *dataInterval, GNEUndoList *undoList)
remove data interval
Definition: GNENet.cpp:718
GNENet::deleteConnection
void deleteConnection(GNEConnection *connection, GNEUndoList *undoList)
remove connection
Definition: GNENet.cpp:621
GNENet::resetJunctionConnections
void resetJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
reset junction's connections
Definition: GNENet.cpp:2066
GNENet::drawGL
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNENet.cpp:182
GNENet::deleteGenericData
void deleteGenericData(GNEGenericData *genericData, GNEUndoList *undoList)
remove generic data
Definition: GNENet.cpp:731
GNENet::splitEdge
std::pair< GNEJunction *, GNEEdge * > splitEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList, GNEJunction *newJunction=0)
split edge at position by inserting a new junction
Definition: GNENet.cpp:906
GNENet::getAttributeCarriers
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:123
GNENet::addReversedEdge
GNEEdge * addReversedEdge(GNEEdge *edge, const bool disconnected, GNEUndoList *undoList)
add reversed edge
Definition: GNENet.cpp:1060
GNENet::splitEdgesBidi
void splitEdgesBidi(GNEEdge *edge, GNEEdge *oppositeEdge, const Position &pos, GNEUndoList *undoList)
split all edges at position by inserting one new junction
Definition: GNENet.cpp:1023
GNENet::removeRestrictedLane
bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge *edge, GNEUndoList *undoList)
remove restricted lane
Definition: GNENet.cpp:892
GNENet::mergeJunctions
void mergeJunctions(GNEJunction *moved, GNEJunction *target, GNEUndoList *undoList)
merge the given junctions edges between the given junctions will be deleted
Definition: GNENet.cpp:1098
GNENet::addRestrictedLane
bool addRestrictedLane(SUMOVehicleClass vclass, GNEEdge *edge, int index, GNEUndoList *undoList)
add restricted lane to edge
Definition: GNENet.cpp:839
GNENet::addGreenVergeLane
bool addGreenVergeLane(GNEEdge *edge, int index, GNEUndoList *undoList)
add restricted lane to edge
Definition: GNENet.cpp:875
GNENet::deleteDataSet
void deleteDataSet(GNEDataSet *dataSet, GNEUndoList *undoList)
remove data set
Definition: GNENet.cpp:705
GNENet::splitJunction
void splitJunction(GNEJunction *junction, bool reconnect, GNEUndoList *undoList)
replace the selected junction by a list of junctions for each unique edge endpoint
Definition: GNENet.cpp:1970
GNENet::selectRoundabout
void selectRoundabout(GNEJunction *junction, GNEUndoList *undoList)
select all roundabout edges and junctions for the current roundabout
Definition: GNENet.cpp:1131
GNENet::replaceJunctionByGeometry
void replaceJunctionByGeometry(GNEJunction *junction, GNEUndoList *undoList)
replace the selected junction by geometry node(s) and merge the edges
Definition: GNENet.cpp:1916
GNENet::getPathManager
GNEPathManager * getPathManager()
get path manager
Definition: GNENet.cpp:135
GNENet::createRoundabout
void createRoundabout(GNEJunction *junction, GNEUndoList *undoList)
transform the given junction into a roundabout
Definition: GNENet.cpp:1150
GNENet::requireRecompute
void requireRecompute()
inform the net about the need for recomputation
Definition: GNENet.cpp:1522
GNENet::initGNEConnections
void initGNEConnections()
initialize GNEConnections
Definition: GNENet.cpp:2860
GNENet::deleteJunction
void deleteJunction(GNEJunction *junction, GNEUndoList *undoList)
removes junction and all incident edges
Definition: GNENet.cpp:370
GNENet::getEdgeCont
NBEdgeCont & getEdgeCont()
returns the NBEdgeCont of the underlying netbuilder
Definition: GNENet.cpp:2148
GNENet::getViewNet
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:2136
GNENet::clearJunctionConnections
void clearJunctionConnections(GNEJunction *junction, GNEUndoList *undoList)
clear junction's connections
Definition: GNENet.cpp:2054
GNENet::computeDemandElements
void computeDemandElements(GNEApplicationWindow *window)
compute demand elements param[in] window The window to inform about delay
Definition: GNENet.cpp:1471
GNENeteditAttributes::drawLaneReference
void drawLaneReference(const GNELane *lane) const
draw lane reference
Definition: GNENeteditAttributes.cpp:196
GNENetworkElement::closeShapeEdited
void closeShapeEdited(GNEUndoList *undoList)
close shape edited
Definition: GNENetworkElement.cpp:230
GNENetworkElement::setFirstGeometryPointShapeEdited
void setFirstGeometryPointShapeEdited(const int index, GNEUndoList *undoList)
set first geometry point shape edited
Definition: GNENetworkElement.cpp:246
GNENetworkElement::openShapeEdited
void openShapeEdited(GNEUndoList *undoList)
open shape edited
Definition: GNENetworkElement.cpp:238
GNENetworkElement::getGeometryPointUnderCursorShapeEdited
int getGeometryPointUnderCursorShapeEdited() const
get index geometry point under cursor of shape edited
Definition: GNENetworkElement.cpp:175
GNENetworkElement::simplifyShapeEdited
void simplifyShapeEdited(GNEUndoList *undoList)
simplify shape edited
Definition: GNENetworkElement.cpp:203
GNENetworkElement::straigthenShapeEdited
void straigthenShapeEdited(GNEUndoList *undoList)
straigthen shape edited
Definition: GNENetworkElement.cpp:220
GNENetworkElement::deleteGeometryPointShapeEdited
void deleteGeometryPointShapeEdited(const int index, GNEUndoList *undoList)
delete geometry point shape edited
Definition: GNENetworkElement.cpp:260
GNENetworkElement::resetShapeEdited
void resetShapeEdited(GNEUndoList *undoList)
reset shape edited
Definition: GNENetworkElement.cpp:273
GNENetworkSelector::clearSelection
void clearSelection()
clear selection
Definition: GNENetworkSelector.cpp:154
GNEOverlappedInspection::overlappedInspectionShown
bool overlappedInspectionShown() const
check if overlappedInspection modul is shown
Definition: GNEOverlappedInspection.cpp:148
GNEOverlappedInspection::checkSavedPosition
bool checkSavedPosition(const Position &clickedPosition) const
check if given position is near to saved position
Definition: GNEOverlappedInspection.cpp:161
GNEPOI
Definition: GNEPOI.h:43
GNEPathCreator::onCmdCreatePath
long onCmdCreatePath(FXObject *, FXSelector, void *)
Definition: GNEPathCreator.cpp:745
GNEPathCreator::abortPathCreation
void abortPathCreation()
abort path creation
Definition: GNEPathCreator.cpp:689
GNEPathCreator::removeLastElement
void removeLastElement()
remove path element
Definition: GNEPathCreator.cpp:713
GNEPathCreator::createPath
bool createPath(const bool useLastRoute)
create path
Definition: GNEPathCreator.cpp:682
GNEPathCreator::drawTemporalRoute
void drawTemporalRoute(const GUIVisualizationSettings &s) const
draw temporal route
Definition: GNEPathCreator.cpp:585
GNEPathManager::PathCalculator::calculateReachability
void calculateReachability(const SUMOVehicleClass vClass, GNEEdge *originEdge)
calculate reachability for given edge
Definition: GNEPathManager.cpp:389
GNEPathManager::PathDraw::clearPathDraw
void clearPathDraw()
clear path draw
Definition: GNEPathManager.cpp:557
GNEPathManager::getPathCalculator
PathCalculator * getPathCalculator()
obtain instance of PathCalculator
Definition: GNEPathManager.cpp:639
GNEPathManager::getPathDraw
PathDraw * getPathDraw()
obtain instance of PathDraw
Definition: GNEPathManager.cpp:673
GNEPersonFrame::show
void show()
show Frame
Definition: GNEPersonFrame.cpp:76
GNEPersonFrame::getPlanCreator
GNEPlanCreator * getPlanCreator() const
get plan creator module
Definition: GNEPersonFrame.cpp:144
GNEPersonFrame::getPlanSelector
GNEPlanSelector * getPlanSelector() const
get personPlan selector
Definition: GNEPersonFrame.cpp:156
GNEPersonFrame::addPerson
bool addPerson(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add vehicle element
Definition: GNEPersonFrame.cpp:98
GNEPersonPlanFrame::show
void show()
show Frame
Definition: GNEPersonPlanFrame.cpp:67
GNEPersonPlanFrame::addPersonPlanElement
bool addPersonPlanElement(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add person plan element
Definition: GNEPersonPlanFrame.cpp:105
GNEPersonPlanFrame::getPlanCreator
GNEPlanCreator * getPlanCreator() const
get plan creator module
Definition: GNEPersonPlanFrame.cpp:158
GNEPersonPlanFrame::resetSelectedPerson
void resetSelectedPerson()
reset selected person
Definition: GNEPersonPlanFrame.cpp:152
GNEPersonPlanFrame::getPlanSelector
GNEPlanSelector * getPlanSelector() const
get personPlan selector
Definition: GNEPersonPlanFrame.cpp:176
GNEPlanCreator::removeLastElement
void removeLastElement()
remove path element
Definition: GNEPlanCreator.cpp:485
GNEPlanCreator::onCmdCreatePath
long onCmdCreatePath(FXObject *, FXSelector, void *)
Definition: GNEPlanCreator.cpp:531
GNEPlanCreator::abortPathCreation
void abortPathCreation()
abort path creation
Definition: GNEPlanCreator.cpp:467
GNEPlanCreator::drawTemporalRoute
void drawTemporalRoute(const GUIVisualizationSettings &s) const
draw temporal route
Definition: GNEPlanCreator.cpp:377
GNEPlanSelector::getCurrentPlanTagProperties
const GNETagProperties & getCurrentPlanTagProperties() const
get current plan tag properties
Definition: GNEPlanSelector.cpp:143
GNEPoly::getVertexIndex
int getVertexIndex(Position pos, bool snapToGrid)
return index of a vertex of shape, or of a new vertex if position is over an shape's edge
Definition: GNEPoly.cpp:350
GNEPoly::closePolygon
void closePolygon(bool allowUndo=true)
close polygon
Definition: GNEPoly.cpp:429
GNEPoly::changeFirstGeometryPoint
void changeFirstGeometryPoint(int oldIndex, bool allowUndo=true)
change first geometry point
Definition: GNEPoly.cpp:450
GNEPoly::deleteGeometryPoint
void deleteGeometryPoint(const Position &pos, bool allowUndo=true)
delete the geometry point closest to the given pos
Definition: GNEPoly.cpp:366
GNEPoly::simplifyShape
void simplifyShape(bool allowUndo=true)
replace the current shape with a rectangle
Definition: GNEPoly.cpp:490
GNEPoly::openPolygon
void openPolygon(bool allowUndo=true)
open polygon
Definition: GNEPoly.cpp:408
GNEProhibitionFrame::Selection::onCmdCancel
long onCmdCancel(FXObject *, FXSelector, void *)
Called when the user presses the Cancel-button discards any prohibition modifications.
Definition: GNEProhibitionFrame.cpp:197
GNEProhibitionFrame::handleProhibitionClick
void handleProhibitionClick(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
handle prohibitions and set the relative coloring
Definition: GNEProhibitionFrame.cpp:247
GNEProhibitionFrame::getSelectionModul
GNEProhibitionFrame::Selection * getSelectionModul() const
get selection module
Definition: GNEProhibitionFrame.cpp:266
GNEProhibitionFrame::show
void show()
show prohibition frame
Definition: GNEProhibitionFrame.cpp:254
GNERouteDistributionFrame::getDistributionSelector
GNEDistributionFrame::DistributionSelector * getDistributionSelector() const
get route distribution selector
Definition: GNERouteDistributionFrame.cpp:59
GNERouteFrame::show
void show()
show delete frame
Definition: GNERouteFrame.cpp:212
GNERouteFrame::getPathCreator
GNEPathCreator * getPathCreator() const
get path creator module
Definition: GNERouteFrame.cpp:246
GNERouteFrame::addEdgeRoute
bool addEdgeRoute(GNEEdge *clickedEdge, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add route edge
Definition: GNERouteFrame.cpp:231
GNERouteHandler::addReverse
static void addReverse(GNEDemandElement *element)
add reverse for given demand element
Definition: GNERouteHandler.cpp:2209
GNERouteHandler::reverse
static void reverse(GNEDemandElement *element)
reverse given demand element
Definition: GNERouteHandler.cpp:2160
GNESelectorFrame::show
void show()
show Frame
Definition: GNESelectorFrame.cpp:960
GNESelectorFrame::clearCurrentSelection
void clearCurrentSelection() const
clear current selection with possibility of undo/redo
Definition: GNESelectorFrame.cpp:1000
GNESelectorFrame::selectAttributeCarrier
bool selectAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
select attribute carrier (element)
Definition: GNESelectorFrame.cpp:1006
GNEShapeFrame::show
void show()
show Frame
Definition: GNEShapeFrame.cpp:257
GNEShapeFrame::processClick
bool processClick(const Position &clickedPosition, const GNEViewNetHelper::ViewObjectsSelector &viewObjects, bool &updateTemporalShape)
process click over Viewnet
Definition: GNEShapeFrame.cpp:266
GNEShapeFrame::getDrawingShapeModule
GNEDrawingShape * getDrawingShapeModule() const
get drawing mode editor
Definition: GNEShapeFrame.cpp:311
GNEStopFrame::show
void show()
show Frame
Definition: GNEStopFrame.cpp:149
GNEStopFrame::addStop
bool addStop(const GNEViewNetHelper::ViewObjectsSelector &viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add Stop element
Definition: GNEStopFrame.cpp:186
GNETAZFrame::CurrentTAZ::setTAZ
void setTAZ(GNETAZ *editedTAZ)
set current TAZ
Definition: GNETAZFrame.cpp:169
GNETAZFrame::CurrentTAZ::getTAZ
GNETAZ * getTAZ() const
get current TAZ
Definition: GNETAZFrame.cpp:218
GNETAZFrame::TAZSaveChanges::isChangesPending
bool isChangesPending() const
return true if there is changes to save
Definition: GNETAZFrame.cpp:438
GNETAZFrame::TAZSaveChanges::onCmdSaveChanges
long onCmdSaveChanges(FXObject *, FXSelector, void *)
Definition: GNETAZFrame.cpp:445
GNETAZFrame::getTAZSaveChangesModule
TAZSaveChanges * getTAZSaveChangesModule() const
get TAZ Save Changes modul
Definition: GNETAZFrame.cpp:1602
GNETAZFrame::getDrawingShapeModule
GNEDrawingShape * getDrawingShapeModule() const
get drawing mode modul
Definition: GNETAZFrame.cpp:1584
GNETAZFrame::getCurrentTAZModule
CurrentTAZ * getCurrentTAZModule() const
get Current TAZ modul
Definition: GNETAZFrame.cpp:1590
GNETAZFrame::processEdgeSelection
void processEdgeSelection(const std::vector< GNEEdge * > &edges)
process selection of edges in view net
Definition: GNETAZFrame.cpp:1552
GNETAZFrame::processClick
bool processClick(const Position &clickedPosition, const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
process click over Viewnet
Definition: GNETAZFrame.cpp:1495
GNETAZ
Definition: GNETAZ.h:34
GNETAZRelDataFrame::setTAZ
bool setTAZ(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
set clicked TAZ
Definition: GNETAZRelDataFrame.cpp:149
GNETAZRelDataFrame::buildTAZRelationData
void buildTAZRelationData()
build TAZRelation data
Definition: GNETAZRelDataFrame.cpp:173
GNETAZRelDataFrame::clearTAZSelection
void clearTAZSelection()
clear TAZ selection
Definition: GNETAZRelDataFrame.cpp:217
GNETLSEditorFrame::TLSAttributes::isSetDetectorsToggleButtonEnabled
bool isSetDetectorsToggleButtonEnabled() const
toggle button for set detectors mode
Definition: GNETLSEditorFrame.cpp:677
GNETLSEditorFrame::TLSAttributes::disableE1DetectorMode
void disableE1DetectorMode()
disable detector mode
Definition: GNETLSEditorFrame.cpp:726
GNETLSEditorFrame::TLSAttributes::getE1Detectors
const std::map< std::string, std::string > & getE1Detectors() const
get E1 detectors vinculated with this TLS
Definition: GNETLSEditorFrame.cpp:720
GNETLSEditorFrame::TLSDefinition::checkHaveModifications
bool checkHaveModifications() const
check if current TLS was modified
Definition: GNETLSEditorFrame.cpp:1487
GNETLSEditorFrame::TLSDefinition::onCmdSaveChanges
long onCmdSaveChanges(FXObject *, FXSelector, void *)
Called when the user presses the save-Button.
Definition: GNETLSEditorFrame.cpp:1792
GNETLSEditorFrame::TLSDefinition::discardChanges
void discardChanges(const bool editJunctionAgain)
discard changes
Definition: GNETLSEditorFrame.cpp:1521
GNETLSEditorFrame::TLSJunction::getSelectedJunctionIDs
const std::vector< std::string > & getSelectedJunctionIDs() const
get selected junction IDs
Definition: GNETLSEditorFrame.cpp:1032
GNETLSEditorFrame::TLSJunction::onCmdCancelJoin
long onCmdCancelJoin(FXObject *, FXSelector, void *)
cancel join
Definition: GNETLSEditorFrame.cpp:1371
GNETLSEditorFrame::TLSJunction::onCmdAcceptJoin
long onCmdAcceptJoin(FXObject *, FXSelector, void *)
accept join
Definition: GNETLSEditorFrame.cpp:1364
GNETLSEditorFrame::TLSJunction::getCurrentJunction
GNEJunction * getCurrentJunction() const
get current modified junction
Definition: GNETLSEditorFrame.cpp:936
GNETLSEditorFrame::TLSJunction::isJoiningJunctions
bool isJoiningJunctions() const
is joining junctions
Definition: GNETLSEditorFrame.cpp:1004
GNETLSEditorFrame::getTLSAttributes
GNETLSEditorFrame::TLSAttributes * getTLSAttributes() const
get module for TLS attributes
Definition: GNETLSEditorFrame.cpp:329
GNETLSEditorFrame::editJunction
void editJunction(GNEJunction *junction)
edits the traffic light for the given junction
Definition: GNETLSEditorFrame.cpp:505
GNETLSEditorFrame::editTLS
void editTLS(const Position &clickedPosition, const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
edits the traffic light for the given clicked junction
Definition: GNETLSEditorFrame.cpp:168
GNETLSEditorFrame::getTLSJunction
GNETLSEditorFrame::TLSJunction * getTLSJunction() const
get module for TLS Junction
Definition: GNETLSEditorFrame.cpp:317
GNETLSEditorFrame::getTLSDefinition
GNETLSEditorFrame::TLSDefinition * getTLSDefinition() const
get module for TLS Definition
Definition: GNETLSEditorFrame.cpp:323
GNETLSEditorFrame::show
void show()
show inspector frame
Definition: GNETLSEditorFrame.cpp:152
GNETagProperties::isContainer
bool isContainer() const
return true if tag correspond to a container element
Definition: GNETagProperties.cpp:394
GNETagProperties::planRoute
bool planRoute() const
return true if tag correspond to a plan placed over route
Definition: GNETagProperties.cpp:514
GNETagProperties::isPlacedInRTree
bool isPlacedInRTree() const
return true if Tag correspond to an element that has to be placed in RTREE
Definition: GNETagProperties.cpp:737
GNETagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNETagProperties.cpp:65
GNETagProperties::hasDialog
bool hasDialog() const
return true if tag correspond to an element that can be edited using a dialog
Definition: GNETagProperties.cpp:724
GNETagProperties::isPerson
bool isPerson() const
return true if tag correspond to a person element
Definition: GNETagProperties.cpp:388
GNETypeDistributionFrame::getDistributionSelector
GNEDistributionFrame::DistributionSelector * getDistributionSelector() const
get type distribution selector
Definition: GNETypeDistributionFrame.cpp:59
GNETypeFrame::show
void show()
show Frame
Definition: GNETypeFrame.cpp:418
GNEUndoList::end
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:240
GNEUndoList::begin
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
Definition: GNEUndoList.cpp:204
GNEUndoList::abortAllChangeGroups
void abortAllChangeGroups()
reverts and discards ALL active chained change groups
Definition: GNEUndoList.cpp:308
GNEUndoList::add
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
Definition: GNEUndoList.cpp:330
GNEVehicleFrame::getPathCreator
GNEPathCreator * getPathCreator() const
get GNEPathCreator module
Definition: GNEVehicleFrame.cpp:243
GNEVehicleFrame::show
void show()
show Frame
Definition: GNEVehicleFrame.cpp:153
GNEVehicleFrame::addVehicle
bool addVehicle(const GNEViewNetHelper::ViewObjectsSelector &viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add vehicle element
Definition: GNEVehicleFrame.cpp:177
GNEViewNetHelper::IntervalBar
class used to group all variables related to interval bar
Definition: GNEViewNetHelper.h:922
GNEViewNetHelper::IntervalBar::hideIntervalBar
void hideIntervalBar()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3180
GNEViewNetHelper::IntervalBar::setGenericDataType
void setGenericDataType()
set generic data type
Definition: GNEViewNetHelper.cpp:3342
GNEViewNetHelper::IntervalBar::showIntervalBar
void showIntervalBar()
show interval option bar
Definition: GNEViewNetHelper.cpp:3171
GNEViewNetHelper::IntervalBar::buildIntervalBarElements
void buildIntervalBarElements()
build interval bar elements
Definition: GNEViewNetHelper.cpp:3120
GNEViewNetHelper::IntervalBar::setInterval
void setInterval()
update limit by interval
Definition: GNEViewNetHelper.cpp:3370
GNEViewNetHelper::LockManager::updateLockMenuBar
void updateLockMenuBar()
update lock inspect menuBar
Definition: GNEViewNetHelper.cpp:161
GNEViewNetHelper::LockManager::isObjectLocked
bool isObjectLocked(GUIGlObjectType objectType, const bool selected) const
check if given GLObject is locked for inspect, select, delete and move
Definition: GNEViewNetHelper.cpp:97
GNEViewNetHelper::ViewObjectsSelector
class used to group all variables related with objects under cursor after a click over view
Definition: GNEViewNetHelper.h:223
GNEViewNetHelper::ViewObjectsSelector::updateObjects
void updateObjects()
update objects (using gViewObjectsHandler)
Definition: GNEViewNetHelper.cpp:224
GNEViewNetHelper::ViewObjectsSelector::getConnectionFront
GNEConnection * getConnectionFront() const
get front connection or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:459
GNEViewNetHelper::ViewObjectsSelector::getAttributeCarriers
const std::vector< GNEAttributeCarrier * > & getAttributeCarriers() const
get vector with ACs
Definition: GNEViewNetHelper.cpp:545
GNEViewNetHelper::ViewObjectsSelector::filterEdges
void filterEdges()
filter (remove) edges
Definition: GNEViewNetHelper.cpp:233
GNEViewNetHelper::ViewObjectsSelector::filterLockedElements
void filterLockedElements(const std::vector< GUIGlObjectType > ignoreFilter={})
filter locked elements (except the ignoreFilter)
Definition: GNEViewNetHelper.cpp:301
GNEViewNetHelper::ViewObjectsSelector::getPOIFront
GNEPOI * getPOIFront() const
get front POI or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:479
GNEViewNetHelper::ViewObjectsSelector::getEdgeFront
GNEEdge * getEdgeFront() const
get front edge or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:396
GNEViewNetHelper::ViewObjectsSelector::getAttributeCarrierFront
GNEAttributeCarrier * getAttributeCarrierFront() const
get front attribute carrier or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:336
GNEViewNetHelper::ViewObjectsSelector::filterDemandElements
void filterDemandElements(const bool includeRoutes)
filter (remove) demand elements
Definition: GNEViewNetHelper.cpp:286
GNEViewNetHelper::ViewObjectsSelector::filterAdditionals
void filterAdditionals(const bool includeStoppigPlaces, const bool includeTAZs)
filter (remove) additionals
Definition: GNEViewNetHelper.cpp:269
GNEViewNetHelper::ViewObjectsSelector::getLaneFront
GNELane * getLaneFront() const
get front lane or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:406
GNEViewNetHelper::ViewObjectsSelector::getAdditionalFront
GNEAdditional * getAdditionalFront() const
get front additional element or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:356
GNEViewNetHelper::ViewObjectsSelector::getLaneFrontNonLocked
GNELane * getLaneFrontNonLocked() const
get front lane or a pointer to nullptr checking if is locked
Definition: GNEViewNetHelper.cpp:416
GNEViewNetHelper::ViewObjectsSelector::getGUIGlObjectFront
const GUIGlObject * getGUIGlObjectFront() const
get front attribute carrier or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:326
GNEViewNetHelper::ViewObjectsSelector::getNetworkElementFront
GNENetworkElement * getNetworkElementFront() const
get front network element or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:346
GNEViewNetHelper::ViewObjectsSelector::getJunctionFront
GNEJunction * getJunctionFront() const
get front junction or a pointer to nullptr
Definition: GNEViewNetHelper.cpp:386
GNEViewNetHelper::ViewObjectsSelector::filterLanes
void filterLanes()
filter (remove) lanes
Definition: GNEViewNetHelper.cpp:244
GNEViewNetHelper::ViewObjectsSelector::getGLObjects
const std::vector< GUIGlObject * > & getGLObjects() const
get vector with GL objects
Definition: GNEViewNetHelper.cpp:539
GNEViewNetHelper::ViewObjectsSelector::filterShapes
void filterShapes()
filter (remove) polys and POIs
Definition: GNEViewNetHelper.cpp:255
GNEViewNet::myEditNetworkElementShapes
GNEViewNetHelper::EditNetworkElementShapes myEditNetworkElementShapes
struct for grouping all variables related with edit shapes
Definition: GNEViewNet.h:737
GNEViewNet::onCmdToggleShowDemandElementsNetwork
long onCmdToggleShowDemandElementsNetwork(FXObject *, FXSelector, void *)
toggle show demand elements (network)
Definition: GNEViewNet.cpp:4446
GNEViewNet::onCmdClosePolygon
long onCmdClosePolygon(FXObject *, FXSelector, void *)
close opened polygon
Definition: GNEViewNet.cpp:2700
GNEViewNet::isCurrentlyMovingElements
bool isCurrentlyMovingElements() const
check if an element is being moved
Definition: GNEViewNet.cpp:1945
GNEViewNet::onCmdEditCrossingShape
long onCmdEditCrossingShape(FXObject *, FXSelector, void *)
edit crossing shape
Definition: GNEViewNet.cpp:3834
GNEViewNet::processMoveMouseNetwork
void processMoveMouseNetwork(const bool mouseLeftButtonPressed)
process move mouse function in Supermode Network
Definition: GNEViewNet.cpp:5939
GNEViewNet::getDataViewOptions
const GNEViewNetHelper::DataViewOptions & getDataViewOptions() const
get data view options
Definition: GNEViewNet.cpp:747
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1849
GNEViewNet::deleteNetworkAttributeCarriers
void deleteNetworkAttributeCarriers(const std::vector< GNEAttributeCarrier * > ACs)
delete given network attribute carriers
Definition: GNEViewNet.cpp:5216
GNEViewNet::onCmdSetFirstGeometryPoint
long onCmdSetFirstGeometryPoint(FXObject *, FXSelector, void *)
set as first geometry point the closes geometry point
Definition: GNEViewNet.cpp:2807
GNEViewNet::onCmdEdgeUseAsTemplate
long onCmdEdgeUseAsTemplate(FXObject *, FXSelector, void *)
use edge as template
Definition: GNEViewNet.cpp:2620
GNEViewNet::onCmdSmoothConnectionShape
long onCmdSmoothConnectionShape(FXObject *, FXSelector, void *)
edit connection shape
Definition: GNEViewNet.cpp:3820
GNEViewNet::myCommonCheckableButtons
GNEViewNetHelper::CommonCheckableButtons myCommonCheckableButtons
variable used to save checkable buttons for common supermodes
Definition: GNEViewNet.h:675
GNEViewNet::onMouseMove
long onMouseMove(FXObject *, FXSelector, void *)
called when user moves mouse
Definition: GNEViewNet.cpp:1500
GNEViewNet::getFrontAttributeCarrier
const GNEAttributeCarrier * getFrontAttributeCarrier() const
get front attributeCarrier
Definition: GNEViewNet.cpp:1912
GNEViewNet::hotkeyBackSpace
void hotkeyBackSpace()
handle backspace keypress
Definition: GNEViewNet.cpp:1804
GNEViewNet::myLastCreatedRoute
GNEDemandElement * myLastCreatedRoute
last created route
Definition: GNEViewNet.h:761
GNEViewNet::getEditModes
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
Definition: GNEViewNet.cpp:723
GNEViewNet::onCmdAddSelected
long onCmdAddSelected(FXObject *, FXSelector, void *)
select AC under cursor
Definition: GNEViewNet.cpp:4606
GNEViewNet::getEditNetworkElementShapes
const GNEViewNetHelper::EditNetworkElementShapes & getEditNetworkElementShapes() const
get Edit Shape module
Definition: GNEViewNet.cpp:759
GNEViewNet::setFrontAttributeCarrier
void setFrontAttributeCarrier(GNEAttributeCarrier *AC)
set front attributeCarrier
Definition: GNEViewNet.cpp:1928
GNEViewNet::getCrossingAtPopupPosition
GNECrossing * getCrossingAtPopupPosition()
try to retrieve a crossing at popup position
Definition: GNEViewNet.cpp:2017
GNEViewNet::buildViewToolBars
void buildViewToolBars(GUIGlChildWindow *v)
builds the view toolbars
Definition: GNEViewNet.cpp:350
GNEViewNet::updateNetworkModeSpecificControls
void updateNetworkModeSpecificControls()
updates Network mode specific controls
Definition: GNEViewNet.cpp:4704
GNEViewNet::onCmdAddTLS
long onCmdAddTLS(FXObject *, FXSelector, void *)
add TLS
Definition: GNEViewNet.cpp:3730
GNEViewNet::onCmdSmoothEdges
long onCmdSmoothEdges(FXObject *, FXSelector, void *)
smooth geometry
Definition: GNEViewNet.cpp:2538
GNEViewNet::onCmdStraightenEdges
long onCmdStraightenEdges(FXObject *, FXSelector, void *)
makes selected edges straight
Definition: GNEViewNet.cpp:2516
GNEViewNet::getMouseButtonKeyPressed
const GNEViewNetHelper::MouseButtonKeyPressed & getMouseButtonKeyPressed() const
get Key Pressed module
Definition: GNEViewNet.cpp:753
GNEViewNet::updateCursor
void updateCursor()
update cursor after every click/key press/release
Definition: GNEViewNet.cpp:3328
GNEViewNet::updateDataModeSpecificControls
void updateDataModeSpecificControls()
updates Data mode specific controls
Definition: GNEViewNet.cpp:5076
GNEViewNet::getEdgeAtPopupPosition
GNEEdge * getEdgeAtPopupPosition()
try to retrieve an edge at popup position
Definition: GNEViewNet.cpp:2047
GNEViewNet::onCmdToggleShowDemandElementsData
long onCmdToggleShowDemandElementsData(FXObject *, FXSelector, void *)
toggle show demand elements (data)
Definition: GNEViewNet.cpp:4467
GNEViewNet::myEditModes
GNEViewNetHelper::EditModes myEditModes
variable used to save variables related with edit moves modes
Definition: GNEViewNet.h:656
GNEViewNet::onCmdReplaceJunction
long onCmdReplaceJunction(FXObject *, FXSelector, void *)
replace node by geometry
Definition: GNEViewNet.cpp:3582
GNEViewNet::restrictLane
bool restrictLane(GNELane *lane, SUMOVehicleClass vclass)
restrict lane
Definition: GNEViewNet.cpp:970
GNEViewNet::onCmdSplitJunction
long onCmdSplitJunction(FXObject *, FXSelector, void *)
split junction into multiple junctions
Definition: GNEViewNet.cpp:3596
GNEViewNet::drawGrid
void drawGrid() const
draw grid and update grid button
Definition: GNEViewNet.cpp:3461
GNEViewNet::onCmdClearConnections
long onCmdClearConnections(FXObject *, FXSelector, void *)
clear junction connections
Definition: GNEViewNet.cpp:3666
GNEViewNet::abortOperation
void abortOperation(bool clearSelection=true)
abort current edition operation
Definition: GNEViewNet.cpp:1577
GNEViewNet::onCmdToggleTAZDrawFill
long onCmdToggleTAZDrawFill(FXObject *, FXSelector, void *)
toggle TAZdrawFill
Definition: GNEViewNet.cpp:4507
GNEViewNet::onCmdResetEndPoints
long onCmdResetEndPoints(FXObject *, FXSelector, void *)
reset edge end points
Definition: GNEViewNet.cpp:3116
GNEViewNet::updateObjectsInPosition
void updateObjectsInPosition(const Position &pos)
get objects in the given position
Definition: GNEViewNet.cpp:508
GNEViewNet::myTestingMode
GNEViewNetHelper::TestingMode myTestingMode
variable used to save variables related with testing mode
Definition: GNEViewNet.h:659
GNEViewNet::getLastCreatedRoute
GNEDemandElement * getLastCreatedRoute() const
get last created route
Definition: GNEViewNet.cpp:1975
GNEViewNet::onCmdToggleWarnAboutMerge
long onCmdToggleWarnAboutMerge(FXObject *, FXSelector, void *)
toggle warn for merge
Definition: GNEViewNet.cpp:4129
GNEViewNet::onCmdToggleDrawSpreadVehicles
long onCmdToggleDrawSpreadVehicles(FXObject *, FXSelector, void *)
toggle draw vehicles in begin position or spread in lane
Definition: GNEViewNet.cpp:4073
GNEViewNet::getPOIAtPopupPosition
GNEPOI * getPOIAtPopupPosition()
try to retrieve a POILane at popup position
Definition: GNEViewNet.cpp:2122
GNEViewNet::mySelectingArea
GNEViewNetHelper::SelectingArea mySelectingArea
variable used for grouping all variables related with selecting areas
Definition: GNEViewNet.h:734
GNEViewNet::getShapeEditedAtPopupPosition
GNENetworkElement * getShapeEditedAtPopupPosition()
try to retreive a edited shape at popup position
Definition: GNEViewNet.cpp:2152
GNEViewNet::getMoveSingleElementValues
const GNEViewNetHelper::MoveSingleElementModul & getMoveSingleElementValues() const
get move single element values
Definition: GNEViewNet.cpp:541
GNEViewNet::onCmdToggleShowConnections
long onCmdToggleShowConnections(FXObject *, FXSelector, void *)
toggle show connections
Definition: GNEViewNet.cpp:3899
GNEViewNet::updateObjectsInBoundary
void updateObjectsInBoundary(const Boundary &boundary)
get objects in the given boundary
Definition: GNEViewNet.cpp:483
GNEViewNet::onCmdLaneReachability
long onCmdLaneReachability(FXObject *, FXSelector sel, void *)
show lane reachability
Definition: GNEViewNet.cpp:3276
GNEViewNet::onCmdToggleShowTAZElements
long onCmdToggleShowTAZElements(FXObject *, FXSelector, void *)
toggle show TAZ elements
Definition: GNEViewNet.cpp:3964
GNEViewNet::myNetworkCheckableButtons
GNEViewNetHelper::NetworkCheckableButtons myNetworkCheckableButtons
variable used to save checkable buttons for Supermode Network
Definition: GNEViewNet.h:678
GNEViewNet::onCmdCloseShapeEdited
long onCmdCloseShapeEdited(FXObject *, FXSelector, void *)
close opened shape edited
Definition: GNEViewNet.cpp:2849
GNEViewNet::getEdgeDataAttrs
std::vector< std::string > getEdgeDataAttrs() const
return list of loaded edgeData attributes
Definition: GNEViewNet.cpp:1261
GNEViewNet::myCreatedPopup
bool myCreatedPopup
flag for mark if during this frame a popup was created (needed to avoid problems in linux with Cursor...
Definition: GNEViewNet.h:770
GNEViewNet::openSelectDialogAtCursor
void openSelectDialogAtCursor(const std::vector< GUIGlObject * > &GLObjects)
open select dialog at cursor
Definition: GNEViewNet.cpp:680
GNEViewNet::onCmdSimplifyShapeEdited
long onCmdSimplifyShapeEdited(FXObject *, FXSelector, void *)
Definition: GNEViewNet.cpp:2819
GNEViewNet::openObjectDialogAtCursor
void openObjectDialogAtCursor(const FXEvent *ev)
open object dialog
Definition: GNEViewNet.cpp:580
GNEViewNet::processClick
void processClick(void *eventData)
Auxiliary function used by onLeftBtnPress(...)
Definition: GNEViewNet.cpp:3313
GNEViewNet::drawNeteditAttributesReferences
void drawNeteditAttributesReferences()
draw circle in testing mode (needed for grid)
Definition: GNEViewNet.cpp:5608
GNEViewNet::onCmdSimplifyShape
long onCmdSimplifyShape(FXObject *, FXSelector, void *)
simply shape of current polygon
Definition: GNEViewNet.cpp:2656
GNEViewNet::getLaneAtPopupPosition
GNELane * getLaneAtPopupPosition()
try to retrieve a lane at popup position
Definition: GNEViewNet.cpp:2062
GNEViewNet::myFrontAttributeCarrier
GNEAttributeCarrier * myFrontAttributeCarrier
front attribute carrier
Definition: GNEViewNet.h:758
GNEViewNet::myMouseButtonKeyPressed
GNEViewNetHelper::MouseButtonKeyPressed myMouseButtonKeyPressed
variable used to save key status after certain events
Definition: GNEViewNet.h:667
GNEViewNet::recalculateBoundaries
void recalculateBoundaries()
recalculate boundaries
Definition: GNEViewNet.cpp:307
GNEViewNet::myIntervalBar
GNEViewNetHelper::IntervalBar myIntervalBar
variable used to save IntervalBar
Definition: GNEViewNet.h:703
GNEViewNet::myViewParent
GNEViewParent * myViewParent
view parent
Definition: GNEViewNet.h:743
GNEViewNet::showJunctionAsBubbles
bool showJunctionAsBubbles() const
return true if junction must be showed as bubbles
Definition: GNEViewNet.cpp:861
GNEViewNet::changeAllPhases
bool changeAllPhases() const
change all phases
Definition: GNEViewNet.cpp:855
GNEViewNet::onCmdEditJunctionShape
long onCmdEditJunctionShape(FXObject *, FXSelector, void *)
edit junction shape
Definition: GNEViewNet.cpp:3532
GNEViewNet::onCmdToggleMoveElevation
long onCmdToggleMoveElevation(FXObject *, FXSelector, void *)
toggle move elevation
Definition: GNEViewNet.cpp:4167
GNEViewNet::getWalkingAreaAtPopupPosition
GNEWalkingArea * getWalkingAreaAtPopupPosition()
try to retrieve a walkingArea at popup position
Definition: GNEViewNet.cpp:2032
GNEViewNet::onCmdToggleShowAllPersonPlans
long onCmdToggleShowAllPersonPlans(FXObject *, FXSelector, void *)
toggle show all person plans in super mode demand
Definition: GNEViewNet.cpp:4300
GNEViewNet::setColorScheme
bool setColorScheme(const std::string &name)
set color scheme
Definition: GNEViewNet.cpp:564
GNEViewNet::doPaintGL
int doPaintGL(int mode, const Boundary &bound)
do paintGL
Definition: GNEViewNet.cpp:1307
GNEViewNet::onCmdOpenAdditionalDialog
long onCmdOpenAdditionalDialog(FXObject *, FXSelector, void *)
open additional dialog
Definition: GNEViewNet.cpp:3301
GNEViewNet::onCmdToggleTAZRelOnlyTo
long onCmdToggleTAZRelOnlyTo(FXObject *, FXSelector, void *)
toggle TAZRez only to
Definition: GNEViewNet.cpp:4545
GNEViewNet::onCmdEgeApplyTemplate
long onCmdEgeApplyTemplate(FXObject *, FXSelector, void *)
apply template to edge
Definition: GNEViewNet.cpp:2630
GNEViewNet::onCmdSetNeteditView
long onCmdSetNeteditView(FXObject *, FXSelector sel, void *)
called when a new view is set
Definition: GNEViewNet.cpp:4650
GNEViewNet::getNetworkViewOptions
const GNEViewNetHelper::NetworkViewOptions & getNetworkViewOptions() const
get network view options
Definition: GNEViewNet.cpp:735
GNEViewNet::hotkeyFocusFrame
void hotkeyFocusFrame()
handle focus frame keypress
Definition: GNEViewNet.cpp:1832
GNEViewNet::onCmdToggleChainEdges
long onCmdToggleChainEdges(FXObject *, FXSelector, void *)
toggle chain edges
Definition: GNEViewNet.cpp:4186
GNEViewNet::myDemandViewOptions
GNEViewNetHelper::DemandViewOptions myDemandViewOptions
variable used to save variables related with view options in supermode Demand
Definition: GNEViewNet.h:695
GNEViewNet::drawTemporalJunctionTLSLines
void drawTemporalJunctionTLSLines() const
draw temporal Junction TLS Lines
Definition: GNEViewNet.cpp:5580
GNEViewNet::getEdgeLaneParamKeys
std::vector< std::string > getEdgeLaneParamKeys(bool edgeKeys) const
return list of available edge parameters
Definition: GNEViewNet.cpp:1229
GNEViewNet::onCmdLaneOperation
long onCmdLaneOperation(FXObject *, FXSelector sel, void *)
add/remove/restrict lane
Definition: GNEViewNet.cpp:3235
GNEViewNet::processMoveMouseData
void processMoveMouseData(const bool mouseLeftButtonPressed)
process move mouse function in Supermode Data
Definition: GNEViewNet.cpp:6284
GNEViewNet::myCurrentFrame
GNEFrame * myCurrentFrame
the current frame
Definition: GNEViewNet.h:749
GNEViewNet::autoSelectNodes
bool autoSelectNodes()
whether to autoselect nodes or to lanes
Definition: GNEViewNet.cpp:839
GNEViewNet::drawTemporalRoundabout
void drawTemporalRoundabout() const
draw temporal roundabout
Definition: GNEViewNet.cpp:5523
GNEViewNet::onCmdToggleLockContainer
long onCmdToggleLockContainer(FXObject *, FXSelector, void *)
toggle lock container in super mode demand
Definition: GNEViewNet.cpp:4373
GNEViewNet::myUndoList
GNEUndoList * myUndoList
a reference to the undolist maintained in the application
Definition: GNEViewNet.h:752
GNEViewNet::drawTranslateFrontAttributeCarrier
void drawTranslateFrontAttributeCarrier(const GNEAttributeCarrier *AC, double typeOrLayer, const double extraOffset=0)
draw front attributeCarrier
Definition: GNEViewNet.cpp:1935
GNEViewNet::myNetworkViewOptions
GNEViewNetHelper::NetworkViewOptions myNetworkViewOptions
variable used to save variables related with view options in supermode Network
Definition: GNEViewNet.h:692
GNEViewNet::doInit
void doInit()
called after some features are already initialized
Definition: GNEViewNet.cpp:336
GNEViewNet::onCmdResetEdgeEndPoints
long onCmdResetEdgeEndPoints(FXObject *, FXSelector, void *)
edit junction shape
Definition: GNEViewNet.cpp:3494
GNEViewNet::buildEditModeControls
void buildEditModeControls()
create edit mode buttons and elements
Definition: GNEViewNet.cpp:4661
GNEViewNet::myMoveSingleElement
GNEViewNetHelper::MoveSingleElementModul myMoveSingleElement
modul used for moving single element
Definition: GNEViewNet.h:709
GNEViewNet::onMiddleBtnRelease
long onMiddleBtnRelease(FXObject *, FXSelector, void *)
called when user releases mouse's left button
Definition: GNEViewNet.cpp:1458
GNEViewNet::getDrawingToggle
int getDrawingToggle() const
get draw toggle (used to avoid drawing junctions twice)
Definition: GNEViewNet.cpp:1301
GNEViewNet::myDataCheckableButtons
GNEViewNetHelper::DataCheckableButtons myDataCheckableButtons
variable used to save checkable buttons for Supermode Data
Definition: GNEViewNet.h:684
GNEViewNet::onCmdToggleShowGrid
long onCmdToggleShowGrid(FXObject *, FXSelector, void *)
toggle show grid
Definition: GNEViewNet.cpp:4021
GNEViewNet::processLeftButtonPressDemand
void processLeftButtonPressDemand(void *eventData)
process left button press function in Supermode Demand
Definition: GNEViewNet.cpp:5961
GNEViewNet::getDemandElementAtPopupPosition
GNEDemandElement * getDemandElementAtPopupPosition()
try to retrieve a demand element at popup position
Definition: GNEViewNet.cpp:2092
GNEViewNet::myTimeFormat
GNEViewNetHelper::TimeFormat myTimeFormat
variable used for grouping all variables related with switch time
Definition: GNEViewNet.h:731
GNEViewNet::onLeaveConvertRoundabout
long onLeaveConvertRoundabout(FXObject *, FXSelector, void *)
leave to convert junction to roundabout
Definition: GNEViewNet.cpp:3658
GNEViewNet::getIntervalBar
GNEViewNetHelper::IntervalBar & getIntervalBar()
get interval bar
Definition: GNEViewNet.cpp:1861
GNEViewNet::onCmdEditLaneShape
long onCmdEditLaneShape(FXObject *, FXSelector, void *)
edit lane shape
Definition: GNEViewNet.cpp:3175
GNEViewNet::onCmdToggleHideNonInspecteDemandElements
long onCmdToggleHideNonInspecteDemandElements(FXObject *, FXSelector, void *)
toggle hide non inspected demand elements
Definition: GNEViewNet.cpp:4224
GNEViewNet::getViewParent
GNEViewParent * getViewParent() const
get the net object
Definition: GNEViewNet.cpp:1843
GNEViewNet::onCmdToggleDrawJunctionShape
long onCmdToggleDrawJunctionShape(FXObject *, FXSelector, void *)
toggle draw junction shape
Definition: GNEViewNet.cpp:4047
GNEViewNet::checkOverLockedElement
bool checkOverLockedElement(const GUIGlObject *GLObject, const bool isSelected) const
check if given element is locked (used for drawing select and delete contour)
Definition: GNEViewNet.cpp:1951
GNEViewNet::onCmdStraightenShapeEdited
long onCmdStraightenShapeEdited(FXObject *, FXSelector, void *)
straight shape edited
Definition: GNEViewNet.cpp:2834
GNEViewNet::onCmdAddReversedEdge
long onCmdAddReversedEdge(FXObject *, FXSelector, void *)
add reversed edge
Definition: GNEViewNet.cpp:2438
GNEViewNet::processLeftButtonReleaseNetwork
void processLeftButtonReleaseNetwork()
process left button release function in Supermode Network
Definition: GNEViewNet.cpp:5904
GNEViewNet::onCmdDeleteGeometryPointShapeEdited
long onCmdDeleteGeometryPointShapeEdited(FXObject *, FXSelector, void *)
delete the closes geometry point in shape edited
Definition: GNEViewNet.cpp:2896
GNEViewNet::checkSelectEdges
bool checkSelectEdges() const
check if select edges (toggle using button or shift)
Definition: GNEViewNet.cpp:1290
GNEViewNet::onMiddleBtnPress
long onMiddleBtnPress(FXObject *, FXSelector, void *)
called when user press mouse's left button
Definition: GNEViewNet.cpp:1446
GNEViewNet::onCmdAddReversedEdgeDisconnected
long onCmdAddReversedEdgeDisconnected(FXObject *, FXSelector, void *)
add reversed edge disconnected
Definition: GNEViewNet.cpp:2459
GNEViewNet::onCmdIntervalBarGenericDataType
long onCmdIntervalBarGenericDataType(FXObject *, FXSelector, void *)
change generic data type in interval bar
Definition: GNEViewNet.cpp:4564
GNEViewNet::onCmdConvertRoundabout
long onCmdConvertRoundabout(FXObject *, FXSelector, void *)
convert junction to roundabout
Definition: GNEViewNet.cpp:3636
GNEViewNet::onCmdRemoveEdgeSelected
long onCmdRemoveEdgeSelected(FXObject *, FXSelector, void *)
unselect Edge under cursor
Definition: GNEViewNet.cpp:4639
GNEViewNet::onCmdAddReverse
long onCmdAddReverse(FXObject *, FXSelector, void *)
add a reverse demand element
Definition: GNEViewNet.cpp:3018
GNEViewNet::onCmdToggleShowShapes
long onCmdToggleShowShapes(FXObject *, FXSelector, void *)
toggle show shapes in super mode data
Definition: GNEViewNet.cpp:4427
GNEViewNet::onRightBtnPress
long onRightBtnPress(FXObject *, FXSelector, void *)
called when user press mouse's right button
Definition: GNEViewNet.cpp:1470
GNEViewNet::onCmdOpenPolygon
long onCmdOpenPolygon(FXObject *, FXSelector, void *)
open closed polygon
Definition: GNEViewNet.cpp:2733
GNEViewNet::onCmdSetCustomGeometryPoint
long onCmdSetCustomGeometryPoint(FXObject *, FXSelector, void *)
set custom geometry point
Definition: GNEViewNet.cpp:3032
GNEViewNet::removeRestrictedLane
bool removeRestrictedLane(GNELane *lane, SUMOVehicleClass vclass)
remove restricted lane
Definition: GNEViewNet.cpp:1131
GNEViewNet::onCmdIntervalBarDataSet
long onCmdIntervalBarDataSet(FXObject *, FXSelector, void *)
change data set in interval bar
Definition: GNEViewNet.cpp:4571
GNEViewNet::getSaveElements
GNEViewNetHelper::SaveElements & getSaveElements()
get variable used to save elements
Definition: GNEViewNet.cpp:958
GNEViewNet::processLeftButtonReleaseDemand
void processLeftButtonReleaseDemand()
process left button release function in Supermode Demand
Definition: GNEViewNet.cpp:6131
GNEViewNet::resetLastClickedPosition
void resetLastClickedPosition()
reset last clicked position
Definition: GNEViewNet.cpp:833
GNEViewNet::getTestingMode
const GNEViewNetHelper::TestingMode & getTestingMode() const
get testing mode
Definition: GNEViewNet.cpp:729
GNEViewNet::getUndoList
GNEUndoList * getUndoList() const
get the undoList object
Definition: GNEViewNet.cpp:1855
GNEViewNet::processLeftButtonPressData
void processLeftButtonPressData(void *eventData)
process left button press function in Supermode Data
Definition: GNEViewNet.cpp:6162
GNEViewNet::onCmdTransformPOI
long onCmdTransformPOI(FXObject *, FXSelector, void *)
transform POI to POILane, and vice versa
Definition: GNEViewNet.cpp:2936
GNEViewNet::saveVisualizationSettings
void saveVisualizationSettings() const
Definition: GNEViewNet.cpp:695
GNEViewNet::mySaveElements
GNEViewNetHelper::SaveElements mySaveElements
variable used for grouping all variables related with salve elements
Definition: GNEViewNet.h:728
GNEViewNet::getMoveMultipleElementValues
const GNEViewNetHelper::MoveMultipleElementModul & getMoveMultipleElementValues() const
get move multiple element values
Definition: GNEViewNet.cpp:547
GNEViewNet::myLockManager
GNEViewNetHelper::LockManager myLockManager
lock manager
Definition: GNEViewNet.h:740
GNEViewNet::onCmdAddEdgeSelected
long onCmdAddEdgeSelected(FXObject *, FXSelector, void *)
select Edge under cursor
Definition: GNEViewNet.cpp:4628
GNEViewNet::onCmdIntervalBarSetEnd
long onCmdIntervalBarSetEnd(FXObject *, FXSelector, void *)
change end in interval bar
Definition: GNEViewNet.cpp:4592
GNEViewNet::getViewObjectsSelector
const GNEViewNetHelper::ViewObjectsSelector & getViewObjectsSelector() const
get objects under cursor
Definition: GNEViewNet.cpp:477
GNEViewNet::drawTemporalDrawingShape
void drawTemporalDrawingShape() const
draw temporal polygon shape in Polygon Mode
Definition: GNEViewNet.cpp:5377
GNEViewNet::setLastCreatedRoute
void setLastCreatedRoute(GNEDemandElement *lastCreatedRoute)
set last created route
Definition: GNEViewNet.cpp:1981
GNEViewNet::removeFromAttributeCarrierInspected
void removeFromAttributeCarrierInspected(const GNEAttributeCarrier *AC)
remove given AC of list of inspected Attribute Carriers
Definition: GNEViewNet.cpp:1901
GNEViewNet::drawTestsCircle
void drawTestsCircle() const
draw circle in testing mode (needed for grid)
Definition: GNEViewNet.cpp:5616
GNEViewNet::onCmdSplitEdgeBidi
long onCmdSplitEdgeBidi(FXObject *, FXSelector, void *)
split edge at cursor position
Definition: GNEViewNet.cpp:2395
GNEViewNet::onCmdAddJoinTLS
long onCmdAddJoinTLS(FXObject *, FXSelector, void *)
add Join TLS
Definition: GNEViewNet.cpp:3758
GNEViewNet::getToolTipID
GUIGlID getToolTipID()
returns the id of object under cursor to show their tooltip
Definition: GNEViewNet.cpp:340
GNEViewNet::getJunctionAtPopupPosition
GNEJunction * getJunctionAtPopupPosition()
try to retrieve a junction at popup position
Definition: GNEViewNet.cpp:1987
GNEViewNet::drawTemporalSplitJunction
void drawTemporalSplitJunction() const
draw temporal split junction in create edge mode
Definition: GNEViewNet.cpp:5481
GNEViewNet::onCmdSetSupermode
long onCmdSetSupermode(FXObject *, FXSelector sel, void *)
Definition: GNEViewNet.cpp:2179
GNEViewNet::onCmdToggleExtendSelection
long onCmdToggleExtendSelection(FXObject *, FXSelector, void *)
toggle extend selection
Definition: GNEViewNet.cpp:3983
GNEViewNet::myDemandCheckableButtons
GNEViewNetHelper::DemandCheckableButtons myDemandCheckableButtons
variable used to save checkable buttons for Supermode Demand
Definition: GNEViewNet.h:681
GNEViewNet::getFrontGLObject
const GUIGlObject * getFrontGLObject() const
get front glObject
Definition: GNEViewNet.cpp:1918
GNEViewNet::checkMergeJunctions
bool checkMergeJunctions()
try to merge moved junction with another junction in that spot return true if merging did take place
Definition: GNEViewNet.cpp:867
GNEViewNet::aksChangeSupermode
bool aksChangeSupermode(const std::string &operation, Supermode expectedSupermode)
ask about change supermode
Definition: GNEViewNet.cpp:910
GNEViewNet::getTAZAtPopupPosition
GNETAZ * getTAZAtPopupPosition()
try to retrieve a TAZ at popup position
Definition: GNEViewNet.cpp:2137
GNEViewNet::onCmdSetMode
long onCmdSetMode(FXObject *, FXSelector sel, void *)
called when user press a mode button (Network or demand)
Definition: GNEViewNet.cpp:2205
GNEViewNet::onCmdResetEdgeEndpoint
long onCmdResetEdgeEndpoint(FXObject *, FXSelector, void *)
change geometry endpoint
Definition: GNEViewNet.cpp:2491
GNEViewNet::askMergeJunctions
bool askMergeJunctions(const GNEJunction *movedJunction, const GNEJunction *targetJunction)
ask merge junctions
Definition: GNEViewNet.cpp:884
GNEViewNet::onCmdIntervalBarSetBegin
long onCmdIntervalBarSetBegin(FXObject *, FXSelector, void *)
change begin in interval bar
Definition: GNEViewNet.cpp:4585
GNEViewNet::onCmdResetLength
long onCmdResetLength(FXObject *, FXSelector, void *)
reset custom edge lengths
Definition: GNEViewNet.cpp:2601
GNEViewNet::myLastClickedPosition
Position myLastClickedPosition
last clicked position
Definition: GNEViewNet.h:767
GNEViewNet::onCmdSelectPolygonElements
long onCmdSelectPolygonElements(FXObject *, FXSelector, void *)
select elements within polygon boundary
Definition: GNEViewNet.cpp:2766
GNEViewNet::onCmdSetFirstGeometryPointShapeEdited
long onCmdSetFirstGeometryPointShapeEdited(FXObject *, FXSelector, void *)
set first geometry point in shape edited
Definition: GNEViewNet.cpp:2879
GNEViewNet::onLeftBtnRelease
long onLeftBtnRelease(FXObject *, FXSelector, void *)
called when user releases mouse's left button
Definition: GNEViewNet.cpp:1419
GNEViewNet::onCmdRemoveSelected
long onCmdRemoveSelected(FXObject *, FXSelector, void *)
unselect AC under cursor
Definition: GNEViewNet.cpp:4617
GNEViewNet::onCmdDeleteGeometryPoint
long onCmdDeleteGeometryPoint(FXObject *, FXSelector, void *)
delete the closes geometry point
Definition: GNEViewNet.cpp:2689
GNEViewNet::onCmdDuplicateLane
long onCmdDuplicateLane(FXObject *, FXSelector, void *)
duplicate selected lane
Definition: GNEViewNet.cpp:3152
GNEViewNet::myInspectedAttributeCarriers
std::vector< GNEAttributeCarrier * > myInspectedAttributeCarriers
current inspected attribute carrier
Definition: GNEViewNet.h:755
GNEViewNet::processLeftButtonPressNetwork
void processLeftButtonPressNetwork(void *eventData)
mouse process functions
Definition: GNEViewNet.cpp:5635
GNEViewNet::hotkeyEnter
void hotkeyEnter()
handle enter keypress
Definition: GNEViewNet.cpp:1733
GNEViewNet::getConnectionAtPopupPosition
GNEConnection * getConnectionAtPopupPosition()
try to retrieve a connection at popup position
Definition: GNEViewNet.cpp:2002
GNEViewNet::onCmdOpenShapeEdited
long onCmdOpenShapeEdited(FXObject *, FXSelector, void *)
open closed shape edited
Definition: GNEViewNet.cpp:2864
GNEViewNet::getInspectedAttributeCarriers
const std::vector< GNEAttributeCarrier * > & getInspectedAttributeCarriers() const
get inspected attribute carriers
Definition: GNEViewNet.cpp:1867
GNEViewNet::onKeyPress
long onKeyPress(FXObject *o, FXSelector sel, void *data)
called when user press a key
Definition: GNEViewNet.cpp:1522
GNEViewNet::onCmdToggleShowOverlappedRoutes
long onCmdToggleShowOverlappedRoutes(FXObject *, FXSelector, void *)
toggle hide non inspected demand elements
Definition: GNEViewNet.cpp:4243
GNEViewNet::onCmdToggleAutoOppositeEdge
long onCmdToggleAutoOppositeEdge(FXObject *, FXSelector, void *)
toggle autoOpposite edge
Definition: GNEViewNet.cpp:4205
GNEViewNet::onCmdSplitEdge
long onCmdSplitEdge(FXObject *, FXSelector, void *)
split edge at cursor position
Definition: GNEViewNet.cpp:2385
GNEViewNet::getLockManager
GNEViewNetHelper::LockManager & getLockManager()
get lock manager
Definition: GNEViewNet.cpp:1873
GNEViewNet::onCmdStraightenEdgesElevation
long onCmdStraightenEdgesElevation(FXObject *, FXSelector, void *)
interpolate z values linear between junctions
Definition: GNEViewNet.cpp:2559
GNEViewNet::updateControls
void updateControls()
update control contents after undo/redo or recompute
Definition: GNEViewNet.cpp:5311
GNEViewNet::~GNEViewNet
~GNEViewNet()
destructor
Definition: GNEViewNet.cpp:303
GNEViewNet::myMoveMultipleElements
GNEViewNetHelper::MoveMultipleElementModul myMoveMultipleElements
modul used for moving multiple elements
Definition: GNEViewNet.h:712
GNEViewNet::onCmdSplitJunctionReconnect
long onCmdSplitJunctionReconnect(FXObject *, FXSelector, void *)
split junction into multiple junctions and reconnect them
Definition: GNEViewNet.cpp:3610
GNEViewNet::onCmdFinishShapeEdited
long onCmdFinishShapeEdited(FXObject *, FXSelector, void *)
finish shape edited
Definition: GNEViewNet.cpp:2928
GNEViewNet::buildSelectionACPopupEntry
void buildSelectionACPopupEntry(GUIGLObjectPopupMenu *ret, GNEAttributeCarrier *AC)
Builds an entry which allows to (de)select the object.
Definition: GNEViewNet.cpp:553
GNEViewNet::hotkeyDel
void hotkeyDel()
handle del keypress
Definition: GNEViewNet.cpp:1674
GNEViewNet::onCmdToggleChangeAllPhases
long onCmdToggleChangeAllPhases(FXObject *, FXSelector, void *)
toggle change all phases
Definition: GNEViewNet.cpp:4002
GNEViewNet::onEnterConvertRoundabout
long onEnterConvertRoundabout(FXObject *, FXSelector, void *)
enter to convert junction to roundabout
Definition: GNEViewNet.cpp:3650
GNEViewNet::myDrawPreviewRoundabout
bool myDrawPreviewRoundabout
draw preview roundabout
Definition: GNEViewNet.h:764
GNEViewNet::isAttributeCarrierInspected
bool isAttributeCarrierInspected(const GNEAttributeCarrier *AC) const
check if attribute carrier is being inspected
Definition: GNEViewNet.cpp:1885
GNEViewNet::GNEViewNet
GNEViewNet()
FOX needs this.
Definition: GNEViewNet.cpp:1204
GNEViewNet::onCmdToggleTAZRelDrawing
long onCmdToggleTAZRelDrawing(FXObject *, FXSelector, void *)
toggle TAZRel drawing
Definition: GNEViewNet.cpp:4488
GNEViewNet::onCmdToggleShowJunctionBubbles
long onCmdToggleShowJunctionBubbles(FXObject *, FXSelector, void *)
toggle show junction bubbles
Definition: GNEViewNet.cpp:4148
GNEViewNet::selectingDetectorsTLSMode
bool selectingDetectorsTLSMode() const
check if we're selecting detectors in TLS mode
Definition: GNEViewNet.cpp:940
GNEViewNet::selectingJunctionsTLSMode
bool selectingJunctionsTLSMode() const
check if we're selecting junctions in TLS mode
Definition: GNEViewNet.cpp:949
GNEViewNet::onCmdToggleShowAdditionalSubElements
long onCmdToggleShowAdditionalSubElements(FXObject *, FXSelector, void *)
toggle show additional sub-elements
Definition: GNEViewNet.cpp:3945
GNEViewNet::onCmdSmoothEdgesElevation
long onCmdSmoothEdgesElevation(FXObject *, FXSelector, void *)
smooth elevation with regard to adjoining edges
Definition: GNEViewNet.cpp:2580
GNEViewNet::onCmdToggleShowAllContainerPlans
long onCmdToggleShowAllContainerPlans(FXObject *, FXSelector, void *)
toggle show all container plans in super mode demand
Definition: GNEViewNet.cpp:4354
GNEViewNet::onCmdResetJunctionShape
long onCmdResetJunctionShape(FXObject *, FXSelector, void *)
reset junction shape
Definition: GNEViewNet.cpp:3556
GNEViewNet::onCmdToggleTAZRelOnlyFrom
long onCmdToggleTAZRelOnlyFrom(FXObject *, FXSelector, void *)
toggle TAZRez only from
Definition: GNEViewNet.cpp:4526
GNEViewNet::onCmdResetShapeEdited
long onCmdResetShapeEdited(FXObject *, FXSelector, void *)
reset shape edited
Definition: GNEViewNet.cpp:2913
GNEViewNet::onRightBtnRelease
long onRightBtnRelease(FXObject *, FXSelector, void *)
called when user releases mouse's right button
Definition: GNEViewNet.cpp:1485
GNEViewNet::buildColorRainbow
void buildColorRainbow(const GUIVisualizationSettings &s, GUIColorScheme &scheme, int active, GUIGlObjectType objectType, const GUIVisualizationRainbowSettings &rs)
recalibrate color scheme according to the current value range
Definition: GNEViewNet.cpp:765
GNEViewNet::onCmdIntervalBarSetParameter
long onCmdIntervalBarSetParameter(FXObject *, FXSelector, void *)
change parameter in interval bar
Definition: GNEViewNet.cpp:4599
GNEViewNet::drawTemporalE1TLSLines
void drawTemporalE1TLSLines() const
draw temporal E1 TLS Lines
Definition: GNEViewNet.cpp:5550
GNEViewNet::onCmdReverseEdge
long onCmdReverseEdge(FXObject *, FXSelector, void *)
reverse edge
Definition: GNEViewNet.cpp:2417
GNEViewNet::deleteDataAttributeCarriers
void deleteDataAttributeCarriers(const std::vector< GNEAttributeCarrier * > ACs)
delete data attribute carriers
Definition: GNEViewNet.cpp:5281
GNEViewNet::processLeftButtonReleaseData
void processLeftButtonReleaseData()
process left button release function in Supermode Data
Definition: GNEViewNet.cpp:6265
GNEViewNet::onCmdToggleShowAdditionals
long onCmdToggleShowAdditionals(FXObject *, FXSelector, void *)
toggle show additionals in super mode data
Definition: GNEViewNet.cpp:4408
GNEViewNet::onCmdToggleLockPerson
long onCmdToggleLockPerson(FXObject *, FXSelector, void *)
toggle lock person in super mode demand
Definition: GNEViewNet.cpp:4319
GNEViewNet::getTimeFormat
GNEViewNetHelper::TimeFormat & getTimeFormat()
get variable used to switch between time formats
Definition: GNEViewNet.cpp:964
GNEViewNet::myNet
GNENet * myNet
Pointer to current net. (We are not responsible for deletion)
Definition: GNEViewNet.h:746
GNEViewNet::getPolygonAtPopupPosition
GNEPoly * getPolygonAtPopupPosition()
try to retrieve a polygon at popup position
Definition: GNEViewNet.cpp:2107
GNEViewNet::onCmdToggleSelectEdges
long onCmdToggleSelectEdges(FXObject *, FXSelector, void *)
toggle select edges
Definition: GNEViewNet.cpp:3882
GNEViewNet::myDataViewOptions
GNEViewNetHelper::DataViewOptions myDataViewOptions
variable used to save variables related with view options in supermode Data
Definition: GNEViewNet.h:698
GNEViewNet::myDrawingToggle
int myDrawingToggle
drawin toggle (used in drawGLElements to avoid draw elements twice)
Definition: GNEViewNet.h:773
GNEViewNet::onCmdToggleShowTrips
long onCmdToggleShowTrips(FXObject *, FXSelector, void *)
toggle show all trips in super mode demand
Definition: GNEViewNet.cpp:4281
GNEViewNet::onCmdToggleHideShapes
long onCmdToggleHideShapes(FXObject *, FXSelector, void *)
toggle hide shapes in super mode demand
Definition: GNEViewNet.cpp:4262
GNEViewNet::onCmdEditEdgeEndpoint
long onCmdEditEdgeEndpoint(FXObject *, FXSelector, void *)
change geometry endpoint
Definition: GNEViewNet.cpp:2480
GNEViewNet::getDemandViewOptions
const GNEViewNetHelper::DemandViewOptions & getDemandViewOptions() const
get demand view options
Definition: GNEViewNet.cpp:741
GNEViewNet::deleteDemandAttributeCarriers
void deleteDemandAttributeCarriers(const std::vector< GNEAttributeCarrier * > ACs)
delete given demand attribute carriers
Definition: GNEViewNet.cpp:5267
GNEViewNet::updateViewNet
void updateViewNet() const
Mark the entire GNEViewNet to be repainted later.
Definition: GNEViewNet.cpp:419
GNEViewNet::onCmdToggleHideConnections
long onCmdToggleHideConnections(FXObject *, FXSelector, void *)
toggle hide connections
Definition: GNEViewNet.cpp:3926
GNEViewNet::openDeleteDialogAtCursor
void openDeleteDialogAtCursor(const std::vector< GUIGlObject * > &GLObjects)
open delete dialog at cursor
Definition: GNEViewNet.cpp:665
GNEViewNet::onKeyRelease
long onKeyRelease(FXObject *o, FXSelector sel, void *data)
called when user release a key
Definition: GNEViewNet.cpp:1547
GNEViewNet::onCmdResetConnections
long onCmdResetConnections(FXObject *, FXSelector, void *)
reset junction connections
Definition: GNEViewNet.cpp:3698
GNEViewNet::setInspectedAttributeCarriers
void setInspectedAttributeCarriers(const std::vector< GNEAttributeCarrier * > ACs)
set inspected attributeCarrier
Definition: GNEViewNet.cpp:1879
GNEViewNet::onCmdResetLaneCustomShape
long onCmdResetLaneCustomShape(FXObject *, FXSelector, void *)
reset custom shapes of selected lanes
Definition: GNEViewNet.cpp:3189
GNEViewNet::addRestrictedLane
bool addRestrictedLane(GNELane *lane, SUMOVehicleClass vclass, const bool insertAtFront)
add restricted lane
Definition: GNEViewNet.cpp:1043
GNEViewNet::setStatusBarText
void setStatusBarText(const std::string &text)
set statusBar text
Definition: GNEViewNet.cpp:827
GNEViewNet::onCmdEditWalkingAreaShape
long onCmdEditWalkingAreaShape(FXObject *, FXSelector, void *)
edit walkingArea shape
Definition: GNEViewNet.cpp:3858
GNEViewNet::processMoveMouseDemand
void processMoveMouseDemand(const bool mouseLeftButtonPressed)
process move mouse function in Supermode Demand
Definition: GNEViewNet.cpp:6150
GNEViewNet::onCmdResetOppositeLane
long onCmdResetOppositeLane(FXObject *, FXSelector, void *)
reset oppositeLane of current lane
Definition: GNEViewNet.cpp:3212
GNEViewNet::setSelectorFrameScale
void setSelectorFrameScale(double selectionScale)
set selection scaling (in GNESelectorFrame)
Definition: GNEViewNet.cpp:849
GNEViewNet::viewUpdated
void viewUpdated()
called when view is updated
Definition: GNEViewNet.cpp:432
GNEViewNet::onCmdEditConnectionShape
long onCmdEditConnectionShape(FXObject *, FXSelector, void *)
edit connection shape
Definition: GNEViewNet.cpp:3802
GNEViewNet::updateDemandModeSpecificControls
void updateDemandModeSpecificControls()
updates Demand mode specific controls
Definition: GNEViewNet.cpp:4904
GNEViewNet::forceSupemodeNetwork
void forceSupemodeNetwork()
force supermode network(used after load/create new network)
Definition: GNEViewNet.cpp:426
GNEViewNet::getAdditionalAtPopupPosition
GNEAdditional * getAdditionalAtPopupPosition()
try to retrieve a additional at popup position
Definition: GNEViewNet.cpp:2077
GNEViewNet::onCmdReverse
long onCmdReverse(FXObject *, FXSelector, void *)
reverse current demand element
Definition: GNEViewNet.cpp:3004
GNEViewNet::drawTemporalJunction
void drawTemporalJunction() const
draw temporal junction in create edge mode
Definition: GNEViewNet.cpp:5414
GNEViewNet::onCmdSelectRoundabout
long onCmdSelectRoundabout(FXObject *, FXSelector, void *)
select all roundabout nodes and edges
Definition: GNEViewNet.cpp:3623
GNEViewNet::onLeftBtnPress
long onLeftBtnPress(FXObject *, FXSelector, void *)
Definition: GNEViewNet.cpp:1397
GNEViewNet::getRelDataAttrs
std::vector< std::string > getRelDataAttrs() const
return list of loaded edgeRelation and tazRelation attributes
Definition: GNEViewNet.cpp:1273
GNEViewNet::drawGLElements
int drawGLElements(const Boundary &bound)
draw functions
Definition: GNEViewNet.cpp:3437
GNEViewNet::onCmdIntervalBarLimit
long onCmdIntervalBarLimit(FXObject *, FXSelector, void *)
change limit interval in interval bar
Definition: GNEViewNet.cpp:4578
GNEViewNet::myViewObjectsSelector
GNEViewNetHelper::ViewObjectsSelector myViewObjectsSelector
variable use to select objects in view
Definition: GNEViewNet.h:650
GNEViewParent
A single child window which contains a view of the simulation area.
Definition: GNEViewParent.h:88
GNEViewParent::getCrossingFrame
GNECrossingFrame * getCrossingFrame() const
get frame for NETWORK_CROSSING
Definition: GNEViewParent.cpp:241
GNEViewParent::getConnectorFrame
GNEConnectorFrame * getConnectorFrame() const
get frame for NETWORK_CONNECT
Definition: GNEViewParent.cpp:223
GNEViewParent::getStopFrame
GNEStopFrame * getStopFrame() const
get frame for DEMAND_STOP
Definition: GNEViewParent.cpp:313
GNEViewParent::getProhibitionFrame
GNEProhibitionFrame * getProhibitionFrame() const
get frame for NETWORK_PROHIBITION
Definition: GNEViewParent.cpp:259
GNEViewParent::getPersonPlanFrame
GNEPersonPlanFrame * getPersonPlanFrame() const
get frame for DEMAND_PERSONFRAME
Definition: GNEViewParent.cpp:325
GNEViewParent::getMeanDataFrame
GNEMeanDataFrame * getMeanDataFrame() const
get frame for DATA_TAZRELDATA
Definition: GNEViewParent.cpp:361
GNEViewParent::getShapeFrame
GNEShapeFrame * getShapeFrame() const
get frame for NETWORK_SHAPE
Definition: GNEViewParent.cpp:253
GNEViewParent::getTAZRelDataFrame
GNETAZRelDataFrame * getTAZRelDataFrame() const
get frame for DATA_TAZRELDATA
Definition: GNEViewParent.cpp:355
GNEViewParent::getMoveFrame
GNEMoveFrame * getMoveFrame() const
get frame for move elements
Definition: GNEViewParent.cpp:217
GNEViewParent::getSelectorFrame
GNESelectorFrame * getSelectorFrame() const
get frame for select elements
Definition: GNEViewParent.cpp:211
GNEViewParent::getContainerPlanFrame
GNEContainerPlanFrame * getContainerPlanFrame() const
get frame for DEMAND_CONTAINERFRAME
Definition: GNEViewParent.cpp:337
GNEViewParent::getEdgeDataFrame
GNEEdgeDataFrame * getEdgeDataFrame() const
get frame for DATA_EDGEDATA
Definition: GNEViewParent.cpp:343
GNEViewParent::getDeleteFrame
GNEDeleteFrame * getDeleteFrame() const
get frame for delete elements
Definition: GNEViewParent.cpp:205
GNEViewParent::getTypeDistributionFrame
GNETypeDistributionFrame * getTypeDistributionFrame() const
get frame for DEMAND_TYPEDISTRIBUTION
Definition: GNEViewParent.cpp:307
GNEViewParent::getVehicleFrame
GNEVehicleFrame * getVehicleFrame() const
get frame for DEMAND_VEHICLE
Definition: GNEViewParent.cpp:295
GNEViewParent::getDecalFrame
GNEDecalFrame * getDecalFrame() const
get frame for NETWORK_DECAL
Definition: GNEViewParent.cpp:271
GNEViewParent::hideAllFrames
void hideAllFrames()
hide all frames
Definition: GNEViewParent.cpp:174
GNEViewParent::getTypeFrame
GNETypeFrame * getTypeFrame() const
get frame for DEMAND_TYPE
Definition: GNEViewParent.cpp:301
GNEViewParent::getTAZFrame
GNETAZFrame * getTAZFrame() const
get frame for NETWORK_TAZ
Definition: GNEViewParent.cpp:247
GNEViewParent::getTLSEditorFrame
GNETLSEditorFrame * getTLSEditorFrame() const
get frame for NETWORK_TLS
Definition: GNEViewParent.cpp:229
GNEViewParent::getGNEAppWindows
GNEApplicationWindow * getGNEAppWindows() const
get GNE Application Windows
Definition: GNEViewParent.cpp:401
GNEViewParent::getContainerFrame
GNEContainerFrame * getContainerFrame() const
get frame for DEMAND_CONTAINER
Definition: GNEViewParent.cpp:331
GNEViewParent::getAdditionalFrame
GNEAdditionalFrame * getAdditionalFrame() const
get frame for NETWORK_ADDITIONAL
Definition: GNEViewParent.cpp:235
GNEViewParent::getRouteDistributionFrame
GNERouteDistributionFrame * getRouteDistributionFrame() const
get frame for DEMAND_ROUTEDISTRIBUTION
Definition: GNEViewParent.cpp:283
GNEViewParent::getWireFrame
GNEWireFrame * getWireFrame() const
get frame for NETWORK_WIRE
Definition: GNEViewParent.cpp:265
GNEViewParent::getPersonFrame
GNEPersonFrame * getPersonFrame() const
get frame for DEMAND_PERSON
Definition: GNEViewParent.cpp:319
GNEViewParent::getInspectorFrame
GNEInspectorFrame * getInspectorFrame() const
get frame for inspect elements
Definition: GNEViewParent.cpp:199
GNEViewParent::getEdgeRelDataFrame
GNEEdgeRelDataFrame * getEdgeRelDataFrame() const
get frame for DATA_EDGERELDATA
Definition: GNEViewParent.cpp:349
GNEViewParent::getCreateEdgeFrame
GNECreateEdgeFrame * getCreateEdgeFrame() const
get frame for NETWORK_CREATEEDGE
Definition: GNEViewParent.cpp:277
GNEViewParent::getRouteFrame
GNERouteFrame * getRouteFrame() const
get frame for DEMAND_ROUTE
Definition: GNEViewParent.cpp:289
GNEWalkingArea
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNEWalkingArea.h:44
GNEWalkingArea::getParentJunction
GNEJunction * getParentJunction() const
get parent Junction
Definition: GNEWalkingArea.cpp:141
GNEWireFrame::getConsecutiveLaneSelector
GNEConsecutiveSelector * getConsecutiveLaneSelector() const
get consecutive lane selector
Definition: GNEWireFrame.cpp:109
GNEWireFrame::createPath
bool createPath(const bool useLastRoute)
create path
Definition: GNEWireFrame.cpp:115
GNEWireFrame::show
void show()
show wire frame
Definition: GNEWireFrame.cpp:63
GNEWireFrame::addWire
bool addWire(const GNEViewNetHelper::ViewObjectsSelector &viewObjects)
add wire element
Definition: GNEWireFrame.cpp:76
GUICompleteSchemeStorage::contains
bool contains(const std::string &name) const
Returns the information whether a setting with the given name is stored.
Definition: GUICompleteSchemeStorage.cpp:79
GUICompleteSchemeStorage::get
GUIVisualizationSettings & get(const std::string &name)
Returns the named scheme.
Definition: GUICompleteSchemeStorage.cpp:67
GUICompleteSchemeStorage::getNames
const std::vector< std::string > & getNames() const
Returns a list of stored settings names.
Definition: GUICompleteSchemeStorage.cpp:105
GUICursorDialog
Dialog for edit rerouter intervals.
Definition: GUICursorDialog.h:38
GUICursorSubSys::getCursor
static FXCursor * getCursor(GUICursor which)
returns a cursor previously defined in the enum GUICursor
Definition: GUICursorSubSys.cpp:88
GUIDesigns::buildFXMenuCommand
static FXMenuCommand * buildFXMenuCommand(FXComposite *p, const std::string &text, FXIcon *icon, FXObject *tgt, FXSelector sel, const bool disable=false)
build menu command
Definition: GUIDesigns.cpp:42
GUIDialog_ViewSettings::getCurrentScheme
std::string getCurrentScheme() const
Returns the name of the currently chosen scheme.
Definition: GUIDialog_ViewSettings.cpp:1564
GUIDialog_ViewSettings::setCurrentScheme
void setCurrentScheme(const std::string &)
Sets the named scheme as the current.
Definition: GUIDialog_ViewSettings.cpp:1570
GUIGLObjectPopupMenu
The popup menu of a globject.
Definition: GUIGLObjectPopupMenu.h:45
GUIGeometry::drawGeometry
static void drawGeometry(const GUIVisualizationSettings::Detail d, const GUIGeometry &geometry, const double width, double offset=0)
draw geometry
Definition: GUIGeometry.cpp:277
GUIGeometry::drawChildLine
static void drawChildLine(const GUIVisualizationSettings &s, const Position &child, const Position &parent, const RGBColor &color, const bool drawEntire, const double lineWidth)
draw line between child and parent (used in netedit)
Definition: GUIGeometry.cpp:457
GUIGeometry::updateGeometry
void updateGeometry(const PositionVector &shape)
update entire geometry
Definition: GUIGeometry.cpp:59
GUIGlChildWindow::getColoringSchemesCombo
MFXComboBoxIcon * getColoringSchemesCombo()
return combobox with the current coloring schemes (standard, fastest standard, real world....
Definition: GUIGlChildWindow.cpp:195
GUIGlChildWindow::getLocatorPopup
FXPopup * getLocatorPopup()
@ brief return a pointer to locator popup
Definition: GUIGlChildWindow.cpp:189
GUIGlObject::getType
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.h:156
GUIGlObject::getMicrosimID
const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition: GUIGlObject.h:143
GUIGlObject::isGLObjectLocked
virtual bool isGLObjectLocked() const
check if element is locked (Currently used only in netedit)
Definition: GUIGlObject.cpp:207
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:104
GUIGlObjectStorage::getObjectBlocking
GUIGlObject * getObjectBlocking(GUIGlID id) const
Returns the object from the container locking it.
Definition: GUIGlObjectStorage.cpp:74
GUIGlObjectStorage::gIDStorage
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
Definition: GUIGlObjectStorage.h:129
GUIIconSubSys::getIcon
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:1133
GUIMainWindow::getStaticTooltipMenu
MFXStaticToolTip * getStaticTooltipMenu() const
get static toolTip for menus
Definition: GUIMainWindow.cpp:209
GUIMainWindow::setStatusBarText
virtual void setStatusBarText(const std::string &)
get status bar text (can be implemented in children)
Definition: GUIMainWindow.h:109
GUIPerspectiveChanger::getRotation
virtual double getRotation() const =0
Returns the rotation of the canvas stored in this changer.
GUIPerspectiveChanger::getZoom
virtual double getZoom() const =0
Returns the zoom factor computed stored in this changer.
GUIPerspectiveChanger::onLeftBtnPress
virtual void onLeftBtnPress(void *data)
mouse functions
Definition: GUIPerspectiveChanger.cpp:42
GUIPerspectiveChanger::getXPos
virtual double getXPos() const =0
Returns the x-offset of the field to show stored in this changer.
GUIPerspectiveChanger::getYPos
virtual double getYPos() const =0
Returns the y-offset of the field to show stored in this changer.
GUIPropertyScheme::getColor
T getColor(const double value) const
Definition: GUIPropertyScheme.h:124
GUIPropertyScheme::getName
const std::string & getName() const
Definition: GUIPropertyScheme.h:151
GUIPropertyScheme::addColor
int addColor(const T &color, const double threshold, const std::string &name="")
Definition: GUIPropertyScheme.h:94
GUISUMOAbstractView::myAmInitialised
bool myAmInitialised
Internal information whether doInit() was called.
Definition: GUISUMOAbstractView.h:593
GUISUMOAbstractView::snapToActiveGrid
Position snapToActiveGrid(const Position &pos, bool snapXY=true) const
Returns a position that is mapped to the closest grid point if the grid is active.
Definition: GUISUMOAbstractView.cpp:205
GUISUMOAbstractView::myCurrentObjectsDialog
std::vector< GUIGlObject * > myCurrentObjectsDialog
vector with current objects dialog
Definition: GUISUMOAbstractView.h:587
GUISUMOAbstractView::onLeftBtnRelease
virtual long onLeftBtnRelease(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1096
GUISUMOAbstractView::myGrid
const SUMORTree * myGrid
The visualization speed-up.
Definition: GUISUMOAbstractView.h:563
GUISUMOAbstractView::openObjectDialog
void openObjectDialog(const std::vector< GUIGlObject * > &objects, const bool filter=true)
open object dialog for the given object
Definition: GUISUMOAbstractView.cpp:1263
GUISUMOAbstractView::paintGLGrid
void paintGLGrid() const
paints a grid
Definition: GUISUMOAbstractView.cpp:595
GUISUMOAbstractView::makeCurrent
FXbool makeCurrent()
A reimplementation due to some internal reasons.
Definition: GUISUMOAbstractView.cpp:975
GUISUMOAbstractView::myClickedPopupPosition
Position myClickedPopupPosition
clicked poup position
Definition: GUISUMOAbstractView.h:581
GUISUMOAbstractView::buildMinMaxRainbow
void buildMinMaxRainbow(const GUIVisualizationSettings &s, GUIColorScheme &scheme, const GUIVisualizationRainbowSettings &rs, double minValue, double maxValue, bool hasMissingData)
helper function for buildColorRainbow
Definition: GUISUMOAbstractView.cpp:1944
GUISUMOAbstractView::onMiddleBtnRelease
virtual long onMiddleBtnRelease(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1125
GUISUMOAbstractView::onMouseMove
virtual long onMouseMove(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1189
GUISUMOAbstractView::myPanning
bool myPanning
Panning flag.
Definition: GUISUMOAbstractView.h:569
GUISUMOAbstractView::myApp
GUIMainWindow * myApp
The application.
Definition: GUISUMOAbstractView.h:557
GUISUMOAbstractView::getObjectsInBoundary
std::vector< GUIGlID > getObjectsInBoundary(Boundary bound)
returns the ids of all objects in the given boundary
Definition: GUISUMOAbstractView.cpp:515
GUISUMOAbstractView::getPopupPosition
const Position & getPopupPosition() const
get position of current popup
Definition: GUISUMOAbstractView.cpp:1013
GUISUMOAbstractView::m2p
double m2p(double meter) const
meter-to-pixels conversion method
Definition: GUISUMOAbstractView.cpp:903
GUISUMOAbstractView::myVisualizationSettings
GUIVisualizationSettings * myVisualizationSettings
visualization settings
Definition: GUISUMOAbstractView.h:590
GUISUMOAbstractView::destroyPopup
void destroyPopup()
destroys the popup
Definition: GUISUMOAbstractView.cpp:1019
GUISUMOAbstractView::onKeyPress
virtual long onKeyPress(FXObject *o, FXSelector sel, void *data)
keyboard functions
Definition: GUISUMOAbstractView.cpp:1294
GUISUMOAbstractView::onMiddleBtnPress
virtual long onMiddleBtnPress(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1108
GUISUMOAbstractView::getPositionInformation
virtual Position getPositionInformation() const
Returns the cursor's x/y position within the network.
Definition: GUISUMOAbstractView.cpp:199
GUISUMOAbstractView::onKeyRelease
virtual long onKeyRelease(FXObject *o, FXSelector sel, void *data)
Definition: GUISUMOAbstractView.cpp:1327
GUISUMOAbstractView::myGUIDialogViewSettings
GUIDialog_ViewSettings * myGUIDialogViewSettings
Visualization changer.
Definition: GUISUMOAbstractView.h:602
GUISUMOAbstractView::drawDecals
void drawDecals()
Draws the stored decals.
Definition: GUISUMOAbstractView.cpp:1780
GUISUMOAbstractView::onRightBtnRelease
virtual long onRightBtnRelease(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1152
GUISUMOAbstractView::myChanger
GUIPerspectiveChanger * myChanger
The perspective changer.
Definition: GUISUMOAbstractView.h:566
GUISUMOAbstractView::myPopup
GUIGLObjectPopupMenu * myPopup
The current popup-menu.
Definition: GUISUMOAbstractView.h:578
GUISUMOAbstractView::onPaint
virtual long onPaint(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1000
GUISUMOAbstractView::onRightBtnPress
virtual long onRightBtnPress(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:1141
GUISUMOAbstractView::openPopupDialog
void openPopupDialog()
open popup dialog
Definition: GUISUMOAbstractView.cpp:1826
GUITextureSubSys::resetTextures
static void resetTextures()
Reset textures.
Definition: GUITextureSubSys.cpp:228
GUIViewObjectsHandler::updateFrontElement
void updateFrontElement(const GUIGlObject *GLObject)
move front element in elements under cursor (currently used only in netedit)
Definition: GUIViewObjectsHandler.cpp:394
GUIViewObjectsHandler::setSelectionPosition
void setSelectionPosition(const Position &pos)
set selection position (usually the mouse position)
Definition: GUIViewObjectsHandler.cpp:66
GUIViewObjectsHandler::isolateEdgeGeometryPoints
void isolateEdgeGeometryPoints()
isolate edge geometry points (used for moving)
Definition: GUIViewObjectsHandler.cpp:419
GUIViewObjectsHandler::setSelectionBoundary
void setSelectionBoundary(const Boundary &boundary)
set selection boundary (usually the mouse position)
Definition: GUIViewObjectsHandler.cpp:76
GUIViewObjectsHandler::getSelectedObjects
const GLObjectsSortedContainer & getSelectedObjects() const
get all elements under cursor sorted by layer
Definition: GUIViewObjectsHandler.cpp:360
GUIViewObjectsHandler::clearSelectedElements
void clearSelectedElements()
clear selected elements
Definition: GUIViewObjectsHandler.cpp:36
GUIViewObjectsHandler::markedEdge
const GNEEdge * markedEdge
marked edge (used in create edge mode, for splitting)
Definition: GUIViewObjectsHandler.h:140
GUIViewObjectsHandler::markedLane
const GNELane * markedLane
marked lane (used in create edge mode, for splitting)
Definition: GUIViewObjectsHandler.h:143
GUIViewObjectsHandler::getMergingJunctions
const std::vector< const GNEJunction * > & getMergingJunctions() const
get merging junctions
Definition: GUIViewObjectsHandler.cpp:441
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:584
GUIVisualizationSettings::junctionSize
GUIVisualizationSizeSettings junctionSize
Definition: GUIVisualizationSettings.h:921
GUIVisualizationSettings::drawForRectangleSelection
bool drawForRectangleSelection
whether drawing is performed for the purpose of selecting objects using a rectangle
Definition: GUIVisualizationSettings.h:1049
GUIVisualizationSettings::name
std::string name
The name of this setting.
Definition: GUIVisualizationSettings.h:704
GUIVisualizationSettings::drawJunctionShape
bool drawJunctionShape
whether the shape of the junction should be drawn
Definition: GUIVisualizationSettings.h:917
GUIVisualizationSettings::disableLaneIcons
bool disableLaneIcons
whether drawing is performed in left-hand networks
Definition: GUIVisualizationSettings.h:1073
GUIVisualizationSettings::lefthand
bool lefthand
whether drawing is performed in left-hand networks
Definition: GUIVisualizationSettings.h:1067
GUIVisualizationSettings::showLane2Lane
bool showLane2Lane
Information whether lane-to-lane arrows shall be drawn.
Definition: GUIVisualizationSettings.h:915
GUIVisualizationSettings::colorSettings
GUIVisualizationColorSettings colorSettings
color settings
Definition: GUIVisualizationSettings.h:1092
GUIVisualizationSettings::showGrid
bool showGrid
Information whether a grid shall be shown.
Definition: GUIVisualizationSettings.h:728
GUIVisualizationSettings::save
void save(OutputDevice &dev) const
Writes the settings into an output device.
Definition: GUIVisualizationSettings.cpp:1874
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:1034
GUIVisualizationSettings::drawForViewObjectsHandler
bool drawForViewObjectsHandler
whether drawing is performed for the purpose of selecting objects in view using ViewObjectsHandler
Definition: GUIVisualizationSettings.h:1046
GUIVisualizationSettings::additionalSettings
GUIVisualizationAdditionalSettings additionalSettings
Additional settings.
Definition: GUIVisualizationSettings.h:1104
GUIVisualizationSettings::selectorFrameScale
double selectorFrameScale
the current selection scaling in netedit (set in SelectorFrame)
Definition: GUIVisualizationSettings.h:1043
GUIVisualizationSettings::junctionColorer
GUIColorer junctionColorer
The junction colorer.
Definition: GUIVisualizationSettings.h:909
GUIVisualizationSettings::SCHEME_NAME_PERMISSION_CODE
static const std::string SCHEME_NAME_PERMISSION_CODE
Definition: GUIVisualizationSettings.h:1083
GUIVisualizationSettings::neteditSizeSettings
GUIVisualizationNeteditSizeSettings neteditSizeSettings
netedit size settings
Definition: GUIVisualizationSettings.h:1098
MFXCheckableButton::amChecked
bool amChecked() const
check if this MFXCheckableButton is checked
Definition: MFXCheckableButton.cpp:52
MFXCheckableButton::setChecked
void setChecked(bool val, const bool inform=false)
check or uncheck this MFXCheckableButton
Definition: MFXCheckableButton.cpp:58
MFXComboBoxIcon::setCurrentItem
long setCurrentItem(const FXint index, FXbool notify=FALSE)
Set the current item (index is zero-based)
Definition: MFXComboBoxIcon.cpp:225
MFXComboBoxIcon::getNumItems
FXint getNumItems() const
Return the number of items in the list.
Definition: MFXComboBoxIcon.cpp:201
MFXComboBoxIcon::appendIconItem
FXint appendIconItem(const FXString &text, FXIcon *icon=nullptr, FXColor bgColor=FXRGB(255, 255, 255), void *ptr=nullptr)
append icon item in the last position
Definition: MFXComboBoxIcon.cpp:297
NBEdgeCont::getAllEdges
EdgeVector getAllEdges() const
return all edges
Definition: NBEdgeCont.cpp:2119
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:92
NBEdge::getGeometry
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:779
NBEdge::getInnerGeometry
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
Definition: NBEdge.cpp:584
NBNode::getControllingTLS
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node)
Definition: NBNode.h:336
NBNode::getShape
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2614
NBNode::getPosition
const Position & getPosition() const
Definition: NBNode.h:260
NBTrafficLightLogicCont::exist
bool exist(const std::string &newID, bool requireComputed=true) const
check if exists a definition with the given ID
Definition: NBTrafficLightLogicCont.cpp:148
OptionsCont::getBool
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Definition: OptionsCont.cpp:228
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice::close
void close()
Closes the device and removes it from the dictionary.
Definition: OutputDevice.cpp:228
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:267
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:254
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:281
OutputDevice::getDevice
static OutputDevice & getDevice(const std::string &name, bool usePrefix=true)
Returns the described OutputDevice.
Definition: OutputDevice.cpp:60
POI
C++ TraCI client API implementation.
Definition: POI.h:34
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:322
Position::distanceTo
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimensions
Definition: Position.h:266
Position::distanceSquaredTo
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:271
Position::x
double x() const
Returns the x-position.
Definition: Position.h:55
Position::y
double y() const
Returns the y-position.
Definition: Position.h:60
PositionVector
A list of positions.
Definition: PositionVector.h:43
PositionVector::positionAtOffset
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
Definition: PositionVector.cpp:250
PositionVector::nearest_offset_to_point2D
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
Definition: PositionVector.cpp:891
PositionVector::indexOfClosest
int indexOfClosest(const Position &p, bool twoD=false) const
Definition: PositionVector.cpp:1014
PositionVector::move2side
void move2side(double amount, double maxExtension=100)
move position vector to side using certain amount
Definition: PositionVector.cpp:1178
PositionVector::getBoxBoundary
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
Definition: PositionVector.cpp:425
PositionVector::pop_front
void pop_front()
pop first Position
Definition: PositionVector.cpp:1412
RGBColor::setAlpha
void setAlpha(unsigned char alpha)
Sets a new alpha value.
Definition: RGBColor.cpp:108
RGBColor::BLUE
static const RGBColor BLUE
Definition: RGBColor.h:187
RGBColor::ORANGE
static const RGBColor ORANGE
Definition: RGBColor.h:191
RGBColor::GREEN
static const RGBColor GREEN
Definition: RGBColor.h:186
RGBColor::fromHSV
static RGBColor fromHSV(double h, double s, double v)
Converts the given hsv-triplet to rgb, inspired by http://alvyray.com/Papers/CG/hsv2rgb....
Definition: RGBColor.cpp:371
RGBColor::BLACK
static const RGBColor BLACK
Definition: RGBColor.h:193
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:185
SUMOPolygon::getShape
const PositionVector & getShape() const
Returns the shape of the polygon.
Definition: SUMOPolygon.cpp:51
SUMORTree::addAdditionalGLObject
void addAdditionalGLObject(GUIGlObject *o, const double exaggeration=1)
Adds an additional object (detector/shape/trigger) for visualisation.
Definition: SUMORTree.h:124
SUMORTree::removeAdditionalGLObject
void removeAdditionalGLObject(GUIGlObject *o, const double exaggeration=1)
Removes an additional object (detector/shape/trigger) from being visualised.
Definition: SUMORTree.h:162
SUMORTree::Search
virtual int Search(const float a_min[2], const float a_max[2], const GUIVisualizationSettings &c) const
Find all within search rectangle.
Definition: SUMORTree.h:116
GNEApplicationWindowHelper::EditMenuCommands::demandViewOptions
DemandViewOptions demandViewOptions
demand view options
Definition: GNEApplicationWindowHelper.h:687
GNEApplicationWindowHelper::EditMenuCommands::networkViewOptions
NetworkViewOptions networkViewOptions
network view options
Definition: GNEApplicationWindowHelper.h:684
GNEApplicationWindowHelper::ToolbarsGrip::modes
FXMenuBar * modes
The application menu bar (for select, inspect...)
Definition: GNEApplicationWindowHelper.h:92
GNEViewNetHelper::CommonCheckableButtons::buildCommonCheckableButtons
void buildCommonCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:3466
GNEViewNetHelper::CommonCheckableButtons::updateCommonCheckableButtons
void updateCommonCheckableButtons()
update Common checkable buttons
Definition: GNEViewNetHelper.cpp:3516
GNEViewNetHelper::CommonCheckableButtons::disableCommonCheckableButtons
void disableCommonCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3508
GNEViewNetHelper::CommonCheckableButtons::selectButton
MFXCheckableButton * selectButton
checkable button for edit mode select
Definition: GNEViewNetHelper.h:1261
GNEViewNetHelper::CommonCheckableButtons::inspectButton
MFXCheckableButton * inspectButton
checkable button for edit mode inspect
Definition: GNEViewNetHelper.h:1255
GNEViewNetHelper::CommonCheckableButtons::deleteButton
MFXCheckableButton * deleteButton
checkable button for edit mode delete
Definition: GNEViewNetHelper.h:1258
GNEViewNetHelper::DataCheckableButtons::disableDataCheckableButtons
void disableDataCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3886
GNEViewNetHelper::DataCheckableButtons::buildDataCheckableButtons
void buildDataCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:3837
GNEViewNetHelper::DataCheckableButtons::updateDataCheckableButtons
void updateDataCheckableButtons()
update Data checkable buttons
Definition: GNEViewNetHelper.cpp:3895
GNEViewNetHelper::DataCheckableButtons::edgeDataButton
MFXCheckableButton * edgeDataButton
checkable button for edit mode "edgeData"
Definition: GNEViewNetHelper.h:1408
GNEViewNetHelper::DataCheckableButtons::edgeRelDataButton
MFXCheckableButton * edgeRelDataButton
checkable button for edit mode "edgeRelData"
Definition: GNEViewNetHelper.h:1411
GNEViewNetHelper::DataCheckableButtons::TAZRelDataButton
MFXCheckableButton * TAZRelDataButton
checkable button for edit mode "TAZRelData"
Definition: GNEViewNetHelper.h:1414
GNEViewNetHelper::DataCheckableButtons::meanDataButton
MFXCheckableButton * meanDataButton
checkable button for edit mode "meanData"
Definition: GNEViewNetHelper.h:1417
GNEViewNetHelper::DataViewOptions
struct used to group all variables related to view options in supermode Data
Definition: GNEViewNetHelper.h:851
GNEViewNetHelper::DataViewOptions::hideDataViewOptionsMenuChecks
void hideDataViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3003
GNEViewNetHelper::DataViewOptions::menuCheckToggleTAZDrawFill
MFXCheckableButton * menuCheckToggleTAZDrawFill
menu check to toggle TAZ draw fill
Definition: GNEViewNetHelper.h:902
GNEViewNetHelper::DataViewOptions::menuCheckShowAdditionals
MFXCheckableButton * menuCheckShowAdditionals
menu check to show Additionals
Definition: GNEViewNetHelper.h:890
GNEViewNetHelper::DataViewOptions::menuCheckShowShapes
MFXCheckableButton * menuCheckShowShapes
menu check to show Shapes
Definition: GNEViewNetHelper.h:893
GNEViewNetHelper::DataViewOptions::menuCheckToggleTAZRelOnlyFrom
MFXCheckableButton * menuCheckToggleTAZRelOnlyFrom
menu check to toggle TAZRel only from
Definition: GNEViewNetHelper.h:905
GNEViewNetHelper::DataViewOptions::menuCheckToggleDrawJunctionShape
MFXCheckableButton * menuCheckToggleDrawJunctionShape
checkable button to show junction shapes
Definition: GNEViewNetHelper.h:887
GNEViewNetHelper::DataViewOptions::buildDataViewOptionsMenuChecks
void buildDataViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:2942
GNEViewNetHelper::DataViewOptions::menuCheckToggleTAZRelDrawing
MFXCheckableButton * menuCheckToggleTAZRelDrawing
menu check to toggle TAZ Rel drawing
Definition: GNEViewNetHelper.h:899
GNEViewNetHelper::DataViewOptions::menuCheckShowDemandElements
MFXCheckableButton * menuCheckShowDemandElements
menu check to show Demand Elements
Definition: GNEViewNetHelper.h:896
GNEViewNetHelper::DataViewOptions::menuCheckToggleTAZRelOnlyTo
MFXCheckableButton * menuCheckToggleTAZRelOnlyTo
menu check to toggle TAZRel only to
Definition: GNEViewNetHelper.h:908
GNEViewNetHelper::DemandCheckableButtons::routeDistributionButton
MFXCheckableButton * routeDistributionButton
checkable button for edit mode create route distributions
Definition: GNEViewNetHelper.h:1355
GNEViewNetHelper::DemandCheckableButtons::containerButton
MFXCheckableButton * containerButton
checkable button for edit mode create containers
Definition: GNEViewNetHelper.h:1376
GNEViewNetHelper::DemandCheckableButtons::moveDemandElementsButton
MFXCheckableButton * moveDemandElementsButton
checkable button for edit mode "move demand elements"
Definition: GNEViewNetHelper.h:1349
GNEViewNetHelper::DemandCheckableButtons::typeButton
MFXCheckableButton * typeButton
checkable button for edit mode create type
Definition: GNEViewNetHelper.h:1361
GNEViewNetHelper::DemandCheckableButtons::buildDemandCheckableButtons
void buildDemandCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:3685
GNEViewNetHelper::DemandCheckableButtons::vehicleButton
MFXCheckableButton * vehicleButton
checkable button for edit mode create vehicles
Definition: GNEViewNetHelper.h:1358
GNEViewNetHelper::DemandCheckableButtons::containerPlanButton
MFXCheckableButton * containerPlanButton
checkable button for edit mode create container plans
Definition: GNEViewNetHelper.h:1379
GNEViewNetHelper::DemandCheckableButtons::routeButton
MFXCheckableButton * routeButton
checkable button for edit mode create routes
Definition: GNEViewNetHelper.h:1352
GNEViewNetHelper::DemandCheckableButtons::stopButton
MFXCheckableButton * stopButton
checkable button for edit mode create stops
Definition: GNEViewNetHelper.h:1367
GNEViewNetHelper::DemandCheckableButtons::personPlanButton
MFXCheckableButton * personPlanButton
checkable button for edit mode create person plans
Definition: GNEViewNetHelper.h:1373
GNEViewNetHelper::DemandCheckableButtons::personButton
MFXCheckableButton * personButton
checkable button for edit mode create persons
Definition: GNEViewNetHelper.h:1370
GNEViewNetHelper::DemandCheckableButtons::updateDemandCheckableButtons
void updateDemandCheckableButtons()
update Demand checkable buttons
Definition: GNEViewNetHelper.cpp:3813
GNEViewNetHelper::DemandCheckableButtons::typeDistributionButton
MFXCheckableButton * typeDistributionButton
checkable button for edit mode create type distribution
Definition: GNEViewNetHelper.h:1364
GNEViewNetHelper::DemandCheckableButtons::disableDemandCheckableButtons
void disableDemandCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3797
GNEViewNetHelper::DemandViewOptions
struct used to group all variables related to view options in supermode Demand
Definition: GNEViewNetHelper.h:747
GNEViewNetHelper::DemandViewOptions::menuCheckShowAllTrips
MFXCheckableButton * menuCheckShowAllTrips
show all trips
Definition: GNEViewNetHelper.h:813
GNEViewNetHelper::DemandViewOptions::lockPerson
void lockPerson(const GNEDemandElement *person)
lock person
Definition: GNEViewNetHelper.cpp:2878
GNEViewNetHelper::DemandViewOptions::menuCheckToggleGrid
MFXCheckableButton * menuCheckToggleGrid
menu check to show grid button
Definition: GNEViewNetHelper.h:801
GNEViewNetHelper::DemandViewOptions::menuCheckToggleDrawJunctionShape
MFXCheckableButton * menuCheckToggleDrawJunctionShape
checkable button to show junction shapes
Definition: GNEViewNetHelper.h:804
GNEViewNetHelper::DemandViewOptions::lockContainer
void lockContainer(const GNEDemandElement *container)
lock container
Definition: GNEViewNetHelper.cpp:2906
GNEViewNetHelper::DemandViewOptions::buildDemandViewOptionsMenuChecks
void buildDemandViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:2664
GNEViewNetHelper::DemandViewOptions::getLockedPerson
const GNEDemandElement * getLockedPerson() const
get locked person
Definition: GNEViewNetHelper.cpp:2890
GNEViewNetHelper::DemandViewOptions::menuCheckDrawSpreadVehicles
MFXCheckableButton * menuCheckDrawSpreadVehicles
menu check to draw vehicles in begin position or spread in lane
Definition: GNEViewNetHelper.h:807
GNEViewNetHelper::DemandViewOptions::menuCheckShowOverlappedRoutes
MFXCheckableButton * menuCheckShowOverlappedRoutes
show overlapped routes
Definition: GNEViewNetHelper.h:831
GNEViewNetHelper::DemandViewOptions::hideDemandViewOptionsMenuChecks
void hideDemandViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:2753
GNEViewNetHelper::DemandViewOptions::menuCheckShowAllPersonPlans
MFXCheckableButton * menuCheckShowAllPersonPlans
show all person plans
Definition: GNEViewNetHelper.h:816
GNEViewNetHelper::DemandViewOptions::menuCheckShowAllContainerPlans
MFXCheckableButton * menuCheckShowAllContainerPlans
show all container plans
Definition: GNEViewNetHelper.h:822
GNEViewNetHelper::DemandViewOptions::menuCheckHideNonInspectedDemandElements
MFXCheckableButton * menuCheckHideNonInspectedDemandElements
Hide non inspected demand elements.
Definition: GNEViewNetHelper.h:828
GNEViewNetHelper::DemandViewOptions::menuCheckHideShapes
MFXCheckableButton * menuCheckHideShapes
Hide shapes (Polygons and POIs)
Definition: GNEViewNetHelper.h:810
GNEViewNetHelper::DemandViewOptions::menuCheckLockPerson
MFXCheckableButton * menuCheckLockPerson
Lock Person.
Definition: GNEViewNetHelper.h:819
GNEViewNetHelper::DemandViewOptions::menuCheckLockContainer
MFXCheckableButton * menuCheckLockContainer
Lock Container.
Definition: GNEViewNetHelper.h:825
GNEViewNetHelper::EditModes
struct used to group all variables related with Supermodes
Definition: GNEViewNetHelper.h:566
GNEViewNetHelper::EditModes::dataEditMode
DataEditMode dataEditMode
the current Data edit mode
Definition: GNEViewNetHelper.h:617
GNEViewNetHelper::EditModes::buildSuperModeButtons
void buildSuperModeButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:2065
GNEViewNetHelper::EditModes::demandEditMode
DemandEditMode demandEditMode
the current Demand edit mode
Definition: GNEViewNetHelper.h:614
GNEViewNetHelper::EditModes::currentSupermode
Supermode currentSupermode
the current supermode
Definition: GNEViewNetHelper.h:608
GNEViewNetHelper::EditModes::networkEditMode
NetworkEditMode networkEditMode
the current Network edit mode
Definition: GNEViewNetHelper.h:611
GNEViewNetHelper::EditModes::isCurrentSupermodeDemand
bool isCurrentSupermodeDemand() const
@check if current supermode is Demand
Definition: GNEViewNetHelper.cpp:2325
GNEViewNetHelper::EditModes::setDemandEditMode
void setDemandEditMode(DemandEditMode demandMode, const bool force=false)
set Demand edit mode
Definition: GNEViewNetHelper.cpp:2247
GNEViewNetHelper::EditModes::dataButton
MFXCheckableButton * dataButton
checkable button for supermode Data
Definition: GNEViewNetHelper.h:626
GNEViewNetHelper::EditModes::isCurrentSupermodeData
bool isCurrentSupermodeData() const
@check if current supermode is Data
Definition: GNEViewNetHelper.cpp:2331
GNEViewNetHelper::EditModes::setView
void setView(FXSelector sel)
set view
Definition: GNEViewNetHelper.cpp:2337
GNEViewNetHelper::EditModes::isCurrentSupermodeNetwork
bool isCurrentSupermodeNetwork() const
@check if current supermode is Network
Definition: GNEViewNetHelper.cpp:2319
GNEViewNetHelper::EditModes::networkButton
MFXCheckableButton * networkButton
checkable button for supermode Network
Definition: GNEViewNetHelper.h:620
GNEViewNetHelper::EditModes::isJuPedSimView
bool isJuPedSimView() const
check if default view is enabled
Definition: GNEViewNetHelper.cpp:2366
GNEViewNetHelper::EditModes::setSupermode
void setSupermode(Supermode supermode, const bool force)
set supermode
Definition: GNEViewNetHelper.cpp:2112
GNEViewNetHelper::EditModes::demandButton
MFXCheckableButton * demandButton
checkable button for supermode Demand
Definition: GNEViewNetHelper.h:623
GNEViewNetHelper::EditModes::setNetworkEditMode
void setNetworkEditMode(NetworkEditMode networkMode, const bool force=false)
set Network edit mode
Definition: GNEViewNetHelper.cpp:2197
GNEViewNetHelper::EditModes::setDataEditMode
void setDataEditMode(DataEditMode dataMode, const bool force=false)
set Data edit mode
Definition: GNEViewNetHelper.cpp:2282
GNEViewNetHelper::EditNetworkElementShapes
struct used to group all variables related with edit shapes of NetworkElements
Definition: GNEViewNetHelper.h:1425
GNEViewNetHelper::EditNetworkElementShapes::getEditedNetworkElement
GNENetworkElement * getEditedNetworkElement() const
pointer to edited network element
Definition: GNEViewNetHelper.cpp:3956
GNEViewNetHelper::EditNetworkElementShapes::startEditCustomShape
void startEditCustomShape(GNENetworkElement *element)
start edit custom shape
Definition: GNEViewNetHelper.cpp:3913
GNEViewNetHelper::MouseButtonKeyPressed
class used to group all variables related with mouse buttons and key pressed after certain events
Definition: GNEViewNetHelper.h:449
GNEViewNetHelper::MouseButtonKeyPressed::shiftKeyPressed
bool shiftKeyPressed() const
check if SHIFT is pressed during current event
Definition: GNEViewNetHelper.cpp:1119
GNEViewNetHelper::MouseButtonKeyPressed::altKeyPressed
bool altKeyPressed() const
check if ALT is pressed during current event
Definition: GNEViewNetHelper.cpp:1139
GNEViewNetHelper::MouseButtonKeyPressed::update
void update(void *eventData)
update status of MouseButtonKeyPressed during current event
Definition: GNEViewNetHelper.cpp:1113
GNEViewNetHelper::MouseButtonKeyPressed::controlKeyPressed
bool controlKeyPressed() const
check if CONTROL is pressed during current event
Definition: GNEViewNetHelper.cpp:1129
GNEViewNetHelper::MouseButtonKeyPressed::mouseLeftButtonPressed
bool mouseLeftButtonPressed() const
check if mouse left button is pressed during current event
Definition: GNEViewNetHelper.cpp:1149
GNEViewNetHelper::MoveMultipleElementModul
struct used to group all variables related with movement of groups of elements
Definition: GNEViewNetHelper.h:1075
GNEViewNetHelper::MoveMultipleElementModul::moveSelection
void moveSelection(const bool mouseLeftButtonPressed)
move selection
Definition: GNEViewNetHelper.cpp:1449
GNEViewNetHelper::MoveMultipleElementModul::isCurrentlyMovingMultipleElements
bool isCurrentlyMovingMultipleElements() const
check if there are moving elements
Definition: GNEViewNetHelper.cpp:1521
GNEViewNetHelper::MoveMultipleElementModul::finishMoveSelection
void finishMoveSelection()
finish moving selection
Definition: GNEViewNetHelper.cpp:1478
GNEViewNetHelper::MoveMultipleElementModul::isMovingSelection
bool isMovingSelection() const
check if currently there is element being moved
Definition: GNEViewNetHelper.cpp:1497
GNEViewNetHelper::MoveMultipleElementModul::resetMovingSelectedEdge
void resetMovingSelectedEdge()
reset flag for moving edge
Definition: GNEViewNetHelper.cpp:1509
GNEViewNetHelper::MoveSingleElementModul
struct used to group all variables related with movement of single elements
Definition: GNEViewNetHelper.h:1033
GNEViewNetHelper::MoveSingleElementModul::beginMoveSingleElementDemandMode
bool beginMoveSingleElementDemandMode()
begin move single element in Demand mode
Definition: GNEViewNetHelper.cpp:1336
GNEViewNetHelper::MoveSingleElementModul::moveSingleElement
void moveSingleElement(const bool mouseLeftButtonPressed)
move single element in Network AND Demand mode
Definition: GNEViewNetHelper.cpp:1361
GNEViewNetHelper::MoveSingleElementModul::isCurrentlyMovingSingleElement
bool isCurrentlyMovingSingleElement() const
check if there are moving elements
Definition: GNEViewNetHelper.cpp:1394
GNEViewNetHelper::MoveSingleElementModul::beginMoveSingleElementNetworkMode
bool beginMoveSingleElementNetworkMode()
begin move single element in Network mode
Definition: GNEViewNetHelper.cpp:1241
GNEViewNetHelper::MoveSingleElementModul::beginMoveNetworkElementShape
bool beginMoveNetworkElementShape()
begin move network elementshape
Definition: GNEViewNetHelper.cpp:1177
GNEViewNetHelper::MoveSingleElementModul::finishMoveSingleElement
void finishMoveSingleElement()
finish moving single elements in Network AND Demand mode
Definition: GNEViewNetHelper.cpp:1381
GNEViewNetHelper::NetworkCheckableButtons::updateNetworkCheckableButtons
void updateNetworkCheckableButtons()
update network checkable buttons
Definition: GNEViewNetHelper.cpp:3661
GNEViewNetHelper::NetworkCheckableButtons::trafficLightButton
MFXCheckableButton * trafficLightButton
checkable button for edit mode traffic light
Definition: GNEViewNetHelper.h:1299
GNEViewNetHelper::NetworkCheckableButtons::moveNetworkElementsButton
MFXCheckableButton * moveNetworkElementsButton
checkable button for edit mode "move network elements"
Definition: GNEViewNetHelper.h:1290
GNEViewNetHelper::NetworkCheckableButtons::additionalButton
MFXCheckableButton * additionalButton
checkable button for edit mode additional
Definition: GNEViewNetHelper.h:1302
GNEViewNetHelper::NetworkCheckableButtons::crossingButton
MFXCheckableButton * crossingButton
checkable button for edit mode crossing
Definition: GNEViewNetHelper.h:1305
GNEViewNetHelper::NetworkCheckableButtons::createEdgeButton
MFXCheckableButton * createEdgeButton
checkable button for edit mode create edge
Definition: GNEViewNetHelper.h:1293
GNEViewNetHelper::NetworkCheckableButtons::prohibitionButton
MFXCheckableButton * prohibitionButton
checkable button for edit mode prohibition
Definition: GNEViewNetHelper.h:1314
GNEViewNetHelper::NetworkCheckableButtons::buildNetworkCheckableButtons
void buildNetworkCheckableButtons()
build checkable buttons
Definition: GNEViewNetHelper.cpp:3532
GNEViewNetHelper::NetworkCheckableButtons::shapeButton
MFXCheckableButton * shapeButton
checkable button for edit mode shape
Definition: GNEViewNetHelper.h:1311
GNEViewNetHelper::NetworkCheckableButtons::connectionButton
MFXCheckableButton * connectionButton
checkable button for edit mode connection
Definition: GNEViewNetHelper.h:1296
GNEViewNetHelper::NetworkCheckableButtons::TAZButton
MFXCheckableButton * TAZButton
checkable button for edit mode TAZ
Definition: GNEViewNetHelper.h:1308
GNEViewNetHelper::NetworkCheckableButtons::disableNetworkCheckableButtons
void disableNetworkCheckableButtons()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:3645
GNEViewNetHelper::NetworkCheckableButtons::wireButton
MFXCheckableButton * wireButton
checkable button for edit mode wires
Definition: GNEViewNetHelper.h:1317
GNEViewNetHelper::NetworkCheckableButtons::decalButton
MFXCheckableButton * decalButton
checkable button for edit mode decals
Definition: GNEViewNetHelper.h:1320
GNEViewNetHelper::NetworkViewOptions
struct used to group all variables related to view options in supermode Network
Definition: GNEViewNetHelper.h:652
GNEViewNetHelper::NetworkViewOptions::menuCheckSelectEdges
MFXCheckableButton * menuCheckSelectEdges
checkable button to select only edges
Definition: GNEViewNetHelper.h:700
GNEViewNetHelper::NetworkViewOptions::menuCheckChainEdges
MFXCheckableButton * menuCheckChainEdges
checkable button to the endpoint for a created edge should be set as the new source
Definition: GNEViewNetHelper.h:730
GNEViewNetHelper::NetworkViewOptions::menuCheckShowDemandElements
MFXCheckableButton * menuCheckShowDemandElements
checkable button to show Demand Elements
Definition: GNEViewNetHelper.h:697
GNEViewNetHelper::NetworkViewOptions::menuCheckMoveElevation
MFXCheckableButton * menuCheckMoveElevation
checkable button to apply movement to elevation
Definition: GNEViewNetHelper.h:727
GNEViewNetHelper::NetworkViewOptions::menuCheckShowTAZElements
MFXCheckableButton * menuCheckShowTAZElements
checkable button to show TAZ elements
Definition: GNEViewNetHelper.h:712
GNEViewNetHelper::NetworkViewOptions::menuCheckAutoOppositeEdge
MFXCheckableButton * menuCheckAutoOppositeEdge
check checkable to create auto create opposite edge
Definition: GNEViewNetHelper.h:733
GNEViewNetHelper::NetworkViewOptions::menuCheckDrawSpreadVehicles
MFXCheckableButton * menuCheckDrawSpreadVehicles
checkable button to draw vehicles in begin position or spread in lane
Definition: GNEViewNetHelper.h:694
GNEViewNetHelper::NetworkViewOptions::menuCheckShowConnections
MFXCheckableButton * menuCheckShowConnections
checkable button to show connections
Definition: GNEViewNetHelper.h:703
GNEViewNetHelper::NetworkViewOptions::menuCheckHideConnections
MFXCheckableButton * menuCheckHideConnections
checkable button to hide connections in connect mode
Definition: GNEViewNetHelper.h:706
GNEViewNetHelper::NetworkViewOptions::menuCheckToggleDrawJunctionShape
MFXCheckableButton * menuCheckToggleDrawJunctionShape
checkable button to show junction shapes
Definition: GNEViewNetHelper.h:691
GNEViewNetHelper::NetworkViewOptions::menuCheckToggleGrid
MFXCheckableButton * menuCheckToggleGrid
checkable button to show grid button
Definition: GNEViewNetHelper.h:688
GNEViewNetHelper::NetworkViewOptions::selectEdges
bool selectEdges() const
check if select edges checkbox is enabled
Definition: GNEViewNetHelper.cpp:2594
GNEViewNetHelper::NetworkViewOptions::menuCheckShowJunctionBubble
MFXCheckableButton * menuCheckShowJunctionBubble
checkable button to show connection as bubble in "Move" mode.
Definition: GNEViewNetHelper.h:724
GNEViewNetHelper::NetworkViewOptions::menuCheckWarnAboutMerge
MFXCheckableButton * menuCheckWarnAboutMerge
checkable button to we should warn about merging junctions
Definition: GNEViewNetHelper.h:721
GNEViewNetHelper::NetworkViewOptions::hideNetworkViewOptionsMenuChecks
void hideNetworkViewOptionsMenuChecks()
hide all options menu checks
Definition: GNEViewNetHelper.cpp:2502
GNEViewNetHelper::NetworkViewOptions::menuCheckShowAdditionalSubElements
MFXCheckableButton * menuCheckShowAdditionalSubElements
checkable button to show additional sub-elements
Definition: GNEViewNetHelper.h:709
GNEViewNetHelper::NetworkViewOptions::buildNetworkViewOptionsMenuChecks
void buildNetworkViewOptionsMenuChecks()
build menu checks
Definition: GNEViewNetHelper.cpp:2380
GNEViewNetHelper::NetworkViewOptions::menuCheckChangeAllPhases
MFXCheckableButton * menuCheckChangeAllPhases
checkable button to set change all phases
Definition: GNEViewNetHelper.h:718
GNEViewNetHelper::NetworkViewOptions::menuCheckExtendSelection
MFXCheckableButton * menuCheckExtendSelection
checkable button to extend to edge nodes
Definition: GNEViewNetHelper.h:715
GNEViewNetHelper::SaveElements
struct used to group all variables related with save elements
Definition: GNEViewNetHelper.h:484
GNEViewNetHelper::SaveElements::buildSaveElementsButtons
void buildSaveElementsButtons()
build save buttons
Definition: GNEViewNetHelper.cpp:1934
GNEViewNetHelper::SelectingArea::finishRectangleSelection
void finishRectangleSelection()
finish rectangle selection
Definition: GNEViewNetHelper.cpp:1675
GNEViewNetHelper::SelectingArea::drawRectangleSelection
void drawRectangleSelection(const RGBColor &color) const
draw rectangle selection
Definition: GNEViewNetHelper.cpp:1721
GNEViewNetHelper::SelectingArea::beginRectangleSelection
void beginRectangleSelection()
begin rectangle selection
Definition: GNEViewNetHelper.cpp:1654
GNEViewNetHelper::SelectingArea::selectingUsingRectangle
bool selectingUsingRectangle
whether we have started rectangle-selection
Definition: GNEViewNetHelper.h:1191
GNEViewNetHelper::SelectingArea::moveRectangleSelection
void moveRectangleSelection()
move rectangle selection
Definition: GNEViewNetHelper.cpp:1662
GNEViewNetHelper::SelectingArea::startDrawing
bool startDrawing
whether we have started rectangle-selection
Definition: GNEViewNetHelper.h:1194
GNEViewNetHelper::SelectingArea::processRectangleSelection
void processRectangleSelection()
process rectangle Selection
Definition: GNEViewNetHelper.cpp:1685
GNEViewNetHelper::SelectingArea::processEdgeRectangleSelection
std::vector< GNEEdge * > processEdgeRectangleSelection()
process rectangle Selection (only limited to Edges)
Definition: GNEViewNetHelper.cpp:1701
GNEViewNetHelper::TestingMode
struct used to group all variables related with testing
Definition: GNEViewNetHelper.h:1211
GNEViewNetHelper::TestingMode::drawTestingElements
void drawTestingElements(GUIMainWindow *mainWindow)
draw testing element
Definition: GNEViewNetHelper.cpp:1867
GNEViewNetHelper::TimeFormat
struct used to group all variables related with time format
Definition: GNEViewNetHelper.h:537
GNEViewNetHelper::TimeFormat::buildTimeFormatButtons
void buildTimeFormatButtons()
build time format buttons
Definition: GNEViewNetHelper.cpp:2008
GUIVisualizationAdditionalSettings::TLSConnectionColor
static const RGBColor TLSConnectionColor
connection color between E1/junctions and TLS
Definition: GUIVisualizationSettings.h:429
GUIVisualizationColorSettings::selectionColor
RGBColor selectionColor
basic selection color
Definition: GUIVisualizationSettings.h:167
GUIVisualizationNeteditSizeSettings::junctionBubbleRadius
static const double junctionBubbleRadius
junction bubble radius
Definition: GUIVisualizationSettings.h:324
GUIVisualizationSizeSettings::getExaggeration
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
Definition: GUIVisualizationSettings.cpp:344