CoCalc -- GNEViewNet.cpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/netedit/GNEViewNet.cpp
¹⁶⁹⁶⁶⁵ views
1
/****************************************************************************/
2
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3
// Copyright (C) 2001-2025 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
/****************************************************************************/
14
/// @file    GNEViewNet.cpp
15
/// @author  Jakob Erdmann
16
/// @author  Pablo Alvarez Lopez
17
/// @date    Feb 2011
18
///
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/basic/GNEInformationBasicDialog.h>
26
#include <netedit/dialogs/basic/GNEQuestionBasicDialog.h>
27
#include <netedit/dialogs/basic/GNEWarningBasicDialog.h>
28
#include <netedit/dialogs/GNEVClassesDialog.h>
29
#include <netedit/dialogs/GNEGeometryPointDialog.h>
30
#include <netedit/dialogs/fix/GNEFixAdditionalElementsDialog.h>
31
#include <netedit/dialogs/fix/GNEFixDemandElementsDialog.h>
32
#include <netedit/dialogs/fix/GNEFixNetworkElements.h>
33
#include <netedit/elements/additional/GNEAdditionalHandler.h>
34
#include <netedit/elements/additional/GNEPOI.h>
35
#include <netedit/elements/additional/GNEPoly.h>
36
#include <netedit/elements/additional/GNETAZ.h>
37
#include <netedit/elements/demand/GNERouteHandler.h>
38
#include <netedit/elements/network/GNEConnection.h>
39
#include <netedit/elements/network/GNECrossing.h>
40
#include <netedit/elements/network/GNEWalkingArea.h>
41
#include <netedit/frames/GNEAttributesEditor.h>
42
#include <netedit/frames/GNEConsecutiveSelector.h>
43
#include <netedit/frames/GNEDrawingShape.h>
44
#include <netedit/frames/GNEOverlappedInspection.h>
45
#include <netedit/frames/GNEPathCreator.h>
46
#include <netedit/frames/GNEPlanCreator.h>
47
#include <netedit/frames/GNEViewObjectSelector.h>
48
#include <netedit/frames/common/GNEDeleteFrame.h>
49
#include <netedit/frames/common/GNEInspectorFrame.h>
50
#include <netedit/frames/common/GNEMoveFrame.h>
51
#include <netedit/frames/common/GNESelectorFrame.h>
52
#include <netedit/frames/data/GNEEdgeDataFrame.h>
53
#include <netedit/frames/data/GNEEdgeRelDataFrame.h>
54
#include <netedit/frames/data/GNEMeanDataFrame.h>
55
#include <netedit/frames/data/GNETAZRelDataFrame.h>
56
#include <netedit/frames/demand/GNEContainerFrame.h>
57
#include <netedit/frames/demand/GNEContainerPlanFrame.h>
58
#include <netedit/frames/demand/GNEPersonFrame.h>
59
#include <netedit/frames/demand/GNEPersonPlanFrame.h>
60
#include <netedit/frames/demand/GNERouteDistributionFrame.h>
61
#include <netedit/frames/demand/GNERouteFrame.h>
62
#include <netedit/frames/demand/GNEStopFrame.h>
63
#include <netedit/frames/demand/GNETypeDistributionFrame.h>
64
#include <netedit/frames/demand/GNETypeFrame.h>
65
#include <netedit/frames/demand/GNEVehicleFrame.h>
66
#include <netedit/frames/network/GNEAdditionalFrame.h>
67
#include <netedit/frames/network/GNEConnectorFrame.h>
68
#include <netedit/frames/network/GNECreateEdgeFrame.h>
69
#include <netedit/frames/network/GNECrossingFrame.h>
70
#include <netedit/frames/network/GNEDecalFrame.h>
71
#include <netedit/frames/network/GNEProhibitionFrame.h>
72
#include <netedit/frames/network/GNEShapeFrame.h>
73
#include <netedit/frames/network/GNETAZFrame.h>
74
#include <netedit/frames/network/GNETLSEditorFrame.h>
75
#include <netedit/frames/network/GNEWireFrame.h>
76
#include <utils/foxtools/MFXMenuCheckIcon.h>
77
#include <utils/gui/cursors/GUICursorSubSys.h>
78
#include <utils/gui/div/GLHelper.h>
79
#include <utils/gui/div/GUIDesigns.h>
80
#include <utils/gui/div/GUIGlobalViewUpdater.h>
81
#include <utils/gui/globjects/GUICursorDialog.h>
82
#include <utils/gui/globjects/GUIGlObjectStorage.h>
83
#include <utils/gui/settings/GUICompleteSchemeStorage.h>
84
#include <utils/gui/windows/GUIDanielPerspectiveChanger.h>
85
#include <utils/gui/windows/GUIDialog_ViewSettings.h>
86

87
#include "GNEApplicationWindow.h"
88
#include "GNENet.h"
89
#include "GNEUndoList.h"
90
#include "GNEViewNet.h"
91
#include "GNEViewParent.h"
92

93
// ===========================================================================
94
// FOX callback mapping
95
// ===========================================================================
96

97
FXDEFMAP(GNEViewNet) GNEViewNetMap[] = {
98
    // Super Modes
99
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F2_SUPERMODE_NETWORK, GNEViewNet::onCmdSetSupermode),
100
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F3_SUPERMODE_DEMAND,  GNEViewNet::onCmdSetSupermode),
101
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_F4_SUPERMODE_DATA,    GNEViewNet::onCmdSetSupermode),
102
    // Modes
103
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS,    GNEViewNet::onCmdSetMode),
104
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_C_MODE_CONNECT_CONTAINER,                 GNEViewNet::onCmdSetMode),
105
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE,       GNEViewNet::onCmdSetMode),
106
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_E_MODE_EDGE_EDGEDATA,                     GNEViewNet::onCmdSetMode),
107
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN,         GNEViewNet::onCmdSetMode),
108
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_I_MODE_INSPECT,                           GNEViewNet::onCmdSetMode),
109
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_L_MODE_PERSONPLAN,                        GNEViewNet::onCmdSetMode),
110
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_M_MODE_MOVE_MEANDATA,                     GNEViewNet::onCmdSetMode),
111
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_P_MODE_POLYGON_PERSON,                    GNEViewNet::onCmdSetMode),
112
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA,        GNEViewNet::onCmdSetMode),
113
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT,             GNEViewNet::onCmdSetMode),
114
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_T_MODE_TLS_TYPE,                          GNEViewNet::onCmdSetMode),
115
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION,            GNEViewNet::onCmdSetMode),
116
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_V_MODE_VEHICLE,                           GNEViewNet::onCmdSetMode),
117
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION,            GNEViewNet::onCmdSetMode),
118
    FXMAPFUNC(SEL_COMMAND, MID_HOTKEY_Z_MODE_TAZ_TAZREL,                        GNEViewNet::onCmdSetMode),
119
    // Network view options
120
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID,               GNEViewNet::onCmdToggleShowGrid),
121
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,  GNEViewNet::onCmdToggleDrawJunctionShape),
122
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES,       GNEViewNet::onCmdToggleDrawSpreadVehicles),
123
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS,       GNEViewNet::onCmdToggleShowDemandElementsNetwork),
124
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES,              GNEViewNet::onCmdToggleSelectEdges),
125
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS,          GNEViewNet::onCmdToggleShowConnections),
126
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS,          GNEViewNet::onCmdToggleHideConnections),
127
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS,       GNEViewNet::onCmdToggleShowAdditionalSubElements),
128
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS,          GNEViewNet::onCmdToggleShowTAZElements),
129
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION,          GNEViewNet::onCmdToggleExtendSelection),
130
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES,          GNEViewNet::onCmdToggleChangeAllPhases),
131
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY,       GNEViewNet::onCmdToggleMergeAutomatically),
132
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES,              GNEViewNet::onCmdToggleShowJunctionBubbles),
133
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION,            GNEViewNet::onCmdToggleMoveElevation),
134
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES,               GNEViewNet::onCmdToggleChainEdges),
135
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES,        GNEViewNet::onCmdToggleAutoOppositeEdge),
136
    // Demand view options
137
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID,                  GNEViewNet::onCmdToggleShowGrid),
138
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,   GNEViewNet::onCmdToggleDrawJunctionShape),
139
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES,        GNEViewNet::onCmdToggleDrawSpreadVehicles),
140
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED,          GNEViewNet::onCmdToggleHideNonInspecteDemandElements),
141
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES,                GNEViewNet::onCmdToggleHideShapes),
142
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS,                 GNEViewNet::onCmdToggleShowTrips),
143
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS,        GNEViewNet::onCmdToggleShowAllPersonPlans),
144
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON,                GNEViewNet::onCmdToggleLockPerson),
145
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS,     GNEViewNet::onCmdToggleShowAllContainerPlans),
146
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER,             GNEViewNet::onCmdToggleLockContainer),
147
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES,      GNEViewNet::onCmdToggleShowOverlappedRoutes),
148
    // Data view options
149
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE, GNEViewNet::onCmdToggleDrawJunctionShape),
150
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS,         GNEViewNet::onCmdToggleShowAdditionals),
151
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES,              GNEViewNet::onCmdToggleShowShapes),
152
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS,      GNEViewNet::onCmdToggleShowDemandElementsData),
153
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING,           GNEViewNet::onCmdToggleTAZRelDrawing),
154
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL,             GNEViewNet::onCmdToggleTAZDrawFill),
155
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM,          GNEViewNet::onCmdToggleTAZRelOnlyFrom),
156
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO,            GNEViewNet::onCmdToggleTAZRelOnlyTo),
157
    // Select elements
158
    FXMAPFUNC(SEL_COMMAND, MID_ADDSELECT,               GNEViewNet::onCmdAddSelected),
159
    FXMAPFUNC(SEL_COMMAND, MID_REMOVESELECT,            GNEViewNet::onCmdRemoveSelected),
160
    FXMAPFUNC(SEL_COMMAND, MID_GNE_ADDSELECT_EDGE,      GNEViewNet::onCmdAddEdgeSelected),
161
    FXMAPFUNC(SEL_COMMAND, MID_GNE_REMOVESELECT_EDGE,   GNEViewNet::onCmdRemoveEdgeSelected),
162
    // Junctions
163
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_EDGE_ENDPOINTS,   GNEViewNet::onCmdResetEdgeEndPoints),
164
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_EDIT_SHAPE,             GNEViewNet::onCmdEditJunctionShape),
165
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_SHAPE,            GNEViewNet::onCmdResetJunctionShape),
166
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_REPLACE,                GNEViewNet::onCmdReplaceJunction),
167
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SPLIT,                  GNEViewNet::onCmdSplitJunction),
168
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SPLIT_RECONNECT,        GNEViewNet::onCmdSplitJunctionReconnect),
169
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_SELECT_ROUNDABOUT,      GNEViewNet::onCmdSelectRoundabout),
170
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_CONVERT_ROUNDABOUT,     GNEViewNet::onCmdConvertRoundabout),
171
    FXMAPFUNC(SEL_ENTER,   MID_GNE_JUNCTION_CONVERT_ROUNDABOUT,     GNEViewNet::onEnterConvertRoundabout),
172
    FXMAPFUNC(SEL_LEAVE,   MID_GNE_JUNCTION_CONVERT_ROUNDABOUT,     GNEViewNet::onLeaveConvertRoundabout),
173
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_CLEAR_CONNECTIONS,      GNEViewNet::onCmdClearConnections),
174
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_RESET_CONNECTIONS,      GNEViewNet::onCmdResetConnections),
175
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_ADDTLS,                 GNEViewNet::onCmdAddTLS),
176
    FXMAPFUNC(SEL_COMMAND, MID_GNE_JUNCTION_ADDJOINTLS,             GNEViewNet::onCmdAddJoinTLS),
177
    // Connections
178
    FXMAPFUNC(SEL_COMMAND, MID_GNE_CONNECTION_EDIT_SHAPE,           GNEViewNet::onCmdEditConnectionShape),
179
    FXMAPFUNC(SEL_COMMAND, MID_GNE_CONNECTION_SMOOTH_SHAPE,         GNEViewNet::onCmdSmoothConnectionShape),
180
    // Crossings
181
    FXMAPFUNC(SEL_COMMAND, MID_GNE_CROSSING_EDIT_SHAPE,             GNEViewNet::onCmdEditCrossingShape),
182
    // WalkingArea
183
    FXMAPFUNC(SEL_COMMAND, MID_GNE_WALKINGAREA_EDIT_SHAPE,          GNEViewNet::onCmdEditWalkingAreaShape),
184
    // Edges
185
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SPLIT,                      GNEViewNet::onCmdSplitEdge),
186
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SPLIT_BIDI,                 GNEViewNet::onCmdSplitEdgeBidi),
187
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_REVERSE,                    GNEViewNet::onCmdReverseEdge),
188
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_ADD_REVERSE,                GNEViewNet::onCmdAddReversedEdge),
189
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_ADD_REVERSE_DISCONNECTED,   GNEViewNet::onCmdAddReversedEdgeDisconnected),
190
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_EDIT_ENDPOINT,              GNEViewNet::onCmdEditEdgeEndpoint),
191
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_RESET_ENDPOINT,             GNEViewNet::onCmdResetEdgeEndpoint),
192
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_STRAIGHTEN,                 GNEViewNet::onCmdStraightenEdges),
193
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SMOOTH,                     GNEViewNet::onCmdSmoothEdges),
194
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_STRAIGHTEN_ELEVATION,       GNEViewNet::onCmdStraightenEdgesElevation),
195
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_SMOOTH_ELEVATION,           GNEViewNet::onCmdSmoothEdgesElevation),
196
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_RESET_LENGTH,               GNEViewNet::onCmdResetLength),
197
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_USEASTEMPLATE,              GNEViewNet::onCmdEdgeUseAsTemplate),
198
    FXMAPFUNC(SEL_COMMAND, MID_GNE_EDGE_APPLYTEMPLATE,              GNEViewNet::onCmdEgeApplyTemplate),
199
    // Lanes
200
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_DUPLICATE,              GNEViewNet::onCmdDuplicateLane),
201
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_EDIT_SHAPE,             GNEViewNet::onCmdEditLaneShape),
202
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_RESET_CUSTOMSHAPE,      GNEViewNet::onCmdResetLaneCustomShape),
203
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_RESET_OPPOSITELANE,     GNEViewNet::onCmdResetOppositeLane),
204
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_SIDEWALK,     GNEViewNet::onCmdLaneOperation),
205
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_BIKE,         GNEViewNet::onCmdLaneOperation),
206
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_BUS,          GNEViewNet::onCmdLaneOperation),
207
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_TRANSFORM_GREENVERGE,   GNEViewNet::onCmdLaneOperation),
208
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_SIDEWALK,           GNEViewNet::onCmdLaneOperation),
209
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_BIKE,               GNEViewNet::onCmdLaneOperation),
210
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_BUS,                GNEViewNet::onCmdLaneOperation),
211
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_GREENVERGE_FRONT,   GNEViewNet::onCmdLaneOperation),
212
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_ADD_GREENVERGE_BACK,    GNEViewNet::onCmdLaneOperation),
213
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_SIDEWALK,        GNEViewNet::onCmdLaneOperation),
214
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_BIKE,            GNEViewNet::onCmdLaneOperation),
215
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_BUS,             GNEViewNet::onCmdLaneOperation),
216
    FXMAPFUNC(SEL_COMMAND, MID_GNE_LANE_REMOVE_GREENVERGE,      GNEViewNet::onCmdLaneOperation),
217
    FXMAPFUNC(SEL_COMMAND, MID_REACHABILITY,                    GNEViewNet::onCmdLaneReachability),
218
    // Additionals
219
    FXMAPFUNC(SEL_COMMAND, MID_OPEN_ADDITIONAL_DIALOG,  GNEViewNet::onCmdOpenAdditionalDialog),
220
    // Polygons
221
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SIMPLIFY_SHAPE,          GNEViewNet::onCmdSimplifyShape),
222
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_CLOSE,                   GNEViewNet::onCmdClosePolygon),
223
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_OPEN,                    GNEViewNet::onCmdOpenPolygon),
224
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SELECT,                  GNEViewNet::onCmdSelectPolygonElements),
225
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_TRIANGULATE,             GNEViewNet::onCmdTriangulatePolygon),
226
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_SET_FIRST_POINT,         GNEViewNet::onCmdSetFirstGeometryPoint),
227
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POLYGON_DELETE_GEOMETRY_POINT,   GNEViewNet::onCmdDeleteGeometryPoint),
228
    // edit custom shapes
229
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_SIMPLIFY,                GNEViewNet::onCmdSimplifyShapeEdited),
230
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_STRAIGHTEN,              GNEViewNet::onCmdStraightenShapeEdited),
231
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_CLOSE,                   GNEViewNet::onCmdCloseShapeEdited),
232
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_OPEN,                    GNEViewNet::onCmdOpenShapeEdited),
233
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_SET_FIRST_POINT,         GNEViewNet::onCmdSetFirstGeometryPointShapeEdited),
234
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_DELETE_GEOMETRY_POINT,   GNEViewNet::onCmdDeleteGeometryPointShapeEdited),
235
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_RESET,                   GNEViewNet::onCmdResetShapeEdited),
236
    FXMAPFUNC(SEL_COMMAND, MID_GNE_SHAPEEDITED_FINISH,                  GNEViewNet::onCmdFinishShapeEdited),
237
    // POIs
238
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POI_TRANSFORM,   GNEViewNet::onCmdTransformPOI),
239
    // Demand elements
240
    FXMAPFUNC(SEL_COMMAND, MID_GNE_REVERSE,     GNEViewNet::onCmdReverse),
241
    FXMAPFUNC(SEL_COMMAND, MID_GNE_ADDREVERSE,  GNEViewNet::onCmdAddReverse),
242
    // Geometry Points
243
    FXMAPFUNC(SEL_COMMAND, MID_GNE_CUSTOM_GEOMETRYPOINT,    GNEViewNet::onCmdSetCustomGeometryPoint),
244
    FXMAPFUNC(SEL_COMMAND, MID_GNE_RESET_GEOMETRYPOINT,     GNEViewNet::onCmdResetEndPoints),
245
    // toolbar views
246
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_VIEW_DEFAULT,   GNEViewNet::onCmdSetNeteditView),
247
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_VIEW_JUPEDSIM,  GNEViewNet::onCmdSetNeteditView),
248
    // IntervalBar
249
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_GENERICDATATYPE,     GNEViewNet::onCmdIntervalBarGenericDataType),
250
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_DATASET,             GNEViewNet::onCmdIntervalBarDataSet),
251
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_LIMITED,             GNEViewNet::onCmdIntervalBarLimit),
252
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_BEGIN,               GNEViewNet::onCmdIntervalBarSetBegin),
253
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_END,                 GNEViewNet::onCmdIntervalBarSetEnd),
254
    FXMAPFUNC(SEL_COMMAND, MID_GNE_INTERVALBAR_PARAMETER,           GNEViewNet::onCmdIntervalBarSetParameter),
255
};
256

257
// Object implementation
258
FXIMPLEMENT(GNEViewNet, GUISUMOAbstractView, GNEViewNetMap, ARRAYNUMBER(GNEViewNetMap))
259

260

261
// ===========================================================================
262
// member method definitions
263
// ===========================================================================
264
#ifdef _MSC_VER
265
#pragma warning(push)
266
#pragma warning(disable: 4355) // mask warning about "this" in initializers
267
#endif
268
GNEViewNet::GNEViewNet(FXComposite* tmpParent, FXComposite* actualParent, GUIMainWindow& app,
269
                       GNEViewParent* viewParent, GNENet* net, GNEUndoList* undoList,
270
                       FXGLVisual* glVis, FXGLCanvas* share) :
271
    GUISUMOAbstractView(tmpParent, app, viewParent, net->getGrid(), glVis, share),
272
    myViewObjectsSelector(this),
273
    myEditModes(this),
274
    myTestingMode(this),
275
    myCommonCheckableButtons(this),
276
    myNetworkCheckableButtons(this),
277
    myDemandCheckableButtons(this),
278
    myDataCheckableButtons(this),
279
    myNetworkViewOptions(this),
280
    myDemandViewOptions(this),
281
    myDataViewOptions(this),
282
    myIntervalBar(this),
283
    myMoveSingleElement(this),
284
    myMoveMultipleElements(this),
285
    myVehicleOptions(this),
286
    myVehicleTypeOptions(this),
287
    mySaveElements(this),
288
    myTimeFormat(this),
289
    mySelectingArea(this),
290
    myEditNetworkElementShapes(this),
291
    myLockManager(this),
292
    myViewParent(viewParent),
293
    myNet(net),
294
    myUndoList(undoList) {
295
    // view must be the final member of actualParent
296
    reparent(actualParent);
297
    // Build edit modes
298
    buildEditModeControls();
299
    // set this net in Net
300
    myNet->setViewNet(this);
301
    // set drag delay
302
    ((GUIDanielPerspectiveChanger*)myChanger)->setDragDelay(100000000); // 100 milliseconds
303
    // Reset textures
304
    GUITextureSubSys::resetTextures();
305
    // init testing mode
306
    myTestingMode.initTestingMode();
307
    // update grid flags
308
    myNetworkViewOptions.menuCheckToggleGrid->setChecked(myVisualizationSettings->showGrid);
309
    myDemandViewOptions.menuCheckToggleGrid->setChecked(myVisualizationSettings->showGrid);
310
    // update junction shape flags
311
    const bool hide = !myVisualizationSettings->drawJunctionShape;
312
    myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
313
    myDemandViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
314
    myDataViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
315
}
316
#ifdef _MSC_VER
317
#pragma warning(pop)
318
#endif
319

320

321
GNEViewNet::~GNEViewNet() {
322
}
323

324

325
void
326
GNEViewNet::recalculateBoundaries() {
327
    if (myNet && makeCurrent()) {
328
        // declare boundary
329
        const Boundary maxBoundary(1000000000.0, 1000000000.0, -1000000000.0, -1000000000.0);
330
        // get all objects in boundary
331
        const std::vector<GUIGlID> GLIDs = getObjectsInBoundary(maxBoundary);
332
        //  finish make OpenGL context current
333
        makeNonCurrent();
334
        // declare set
335
        std::set<GNEAttributeCarrier*> ACs;
336
        // iterate over GUIGlIDs
337
        for (const auto& GLId : GLIDs) {
338
            GNEAttributeCarrier* AC = myNet->getAttributeCarriers()->retrieveAttributeCarrier(GLId);
339
            // Make sure that object exists
340
            if (AC && AC->getTagProperty()->isPlacedInRTree()) {
341
                ACs.insert(AC);
342
            }
343
        }
344
        // interate over ACs
345
        for (const auto& AC : ACs) {
346
            // remove object and insert again with exaggeration
347
            myNet->getGrid().removeAdditionalGLObject(AC->getGUIGlObject());
348
            myNet->getGrid().addAdditionalGLObject(AC->getGUIGlObject(), AC->getGUIGlObject()->getExaggeration(*myVisualizationSettings));
349
        }
350
    }
351
}
352

353

354
void
355
GNEViewNet::doInit() {}
356

357

358
GUIGlID
359
GNEViewNet::getToolTipID() {
360
    if (myViewObjectsSelector.getGUIGlObjectFront()) {
361
        return myViewObjectsSelector.getGUIGlObjectFront()->getGlID();
362
    } else {
363
        return 0;
364
    }
365
}
366

367

368
void
369
GNEViewNet::buildViewToolBars(GUIGlChildWindow* v) {
370
    // build coloring tools
371
    {
372
        for (auto it_names : gSchemeStorage.getNames()) {
373
            v->getColoringSchemesCombo()->appendIconItem(it_names.c_str());
374
            if (it_names == myVisualizationSettings->name) {
375
                v->getColoringSchemesCombo()->setCurrentItem(v->getColoringSchemesCombo()->getNumItems() - 1);
376
            }
377
        }
378
    }
379
    // for junctions
380
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
381
                         std::string("\t") + TL("Locate Junctions") + std::string("\t") + TL("Locate a junction within the network. (Shift+J)"),
382
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEJUNCTION), v, MID_HOTKEY_SHIFT_J_LOCATEJUNCTION, GUIDesignButtonPopup);
383
    // for edges
384
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
385
                         std::string("\t") + TL("Locate Edges") + std::string("\t") + TL("Locate an edge within the network. (Shift+E)"),
386
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEEDGE), v, MID_HOTKEY_SHIFT_E_LOCATEEDGE, GUIDesignButtonPopup);
387
    // for walkingAreas
388
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
389
                         std::string("\t") + TL("Locate WalkingAreas") + std::string("\t") + TL("Locate a walkingArea within the network. (Shift+W)"),
390
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEWALKINGAREA), v, MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA, GUIDesignButtonPopup);
391
    // for vehicles
392
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
393
                         std::string("\t") + TL("Locate Vehicles") + std::string("\t") + TL("Locate a vehicle within the network. (Shift+V)"),
394
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEVEHICLE), v, MID_HOTKEY_SHIFT_V_LOCATEVEHICLE, GUIDesignButtonPopup);
395
    // for person
396
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
397
                         std::string("\t") + TL("Locate Persons") + std::string("\t") + TL("Locate a person within the network. (Shift+P)"),
398
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEPERSON), v, MID_HOTKEY_SHIFT_P_LOCATEPERSON, GUIDesignButtonPopup);
399
    // for container
400
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
401
                         std::string("\t") + TL("Locate Containers") + std::string("\t") + TL("Locate a container within the network. (Shift+C)"),
402
                         GUIIconSubSys::getIcon(GUIIcon::LOCATECONTAINER), v, MID_HOTKEY_SHIFT_C_LOCATECONTAINER, GUIDesignButtonPopup);
403
    // for routes
404
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
405
                         std::string("\t") + TL("Locate Route") + std::string("\t") + TL("Locate a route within the network. (Shift+R)"),
406
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEROUTE), v, MID_HOTKEY_SHIFT_R_LOCATEROUTE, GUIDesignButtonPopup);
407
    // for routes
408
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
409
                         std::string("\t") + TL("Locate Stops") + std::string("\t") + TL("Locate a stop within the network. (Shift+S)"),
410
                         GUIIconSubSys::getIcon(GUIIcon::LOCATESTOP), v, MID_HOTKEY_SHIFT_S_LOCATESTOP, GUIDesignButtonPopup);
411
    // for persons (currently unused)
412
    /*
413
    new MFXButtonTooltip(v->getLocatorPopup(),
414
                         std::string("\t") + TL("Locate Vehicle\tLocate a person within the network.",
415
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEPERSON), &v, MID_LOCATEPERSON,
416
                         GUIDesignButtonPopup);
417
    */
418
    // for tls
419
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
420
                         std::string("\t") + TL("Locate TLS") + std::string("\t") + TL("Locate a tls within the network. (Shift+T)"),
421
                         GUIIconSubSys::getIcon(GUIIcon::LOCATETLS), v, MID_HOTKEY_SHIFT_T_LOCATETLS, GUIDesignButtonPopup);
422
    // for additional stuff
423
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
424
                         std::string("\t") + TL("Locate Additional") + std::string("\t") + TL("Locate an additional structure within the network. (Shift+A)"),
425
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEADD), v, MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL, GUIDesignButtonPopup);
426
    // for pois
427
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
428
                         std::string("\t") + TL("Locate PoI") + std::string("\t") + TL("Locate a PoI within the network. (Shift+O)"),
429
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEPOI), v, MID_HOTKEY_SHIFT_O_LOCATEPOI, GUIDesignButtonPopup);
430
    // for polygons
431
    new MFXButtonTooltip(v->getLocatorPopup(), myViewParent->getGNEAppWindows()->getStaticTooltipMenu(),
432
                         std::string("\t") + TL("Locate Polygon") + std::string("\t") + TL("Locate a Polygon within the network. (Shift+L)"),
433
                         GUIIconSubSys::getIcon(GUIIcon::LOCATEPOLY), v, MID_HOTKEY_SHIFT_L_LOCATEPOLY, GUIDesignButtonPopup);
434
}
435

436

437
void
438
GNEViewNet::updateViewNet(const bool ignoreViewUpdater) const {
439
    // this call is only used for breakpoints (to check when view is updated)
440
    if (ignoreViewUpdater || gViewUpdater.allowUpdate()) {
441
        GUISUMOAbstractView::update();
442
    }
443
}
444

445

446
void
447
GNEViewNet::forceSupemodeNetwork() {
448
    myEditModes.setSupermode(Supermode::NETWORK, true);
449
}
450

451

452
void
453
GNEViewNet::viewUpdated() {
454
    if (myEditModes.isJuPedSimView()) {
455
        // hide data button (and adjust width)
456
        myEditModes.dataButton->hide();
457
        // check network modes
458
        switch (myEditModes.networkEditMode) {
459
            case NetworkEditMode::NETWORK_CONNECT:
460
            case NetworkEditMode::NETWORK_TLS:
461
            case NetworkEditMode::NETWORK_PROHIBITION:
462
            case NetworkEditMode::NETWORK_WIRE:
463
            case NetworkEditMode::NETWORK_DECAL:
464
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_INSPECT);
465
                break;
466
            default:
467
                break;
468
        }
469
        // check demand modes
470
        switch (myEditModes.demandEditMode) {
471
            case DemandEditMode::DEMAND_MOVE:
472
            case DemandEditMode::DEMAND_VEHICLE:
473
            case DemandEditMode::DEMAND_STOP:
474
            case DemandEditMode::DEMAND_CONTAINER:
475
            case DemandEditMode::DEMAND_CONTAINERPLAN:
476
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_INSPECT);
477
                break;
478
            default:
479
                break;
480
        }
481
        // go to network mode if we're in data mode
482
        if (myEditModes.isCurrentSupermodeData()) {
483
            forceSupemodeNetwork();
484
        } else {
485
            // refresh current supermode
486
            myEditModes.setSupermode(myEditModes.currentSupermode, true);
487
        }
488
    } else {
489
        // show data button
490
        myEditModes.dataButton->show();
491
        // refresh current supermode
492
        myEditModes.setSupermode(myEditModes.currentSupermode, true);
493
    }
494
}
495

496

497
const GNEViewNetHelper::ViewObjectsSelector&
498
GNEViewNet::getViewObjectsSelector() const {
499
    return myViewObjectsSelector;
500
}
501

502

503
void
504
GNEViewNet::updateObjectsInPosition(const Position& pos) {
505
    // clear post drawing elements
506
    gViewObjectsHandler.reset();
507
    // set selection position in gObjectsInPosition
508
    gViewObjectsHandler.setSelectionPosition(pos);
509
    // create an small boundary
510
    Boundary positionBoundary;
511
    positionBoundary.add(pos);
512
    positionBoundary.grow(POSITION_EPS);
513
    // push matrix
514
    GLHelper::pushMatrix();
515
    // enable draw for view objects handler (this calculate the contours)
516
    myVisualizationSettings->drawForViewObjectsHandler = true;
517
    // draw all GL elements within the small boundary
518
    drawGLElements(positionBoundary);
519
    // swap selected objects (needed after selecting)
520
    gViewObjectsHandler.reverseSelectedObjects();
521
    // check if filter edges that have the mouse over their geometry points
522
    if (myEditModes.isCurrentSupermodeNetwork() && myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
523
        gViewObjectsHandler.isolateEdgeGeometryPoints();
524
    }
525
    // restore draw for view objects handler (this calculate the contours)
526
    myVisualizationSettings->drawForViewObjectsHandler = false;
527
    // pop matrix
528
    GLHelper::popMatrix();
529
    // check if update front elements
530
    for (const auto& AC : myMarkFrontElements.getACs()) {
531
        gViewObjectsHandler.updateFrontObject(AC->getGUIGlObject());
532
    }
533
    // after draw elements, update objects under cursor
534
    myViewObjectsSelector.updateObjects();
535
}
536

537

538
void
539
GNEViewNet::updateObjectsInShape(const PositionVector& shape) {
540
    if (shape.size() == 1) {
541
        // if our shape has only one ponit, use updateObjectsInPosition
542
        updateObjectsInPosition(shape.front());
543
    } else if (shape.size() > 1) {
544
        // triangulate shape
545
        const auto triangles = Triangle::triangulate(shape);
546
        // clear post drawing elements
547
        gViewObjectsHandler.reset();
548
        // push matrix
549
        GLHelper::pushMatrix();
550
        // enable draw for object under cursor and rectangle selection
551
        myVisualizationSettings->drawForViewObjectsHandler = true;
552
        myVisualizationSettings->drawForRectangleSelection = true;
553
        // draw all GL elements within the boundares formed by triangles
554
        for (const auto& triangle : triangles) {
555
            gViewObjectsHandler.setSelectionTriangle(triangle);
556
            drawGLElements(triangle.getBoundary());
557
        }
558
        // restore draw for object under cursor
559
        myVisualizationSettings->drawForViewObjectsHandler = false;
560
        myVisualizationSettings->drawForRectangleSelection = false;
561
        // pop matrix
562
        GLHelper::popMatrix();
563
        // check if update front elements
564
        for (const auto& AC : myMarkFrontElements.getACs()) {
565
            gViewObjectsHandler.updateFrontObject(AC->getGUIGlObject());
566
        }
567
        // after draw elements, update objects under cursor
568
        myViewObjectsSelector.updateObjects();
569
    }
570
}
571

572

573
void
574
GNEViewNet::redrawPathElementContours() {
575
    // if we're inspecting an element, add it to redraw path elements
576
    for (const auto& AC : myInspectedElements.getACs()) {
577
        const auto pathElement = dynamic_cast<const GNEPathElement*>(AC);
578
        if (pathElement) {
579
            gViewObjectsHandler.addToRedrawPathElements(pathElement);
580
        }
581
    }
582
    // enable draw for view objects handler (this calculate the contours)
583
    myVisualizationSettings->drawForViewObjectsHandler = true;
584
    // push matrix
585
    GLHelper::pushMatrix();
586
    // redraw elements in buffer
587
    myNet->getNetworkPathManager()->redrawPathElements(*myVisualizationSettings);
588
    myNet->getDemandPathManager()->redrawPathElements(*myVisualizationSettings);
589
    myNet->getDataPathManager()->redrawPathElements(*myVisualizationSettings);
590
    // pop matrix
591
    GLHelper::popMatrix();
592
    // disable drawForViewObjectsHandler
593
    myVisualizationSettings->drawForViewObjectsHandler = false;
594
}
595

596

597
const GNEViewNetHelper::MoveSingleElementModul&
598
GNEViewNet::getMoveSingleElementValues() const {
599
    return myMoveSingleElement;
600
}
601

602

603
const GNEViewNetHelper::MoveMultipleElementModul&
604
GNEViewNet::getMoveMultipleElementValues() const {
605
    return myMoveMultipleElements;
606
}
607

608

609
bool
610
GNEViewNet::setColorScheme(const std::string& name) {
611
    if (!gSchemeStorage.contains(name)) {
612
        return false;
613
    }
614
    if (myGUIDialogViewSettings != nullptr) {
615
        if (myGUIDialogViewSettings->getCurrentScheme() != name) {
616
            myGUIDialogViewSettings->setCurrentScheme(name);
617
        }
618
    }
619
    myVisualizationSettings = &gSchemeStorage.get(name.c_str());
620
    updateViewNet();
621
    return true;
622
}
623

624

625
void
626
GNEViewNet::openObjectDialogAtCursor(const FXEvent* /*ev*/) {
627
    // reimplemented from GUISUMOAbstractView due GNEOverlappedInspection
628
    ungrab();
629
    // make network current
630
    if (isEnabled() && myAmInitialised) {
631
        // check if we're cliking while alt button is pressed
632
        if (myMouseButtonKeyPressed.altKeyPressed()) {
633
            // set clicked popup position
634
            myClickedPopupPosition = getPositionInformation();
635
            // create cursor popup dialog for mark front element
636
            myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::FRONT_ELEMENT, this, myViewObjectsSelector.getGLObjects());
637
            // open popup dialog
638
            openPopupDialog();
639
        } else if (myViewObjectsSelector.getGLObjects().empty()) {
640
            openObjectDialog({myNet});
641
        } else {
642
            // declare filtered objects
643
            std::vector<GUIGlObject*> filteredGLObjects;
644
            // get GUIGLObject front
645
            GUIGlObject* overlappedElement = nullptr;
646
            // we need to check if we're inspecting a overlapping element
647
            if (myViewParent->getInspectorFrame()->getOverlappedInspection()->overlappedInspectionShown() &&
648
                    myInspectedElements.getFirstAC()) {
649
                overlappedElement = myInspectedElements.getFirstAC()->getGUIGlObject();
650
                filteredGLObjects.push_back(overlappedElement);
651
            }
652
            bool connections = false;
653
            bool TLS = false;
654
            // fill filtered objects
655
            if ((myViewObjectsSelector.getGLObjects().size() == 1) && (myViewObjectsSelector.getGLObjects().back()->getType() == GLO_EDGE)) {
656
                // special case for edge geometry points (because edges uses the lane pop ups)
657
                filteredGLObjects.push_back(myViewObjectsSelector.getGLObjects().back());
658
            } else {
659
                for (const auto& glObject : myViewObjectsSelector.getGLObjects()) {
660
                    // always avoid edges
661
                    if (glObject->getType() == GLO_EDGE) {
662
                        continue;
663
                    }
664
                    if (glObject->getType() == GLO_CONNECTION) {
665
                        connections = true;
666
                    }
667
                    if (glObject->getType() == GLO_TLLOGIC) {
668
                        TLS = true;
669
                    }
670
                    filteredGLObjects.push_back(glObject);
671
                }
672
                auto it = filteredGLObjects.begin();
673
                if (connections) {
674
                    // filter junctions if there are connections
675
                    while (it != filteredGLObjects.end()) {
676
                        if ((*it)->getType() == GLO_JUNCTION) {
677
                            it = filteredGLObjects.erase(it);
678
                        } else {
679
                            it++;
680
                        }
681
                    }
682
                } else if (TLS) {
683
                    // filter all elements except TLLogic
684
                    while (it != filteredGLObjects.end()) {
685
                        if ((*it)->getType() != GLO_TLLOGIC) {
686
                            it = filteredGLObjects.erase(it);
687
                        } else {
688
                            it++;
689
                        }
690
                    }
691
                }
692
            }
693
            // remove duplicated elements using an unordered set
694
            auto itDuplicated = filteredGLObjects.begin();
695
            std::unordered_set<GUIGlObject*> unorderedSet;
696
            for (auto itElement = filteredGLObjects.begin(); itElement != filteredGLObjects.end(); itElement++) {
697
                if (unorderedSet.insert(*itElement).second) {
698
                    *itDuplicated++ = *itElement;
699
                }
700
            }
701
            filteredGLObjects.erase(itDuplicated, filteredGLObjects.end());
702
            // open object dialog
703
            openObjectDialog(filteredGLObjects);
704
        }
705
    }
706
}
707

708

709
void
710
GNEViewNet::openDeleteDialogAtCursor(const std::vector<GUIGlObject*>& GLObjects) {
711
    if (myPopup) {
712
        destroyPopup();
713
    }
714
    // set clicked popup position
715
    myClickedPopupPosition = getPositionInformation();
716
    // create cursor popup dialog for delete element
717
    myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::DELETE_ELEMENT, this, GLObjects);
718
    myCreatedPopup = true;
719
    // open popup dialog
720
    openPopupDialog();
721
}
722

723

724
void
725
GNEViewNet::openSelectDialogAtCursor(const std::vector<GUIGlObject*>& GLObjects) {
726
    if (myPopup) {
727
        destroyPopup();
728
    }
729
    // set clicked popup position
730
    myClickedPopupPosition = getPositionInformation();
731
    // create cursor popup dialog for select element
732
    myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::SELECT_ELEMENT, this, GLObjects);
733
    myCreatedPopup = true;
734
    // open popup dialog
735
    openPopupDialog();
736
}
737

738

739
void
740
GNEViewNet::saveVisualizationSettings() const {
741
    // first check if we have to save gui settings in a file (only used for testing purposes)
742
    const auto& neteditOptions = OptionsCont::getOptions();
743
    if (neteditOptions.getString("gui-testing.setting-output").size() > 0) {
744
        try {
745
            // open output device
746
            OutputDevice& output = OutputDevice::getDevice(neteditOptions.getString("gui-testing.setting-output"));
747
            // save view settings
748
            output.openTag(SUMO_TAG_VIEWSETTINGS);
749
            myVisualizationSettings->save(output);
750
            // save viewport (zoom, X, Y and Z)
751
            output.openTag(SUMO_TAG_VIEWPORT);
752
            output.writeAttr(SUMO_ATTR_ZOOM, myChanger->getZoom());
753
            output.writeAttr(SUMO_ATTR_X, myChanger->getXPos());
754
            output.writeAttr(SUMO_ATTR_Y, myChanger->getYPos());
755
            output.writeAttr(SUMO_ATTR_ANGLE, myChanger->getRotation());
756
            output.closeTag();
757
            output.closeTag();
758
            // close output device
759
            output.close();
760
        } catch (...) {
761
            WRITE_ERROR(TL("GUI-Settings cannot be saved in ") + neteditOptions.getString("gui-testing.setting-output"));
762
        }
763
    }
764
}
765

766

767
const GNEViewNetHelper::EditModes&
768
GNEViewNet::getEditModes() const {
769
    return myEditModes;
770
}
771

772

773
const GNEViewNetHelper::TestingMode&
774
GNEViewNet::getTestingMode() const {
775
    return myTestingMode;
776
}
777

778

779
const GNEViewNetHelper::NetworkViewOptions&
780
GNEViewNet::getNetworkViewOptions() const {
781
    return myNetworkViewOptions;
782
}
783

784

785
const GNEViewNetHelper::DemandViewOptions&
786
GNEViewNet::getDemandViewOptions() const {
787
    return myDemandViewOptions;
788
}
789

790

791
const GNEViewNetHelper::DataViewOptions&
792
GNEViewNet::getDataViewOptions() const {
793
    return myDataViewOptions;
794
}
795

796

797
const GNEViewNetHelper::MouseButtonKeyPressed&
798
GNEViewNet::getMouseButtonKeyPressed() const {
799
    return myMouseButtonKeyPressed;
800
}
801

802

803
const GNEViewNetHelper::EditNetworkElementShapes&
804
GNEViewNet::getEditNetworkElementShapes() const {
805
    return myEditNetworkElementShapes;
806
}
807

808

809
void
810
GNEViewNet::buildColorRainbow(const GUIVisualizationSettings& s, GUIColorScheme& scheme, int active, GUIGlObjectType objectType,
811
                              const GUIVisualizationRainbowSettings& rs) {
812
    assert(!scheme.isFixed());
813
    double minValue = std::numeric_limits<double>::infinity();
814
    double maxValue = -std::numeric_limits<double>::infinity();
815
    // retrieve range
816
    bool hasMissingData = false;
817
    if (objectType == GLO_LANE) {
818
        // XXX (see #3409) multi-colors are not currently handled. this is a quick hack
819
        if (active == 9) {
820
            active = 8; // segment height, fall back to start height
821
        } else if (active == 11) {
822
            active = 10; // segment incline, fall back to total incline
823
        }
824
        for (const auto& lane : myNet->getAttributeCarriers()->getLanes()) {
825
            const double val = lane.second->getColorValue(s, active);
826
            if (val == s.MISSING_DATA) {
827
                hasMissingData = true;
828
                continue;
829
            }
830
            minValue = MIN2(minValue, val);
831
            maxValue = MAX2(maxValue, val);
832
        }
833
    } else if (objectType == GLO_VEHICLE) {
834
        for (const auto& tagMap : myNet->getAttributeCarriers()->getDemandElements()) {
835
            for (const auto& objItem : tagMap.second) {
836
                const double val = objItem.first->getColorValue(s, active);
837
                if (val == s.MISSING_DATA) {
838
                    hasMissingData = true;
839
                    continue;
840
                }
841
                minValue = MIN2(minValue, val);
842
                maxValue = MAX2(maxValue, val);
843
            }
844
        }
845
    } else if (objectType == GLO_JUNCTION) {
846
        if (active == 3) {
847
            for (const auto& junction : myNet->getAttributeCarriers()->getJunctions()) {
848
                minValue = MIN2(minValue, junction.second->getPositionInView().z());
849
                maxValue = MAX2(maxValue, junction.second->getPositionInView().z());
850
            }
851
        }
852
    } else if (objectType == GLO_TAZRELDATA) {
853
        if (active == 4) {
854
            for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_TAZREL)) {
855
                const double value = genericData.second->getColorValue(s, active);
856
                if (value == s.MISSING_DATA) {
857
                    continue;
858
                }
859
                minValue = MIN2(minValue, value);
860
                maxValue = MAX2(maxValue, value);
861
            }
862
        }
863
    }
864
    if (scheme.getName() == GUIVisualizationSettings::SCHEME_NAME_PERMISSION_CODE) {
865
        scheme.clear();
866
        // add threshold for every distinct value
867
        std::set<SVCPermissions> codes;
868
        for (const auto& lane : myNet->getAttributeCarriers()->getLanes()) {
869
            codes.insert(lane.second->getParentEdge()->getNBEdge()->getPermissions(lane.second->getIndex()));
870
        }
871
        int step = MAX2(1, 360 / (int)codes.size());
872
        int hue = 0;
873
        for (SVCPermissions p : codes) {
874
            scheme.addColor(RGBColor::fromHSV(hue, 1, 1), (double)p);
875
            hue = (hue + step) % 360;
876
        }
877
        return;
878
    }
879
    buildMinMaxRainbow(s, scheme, rs, minValue, maxValue, hasMissingData);
880
}
881

882

883
void
884
GNEViewNet::setStatusBarText(const std::string& text) {
885
    myApp->setStatusBarText(text);
886
}
887

888

889
bool
890
GNEViewNet::autoSelectNodes() {
891
    if (myLockManager.isObjectLocked(GLO_JUNCTION, false)) {
892
        return false;
893
    } else {
894
        return myNetworkViewOptions.menuCheckExtendSelection->amChecked();
895
    }
896
}
897

898

899
void
900
GNEViewNet::setSelectorFrameScale(double selectionScale) {
901
    myVisualizationSettings->selectorFrameScale = selectionScale;
902
}
903

904

905
bool
906
GNEViewNet::changeAllPhases() const {
907
    return (myNetworkViewOptions.menuCheckChangeAllPhases->amChecked() != 0);
908
}
909

910

911
bool
912
GNEViewNet::showJunctionAsBubbles() const {
913
    return (myNetworkViewOptions.menuCheckShowJunctionBubble->shown() &&
914
            myNetworkViewOptions.menuCheckShowJunctionBubble->amChecked());
915
}
916

917

918
bool
919
GNEViewNet::askMergeJunctions(const GNEJunction* movedJunction, const GNEJunction* targetJunction, bool& alreadyAsked) {
920
    if (alreadyAsked) {
921
        return false;
922
    } else if (myNetworkViewOptions.menuCheckMergeAutomatically->amChecked()) {
923
        return true;
924
    } else {
925
        alreadyAsked = true;
926
        // open question box
927
        const std::string header = TL("Confirm Junction Merger");
928
        const std::string body = TLF("Do you wish to merge junctions '%' and '%'?\n('%' will be eliminated and its roads added to '%')",
929
                                     movedJunction->getMicrosimID(),
930
                                     targetJunction->getMicrosimID(),
931
                                     movedJunction->getMicrosimID(),
932
                                     targetJunction->getMicrosimID());
933
        const auto questionDialog = GNEQuestionBasicDialog(myViewParent->getGNEAppWindows(), GNEDialog::Buttons::YES_NO, header, body);
934
        // continue depending of result
935
        if (questionDialog.getResult() == GNEDialog::Result::ACCEPT) {
936
            return true;
937
        } else {
938
            return false;
939
        }
940
    }
941
}
942

943

944
bool
945
GNEViewNet::aksChangeSupermode(const std::string& operation, Supermode expectedSupermode) {
946
    // first check if ignore option is enabled
947
    if (OptionsCont::getOptions().getBool("ignore-supermode-question")) {
948
        return true;
949
    }
950
    std::string body;
951
    if (expectedSupermode == Supermode::NETWORK) {
952
        body = TLF("% requires switch to network mode. Continue?", operation);
953
    } else if (expectedSupermode == Supermode::DEMAND) {
954
        body = TLF("% requires switch to demand mode. Continue?", operation);
955
    } else if (expectedSupermode == Supermode::DATA) {
956
        body = TLF("% requires switch to data mode. Continue?", operation);
957
    } else {
958
        throw ProcessError("invalid expected supermode");
959
    }
960
    // open question dialog
961
    const auto questionDialog = GNEQuestionBasicDialog(myViewParent->getGNEAppWindows(), GNEDialog::Buttons::YES_NO,
962
                                TL("Confirm switch mode"), body);
963
    // continue depending of result
964
    if (questionDialog.getResult() == GNEDialog::Result::ACCEPT) {
965
        myEditModes.setSupermode(expectedSupermode, true);
966
        return true;
967
    } else {
968
        return false;
969
    }
970
}
971

972

973
bool
974
GNEViewNet::selectingDetectorsTLSMode() const {
975
    // separate conditions for code legibly
976
    const bool TLSMode = (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS));
977
    const bool selectingDetectors = myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled();
978
    return (TLSMode && selectingDetectors);
979
}
980

981

982
bool
983
GNEViewNet::selectingJunctionsTLSMode() const {
984
    // separate conditions for code legibly
985
    const bool TLSMode = (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS));
986
    const bool selectingJunctions = myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions();
987
    return (TLSMode && selectingJunctions);
988
}
989

990

991
GNEViewNetHelper::SaveElements&
992
GNEViewNet::getSaveElements() {
993
    return mySaveElements;
994
}
995

996

997
GNEViewNetHelper::TimeFormat&
998
GNEViewNet::getTimeFormat() {
999
    return myTimeFormat;
1000
}
1001

1002

1003
bool
1004
GNEViewNet::restrictLane(GNELane* lane, SUMOVehicleClass vclass) {
1005
    // Get selected lanes
1006
    const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
1007
    // Declare map of edges and lanes
1008
    std::map<GNEEdge*, GNELane*> mapOfEdgesAndLanes;
1009
    // Iterate over selected lanes
1010
    for (const auto& selectedLane : selectedLanes) {
1011
        mapOfEdgesAndLanes[myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID())] = selectedLane;
1012
    }
1013
    // Throw warning dialog if there hare multiple lanes selected in the same edge
1014
    if (mapOfEdgesAndLanes.size() != selectedLanes.size()) {
1015
        const std::string header = TL("Multiple lane in the same edge selected");
1016
        const std::string bodyA = TL("There are selected lanes that belong to the same edge.");
1017
        const std::string bodyB = TLF("Only one lane per edge will be restricted to %.", toString(vclass));
1018
        // Show warning dialog
1019
        GNEWarningBasicDialog(myViewParent->getGNEAppWindows(), header, bodyA, bodyB);
1020
    }
1021
    // If we handeln a set of lanes
1022
    if (mapOfEdgesAndLanes.size() > 0) {
1023
        // declare counter for number of Sidewalks
1024
        int counter = 0;
1025
        // iterate over selected lanes
1026
        for (const auto& edgeLane : mapOfEdgesAndLanes) {
1027
            if (edgeLane.first->hasRestrictedLane(vclass)) {
1028
                counter++;
1029
            }
1030
        }
1031
        // if all edges parent own a Sidewalk, stop function
1032
        if (counter == (int)mapOfEdgesAndLanes.size()) {
1033
            const std::string header = TLF("Set vclass to % for selected lanes", toString(vclass));
1034
            const std::string body = TLF("All lanes own already another lane in the same edge with a restriction for %", toString(vclass));
1035
            // show information dialog
1036
            GNEInformationBasicDialog(myViewParent->getGNEAppWindows(), header, body);
1037
            return 0;
1038
        } else {
1039
            // Ask confirmation to user
1040
            const std::string header = TLF("Set vclass to % for selected lanes", toString(vclass));
1041
            const std::string body = TLF("% lanes will be restricted to %. Continue?", toString(mapOfEdgesAndLanes.size() - counter), toString(vclass));
1042
            // show question dialog
1043
            const auto questionDialog = GNEQuestionBasicDialog(myViewParent->getGNEAppWindows(), GNEDialog::Buttons::YES_NO, header, body);
1044
            // continue depending of result
1045
            if (questionDialog.getResult() != GNEDialog::Result::ACCEPT) { //1:yes, 2:no, 4:esc
1046
                return 0;
1047
            }
1048
        }
1049
        // begin undo operation
1050
        myUndoList->begin(lane, "restrict lanes to " + toString(vclass));
1051
        // iterate over selected lanes
1052
        for (const auto& edgeLane : mapOfEdgesAndLanes) {
1053
            // Transform lane to Sidewalk
1054
            myNet->restrictLane(vclass, edgeLane.second, myUndoList);
1055
        }
1056
        // end undo operation
1057
        myUndoList->end();
1058
    } else {
1059
        // If only have a single lane, start undo/redo operation
1060
        myUndoList->begin(lane, TL("restrict lane to ") + toString(vclass));
1061
        // Transform lane to Sidewalk
1062
        myNet->restrictLane(vclass, lane, myUndoList);
1063
        // end undo operation
1064
        myUndoList->end();
1065
    }
1066
    return 1;
1067
}
1068

1069

1070
bool
1071
GNEViewNet::addRestrictedLane(GNELane* lane, SUMOVehicleClass vclass, const bool insertAtFront) {
1072
    // Get selected edges
1073
    const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
1074
    // get selected lanes
1075
    const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
1076
    // Declare set of edges
1077
    std::set<GNEEdge*> setOfEdges;
1078
    // Fill set of edges with vector of edges
1079
    for (const auto& edge : selectedEdges) {
1080
        setOfEdges.insert(edge);
1081
    }
1082
    // iterate over selected lanes
1083
    for (const auto& selectedLane : selectedLanes) {
1084
        // Insert pointer to edge into set of edges (To avoid duplicates)
1085
        setOfEdges.insert(myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID()));
1086
    }
1087
    // If we handeln a set of edges
1088
    if (lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) {
1089
        // declare counter for number of restrictions
1090
        int counter = 0;
1091
        // iterate over set of edges
1092
        for (const auto& edge : setOfEdges) {
1093
            // update counter if edge has already a restricted lane of type "vclass"
1094
            if (edge->hasRestrictedLane(vclass)) {
1095
                counter++;
1096
            }
1097
        }
1098
        // if all lanes own a Sidewalk, stop function
1099
        if (counter == (int)setOfEdges.size()) {
1100
            const std::string header = TLF("Add vclass % to selected lanes", toString(vclass));
1101
            const std::string body = TLF("All lanes own already another lane in the same edge with a restriction to %.", toString(vclass));
1102
            // show information dialog
1103
            GNEInformationBasicDialog(myViewParent->getGNEAppWindows(), header, body);
1104
            return 0;
1105
        } else {
1106
            // Ask confirmation to user
1107
            const std::string header = TLF("Add vclass % to selected lanes", toString(vclass));
1108
            const std::string body = TLF("% restrictions to % will be added. Continue?", toString(setOfEdges.size() - counter), toString(vclass));
1109
            // show question dialog
1110
            const auto questionDialog = GNEQuestionBasicDialog(myViewParent->getGNEAppWindows(), GNEDialog::Buttons::YES_NO, header, body);
1111
            // continue depending of result
1112
            if (questionDialog.getResult() != GNEDialog::Result::ACCEPT) { //1:yes, 2:no, 4:esc
1113
                return 0;
1114
            }
1115
        }
1116
        // begin undo operation
1117
        myUndoList->begin(lane, TL("add restrictions for ") + toString(vclass));
1118
        // iterate over set of edges
1119
        for (const auto& edge : setOfEdges) {
1120
            // add restricted lane (guess target)
1121
            myNet->addRestrictedLane(vclass, edge, -1, myUndoList);
1122
        }
1123
        // end undo operation
1124
        myUndoList->end();
1125
    } else {
1126
        // If only have a single lane, start undo/redo operation
1127
        myUndoList->begin(lane, TL("add vclass for ") + toString(vclass));
1128
        // Add restricted lane
1129
        if (vclass == SVC_PEDESTRIAN) {
1130
            // always add pedestrian lanes on the right
1131
            myNet->addRestrictedLane(vclass, lane->getParentEdge(), 0, myUndoList);
1132
        } else if (vclass == SVC_IGNORING) {
1133
            if (insertAtFront) {
1134
                myNet->addGreenVergeLane(lane->getParentEdge(), lane->getIndex() + 1, myUndoList);
1135
            } else {
1136
                myNet->addGreenVergeLane(lane->getParentEdge(), lane->getIndex(), myUndoList);
1137
            }
1138
        } else if (lane->getParentEdge()->getChildLanes().size() == 1) {
1139
            // guess insertion position if there is only 1 lane
1140
            myNet->addRestrictedLane(vclass, lane->getParentEdge(), -1, myUndoList);
1141
        } else {
1142
            myNet->addRestrictedLane(vclass, lane->getParentEdge(), lane->getIndex(), myUndoList);
1143
        }
1144
        // end undo/redo operation
1145
        myUndoList->end();
1146
    }
1147
    return 1;
1148
}
1149

1150

1151
bool
1152
GNEViewNet::removeRestrictedLane(GNELane* lane, SUMOVehicleClass vclass) {
1153
    // Get selected edges
1154
    const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
1155
    // get selected lanes
1156
    const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
1157
    // Declare set of edges
1158
    std::set<GNEEdge*> setOfEdges;
1159
    // Fill set of edges with vector of edges
1160
    for (const auto& edge : selectedEdges) {
1161
        setOfEdges.insert(edge);
1162
    }
1163
    // iterate over selected lanes
1164
    for (const auto& selectedLane : selectedLanes) {
1165
        // Insert pointer to edge into set of edges (To avoid duplicates)
1166
        setOfEdges.insert(myNet->getAttributeCarriers()->retrieveEdge(selectedLane->getParentEdge()->getID()));
1167
    }
1168
    // If we handeln a set of edges
1169
    if (setOfEdges.size() > 0) {
1170
        // declare counter for number of restrictions
1171
        int counter = 0;
1172
        // iterate over set of edges
1173
        for (const auto& edge : setOfEdges) {
1174
            // update counter if edge has already a restricted lane of type "vclass"
1175
            if (edge->hasRestrictedLane(vclass)) {
1176
                counter++;
1177
            }
1178
        }
1179
        // if all lanes don't own a Sidewalk, stop function
1180
        if (counter == 0) {
1181
            const std::string header = TLF("Remove vclass % from selected lanes", toString(vclass));
1182
            const std::string body = TLF("The selected lanes and edges don't have a restriction to %.", toString(vclass));
1183
            // show information dialog
1184
            GNEInformationBasicDialog(myViewParent->getGNEAppWindows(), header, body);
1185
            return 0;
1186
        } else {
1187
            // Ask confirmation to user
1188
            const std::string header = TLF("Remove vclass % from selected lanes", toString(vclass));
1189
            const std::string body = TLF("% restrictions to % will be removed. Continue?", toString(setOfEdges.size() - counter), toString(vclass));
1190
            // show question dialog
1191
            const auto questionDialog = GNEQuestionBasicDialog(myViewParent->getGNEAppWindows(), GNEDialog::Buttons::YES_NO, header, body);
1192
            // continue depending of result
1193
            if (questionDialog.getResult() != GNEDialog::Result::ACCEPT) { //1:yes, 2:no, 4:esc
1194
                return 0;
1195
            }
1196
        }
1197
        // begin undo operation
1198
        myUndoList->begin(lane, "Remove restrictions for " + toString(vclass));
1199
        // iterate over set of edges
1200
        for (const auto& edge : setOfEdges) {
1201
            // add Sidewalk
1202
            myNet->removeRestrictedLane(vclass, edge, myUndoList);
1203
        }
1204
        // end undo operation
1205
        myUndoList->end();
1206
    } else {
1207
        // If only have a single lane, start undo/redo operation
1208
        myUndoList->begin(lane, TL("Remove vclass for ") + toString(vclass));
1209
        // Remove Sidewalk
1210
        myNet->removeRestrictedLane(vclass, lane->getParentEdge(), myUndoList);
1211
        // end undo/redo operation
1212
        myUndoList->end();
1213
    }
1214
    return 1;
1215
}
1216

1217

1218
#ifdef _MSC_VER
1219
#pragma warning(push)
1220
#pragma warning(disable: 4355) // mask warning about "this" in initializers
1221
#endif
1222
GNEViewNet::GNEViewNet() :
1223
    myViewObjectsSelector(this),
1224
    myEditModes(this),
1225
    myTestingMode(this),
1226
    myCommonCheckableButtons(this),
1227
    myNetworkCheckableButtons(this),
1228
    myDemandCheckableButtons(this),
1229
    myDataCheckableButtons(this),
1230
    myNetworkViewOptions(this),
1231
    myDemandViewOptions(this),
1232
    myDataViewOptions(this),
1233
    myIntervalBar(this),
1234
    myMoveSingleElement(this),
1235
    myMoveMultipleElements(this),
1236
    myVehicleOptions(this),
1237
    myVehicleTypeOptions(this),
1238
    mySaveElements(this),
1239
    myTimeFormat(this),
1240
    mySelectingArea(this),
1241
    myEditNetworkElementShapes(this),
1242
    myLockManager(this) {
1243
}
1244
#ifdef _MSC_VER
1245
#pragma warning(pop)
1246
#endif
1247

1248

1249
std::vector<std::string>
1250
GNEViewNet::getEdgeLaneParamKeys(bool edgeKeys) const {
1251
    std::set<std::string> keys;
1252
    for (const NBEdge* e : myNet->getEdgeCont().getAllEdges()) {
1253
        if (edgeKeys) {
1254
            for (const auto& item : e->getParametersMap()) {
1255
                keys.insert(item.first);
1256
            }
1257
            for (const auto& con : e->getConnections()) {
1258
                for (const auto& item : con.getParametersMap()) {
1259
                    keys.insert(item.first);
1260
                }
1261
            }
1262
        } else {
1263
            for (const auto& lane : e->getLanes()) {
1264
                int i = 0;
1265
                for (const auto& item : lane.getParametersMap()) {
1266
                    keys.insert(item.first);
1267
                }
1268
                for (const auto& con : e->getConnectionsFromLane(i)) {
1269
                    for (const auto& item : con.getParametersMap()) {
1270
                        keys.insert(item.first);
1271
                    }
1272
                }
1273
                i++;
1274
            }
1275
        }
1276
    }
1277
    return std::vector<std::string>(keys.begin(), keys.end());
1278
}
1279

1280

1281
std::vector<std::string>
1282
GNEViewNet::getEdgeDataAttrs() const {
1283
    std::set<std::string> keys;
1284
    for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(GNE_TAG_EDGEREL_SINGLE)) {
1285
        for (const auto& parameter : genericData.second->getACParametersMap()) {
1286
            keys.insert(parameter.first);
1287
        }
1288
    }
1289
    return std::vector<std::string>(keys.begin(), keys.end());
1290
}
1291

1292

1293
std::vector<std::string>
1294
GNEViewNet::getRelDataAttrs() const {
1295
    std::set<std::string> keys;
1296
    for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_TAZREL)) {
1297
        for (const auto& parameter : genericData.second->getACParametersMap()) {
1298
            keys.insert(parameter.first);
1299
        }
1300
    }
1301
    for (const auto& genericData : myNet->getAttributeCarriers()->getGenericDatas().at(SUMO_TAG_EDGEREL)) {
1302
        for (const auto& parameter : genericData.second->getACParametersMap()) {
1303
            keys.insert(parameter.first);
1304
        }
1305
    }
1306
    return std::vector<std::string>(keys.begin(), keys.end());
1307
}
1308

1309

1310
bool
1311
GNEViewNet::checkSelectEdges() const {
1312
    if ((myNetworkViewOptions.selectEdges() && !myMouseButtonKeyPressed.shiftKeyPressed()) ||
1313
            (!myNetworkViewOptions.selectEdges() && myMouseButtonKeyPressed.shiftKeyPressed())) {
1314
        return true;
1315
    } else {
1316
        return false;
1317
    }
1318
}
1319

1320

1321
int
1322
GNEViewNet::getDrawingToggle() const {
1323
    return myDrawingToggle;
1324
}
1325

1326

1327
int
1328
GNEViewNet::doPaintGL(int mode, const Boundary& drawingBoundary) {
1329
    // set lefthand and laneIcons
1330
    myVisualizationSettings->lefthand = OptionsCont::getOptions().getBool("lefthand");
1331
    myVisualizationSettings->disableLaneIcons = OptionsCont::getOptions().getBool("disable-laneIcons");
1332
    // first step: update objects under cursor
1333
    updateObjectsInPosition(myNet->getViewNet()->getPositionInformation());
1334
    // second step: redraw contour of path elements (needed if we're inspecting a path element like a route or trip)
1335
    redrawPathElementContours();
1336
    // set render modes
1337
    glRenderMode(mode);
1338
    glMatrixMode(GL_MODELVIEW);
1339
    GLHelper::pushMatrix();
1340
    glDisable(GL_TEXTURE_2D);
1341
    glDisable(GL_ALPHA_TEST);
1342
    glEnable(GL_BLEND);
1343
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1344
    glEnable(GL_DEPTH_TEST);
1345
    // visualize rectangular selection
1346
    mySelectingArea.drawRectangleSelection(myVisualizationSettings->colorSettings.selectionColor);
1347
    // draw decals
1348
    drawDecals();
1349
    // draw grid (and update grid button)
1350
    drawGrid();
1351
    // update show connections
1352
    myNetworkViewOptions.menuCheckShowConnections->setChecked(myVisualizationSettings->showLane2Lane);
1353
    // draw temporal junction
1354
    drawTemporalJunction();
1355
    // draw temporal drawing shape
1356
    drawTemporalDrawingShape();
1357
    // draw testing elements
1358
    myTestingMode.drawTestingElements(myApp);
1359
    // draw temporal E2 multilane detectors
1360
    myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->drawTemporalConsecutiveLanePath();
1361
    // draw temporal overhead wires
1362
    myViewParent->getWireFrame()->getConsecutiveLaneSelector()->drawTemporalConsecutiveLanePath();
1363
    // draw temporal trip/flow route
1364
    myViewParent->getVehicleFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1365
    // draw temporal person plan route
1366
    myViewParent->getPersonFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1367
    myViewParent->getPersonPlanFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1368
    // draw temporal container plan route
1369
    myViewParent->getContainerFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1370
    myViewParent->getContainerPlanFrame()->getPlanCreator()->drawTemporalRoute(*myVisualizationSettings);
1371
    // draw temporal route
1372
    myViewParent->getRouteFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1373
    // draw temporal edgeRelPath
1374
    myViewParent->getEdgeRelDataFrame()->getPathCreator()->drawTemporalRoute(*myVisualizationSettings);
1375
    // check menu checks of supermode demand
1376
    if (myEditModes.isCurrentSupermodeDemand()) {
1377
        // enable or disable menuCheckShowAllPersonPlans depending of there is a locked person
1378
        if (myDemandViewOptions.getLockedPerson()) {
1379
            myDemandViewOptions.menuCheckShowAllPersonPlans->disable();
1380
        } else {
1381
            myDemandViewOptions.menuCheckShowAllPersonPlans->enable();
1382
        }
1383
    }
1384
    // clear pathDraw
1385
    myNet->getNetworkPathManager()->getPathDraw()->clearPathDraw();
1386
    myNet->getDemandPathManager()->getPathDraw()->clearPathDraw();
1387
    myNet->getDataPathManager()->getPathDraw()->clearPathDraw();
1388
    // update ignore hide by zoom
1389
    myVisualizationSettings->updateIgnoreHideByZoom();
1390
    // draw network (boundary
1391
    myNet->drawGL(*myVisualizationSettings);
1392
    // draw all GL elements
1393
    int hits = drawGLElements(drawingBoundary);
1394
    // after drawing all elements, update list of merged junctions
1395
    myViewObjectsSelector.updateMergingJunctions();
1396
    // draw temporal split junction
1397
    drawTemporalSplitJunction();
1398
    // draw temporal roundabout
1399
    drawTemporalRoundabout();
1400
    // draw temporal lines between E1 detectors and junctions in TLS Mode
1401
    drawTemporalE1TLSLines();
1402
    // draw temporal lines between junctions in TLS Mode
1403
    drawTemporalJunctionTLSLines();
1404
    // draw netedit attributes references
1405
    drawNeteditAttributesReferences();
1406
    // draw test circle
1407
    drawTestsCircle();
1408
    // pop draw matrix
1409
    GLHelper::popMatrix();
1410
    // update interval bar
1411
    myIntervalBar.markForUpdate();
1412
    // check if recopute boundaries (Deactivated, continue after 1.14 release)
1413
    /*
1414
        if (gObjectsInPosition.recomputeBoundaries != GLO_NETWORK) {
1415
            myNet->getGrid().updateBoundaries(gObjectsInPosition.recomputeBoundaries);
1416
        }
1417
    */
1418
    return hits;
1419
}
1420

1421

1422
long
1423
GNEViewNet::onLeftBtnPress(FXObject* obj, FXSelector, void* eventData) {
1424
    // check if we're in test mode
1425
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1426
        // set focus in view net
1427
        setFocus();
1428
        // update MouseButtonKeyPressed
1429
        myMouseButtonKeyPressed.update(eventData);
1430
        // process left button press function depending of supermode
1431
        if (myEditModes.isCurrentSupermodeNetwork()) {
1432
            processLeftButtonPressNetwork(eventData);
1433
        } else if (myEditModes.isCurrentSupermodeDemand()) {
1434
            processLeftButtonPressDemand(eventData);
1435
        } else if (myEditModes.isCurrentSupermodeData()) {
1436
            processLeftButtonPressData(eventData);
1437
        }
1438
        // update cursor
1439
        updateCursor();
1440
        // update view
1441
        updateViewNet();
1442
        return 1;
1443
    } else {
1444
        return 0;
1445
    }
1446
}
1447

1448

1449
long
1450
GNEViewNet::onLeftBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1451
    // check if we're in test mode
1452
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1453
        // avoid closing Popup dialog in Linux
1454
        if (myCreatedPopup) {
1455
            myCreatedPopup = false;
1456
            return 1;
1457
        }
1458
        // process parent function
1459
        GUISUMOAbstractView::onLeftBtnRelease(obj, sel, eventData);
1460
        // update MouseButtonKeyPressed
1461
        myMouseButtonKeyPressed.update(eventData);
1462
        // process left button release function depending of supermode
1463
        if (myEditModes.isCurrentSupermodeNetwork()) {
1464
            processLeftButtonReleaseNetwork();
1465
        } else if (myEditModes.isCurrentSupermodeDemand()) {
1466
            processLeftButtonReleaseDemand();
1467
        } else if (myEditModes.isCurrentSupermodeData()) {
1468
            processLeftButtonReleaseData();
1469
        }
1470
        // update cursor
1471
        updateCursor();
1472
        // update view
1473
        updateViewNet();
1474
        return 1;
1475
    } else {
1476
        return 0;
1477
    }
1478
}
1479

1480

1481
long
1482
GNEViewNet::onMiddleBtnPress(FXObject* obj, FXSelector sel, void* eventData) {
1483
    // check if we're in test mode
1484
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1485
        // process parent function
1486
        GUISUMOAbstractView::onMiddleBtnPress(obj, sel, eventData);
1487
        // update cursor
1488
        updateCursor();
1489
        // update view
1490
        updateViewNet();
1491
        return 1;
1492
    } else {
1493
        return 0;
1494
    }
1495
}
1496

1497

1498
long
1499
GNEViewNet::onMiddleBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1500
    // check if we're in test mode
1501
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1502
        // process parent function
1503
        GUISUMOAbstractView::onMiddleBtnRelease(obj, sel, eventData);
1504
        // update cursor
1505
        updateCursor();
1506
        // update view
1507
        updateViewNet();
1508
        return 1;
1509
    } else {
1510
        return 0;
1511
    }
1512
}
1513

1514

1515
long
1516
GNEViewNet::onRightBtnPress(FXObject* obj, FXSelector sel, void* eventData) {
1517
    // check if we're in test mode
1518
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1519
        // update MouseButtonKeyPressed
1520
        myMouseButtonKeyPressed.update(eventData);
1521
        // update cursor
1522
        updateCursor();
1523
        if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1524
            // disable right button press during drawing polygon
1525
            return 1;
1526
        } else {
1527
            return GUISUMOAbstractView::onRightBtnPress(obj, sel, eventData);
1528
        }
1529
    } else {
1530
        return 0;
1531
    }
1532
}
1533

1534

1535
long
1536
GNEViewNet::onRightBtnRelease(FXObject* obj, FXSelector sel, void* eventData) {
1537
    // check if we're in test mode
1538
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1539
        // update MouseButtonKeyPressed
1540
        myMouseButtonKeyPressed.update(eventData);
1541
        // update cursor
1542
        updateCursor();
1543
        // disable right button release during drawing polygon
1544
        if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1545
            return 1;
1546
        } else {
1547
            return GUISUMOAbstractView::onRightBtnRelease(obj, sel, eventData);
1548
        }
1549
    } else {
1550
        return 0;
1551
    }
1552
}
1553

1554

1555
long
1556
GNEViewNet::onMouseMove(FXObject* obj, FXSelector sel, void* eventData) {
1557
    // check if we're in test mode
1558
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1559
        // process mouse move in GUISUMOAbstractView
1560
        GUISUMOAbstractView::onMouseMove(obj, sel, eventData);
1561
        // update MouseButtonKeyPressed
1562
        myMouseButtonKeyPressed.update(eventData);
1563
        // update cursor
1564
        updateCursor();
1565
        // process mouse move function depending of supermode
1566
        if (myEditModes.isCurrentSupermodeNetwork()) {
1567
            processMoveMouseNetwork(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1568
        } else if (myEditModes.isCurrentSupermodeDemand()) {
1569
            processMoveMouseDemand(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1570
        } else if (myEditModes.isCurrentSupermodeData()) {
1571
            processMoveMouseData(myMouseButtonKeyPressed.mouseLeftButtonPressed());
1572
        }
1573
        // update view
1574
        updateViewNet();
1575
        return 1;
1576
    } else {
1577
        return 0;
1578
    }
1579
}
1580

1581

1582
long
1583
GNEViewNet::onKeyPress(FXObject* obj, FXSelector sel, void* eventData) {
1584
    // check if we're in test mode
1585
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1586
        // update MouseButtonKeyPressed
1587
        myMouseButtonKeyPressed.update(eventData);
1588
        // update cursor
1589
        updateCursor();
1590
        // continue depending of current edit mode
1591
        if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1592
            // update viewNet (for temporal junction)
1593
            updateViewNet();
1594
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1595
            // change "delete last created point" depending of shift key
1596
            myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1597
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1598
            // change "delete last created point" depending of shift key
1599
            myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1600
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) || (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE)) {
1601
            updateViewNet();
1602
        }
1603
        return GUISUMOAbstractView::onKeyPress(obj, sel, eventData);
1604
    } else {
1605
        return 0;
1606
    }
1607
}
1608

1609

1610
long
1611
GNEViewNet::onKeyRelease(FXObject* obj, FXSelector sel, void* eventData) {
1612
    // check if we're in test mode
1613
    if (myViewParent->getGNEAppWindows()->allowInputSignals(obj)) {
1614
        // update MouseButtonKeyPressed
1615
        myMouseButtonKeyPressed.update(eventData);
1616
        // update cursor
1617
        updateCursor();
1618
        // continue depending of current edit mode
1619
        if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1620
            // update viewNet (for temporal junction)
1621
            updateViewNet();
1622
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1623
            // change "delete last created point" depending of shift key
1624
            myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1625
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1626
            // change "delete last created point" depending of shift key
1627
            myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
1628
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) || (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE)) {
1629
            updateViewNet();
1630
        }
1631
        // check if selecting using rectangle has to be disabled
1632
        if (mySelectingArea.selectingUsingRectangle && !myMouseButtonKeyPressed.shiftKeyPressed()) {
1633
            mySelectingArea.selectingUsingRectangle = false;
1634
            updateViewNet();
1635
        }
1636
        return GUISUMOAbstractView::onKeyRelease(obj, sel, eventData);
1637
    } else {
1638
        return 0;
1639
    }
1640
}
1641

1642

1643
void
1644
GNEViewNet::abortOperation(bool clearSelection) {
1645
    // steal focus from any text fields and place it over view net
1646
    setFocus();
1647
    // check what supermode is enabled
1648
    if (myEditModes.isCurrentSupermodeNetwork()) {
1649
        // abort operation depending of current mode
1650
        if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) {
1651
            // abort edge creation in create edge frame
1652
            myViewParent->getCreateEdgeFrame()->abortEdgeCreation();
1653
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
1654
            mySelectingArea.selectingUsingRectangle = false;
1655
            // check if current selection has to be cleaned
1656
            if (clearSelection) {
1657
                myViewParent->getSelectorFrame()->clearCurrentSelection();
1658
            }
1659
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
1660
            // abort changes in Connector Frame
1661
            myViewParent->getConnectorFrame()->getConnectionModifications()->onCmdCancelModifications(0, 0, 0);
1662
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS) {
1663
            // continue depending of current TLS frame state
1664
            if (myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled()) {
1665
                myViewParent->getTLSEditorFrame()->getTLSAttributes()->disableE1DetectorMode();
1666
            } else if (myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions()) {
1667
                myViewParent->getTLSEditorFrame()->getTLSJunction()->onCmdCancelJoin(nullptr, 0, nullptr);
1668
            } else {
1669
                myViewParent->getTLSEditorFrame()->getTLSPrograms()->discardChanges(false);
1670
            }
1671
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
1672
            myEditNetworkElementShapes.stopEditCustomShape();
1673
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CROSSING) {
1674
            myViewParent->getCrossingFrame()->clearEdgesHotkey();
1675
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) {
1676
            // abort current drawing
1677
            myViewParent->getShapeFrame()->getDrawingShapeModule()->abortDrawing();
1678
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
1679
            if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1680
                // abort current drawing
1681
                myViewParent->getTAZFrame()->getDrawingShapeModule()->abortDrawing();
1682
            } else if (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() != nullptr) {
1683
                // finish current editing TAZ
1684
                myViewParent->getTAZFrame()->getCurrentTAZModule()->setTAZ(nullptr);
1685
            }
1686
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_PROHIBITION) {
1687
            myViewParent->getProhibitionFrame()->getSelectionModul()->onCmdCancel(nullptr, 0, nullptr);
1688
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1689
            // clear view selection
1690
            myViewParent->getAdditionalFrame()->getViewObjetsSelector()->clearSelection();
1691
            // abort path
1692
            myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->abortPathCreation();
1693
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_WIRE) {
1694
            // abort path
1695
            myViewParent->getWireFrame()->getConsecutiveLaneSelector()->abortPathCreation();
1696
        }
1697
    } else if (myEditModes.isCurrentSupermodeDemand()) {
1698
        // abort operation depending of current mode
1699
        if (myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) {
1700
            mySelectingArea.selectingUsingRectangle = false;
1701
            // check if current selection has to be cleaned
1702
            if (clearSelection) {
1703
                myViewParent->getSelectorFrame()->clearCurrentSelection();
1704
            }
1705
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1706
            myViewParent->getRouteFrame()->getPathCreator()->abortPathCreation();
1707
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1708
            myViewParent->getVehicleFrame()->getPathCreator()->abortPathCreation();
1709
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1710
            myViewParent->getPersonFrame()->getPlanCreator()->abortPathCreation();
1711
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1712
            myViewParent->getPersonPlanFrame()->getPlanCreator()->abortPathCreation();
1713
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1714
            myViewParent->getContainerFrame()->getPlanCreator()->abortPathCreation();
1715
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1716
            myViewParent->getContainerPlanFrame()->getPlanCreator()->abortPathCreation();
1717
        }
1718
    } else if (myEditModes.isCurrentSupermodeData()) {
1719
        // abort operation depending of current mode
1720
        if (myEditModes.dataEditMode == DataEditMode::DATA_SELECT) {
1721
            mySelectingArea.selectingUsingRectangle = false;
1722
            // check if current selection has to be cleaned
1723
            if (clearSelection) {
1724
                myViewParent->getSelectorFrame()->clearCurrentSelection();
1725
            }
1726
        } else if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1727
            myViewParent->getEdgeRelDataFrame()->getPathCreator()->abortPathCreation();
1728
        } else if (myEditModes.dataEditMode == DataEditMode::DATA_TAZRELDATA) {
1729
            myViewParent->getTAZRelDataFrame()->clearTAZSelection();
1730
        }
1731
    }
1732
    // abort undo list
1733
    myUndoList->abortAllChangeGroups();
1734
    // update view
1735
    updateViewNet();
1736
}
1737

1738

1739
void
1740
GNEViewNet::hotkeyDel() {
1741
    // delete elements depending of current supermode
1742
    if (myEditModes.isCurrentSupermodeNetwork()) {
1743
        if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) || (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS)) {
1744
            setStatusBarText(TL("Cannot delete in this mode"));
1745
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT) && myInspectedElements.getFirstAC()) {
1746
            // delete inspected elements
1747
            myUndoList->begin(GUIIcon::MODEDELETE, TL("delete network inspected elements"));
1748
            while (myInspectedElements.isInspectingElements()) {
1749
                deleteNetworkAttributeCarrier(myInspectedElements.getFirstAC());
1750
            }
1751
            myUndoList->end();
1752
        } else {
1753
            // get selected ACs
1754
            const auto selectedNetworkACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1755
            // delete selected elements
1756
            if (selectedNetworkACs.size() > 0) {
1757
                myUndoList->begin(GUIIcon::MODEDELETE, TL("delete network selection"));
1758
                for (const auto selectedAC : selectedNetworkACs) {
1759
                    deleteNetworkAttributeCarrier(selectedAC);
1760
                }
1761
                myUndoList->end();
1762
            }
1763
        }
1764
    } else if (myEditModes.isCurrentSupermodeDemand()) {
1765
        if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) && myInspectedElements.getFirstAC()) {
1766
            // delete inspected elements
1767
            myUndoList->begin(GUIIcon::MODEDELETE, TL("delete demand inspected elements"));
1768
            while (myInspectedElements.isInspectingElements()) {
1769
                deleteDemandAttributeCarrier(myInspectedElements.getFirstAC());
1770
            }
1771
            myUndoList->end();
1772
        } else {
1773
            // get selected ACs
1774
            const auto selectedDemandACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1775
            // delete selected elements
1776
            if (selectedDemandACs.size() > 0) {
1777
                myUndoList->begin(GUIIcon::MODEDELETE, TL("delete demand selection"));
1778
                for (const auto selectedAC : selectedDemandACs) {
1779
                    deleteDemandAttributeCarrier(selectedAC);
1780
                }
1781
                myUndoList->end();
1782
            }
1783
        }
1784
    } else if (myEditModes.isCurrentSupermodeData()) {
1785
        if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) && myInspectedElements.getFirstAC()) {
1786
            // delete inspected elements
1787
            myUndoList->begin(GUIIcon::MODEDELETE, TL("delete data inspected elements"));
1788
            while (myInspectedElements.isInspectingElements()) {
1789
                deleteDataAttributeCarrier(myInspectedElements.getFirstAC());
1790
            }
1791
            myUndoList->end();
1792
        } else {
1793
            // get selected ACs
1794
            const auto selectedDataACs = myNet->getAttributeCarriers()->getSelectedAttributeCarriers(false);
1795
            // delete selected elements
1796
            if (selectedDataACs.size() > 0) {
1797
                myUndoList->begin(GUIIcon::MODEDELETE, TL("delete data selection"));
1798
                for (const auto selectedAC : selectedDataACs) {
1799
                    deleteDataAttributeCarrier(selectedAC);
1800
                }
1801
                myUndoList->end();
1802
            }
1803
        }
1804
    }
1805
}
1806

1807

1808
void
1809
GNEViewNet::hotkeyEnter() {
1810
    // check what supermode is enabled
1811
    if (myEditModes.isCurrentSupermodeNetwork()) {
1812
        // abort operation depending of current mode
1813
        if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CONNECT) {
1814
            // Accept changes in Connector Frame
1815
            myViewParent->getConnectorFrame()->getConnectionModifications()->onCmdSaveModifications(0, 0, 0);
1816
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TLS) {
1817
            // continue depending of current TLS frame state
1818
            if (myViewParent->getTLSEditorFrame()->getTLSAttributes()->isSetDetectorsToggleButtonEnabled()) {
1819
                myViewParent->getTLSEditorFrame()->getTLSAttributes()->disableE1DetectorMode();
1820
            } else if (myViewParent->getTLSEditorFrame()->getTLSJunction()->isJoiningJunctions()) {
1821
                myViewParent->getTLSEditorFrame()->getTLSJunction()->onCmdAcceptJoin(nullptr, 0, nullptr);
1822
            } else if (myViewParent->getTLSEditorFrame()->getTLSPrograms()->checkHaveModifications()) {
1823
                myViewParent->getTLSEditorFrame()->getTLSPrograms()->onCmdSaveChanges(nullptr, 0, nullptr);
1824
            }
1825
        } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) && (myEditNetworkElementShapes.getEditedNetworkElement() != nullptr)) {
1826
            myEditNetworkElementShapes.commitShapeEdited();
1827
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) {
1828
            if (myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
1829
                // stop current drawing
1830
                myViewParent->getShapeFrame()->getDrawingShapeModule()->stopDrawing();
1831
            } else {
1832
                // start drawing
1833
                myViewParent->getShapeFrame()->getDrawingShapeModule()->startDrawing();
1834
            }
1835
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CROSSING) {
1836
            myViewParent->getCrossingFrame()->createCrossingHotkey();
1837
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
1838
            if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
1839
                // stop current drawing
1840
                myViewParent->getTAZFrame()->getDrawingShapeModule()->stopDrawing();
1841
            } else if (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() == nullptr) {
1842
                // start drawing
1843
                myViewParent->getTAZFrame()->getDrawingShapeModule()->startDrawing();
1844
            } else if (myViewParent->getTAZFrame()->getTAZSaveChangesModule()->isChangesPending()) {
1845
                // save pending changes
1846
                myViewParent->getTAZFrame()->getTAZSaveChangesModule()->onCmdSaveChanges(0, 0, 0);
1847
            }
1848
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1849
            // create path element
1850
            myViewParent->getAdditionalFrame()->createPath(false);
1851
        } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_WIRE) {
1852
            // create path element
1853
            myViewParent->getWireFrame()->createPath(false);
1854
        }
1855
    } else if (myEditModes.isCurrentSupermodeDemand()) {
1856
        if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1857
            myViewParent->getRouteFrame()->getPathCreator()->createPath(false);
1858
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1859
            myViewParent->getVehicleFrame()->getPathCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1860
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1861
            myViewParent->getPersonFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1862
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1863
            myViewParent->getPersonPlanFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1864
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1865
            myViewParent->getContainerFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1866
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1867
            myViewParent->getContainerPlanFrame()->getPlanCreator()->onCmdCreatePath(nullptr, 0, nullptr);
1868
        }
1869
    } else if (myEditModes.isCurrentSupermodeData()) {
1870
        if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1871
            myViewParent->getEdgeRelDataFrame()->getPathCreator()->createPath(false);
1872
        } else if (myEditModes.dataEditMode == DataEditMode::DATA_TAZRELDATA) {
1873
            myViewParent->getTAZRelDataFrame()->buildTAZRelationData();
1874
        }
1875
    }
1876
}
1877

1878

1879
void
1880
GNEViewNet::hotkeyBackSpace() {
1881
    // check what supermode is enabled
1882
    if (myEditModes.isCurrentSupermodeNetwork()) {
1883
        if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) {
1884
            myViewParent->getAdditionalFrame()->getConsecutiveLaneSelector()->removeLastElement();
1885
        }
1886
    } else if (myEditModes.isCurrentSupermodeDemand()) {
1887
        if (myEditModes.demandEditMode == DemandEditMode::DEMAND_ROUTE) {
1888
            myViewParent->getRouteFrame()->getPathCreator()->removeLastElement();
1889
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) {
1890
            myViewParent->getVehicleFrame()->getPathCreator()->removeLastElement();
1891
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSON) {
1892
            myViewParent->getPersonFrame()->getPlanCreator()->removeLastElement();
1893
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_PERSONPLAN) {
1894
            myViewParent->getPersonPlanFrame()->getPlanCreator()->removeLastElement();
1895
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINER) {
1896
            myViewParent->getContainerFrame()->getPlanCreator()->removeLastElement();
1897
        } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_CONTAINERPLAN) {
1898
            myViewParent->getContainerPlanFrame()->getPlanCreator()->removeLastElement();
1899
        }
1900
    } else if (myEditModes.isCurrentSupermodeData()) {
1901
        if (myEditModes.dataEditMode == DataEditMode::DATA_EDGERELDATA) {
1902
            myViewParent->getEdgeRelDataFrame()->getPathCreator()->removeLastElement();
1903
        }
1904
    }
1905
}
1906

1907
void
1908
GNEViewNet::hotkeyFocusFrame() {
1909
    // if there is a visible frame, set focus over it. In other case, set focus over ViewNet
1910
    if (myCurrentFrame != nullptr) {
1911
        myCurrentFrame->focusUpperElement();
1912
    } else {
1913
        setFocus();
1914
    }
1915
}
1916

1917

1918
GNEViewParent*
1919
GNEViewNet::getViewParent() const {
1920
    return myViewParent;
1921
}
1922

1923

1924
GNENet*
1925
GNEViewNet::getNet() const {
1926
    return myNet;
1927
}
1928

1929

1930
GNEUndoList*
1931
GNEViewNet::getUndoList() const {
1932
    return myUndoList;
1933
}
1934

1935

1936
GNEViewNetHelper::IntervalBar&
1937
GNEViewNet::getIntervalBar() {
1938
    return myIntervalBar;
1939
}
1940

1941

1942
GNEViewNetHelper::LockManager&
1943
GNEViewNet::getLockManager() {
1944
    return myLockManager;
1945
}
1946

1947

1948
GNEViewNetHelper::InspectedElements&
1949
GNEViewNet::getInspectedElements() {
1950
    return myInspectedElements;
1951
}
1952

1953

1954
GNEViewNetHelper::MarkFrontElements&
1955
GNEViewNet::getMarkFrontElements() {
1956
    return myMarkFrontElements;
1957
}
1958

1959

1960
bool
1961
GNEViewNet::isCurrentlyMovingElements() const {
1962
    return myMoveSingleElement.isCurrentlyMovingSingleElement() || myMoveMultipleElements.isCurrentlyMovingMultipleElements();
1963
}
1964

1965

1966
bool
1967
GNEViewNet::checkOverLockedElement(const GUIGlObject* GLObject, const bool isSelected) const {
1968
    // check if elemet is blocked
1969
    if (myLockManager.isObjectLocked(GLObject->getType(), isSelected)) {
1970
        return false;
1971
    }
1972
    // get front GLObject
1973
    const auto glObjectFront = myViewObjectsSelector.getGUIGlObjectFront();
1974
    // check if element is under cursor
1975
    if (glObjectFront) {
1976
        if (glObjectFront == GLObject) {
1977
            return true;
1978
        } else if (glObjectFront->getType() == GLObject->getType()) {
1979
            for (const auto& glObjectUnderCursor : myViewObjectsSelector.getGLObjects()) {
1980
                if (glObjectUnderCursor == GLObject) {
1981
                    return true;
1982
                }
1983
            }
1984
        }
1985
    }
1986
    return false;
1987
}
1988

1989

1990
GNEDemandElement*
1991
GNEViewNet::getLastCreatedRoute() const {
1992
    return myLastCreatedRoute;
1993
}
1994

1995

1996
void
1997
GNEViewNet::setLastCreatedRoute(GNEDemandElement* lastCreatedRoute) {
1998
    myLastCreatedRoute = lastCreatedRoute;
1999
}
2000

2001

2002
GNEJunction*
2003
GNEViewNet::getJunctionAtPopupPosition() {
2004
    // get first object that can be found in their container
2005
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2006
        for (const auto& glObject : glObjectLayer.second) {
2007
            auto junction = myNet->getAttributeCarriers()->retrieveJunction(glObject.object->getMicrosimID(), false);
2008
            if (junction) {
2009
                return junction;
2010
            }
2011
        }
2012
    }
2013
    return nullptr;
2014
}
2015

2016

2017
GNEConnection*
2018
GNEViewNet::getConnectionAtPopupPosition() {
2019
    // get first object that can be found in their container
2020
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2021
        for (const auto& glObject : glObjectLayer.second) {
2022
            auto connection = myNet->getAttributeCarriers()->retrieveConnection(glObject.object, false);
2023
            if (connection) {
2024
                return connection;
2025
            }
2026
        }
2027
    }
2028
    return nullptr;
2029
}
2030

2031

2032
GNECrossing*
2033
GNEViewNet::getCrossingAtPopupPosition() {
2034
    // get first object that can be found in their container
2035
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2036
        for (const auto& glObject : glObjectLayer.second) {
2037
            auto crossing = myNet->getAttributeCarriers()->retrieveCrossing(glObject.object, false);
2038
            if (crossing) {
2039
                return crossing;
2040
            }
2041
        }
2042
    }
2043
    return nullptr;
2044
}
2045

2046

2047
GNEWalkingArea*
2048
GNEViewNet::getWalkingAreaAtPopupPosition() {
2049
    // get first object that can be found in their container
2050
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2051
        for (const auto& glObject : glObjectLayer.second) {
2052
            auto walkingArea = myNet->getAttributeCarriers()->retrieveWalkingArea(glObject.object, false);
2053
            if (walkingArea) {
2054
                return walkingArea;
2055
            }
2056
        }
2057
    }
2058
    return nullptr;
2059
}
2060

2061

2062
GNEEdge*
2063
GNEViewNet::getEdgeAtPopupPosition() {
2064
    // get first object that can be found in their container
2065
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2066
        for (const auto& glObject : glObjectLayer.second) {
2067
            auto edge = myNet->getAttributeCarriers()->retrieveEdge(glObject.object->getMicrosimID(), false);
2068
            if (edge) {
2069
                return edge;
2070
            }
2071
        }
2072
    }
2073
    return nullptr;
2074
}
2075

2076

2077
GNELane*
2078
GNEViewNet::getLaneAtPopupPosition() {
2079
    // get first object that can be found in their container
2080
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2081
        for (const auto& glObject : glObjectLayer.second) {
2082
            auto lane = myNet->getAttributeCarriers()->retrieveLane(glObject.object, false);
2083
            if (lane) {
2084
                return lane;
2085
            }
2086
        }
2087
    }
2088
    return nullptr;
2089
}
2090

2091

2092
GNEAdditional*
2093
GNEViewNet::getAdditionalAtPopupPosition() {
2094
    // get first object that can be found in their container
2095
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2096
        for (const auto& glObject : glObjectLayer.second) {
2097
            auto additionalElement = myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false);
2098
            if (additionalElement) {
2099
                return additionalElement;
2100
            }
2101
        }
2102
    }
2103
    return nullptr;
2104
}
2105

2106

2107
GNEDemandElement*
2108
GNEViewNet::getDemandElementAtPopupPosition() {
2109
    // get first object that can be found in their container
2110
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2111
        for (const auto& glObject : glObjectLayer.second) {
2112
            auto demandElement = myNet->getAttributeCarriers()->retrieveDemandElement(glObject.object, false);
2113
            if (demandElement) {
2114
                return demandElement;
2115
            }
2116
        }
2117
    }
2118
    return nullptr;
2119
}
2120

2121

2122
GNEPoly*
2123
GNEViewNet::getPolygonAtPopupPosition() {
2124
    // get first object that can be parsed to poly element
2125
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2126
        for (const auto& glObject : glObjectLayer.second) {
2127
            auto polygon = dynamic_cast<GNEPoly*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2128
            if (polygon) {
2129
                return polygon;
2130
            }
2131
        }
2132
    }
2133
    return nullptr;
2134
}
2135

2136

2137
GNEPOI*
2138
GNEViewNet::getPOIAtPopupPosition() {
2139
    // get first object that can be parsed to POI element
2140
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2141
        for (const auto& glObject : glObjectLayer.second) {
2142
            auto POI = dynamic_cast<GNEPOI*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2143
            if (POI) {
2144
                return POI;
2145
            }
2146
        }
2147
    }
2148
    return nullptr;
2149
}
2150

2151

2152
GNETAZ*
2153
GNEViewNet::getTAZAtPopupPosition() {
2154
    // get first object that can be parsed to TAZ element
2155
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2156
        for (const auto& glObject : glObjectLayer.second) {
2157
            auto TAZ = dynamic_cast<GNETAZ*>(myNet->getAttributeCarriers()->retrieveAdditional(glObject.object, false));
2158
            if (TAZ) {
2159
                return TAZ;
2160
            }
2161
        }
2162
    }
2163
    return nullptr;
2164
}
2165

2166

2167
GNENetworkElement*
2168
GNEViewNet::getShapeEditedAtPopupPosition() {
2169
    // get first object that can be parsed to TAZ element
2170
    for (const auto& glObjectLayer : gViewObjectsHandler.getSelectedObjects()) {
2171
        for (const auto& glObject : glObjectLayer.second) {
2172
            if (glObject.object->getType() == GLO_JUNCTION) {
2173
                auto junction = myNet->getAttributeCarriers()->retrieveJunction(glObject.object->getMicrosimID());
2174
                if (junction->isShapeEdited()) {
2175
                    return junction;
2176
                }
2177
            } else if (glObject.object->getType() == GLO_CROSSING) {
2178
                auto crossing = myNet->getAttributeCarriers()->retrieveCrossing(glObject.object);
2179
                if (crossing->isShapeEdited()) {
2180
                    return crossing;
2181
                }
2182
            } else if (glObject.object->getType() == GLO_CONNECTION) {
2183
                auto connection = myNet->getAttributeCarriers()->retrieveConnection(glObject.object);
2184
                if (connection->isShapeEdited()) {
2185
                    return connection;
2186
                }
2187
            }
2188
        }
2189
    }
2190
    return nullptr;
2191
}
2192

2193

2194
long
2195
GNEViewNet::onCmdSetSupermode(FXObject*, FXSelector sel, void*) {
2196
    // check what network mode will be set
2197
    switch (FXSELID(sel)) {
2198
        case MID_HOTKEY_F2_SUPERMODE_NETWORK:
2199
            if (myEditModes.networkButton->shown()) {
2200
                myEditModes.setSupermode(Supermode::NETWORK, false);
2201
            }
2202
            break;
2203
        case MID_HOTKEY_F3_SUPERMODE_DEMAND:
2204
            if (myEditModes.demandButton->shown()) {
2205
                myEditModes.setSupermode(Supermode::DEMAND, false);
2206
            }
2207
            break;
2208
        case MID_HOTKEY_F4_SUPERMODE_DATA:
2209
            if (myEditModes.dataButton->shown()) {
2210
                myEditModes.setSupermode(Supermode::DATA, false);
2211
            }
2212
            break;
2213
        default:
2214
            break;
2215
    }
2216
    return 1;
2217
}
2218

2219

2220
long
2221
GNEViewNet::onCmdSetMode(FXObject*, FXSelector sel, void*) {
2222
    // first filter modes depending of view
2223
    if (myEditModes.isJuPedSimView()) {
2224
        // network
2225
        if (myEditModes.isCurrentSupermodeNetwork()) {
2226
            switch (FXSELID(sel)) {
2227
                // common
2228
                case MID_HOTKEY_I_MODE_INSPECT:
2229
                case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2230
                case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2231
                // infrastructure
2232
                case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2233
                case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2234
                case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2235
                case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2236
                // shapes
2237
                case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2238
                case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2239
                    break;
2240
                default:
2241
                    return 0;
2242
            }
2243
        }
2244
        // demand
2245
        if (myEditModes.isCurrentSupermodeDemand()) {
2246
            switch (FXSELID(sel)) {
2247
                // common
2248
                case MID_HOTKEY_I_MODE_INSPECT:
2249
                case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2250
                case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2251
                // persons
2252
                case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2253
                case MID_HOTKEY_L_MODE_PERSONPLAN:
2254
                // routes
2255
                case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2256
                case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2257
                // types
2258
                case MID_HOTKEY_T_MODE_TLS_TYPE:
2259
                case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2260
                    break;
2261
                default:
2262
                    return 0;
2263
            }
2264
        }
2265
        // data
2266
        if (myEditModes.isCurrentSupermodeData()) {
2267
            // all modes disabled
2268
            return 0;
2269
        }
2270
    }
2271
    // continue depending of supermode
2272
    if (myEditModes.isCurrentSupermodeNetwork()) {
2273
        // check what network mode will be set
2274
        switch (FXSELID(sel)) {
2275
            case MID_HOTKEY_I_MODE_INSPECT:
2276
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_INSPECT);
2277
                break;
2278
            case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2279
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_DELETE);
2280
                break;
2281
            case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2282
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_SELECT);
2283
                break;
2284
            case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2285
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_MOVE);
2286
                break;
2287
            case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2288
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CREATE_EDGE);
2289
                break;
2290
            case MID_HOTKEY_C_MODE_CONNECT_CONTAINER:
2291
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CONNECT);
2292
                break;
2293
            case MID_HOTKEY_T_MODE_TLS_TYPE:
2294
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS);
2295
                break;
2296
            case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2297
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_ADDITIONAL);
2298
                break;
2299
            case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2300
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_CROSSING);
2301
                break;
2302
            case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2303
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TAZ);
2304
                break;
2305
            case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2306
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_SHAPE);
2307
                break;
2308
            case MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN:
2309
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_PROHIBITION);
2310
                break;
2311
            case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2312
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_WIRE);
2313
                break;
2314
            case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2315
                myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_DECAL);
2316
                break;
2317
            default:
2318
                break;
2319
        }
2320
    } else if (myEditModes.isCurrentSupermodeDemand()) {
2321
        // check what demand mode will be set
2322
        switch (FXSELID(sel)) {
2323
            case MID_HOTKEY_L_MODE_PERSONPLAN:
2324
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_PERSONPLAN);
2325
                break;
2326
            case MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN:
2327
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_CONTAINERPLAN);
2328
                break;
2329
            case MID_HOTKEY_I_MODE_INSPECT:
2330
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_INSPECT);
2331
                break;
2332
            case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2333
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_DELETE);
2334
                break;
2335
            case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2336
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_SELECT);
2337
                break;
2338
            case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2339
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_MOVE);
2340
                break;
2341
            case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2342
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_ROUTE);
2343
                break;
2344
            case MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION:
2345
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_ROUTEDISTRIBUTION);
2346
                break;
2347
            case MID_HOTKEY_V_MODE_VEHICLE:
2348
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_VEHICLE);
2349
                break;
2350
            case MID_HOTKEY_T_MODE_TLS_TYPE:
2351
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_TYPE);
2352
                break;
2353
            case MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION:
2354
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_TYPEDISTRIBUTION);
2355
                break;
2356
            case MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS:
2357
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_STOP);
2358
                break;
2359
            case MID_HOTKEY_P_MODE_POLYGON_PERSON:
2360
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_PERSON);
2361
                break;
2362
            case MID_HOTKEY_C_MODE_CONNECT_CONTAINER:
2363
                myEditModes.setDemandEditMode(DemandEditMode::DEMAND_CONTAINER);
2364
                break;
2365
            default:
2366
                break;
2367
        }
2368
    } else if (myEditModes.isCurrentSupermodeData()) {
2369
        // check what demand mode will be set
2370
        switch (FXSELID(sel)) {
2371
            case MID_HOTKEY_I_MODE_INSPECT:
2372
                myEditModes.setDataEditMode(DataEditMode::DATA_INSPECT);
2373
                break;
2374
            case MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE:
2375
                myEditModes.setDataEditMode(DataEditMode::DATA_DELETE);
2376
                break;
2377
            case MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT:
2378
                myEditModes.setDataEditMode(DataEditMode::DATA_SELECT);
2379
                break;
2380
            case MID_HOTKEY_E_MODE_EDGE_EDGEDATA:
2381
                myEditModes.setDataEditMode(DataEditMode::DATA_EDGEDATA);
2382
                break;
2383
            case MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA:
2384
                myEditModes.setDataEditMode(DataEditMode::DATA_EDGERELDATA);
2385
                break;
2386
            case MID_HOTKEY_Z_MODE_TAZ_TAZREL:
2387
                myEditModes.setDataEditMode(DataEditMode::DATA_TAZRELDATA);
2388
                break;
2389
            case MID_HOTKEY_M_MODE_MOVE_MEANDATA:
2390
                myEditModes.setDataEditMode(DataEditMode::DATA_MEANDATA);
2391
                break;
2392
            default:
2393
                break;
2394
        }
2395
    }
2396
    return 1;
2397
}
2398

2399

2400
long
2401
GNEViewNet::onCmdSplitEdge(FXObject*, FXSelector, void*) {
2402
    GNEEdge* edge = getEdgeAtPopupPosition();
2403
    if (edge != nullptr) {
2404
        myNet->splitEdge(edge, edge->getSplitPos(getPopupPosition()), myUndoList);
2405
    }
2406
    return 1;
2407
}
2408

2409

2410
long
2411
GNEViewNet::onCmdSplitEdgeBidi(FXObject*, FXSelector, void*) {
2412
    GNEEdge* edge = getEdgeAtPopupPosition();
2413
    if (edge != nullptr) {
2414
        // obtain reverse edge
2415
        const auto oppositeEdges = edge->getOppositeEdges();
2416
        // check that reverse edge works
2417
        if (oppositeEdges.size() > 0) {
2418
            for (const auto& oppositeEdge : oppositeEdges) {
2419
                // get reverse inner geometry
2420
                const auto reverseGeometry = oppositeEdge->getNBEdge()->getInnerGeometry().reverse();
2421
                if (reverseGeometry == edge->getNBEdge()->getInnerGeometry()) {
2422
                    myNet->splitEdgesBidi(edge, oppositeEdge, edge->getSplitPos(getPopupPosition()), myUndoList);
2423
                    return 1;
2424
                }
2425
            }
2426
        }
2427
    }
2428
    return 1;
2429
}
2430

2431

2432
long
2433
GNEViewNet::onCmdReverseEdge(FXObject*, FXSelector, void*) {
2434
    GNEEdge* edge = getEdgeAtPopupPosition();
2435
    if (edge != nullptr) {
2436
        if (edge->isAttributeCarrierSelected()) {
2437
            myUndoList->begin(edge, TL("Reverse selected edges"));
2438
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2439
            for (const auto& selectedEdge : selectedEdges) {
2440
                myNet->reverseEdge(selectedEdge, myUndoList);
2441
            }
2442
            myUndoList->end();
2443
        } else {
2444
            myUndoList->begin(edge, TL("Reverse edge"));
2445
            myNet->reverseEdge(edge, myUndoList);
2446
            myUndoList->end();
2447
        }
2448
    }
2449
    return 1;
2450
}
2451

2452

2453
long
2454
GNEViewNet::onCmdAddReversedEdge(FXObject*, FXSelector, void*) {
2455
    GNEEdge* edge = getEdgeAtPopupPosition();
2456
    if (edge != nullptr) {
2457
        if (edge->isAttributeCarrierSelected()) {
2458
            myUndoList->begin(edge, TL("Add Reverse edge for selected edges"));
2459
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2460
            for (const auto& selectedEdge : selectedEdges) {
2461
                myNet->addReversedEdge(selectedEdge, false, myUndoList);
2462
            }
2463
            myUndoList->end();
2464
        } else {
2465
            myUndoList->begin(edge, TL("Add reverse edge"));
2466
            myNet->addReversedEdge(edge, false, myUndoList);
2467
            myUndoList->end();
2468
        }
2469
    }
2470
    return 1;
2471
}
2472

2473

2474
long
2475
GNEViewNet::onCmdAddReversedEdgeDisconnected(FXObject*, FXSelector, void*) {
2476
    GNEEdge* edge = getEdgeAtPopupPosition();
2477
    if (edge != nullptr) {
2478
        if (edge->isAttributeCarrierSelected()) {
2479
            myUndoList->begin(edge, TL("Add Reverse disconnected edge for selected edges"));
2480
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2481
            for (const auto& selectedEdge : selectedEdges) {
2482
                myNet->addReversedEdge(selectedEdge, true, myUndoList);
2483
            }
2484
            myUndoList->end();
2485
        } else {
2486
            myUndoList->begin(edge, TL("Add reverse disconnected edge"));
2487
            myNet->addReversedEdge(edge, true, myUndoList);
2488
            myUndoList->end();
2489
        }
2490
    }
2491
    return 1;
2492
}
2493

2494

2495
long
2496
GNEViewNet::onCmdEditEdgeEndpoint(FXObject*, FXSelector, void*) {
2497
    GNEEdge* edge = getEdgeAtPopupPosition();
2498
    if (edge != nullptr) {
2499
        // snap to active grid the Popup position
2500
        edge->editEndpoint(getPopupPosition(), myUndoList);
2501
    }
2502
    return 1;
2503
}
2504

2505

2506
long
2507
GNEViewNet::onCmdResetEdgeEndpoint(FXObject*, FXSelector, void*) {
2508
    GNEEdge* edge = getEdgeAtPopupPosition();
2509
    if (edge != nullptr) {
2510
        // check if edge is selected
2511
        if (edge->isAttributeCarrierSelected()) {
2512
            // get all selected edges
2513
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2514
            // begin operation
2515
            myUndoList->begin(edge, TL("reset geometry points"));
2516
            // iterate over selected edges
2517
            for (const auto& selectedEdge : selectedEdges) {
2518
                // reset both end points
2519
                selectedEdge->resetBothEndpoint(myUndoList);
2520
            }
2521
            // end operation
2522
            myUndoList->end();
2523
        } else {
2524
            edge->resetEndpoint(getPopupPosition(), myUndoList);
2525
        }
2526
    }
2527
    return 1;
2528
}
2529

2530

2531
long
2532
GNEViewNet::onCmdStraightenEdges(FXObject*, FXSelector, void*) {
2533
    GNEEdge* edge = getEdgeAtPopupPosition();
2534
    if (edge != nullptr) {
2535
        if (edge->isAttributeCarrierSelected()) {
2536
            myUndoList->begin(edge, TL("straighten selected edges"));
2537
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2538
            for (const auto& selectedEdge : selectedEdges) {
2539
                selectedEdge->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
2540
            }
2541
            myUndoList->end();
2542
        } else {
2543

2544
            myUndoList->begin(edge, TL("straighten edge"));
2545
            edge->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
2546
            myUndoList->end();
2547
        }
2548
    }
2549
    return 1;
2550
}
2551

2552

2553
long
2554
GNEViewNet::onCmdSmoothEdges(FXObject*, FXSelector, void*) {
2555
    GNEEdge* edge = getEdgeAtPopupPosition();
2556
    if (edge != nullptr) {
2557
        if (edge->isAttributeCarrierSelected()) {
2558
            myUndoList->begin(edge, TL("smooth selected edges"));
2559
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2560
            for (const auto& selectedEdge : selectedEdges) {
2561
                selectedEdge->smooth(myUndoList);
2562
            }
2563
            myUndoList->end();
2564
        } else {
2565
            myUndoList->begin(edge, TL("smooth edge"));
2566
            edge->smooth(myUndoList);
2567
            myUndoList->end();
2568
        }
2569
    }
2570
    return 1;
2571
}
2572

2573

2574
long
2575
GNEViewNet::onCmdStraightenEdgesElevation(FXObject*, FXSelector, void*) {
2576
    GNEEdge* edge = getEdgeAtPopupPosition();
2577
    if (edge != nullptr) {
2578
        if (edge->isAttributeCarrierSelected()) {
2579
            myUndoList->begin(edge, TL("straighten elevation of selected edges"));
2580
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2581
            for (const auto& selectedEdge : selectedEdges) {
2582
                selectedEdge->straightenElevation(myUndoList);
2583
            }
2584
            myUndoList->end();
2585
        } else {
2586
            myUndoList->begin(edge, TL("straighten edge elevation"));
2587
            edge->straightenElevation(myUndoList);
2588
            myUndoList->end();
2589
        }
2590
    }
2591
    return 1;
2592
}
2593

2594

2595
long
2596
GNEViewNet::onCmdSmoothEdgesElevation(FXObject*, FXSelector, void*) {
2597
    GNEEdge* edge = getEdgeAtPopupPosition();
2598
    if (edge != nullptr) {
2599
        if (edge->isAttributeCarrierSelected()) {
2600
            myUndoList->begin(edge, TL("smooth elevation of selected edges"));
2601
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2602
            for (const auto& selectedEdge : selectedEdges) {
2603
                selectedEdge->smoothElevation(myUndoList);
2604
            }
2605
            myUndoList->end();
2606
        } else {
2607
            myUndoList->begin(edge, TL("smooth edge elevation"));
2608
            edge->smoothElevation(myUndoList);
2609
            myUndoList->end();
2610
        }
2611
    }
2612
    return 1;
2613
}
2614

2615

2616
long
2617
GNEViewNet::onCmdResetLength(FXObject*, FXSelector, void*) {
2618
    GNEEdge* edge = getEdgeAtPopupPosition();
2619
    if (edge != nullptr) {
2620
        if (edge->isAttributeCarrierSelected()) {
2621
            myUndoList->begin(edge, TL("reset edge lengths"));
2622
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
2623
            for (const auto& selectedEdge : selectedEdges) {
2624
                selectedEdge->setAttribute(SUMO_ATTR_LENGTH, "-1", myUndoList);
2625
            }
2626
            myUndoList->end();
2627
        } else {
2628
            edge->setAttribute(SUMO_ATTR_LENGTH, "-1", myUndoList);
2629
        }
2630
    }
2631
    return 1;
2632
}
2633

2634

2635
long
2636
GNEViewNet::onCmdEdgeUseAsTemplate(FXObject*, FXSelector, void*) {
2637
    GNEEdge* edge = getEdgeAtPopupPosition();
2638
    if (edge != nullptr) {
2639
        myViewParent->getInspectorFrame()->getTemplateEditor()->setEdgeTemplate(edge);
2640
    }
2641
    return 1;
2642
}
2643

2644

2645
long
2646
GNEViewNet::onCmdEgeApplyTemplate(FXObject*, FXSelector, void*) {
2647
    GNEEdge* edgeAtPosition = getEdgeAtPopupPosition();
2648
    if ((edgeAtPosition != nullptr) && myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate()) {
2649
        // begin copy template
2650
        myUndoList->begin(edgeAtPosition, TL("copy edge template"));
2651
        if (edgeAtPosition->isAttributeCarrierSelected()) {
2652
            // copy template in all selected edges
2653
            for (const auto& edge : myNet->getAttributeCarriers()->getEdges()) {
2654
                if (edge.second->isAttributeCarrierSelected()) {
2655
                    edge.second->copyTemplate(myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate(), myUndoList);
2656
                }
2657
            }
2658
        } else {
2659
            // copy template
2660
            edgeAtPosition->copyTemplate(myViewParent->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate(), myUndoList);
2661
        }
2662
        // end copy template
2663
        myUndoList->end();
2664
    }
2665
    return 1;
2666
}
2667

2668

2669
long
2670
GNEViewNet::onCmdSimplifyShape(FXObject*, FXSelector, void*) {
2671
    // get polygon under mouse
2672
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2673
    // check polygon
2674
    if (polygonUnderMouse) {
2675
        // check if shape is selected
2676
        if (polygonUnderMouse->isAttributeCarrierSelected()) {
2677
            // begin undo-list
2678
            myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("simplify shapes"));
2679
            // get shapes
2680
            const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2681
            // iterate over shapes
2682
            for (const auto& selectedShape : selectedShapes) {
2683
                // check if shape is a poly
2684
                if ((selectedShape->getTagProperty()->getTag() == SUMO_TAG_POLY) ||
2685
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2686
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_OBSTACLE)) {
2687
                    // simplify shape
2688
                    dynamic_cast<GNEPoly*>(selectedShape)->simplifyShape();
2689
                }
2690
            }
2691
            // end undo-list
2692
            myNet->getViewNet()->getUndoList()->end();
2693
        } else {
2694
            polygonUnderMouse->simplifyShape();
2695
        }
2696
    }
2697
    return 1;
2698
}
2699

2700

2701
long
2702
GNEViewNet::onCmdDeleteGeometryPoint(FXObject*, FXSelector, void*) {
2703
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2704
    if (polygonUnderMouse) {
2705
        polygonUnderMouse->deleteGeometryPoint(getPopupPosition());
2706
    }
2707
    return 1;
2708
}
2709

2710

2711
long
2712
GNEViewNet::onCmdClosePolygon(FXObject*, FXSelector, void*) {
2713
    // get polygon under mouse
2714
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2715
    // check polygon
2716
    if (polygonUnderMouse) {
2717
        // check if shape is selected
2718
        if (polygonUnderMouse->isAttributeCarrierSelected()) {
2719
            // begin undo-list
2720
            myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("close polygon shapes"));
2721
            // get selectedshapes
2722
            const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2723
            // iterate over shapes
2724
            for (const auto& selectedShape : selectedShapes) {
2725
                // check if shape is a poly
2726
                if ((selectedShape->getTagProperty()->getTag() == SUMO_TAG_POLY) ||
2727
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2728
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_OBSTACLE)) {
2729
                    // close polygon
2730
                    dynamic_cast<GNEPoly*>(selectedShape)->closePolygon();
2731
                }
2732
            }
2733
            // end undo-list
2734
            myNet->getViewNet()->getUndoList()->end();
2735
        } else {
2736
            polygonUnderMouse->closePolygon();
2737
        }
2738
    }
2739
    return 1;
2740
}
2741

2742

2743
long
2744
GNEViewNet::onCmdOpenPolygon(FXObject*, FXSelector, void*) {
2745
    // get polygon under mouse
2746
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2747
    // check polygon
2748
    if (polygonUnderMouse) {
2749
        // check if shape is selected
2750
        if (polygonUnderMouse->isAttributeCarrierSelected()) {
2751
            // begin undo-list
2752
            myNet->getViewNet()->getUndoList()->begin(polygonUnderMouse, TL("open polygon shapes"));
2753
            // get shapes
2754
            const auto selectedShapes = myNet->getAttributeCarriers()->getSelectedShapes();
2755
            // iterate over shapes
2756
            for (const auto& selectedShape : selectedShapes) {
2757
                // check if shape is a poly
2758
                if ((selectedShape->getTagProperty()->getTag() == SUMO_TAG_POLY) ||
2759
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_WALKABLEAREA) ||
2760
                        (selectedShape->getTagProperty()->getTag() == GNE_TAG_JPS_OBSTACLE)) {
2761
                    // open polygon
2762
                    dynamic_cast<GNEPoly*>(selectedShape)->openPolygon();
2763
                }
2764
            }
2765
            // end undo-list
2766
            myNet->getViewNet()->getUndoList()->end();
2767
        } else {
2768
            polygonUnderMouse->openPolygon();
2769
        }
2770
    }
2771
    return 1;
2772
}
2773

2774

2775
long
2776
GNEViewNet::onCmdSelectPolygonElements(FXObject*, FXSelector, void*) {
2777
    // get polygon under mouse
2778
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2779
    // check polygon
2780
    if (polygonUnderMouse) {
2781
        // get all elements under polygon shape
2782
        updateObjectsInShape(polygonUnderMouse->getShape());
2783
        // declare filtered ACs
2784
        std::vector<GNEAttributeCarrier*> ACsUnderPolygon;
2785
        ACsUnderPolygon.reserve(myViewObjectsSelector.getAttributeCarriers().size());
2786
        // iterate over obtained GUIGlIDs
2787
        for (const auto& AC : myViewObjectsSelector.getAttributeCarriers()) {
2788
            if ((AC->getTagProperty()->getTag() == SUMO_TAG_EDGE) && checkSelectEdges()) {
2789
                ACsUnderPolygon.push_back(AC);
2790
            } else if ((AC->getTagProperty()->getTag() == SUMO_TAG_LANE) && !checkSelectEdges()) {
2791
                ACsUnderPolygon.push_back(AC);
2792
            } else if (!AC->getTagProperty()->isSymbol() && (AC != polygonUnderMouse)) {
2793
                ACsUnderPolygon.push_back(AC);
2794
            }
2795
        }
2796
        // continue if there are ACs
2797
        if (ACsUnderPolygon.size() > 0) {
2798
            // begin undo-list
2799
            myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODESELECT, TL("select within polygon boundary"));
2800
            // iterate over shapes
2801
            for (const auto& AC : ACsUnderPolygon) {
2802
                AC->setAttribute(GNE_ATTR_SELECTED, "true", myUndoList);
2803
            }
2804
            // end undo-list
2805
            myNet->getViewNet()->getUndoList()->end();
2806
        }
2807
    }
2808
    return 1;
2809
}
2810

2811

2812
long
2813
GNEViewNet::onCmdTriangulatePolygon(FXObject*, FXSelector, void*) {
2814
// get polygon under mouse
2815
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2816
    // check polygon
2817
    if (polygonUnderMouse) {
2818
        // declare additional handler
2819
        GNEAdditionalHandler additionalHandler(myNet, polygonUnderMouse->getFilename(), myViewParent->getGNEAppWindows()->isUndoRedoAllowed());
2820
        // triangulate shape
2821
        const auto triangulation = Triangle::triangulate(polygonUnderMouse->getShape());
2822
        // begin undo-list
2823
        myNet->getViewNet()->getUndoList()->begin(GUIIcon::POLY, TL("triangulate polygon"));
2824
        // create every individual triangle
2825
        for (const auto& triangle : triangulation) {
2826
            auto basePolygon = polygonUnderMouse->getSumoBaseObject();
2827
            basePolygon->addStringAttribute(SUMO_ATTR_ID, myNet->getAttributeCarriers()->generateAdditionalID(polygonUnderMouse->getTagProperty()->getTag()));
2828
            basePolygon->addPositionVectorAttribute(SUMO_ATTR_SHAPE, triangle.getShape());
2829
            // build shape
2830
            additionalHandler.parseSumoBaseObject(basePolygon);
2831
        }
2832
        // delete original polygon
2833
        myNet->deleteAdditional(polygonUnderMouse, myNet->getViewNet()->getUndoList());
2834
        // end undo-list
2835
        myNet->getViewNet()->getUndoList()->end();
2836
    }
2837
    return 1;
2838
}
2839

2840

2841
long
2842
GNEViewNet::onCmdSetFirstGeometryPoint(FXObject*, FXSelector, void*) {
2843
    GNEPoly* polygonUnderMouse = getPolygonAtPopupPosition();
2844
    if (polygonUnderMouse) {
2845
        polygonUnderMouse->changeFirstGeometryPoint(polygonUnderMouse->getVertexIndex(getPopupPosition(), false));
2846
    }
2847

2848
    return 1;
2849
}
2850

2851

2852
long
2853
GNEViewNet::onCmdSimplifyShapeEdited(FXObject*, FXSelector, void*) {
2854
    auto undoList = myNet->getViewNet()->getUndoList();
2855
    // get shape edited under mouse
2856
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2857
    if (shapeEdited) {
2858
        // simplify edited shape using undo-redo
2859
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2860
        shapeEdited->simplifyShapeEdited(undoList);
2861
        undoList->end();
2862
    }
2863
    return 1;
2864
}
2865

2866

2867
long
2868
GNEViewNet::onCmdStraightenShapeEdited(FXObject*, FXSelector, void*) {
2869
    auto undoList = myNet->getViewNet()->getUndoList();
2870
    // get shape edited under mouse
2871
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2872
    if (shapeEdited) {
2873
        // simplify edited shape using undo-redo
2874
        undoList->begin(shapeEdited, TL("straighten edited shape"));
2875
        shapeEdited->straigthenShapeEdited(undoList);
2876
        undoList->end();
2877
    }
2878
    return 1;
2879
}
2880

2881

2882
long
2883
GNEViewNet::onCmdCloseShapeEdited(FXObject*, FXSelector, void*) {
2884
    auto undoList = myNet->getViewNet()->getUndoList();
2885
    // get shape edited under mouse
2886
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2887
    if (shapeEdited) {
2888
        // close edited shape using undo-redo
2889
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2890
        shapeEdited->closeShapeEdited(undoList);
2891
        undoList->end();
2892
    }
2893
    return 1;
2894
}
2895

2896

2897
long
2898
GNEViewNet::onCmdOpenShapeEdited(FXObject*, FXSelector, void*) {
2899
    auto undoList = myNet->getViewNet()->getUndoList();
2900
    // get shape edited under mouse
2901
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2902
    if (shapeEdited) {
2903
        // open edited shape using undo-redo
2904
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2905
        shapeEdited->openShapeEdited(undoList);
2906
        undoList->end();
2907
    }
2908
    return 1;
2909
}
2910

2911

2912
long
2913
GNEViewNet::onCmdSetFirstGeometryPointShapeEdited(FXObject*, FXSelector, void*) {
2914
    auto undoList = myNet->getViewNet()->getUndoList();
2915
    // get shape edited under mouse
2916
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2917
    if (shapeEdited) {
2918
        // get geometry point index under cursor
2919
        const auto geometryPointIndex = shapeEdited->getGeometryPointUnderCursorShapeEdited();
2920
        // set first geometry point in edited shape using undo-redo
2921
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2922
        shapeEdited->setFirstGeometryPointShapeEdited(geometryPointIndex, undoList);
2923
        undoList->end();
2924
    }
2925
    return 1;
2926
}
2927

2928

2929
long
2930
GNEViewNet::onCmdDeleteGeometryPointShapeEdited(FXObject*, FXSelector, void*) {
2931
    auto undoList = myNet->getViewNet()->getUndoList();
2932
    // get shape edited under mouse
2933
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2934
    if (shapeEdited) {
2935
        // get geometry point index under cursor
2936
        const auto geometryPointIndex = shapeEdited->getGeometryPointUnderCursorShapeEdited();
2937
        // delete geometry point edited shape using undo-redo
2938
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2939
        shapeEdited->deleteGeometryPointShapeEdited(geometryPointIndex, undoList);
2940
        undoList->end();
2941
    }
2942
    return 1;
2943
}
2944

2945

2946
long
2947
GNEViewNet::onCmdResetShapeEdited(FXObject*, FXSelector, void*) {
2948
    auto undoList = myNet->getViewNet()->getUndoList();
2949
    // get shape edited under mouse
2950
    GNENetworkElement* shapeEdited = getShapeEditedAtPopupPosition();
2951
    if (shapeEdited) {
2952
        // simplify edited shape using undo-redo
2953
        undoList->begin(shapeEdited, TL("simplify edited shape"));
2954
        shapeEdited->resetShapeEdited(undoList);
2955
        undoList->end();
2956
    }
2957
    return 1;
2958
}
2959

2960

2961
long
2962
GNEViewNet::onCmdFinishShapeEdited(FXObject*, FXSelector, void*) {
2963
    // the same behavior as when we press enter
2964
    hotkeyEnter();
2965
    return 1;
2966
}
2967

2968

2969
long
2970
GNEViewNet::onCmdTransformPOI(FXObject*, FXSelector, void*) {
2971
    // obtain POI at popup position
2972
    GNEPOI* POI = getPOIAtPopupPosition();
2973
    if (POI) {
2974
        // declare additional handler
2975
        GNEAdditionalHandler additionalHandler(myNet, POI->getFilename(), myViewParent->getGNEAppWindows()->isUndoRedoAllowed());
2976
        // check what type of POI will be transformed
2977
        if (POI->getTagProperty()->getTag() == SUMO_TAG_POI) {
2978
            // obtain lanes around POI boundary
2979
            std::vector<GUIGlID> GLIDs = getObjectsInBoundary(POI->getCenteringBoundary());
2980
            std::vector<GNELane*> lanes;
2981
            for (const auto& GLID : GLIDs) {
2982
                GNELane* lane = dynamic_cast<GNELane*>(GUIGlObjectStorage::gIDStorage.getObjectBlocking(GLID));
2983
                if (lane) {
2984
                    lanes.push_back(lane);
2985
                }
2986
            }
2987
            if (lanes.empty()) {
2988
                WRITE_WARNINGF(TL("No lanes around % to attach it"), toString(SUMO_TAG_POI));
2989
            } else {
2990
                // obtain nearest lane to POI
2991
                GNELane* nearestLane = lanes.front();
2992
                double minorPosOverLane = nearestLane->getLaneShape().nearest_offset_to_point2D(POI->getPositionInView());
2993
                double minorLateralOffset = nearestLane->getLaneShape().positionAtOffset(minorPosOverLane).distanceTo(POI->getPositionInView());
2994
                for (const auto& lane : lanes) {
2995
                    double posOverLane = lane->getLaneShape().nearest_offset_to_point2D(POI->getPositionInView());
2996
                    double lateralOffset = lane->getLaneShape().positionAtOffset(posOverLane).distanceTo(POI->getPositionInView());
2997
                    if (lateralOffset < minorLateralOffset) {
2998
                        minorPosOverLane = posOverLane;
2999
                        minorLateralOffset = lateralOffset;
3000
                        nearestLane = lane;
3001
                    }
3002
                }
3003
                // get sumo base object of POI (And all common attributes)
3004
                CommonXMLStructure::SumoBaseObject* POIBaseObject = POI->getSumoBaseObject();
3005
                // add specific attributes
3006
                POIBaseObject->addStringAttribute(SUMO_ATTR_LANE, nearestLane->getID());
3007
                POIBaseObject->addDoubleAttribute(SUMO_ATTR_POSITION, minorPosOverLane);
3008
                POIBaseObject->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, POI->getFriendlyPos());
3009
                POIBaseObject->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, 0);
3010
                // remove POI
3011
                myUndoList->begin(POI, TL("attach POI into lane"));
3012
                myNet->deleteAdditional(POI, myUndoList);
3013
                // add new POI use route handler
3014
                additionalHandler.parseSumoBaseObject(POIBaseObject);
3015
                myUndoList->end();
3016
            }
3017
        } else {
3018
            // get sumo base object of POI (And all common attributes)
3019
            CommonXMLStructure::SumoBaseObject* POIBaseObject = POI->getSumoBaseObject();
3020
            // add specific attributes
3021
            POIBaseObject->addDoubleAttribute(SUMO_ATTR_X, POI->x());
3022
            POIBaseObject->addDoubleAttribute(SUMO_ATTR_Y, POI->y());
3023
            // remove POI
3024
            myUndoList->begin(POI, TL("release POI from lane"));
3025
            myNet->deleteAdditional(POI, myUndoList);
3026
            // add new POI use route handler
3027
            additionalHandler.parseSumoBaseObject(POIBaseObject);
3028
            myUndoList->end();
3029
        }
3030
    }
3031
    return 1;
3032
}
3033

3034

3035
long
3036
GNEViewNet::onCmdReverse(FXObject*, FXSelector, void*) {
3037
    // obtain demand element at popup position
3038
    GNEDemandElement* demandElement = getDemandElementAtPopupPosition();
3039
    if (demandElement) {
3040
        // begin undo list
3041
        myUndoList->begin(demandElement, TLF("reverse % '%'", demandElement->getTagStr(), demandElement->getID()));
3042
        GNERouteHandler::reverse(demandElement);
3043
        myUndoList->end();
3044
    }
3045
    return 1;
3046
}
3047

3048

3049
long
3050
GNEViewNet::onCmdAddReverse(FXObject*, FXSelector, void*) {
3051
    // obtain demand element at popup position
3052
    GNEDemandElement* demandElement = getDemandElementAtPopupPosition();
3053
    if (demandElement) {
3054
        // begin undo list
3055
        myUndoList->begin(demandElement, TLF("add reverse '%'", demandElement->getTagStr()));
3056
        GNERouteHandler::addReverse(demandElement);
3057
        myUndoList->end();
3058
    }
3059
    return 1;
3060
}
3061

3062

3063
long
3064
GNEViewNet::onCmdSetCustomGeometryPoint(FXObject*, FXSelector, void*) {
3065
    // get element at popup position
3066
    GNEEdge* edge = getEdgeAtPopupPosition();
3067
    GNEPoly* poly = getPolygonAtPopupPosition();
3068
    GNETAZ* TAZ = getTAZAtPopupPosition();
3069
    // check element
3070
    if (edge != nullptr) {
3071
        // make a copy of edge geometry
3072
        auto edgeGeometry = edge->getNBEdge()->getGeometry();
3073
        // get index position
3074
        const int index = edgeGeometry.indexOfClosest(getPositionInformation(), true);
3075
        // edit position using GNEGeometryPointDialog
3076
        const auto geometryPointDialog = GNEGeometryPointDialog(myViewParent->getGNEAppWindows(), edgeGeometry[index]);
3077
        // now check position
3078
        if ((geometryPointDialog.getResult() == GNEDialog::Result::ACCEPT) && (geometryPointDialog.getEditedPosition() != edgeGeometry[index])) {
3079
            // update new position
3080
            edgeGeometry[index] = geometryPointDialog.getEditedPosition();
3081
            // begin undo list
3082
            myUndoList->begin(edge, TL("change edge Geometry Point position"));
3083
            // continue depending of index
3084
            if (index == 0) {
3085
                // change shape start
3086
                GNEChange_Attribute::changeAttribute(edge, GNE_ATTR_SHAPE_START, toString(edgeGeometry.front()), myUndoList);
3087
            } else if (index == ((int)edgeGeometry.size() - 1)) {
3088
                // change shape end
3089
                GNEChange_Attribute::changeAttribute(edge, GNE_ATTR_SHAPE_END, toString(edgeGeometry.back()), myUndoList);
3090
            } else {
3091
                // remove front and back geometry points
3092
                edgeGeometry.pop_front();
3093
                edgeGeometry.pop_back();
3094
                // change shape
3095
                GNEChange_Attribute::changeAttribute(edge, SUMO_ATTR_SHAPE, toString(edgeGeometry), myUndoList);
3096
            }
3097
            // end undo list
3098
            myUndoList->end();
3099
        }
3100
    } else if (poly != nullptr) {
3101
        // make a copy of polygon geometry
3102
        PositionVector polygonGeometry = poly->getShape();
3103
        // get index position
3104
        const int index = polygonGeometry.indexOfClosest(getPositionInformation(), true);
3105
        // edit position using GNEGeometryPointDialog
3106
        const auto geometryPointDialog = GNEGeometryPointDialog(myViewParent->getGNEAppWindows(), polygonGeometry[index]);
3107
        // now check position
3108
        if ((geometryPointDialog.getResult() == GNEDialog::Result::ACCEPT) && (geometryPointDialog.getEditedPosition() != polygonGeometry[index])) {
3109
            // update new position
3110
            polygonGeometry[index] = geometryPointDialog.getEditedPosition();
3111
            // begin undo list
3112
            myUndoList->begin(poly, TL("change polygon Geometry Point position"));
3113
            // change shape
3114
            GNEChange_Attribute::changeAttribute(poly, SUMO_ATTR_SHAPE, toString(polygonGeometry), myUndoList);
3115
            // end undo list
3116
            myUndoList->end();
3117
        }
3118
    } else if (TAZ != nullptr) {
3119
        // make a copy of TAZ geometry
3120
        PositionVector TAZGeometry = TAZ->getAdditionalGeometry().getShape();
3121
        // get index position
3122
        const int index = TAZGeometry.indexOfClosest(getPositionInformation(), true);
3123
        // edit position using GNEGeometryPointDialog
3124
        const auto geometryPointDialog = GNEGeometryPointDialog(myViewParent->getGNEAppWindows(), TAZGeometry[index]);
3125
        // now check position
3126
        if ((geometryPointDialog.getResult() == GNEDialog::Result::ACCEPT) && (geometryPointDialog.getEditedPosition() != TAZGeometry[index])) {
3127
            // update new position
3128
            TAZGeometry[index] = geometryPointDialog.getEditedPosition();
3129
            // begin undo list
3130
            myUndoList->begin(TAZ, TL("change TAZ Geometry Point position"));
3131
            // change shape
3132
            GNEChange_Attribute::changeAttribute(TAZ, SUMO_ATTR_SHAPE, toString(TAZGeometry), myUndoList);
3133
            // end undo list
3134
            myUndoList->end();
3135
        }
3136
    }
3137
    return 1;
3138
}
3139

3140

3141
long
3142
GNEViewNet::onCmdResetEndPoints(FXObject*, FXSelector, void*) {
3143
    // get lane at popup position
3144
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3145
    // check element
3146
    if (laneAtPopupPosition != nullptr) {
3147
        // get parent edge
3148
        GNEEdge* edge = laneAtPopupPosition->getParentEdge();
3149
        // check if edge is selected
3150
        if (edge->isAttributeCarrierSelected()) {
3151
            // get selected edges
3152
            const auto selectedEdges = myNet->getAttributeCarriers()->getSelectedEdges();
3153
            // begin undo list
3154
            myUndoList->begin(edge, TL("reset end points of selected edges"));
3155
            // iterate over edges
3156
            for (const auto& selectedEdge : selectedEdges) {
3157
                // reset both end points
3158
                selectedEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3159
                selectedEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3160
            }
3161
            // end undo list
3162
            myUndoList->end();
3163
        } else {
3164
            // begin undo list
3165
            myUndoList->begin(edge, TL("reset end points of edge '") + edge->getID());
3166
            // reset both end points
3167
            edge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3168
            edge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3169
            // end undo list
3170
            myUndoList->end();
3171
        }
3172
    }
3173
    return 1;
3174
}
3175

3176

3177
long
3178
GNEViewNet::onCmdDuplicateLane(FXObject*, FXSelector, void*) {
3179
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3180
    if (laneAtPopupPosition != nullptr) {
3181
        // when duplicating an unselected lane, keep all connections as they
3182
        // are, otherwise recompute them
3183
        if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3184
            myUndoList->begin(laneAtPopupPosition, TL("duplicate selected lanes"));
3185
            const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3186
            for (const auto& lane : selectedLanes) {
3187
                myNet->duplicateLane(lane, myUndoList, true);
3188
            }
3189
            myUndoList->end();
3190
        } else {
3191
            myUndoList->begin(laneAtPopupPosition, TL("duplicate lane"));
3192
            myNet->duplicateLane(laneAtPopupPosition, myUndoList, false);
3193
            myUndoList->end();
3194
        }
3195
    }
3196
    return 1;
3197
}
3198

3199

3200
long
3201
GNEViewNet::onCmdEditLaneShape(FXObject*, FXSelector, void*) {
3202
    // Obtain lane under mouse
3203
    GNELane* lane = getLaneAtPopupPosition();
3204
    if (lane) {
3205
        myEditNetworkElementShapes.startEditCustomShape(lane);
3206
    }
3207
    // destroy pop-up and update view Net
3208
    destroyPopup();
3209
    setFocus();
3210
    return 1;
3211
}
3212

3213

3214
long
3215
GNEViewNet::onCmdResetLaneCustomShape(FXObject*, FXSelector, void*) {
3216
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3217
    if (laneAtPopupPosition != nullptr) {
3218
        // when duplicating an unselected lane, keep all connections as they
3219
        // are, otherwise recompute them
3220
        if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3221
            myUndoList->begin(laneAtPopupPosition, TL("reset custom lane shapes"));
3222
            const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3223
            for (const auto& lane : selectedLanes) {
3224
                lane->setAttribute(SUMO_ATTR_CUSTOMSHAPE, "", myUndoList);
3225
            }
3226
            myUndoList->end();
3227
        } else {
3228
            myUndoList->begin(laneAtPopupPosition, TL("reset custom lane shape"));
3229
            laneAtPopupPosition->setAttribute(SUMO_ATTR_CUSTOMSHAPE, "", myUndoList);
3230
            myUndoList->end();
3231
        }
3232
    }
3233
    return 1;
3234
}
3235

3236

3237
long
3238
GNEViewNet::onCmdResetOppositeLane(FXObject*, FXSelector, void*) {
3239
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3240
    if (laneAtPopupPosition != nullptr) {
3241
        // when duplicating an unselected lane, keep all connections as they
3242
        // are, otherwise recompute them
3243
        if (laneAtPopupPosition->isAttributeCarrierSelected()) {
3244
            myUndoList->begin(laneAtPopupPosition, TL("reset opposite lanes"));
3245
            const auto selectedLanes = myNet->getAttributeCarriers()->getSelectedLanes();
3246
            for (const auto& lane : selectedLanes) {
3247
                lane->setAttribute(GNE_ATTR_OPPOSITE, "", myUndoList);
3248
            }
3249
            myUndoList->end();
3250
        } else {
3251
            myUndoList->begin(laneAtPopupPosition, TL("reset opposite lane"));
3252
            laneAtPopupPosition->setAttribute(GNE_ATTR_OPPOSITE, "", myUndoList);
3253
            myUndoList->end();
3254
        }
3255
    }
3256
    return 1;
3257
}
3258

3259

3260
long
3261
GNEViewNet::onCmdLaneOperation(FXObject*, FXSelector sel, void*) {
3262
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3263
    if (laneAtPopupPosition) {
3264
        // check lane operation
3265
        switch (FXSELID(sel)) {
3266
            case MID_GNE_LANE_TRANSFORM_SIDEWALK:
3267
                return restrictLane(laneAtPopupPosition, SVC_PEDESTRIAN);
3268
            case MID_GNE_LANE_TRANSFORM_BIKE:
3269
                return restrictLane(laneAtPopupPosition, SVC_BICYCLE);
3270
            case MID_GNE_LANE_TRANSFORM_BUS:
3271
                return restrictLane(laneAtPopupPosition, SVC_BUS);
3272
            case MID_GNE_LANE_TRANSFORM_GREENVERGE:
3273
                return restrictLane(laneAtPopupPosition, SVC_IGNORING);
3274
            case MID_GNE_LANE_ADD_SIDEWALK:
3275
                return addRestrictedLane(laneAtPopupPosition, SVC_PEDESTRIAN, false);
3276
            case MID_GNE_LANE_ADD_BIKE:
3277
                return addRestrictedLane(laneAtPopupPosition, SVC_BICYCLE, false);
3278
            case MID_GNE_LANE_ADD_BUS:
3279
                return addRestrictedLane(laneAtPopupPosition, SVC_BUS, false);
3280
            case MID_GNE_LANE_ADD_GREENVERGE_FRONT:
3281
                return addRestrictedLane(laneAtPopupPosition, SVC_IGNORING, true);
3282
            case MID_GNE_LANE_ADD_GREENVERGE_BACK:
3283
                return addRestrictedLane(laneAtPopupPosition, SVC_IGNORING, false);
3284
            case MID_GNE_LANE_REMOVE_SIDEWALK:
3285
                return removeRestrictedLane(laneAtPopupPosition, SVC_PEDESTRIAN);
3286
            case MID_GNE_LANE_REMOVE_BIKE:
3287
                return removeRestrictedLane(laneAtPopupPosition, SVC_BICYCLE);
3288
            case MID_GNE_LANE_REMOVE_BUS:
3289
                return removeRestrictedLane(laneAtPopupPosition, SVC_BUS);
3290
            case MID_GNE_LANE_REMOVE_GREENVERGE:
3291
                return removeRestrictedLane(laneAtPopupPosition, SVC_IGNORING);
3292
            default:
3293
                return 0;
3294
        }
3295
    } else {
3296
        return 0;
3297
    }
3298
}
3299

3300

3301
long
3302
GNEViewNet::onCmdLaneReachability(FXObject* menu, FXSelector, void*) {
3303
    GNELane* laneAtPopupPosition = getLaneAtPopupPosition();
3304
    if (laneAtPopupPosition != nullptr) {
3305
        // obtain vClass
3306
        const SUMOVehicleClass vClass = SumoVehicleClassStrings.get(dynamic_cast<FXMenuCommand*>(menu)->getText().text());
3307
        // calculate reachability
3308
        myNet->getDemandPathManager()->getPathCalculator()->calculateReachability(vClass, laneAtPopupPosition->getParentEdge());
3309
        // select all lanes with reachability greater than 0
3310
        myUndoList->begin(laneAtPopupPosition, TL("select lane reachability"));
3311
        for (const auto& edge : myNet->getAttributeCarriers()->getEdges()) {
3312
            for (const auto& lane : edge.second->getChildLanes()) {
3313
                if (lane->getReachability() >= 0) {
3314
                    lane->setAttribute(GNE_ATTR_SELECTED, "true", myUndoList);
3315
                }
3316
            }
3317
        }
3318
        myUndoList->end();
3319
    }
3320
    return 1;
3321
}
3322

3323

3324
long
3325
GNEViewNet::onCmdOpenAdditionalDialog(FXObject*, FXSelector, void*) {
3326
    // retrieve additional under cursor
3327
    GNEAdditional* addtional = getAdditionalAtPopupPosition();
3328
    // check if additional can open dialog
3329
    if (addtional && addtional->getTagProperty()->hasDialog()) {
3330
        addtional->openAdditionalDialog();
3331
    }
3332
    return 1;
3333
}
3334

3335

3336
void
3337
GNEViewNet::processClick(void* eventData) {
3338
    FXEvent* evt = (FXEvent*)eventData;
3339
    // process click
3340
    destroyPopup();
3341
    setFocus();
3342
    myChanger->onLeftBtnPress(eventData);
3343
    grab();
3344
    // Check there are double click
3345
    if (evt->click_count == 2) {
3346
        handle(this, FXSEL(SEL_DOUBLECLICKED, 0), eventData);
3347
    }
3348
}
3349

3350

3351
void
3352
GNEViewNet::updateCursor() {
3353
    // first check if we're panning
3354
    if (myPanning) {
3355
        // move view
3356
        setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3357
        setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3358
    } else {
3359
        // declare flags
3360
        bool cursorMoveView = false;
3361
        bool cursorInspect = false;
3362
        bool cursorSelect = false;
3363
        bool cursorMoveElement = false;
3364
        bool cursorDelete = false;
3365
        // continue depending of supermode
3366
        if (myEditModes.isCurrentSupermodeNetwork()) {
3367
            // move view
3368
            if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) ||
3369
                    (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) ||
3370
                    (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL) ||
3371
                    (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) ||
3372
                    (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ)) {
3373
                cursorMoveView = true;
3374
            }
3375
            // specific mode
3376
            if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT) {
3377
                cursorInspect = true;
3378
            } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
3379
                cursorSelect = true;
3380
            } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_MOVE) {
3381
                cursorMoveElement = true;
3382
            } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_DELETE) {
3383
                cursorDelete = true;
3384
            }
3385
        } else if (myEditModes.isCurrentSupermodeDemand()) {
3386
            // move view
3387
            if ((myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) ||
3388
                    (myEditModes.demandEditMode == DemandEditMode::DEMAND_VEHICLE) ||
3389
                    (myEditModes.demandEditMode == DemandEditMode::DEMAND_STOP)) {
3390
                cursorMoveView = true;
3391
            }
3392
            // specific mode
3393
            if (myEditModes.demandEditMode == DemandEditMode::DEMAND_INSPECT) {
3394
                cursorInspect = true;
3395
            } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_SELECT) {
3396
                cursorSelect = true;
3397
            } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_MOVE) {
3398
                cursorMoveElement = true;
3399
            } else if (myEditModes.demandEditMode == DemandEditMode::DEMAND_DELETE) {
3400
                cursorDelete = true;
3401
            }
3402
        } else if (myEditModes.isCurrentSupermodeData()) {
3403
            // move view
3404
            if (myEditModes.dataEditMode == DataEditMode::DATA_SELECT) {
3405
                cursorMoveView = true;
3406
            }
3407
            // specific mode
3408
            if (myEditModes.dataEditMode == DataEditMode::DATA_INSPECT) {
3409
                cursorInspect = true;
3410
            } else if (myEditModes.dataEditMode == DataEditMode::DATA_SELECT) {
3411
                cursorSelect = true;
3412
            } else if (myEditModes.dataEditMode == DataEditMode::DATA_DELETE) {
3413
                cursorDelete = true;
3414
            }
3415
        }
3416
        // set cursor
3417
        if (myMouseButtonKeyPressed.controlKeyPressed() && cursorMoveView) {
3418
            // move view cursor if control key is pressed
3419
            setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3420
            setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEVIEW));
3421
        } else if (cursorInspect) {
3422
            // special case for inspect lanes
3423
            if (!checkSelectEdges() && myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_INSPECT)) {
3424
                // inspect lane cursor
3425
                setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT_LANE));
3426
                setDragCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT_LANE));
3427
            } else {
3428
                // inspect cursor
3429
                setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT));
3430
                setDragCursor(GUICursorSubSys::getCursor(GUICursor::INSPECT));
3431
            }
3432
        } else if (cursorSelect) {
3433
            // special case for select lanes
3434
            if (!checkSelectEdges() && myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT)) {
3435
                // select lane cursor
3436
                setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::SELECT_LANE));
3437
                setDragCursor(GUICursorSubSys::getCursor(GUICursor::SELECT_LANE));
3438
            } else {
3439
                // select cursor
3440
                setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::SELECT));
3441
                setDragCursor(GUICursorSubSys::getCursor(GUICursor::SELECT));
3442
            }
3443
        } else if (cursorMoveElement) {
3444
            // move cursor
3445
            setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::MOVEELEMENT));
3446
            setDragCursor(GUICursorSubSys::getCursor(GUICursor::MOVEELEMENT));
3447
        } else if (cursorDelete) {
3448
            // delete cursor
3449
            setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::DELETE_CURSOR));
3450
            setDragCursor(GUICursorSubSys::getCursor(GUICursor::DELETE_CURSOR));
3451
        } else {
3452
            // default cursor
3453
            setDefaultCursor(GUICursorSubSys::getCursor(GUICursor::DEFAULT));
3454
            setDragCursor(GUICursorSubSys::getCursor(GUICursor::DEFAULT));
3455
        }
3456
    }
3457
}
3458

3459

3460
int
3461
GNEViewNet::drawGLElements(const Boundary& bound) {
3462
    // udpdate drawing toggle
3463
    if (myDrawingToggle > 10000) {
3464
        myDrawingToggle = 0;
3465
    } else {
3466
        myDrawingToggle++;
3467
    }
3468
    // set default scale
3469
    myVisualizationSettings->scale = m2p(SUMO_const_laneWidth);
3470
    // calculate boundary extremes
3471
    const float minB[2] = { (float)bound.xmin(), (float)bound.ymin() };
3472
    const float maxB[2] = { (float)bound.xmax(), (float)bound.ymax() };
3473
    // reset gl line to 1
3474
    glLineWidth(1);
3475
    // set drawing modes
3476
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
3477
    glEnable(GL_POLYGON_OFFSET_FILL);
3478
    glEnable(GL_POLYGON_OFFSET_LINE);
3479
    // draw all elements between minB and maxB, obtain objects included in minB and maxB
3480
    return myGrid->Search(minB, maxB, *myVisualizationSettings);
3481
}
3482

3483

3484
void
3485
GNEViewNet::drawGrid() const {
3486
    // depending of the visualizationSettings, enable or disable check box show grid
3487
    if (myVisualizationSettings->showGrid) {
3488
        // change show grid
3489
        if (!myNetworkViewOptions.menuCheckToggleGrid->amChecked() ||
3490
                !myDemandViewOptions.menuCheckToggleGrid->amChecked()) {
3491
            // change to true
3492
            myNetworkViewOptions.menuCheckToggleGrid->setChecked(true);
3493
            myDemandViewOptions.menuCheckToggleGrid->setChecked(true);
3494
            // update show grid buttons
3495
            myNetworkViewOptions.menuCheckToggleGrid->update();
3496
            myNetworkViewOptions.menuCheckToggleGrid->update();
3497
        }
3498
        // draw grid only in network and demand mode
3499
        if (myEditModes.isCurrentSupermodeNetwork() || myEditModes.isCurrentSupermodeDemand()) {
3500
            paintGLGrid();
3501
        }
3502
    } else {
3503
        // change show grid
3504
        if (myNetworkViewOptions.menuCheckToggleGrid->amChecked() ||
3505
                myDemandViewOptions.menuCheckToggleGrid->amChecked()) {
3506
            // change to false
3507
            myNetworkViewOptions.menuCheckToggleGrid->setChecked(false);
3508
            myDemandViewOptions.menuCheckToggleGrid->setChecked(false);
3509
            // update show grid buttons
3510
            myNetworkViewOptions.menuCheckToggleGrid->update();
3511
            myNetworkViewOptions.menuCheckToggleGrid->update();
3512
        }
3513
    }
3514
}
3515

3516

3517
long
3518
GNEViewNet::onCmdResetEdgeEndPoints(FXObject*, FXSelector, void*) {
3519
    // Obtain junction under mouse
3520
    GNEJunction* junction = getJunctionAtPopupPosition();
3521
    if (junction) {
3522
        myUndoList->begin(GUIIcon::EDGE, TL("reset edge endpoints"));
3523
        // are, otherwise recompute them
3524
        if (junction->isAttributeCarrierSelected()) {
3525
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3526
            for (const auto& selectedJunction : selectedJunctions) {
3527
                // reset shape end from incoming edges
3528
                for (const auto& incomingEdge : selectedJunction->getGNEIncomingEdges()) {
3529
                    incomingEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3530
                }
3531
                // reset shape start from outgoing edges
3532
                for (const auto& outgoingEdge : selectedJunction->getGNEOutgoingEdges()) {
3533
                    outgoingEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3534
                }
3535
            }
3536
        } else {
3537
            // reset shape end from incoming edges
3538
            for (const auto& incomingEdge : junction->getGNEIncomingEdges()) {
3539
                incomingEdge->setAttribute(GNE_ATTR_SHAPE_END, "", myUndoList);
3540
            }
3541
            // reset shape start from outgoing edges
3542
            for (const auto& outgoingEdge : junction->getGNEOutgoingEdges()) {
3543
                outgoingEdge->setAttribute(GNE_ATTR_SHAPE_START, "", myUndoList);
3544
            }
3545
        }
3546
        myUndoList->end();
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::onCmdEditJunctionShape(FXObject*, FXSelector, void*) {
3557
    // Obtain junction under mouse
3558
    GNEJunction* junction = getJunctionAtPopupPosition();
3559
    if (junction) {
3560
        // check if network has to be updated
3561
        if (junction->getNBNode()->getShape().size() == 0) {
3562
            // recompute the whole network
3563
            myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3564
        }
3565
        // if grid is enabled, show warning
3566
        if (myVisualizationSettings->showGrid) {
3567
            WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3568
        }
3569
        // start edit custom shape
3570
        myEditNetworkElementShapes.startEditCustomShape(junction);
3571
    }
3572
    // destroy pop-up and set focus in view net
3573
    destroyPopup();
3574
    setFocus();
3575
    return 1;
3576
}
3577

3578

3579
long
3580
GNEViewNet::onCmdResetJunctionShape(FXObject*, FXSelector, void*) {
3581
    // Obtain junction under mouse
3582
    GNEJunction* junction = getJunctionAtPopupPosition();
3583
    if (junction) {
3584
        // are, otherwise recompute them
3585
        if (junction->isAttributeCarrierSelected()) {
3586
            myUndoList->begin(junction, TL("reset custom junction shapes"));
3587
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3588
            for (const auto& selectedJunction : selectedJunctions) {
3589
                selectedJunction->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
3590
            }
3591
            myUndoList->end();
3592
        } else {
3593
            myUndoList->begin(junction, TL("reset custom junction shape"));
3594
            junction->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
3595
            myUndoList->end();
3596
        }
3597
    }
3598
    // destroy pop-up and set focus in view net
3599
    destroyPopup();
3600
    setFocus();
3601
    return 1;
3602
}
3603

3604

3605
long
3606
GNEViewNet::onCmdReplaceJunction(FXObject*, FXSelector, void*) {
3607
    GNEJunction* junction = getJunctionAtPopupPosition();
3608
    if (junction != nullptr) {
3609
        myNet->replaceJunctionByGeometry(junction, myUndoList);
3610
    }
3611
    // destroy pop-up and set focus in view net
3612
    destroyPopup();
3613
    setFocus();
3614
    return 1;
3615
}
3616

3617

3618
long
3619
GNEViewNet::onCmdSplitJunction(FXObject*, FXSelector, void*) {
3620
    GNEJunction* junction = getJunctionAtPopupPosition();
3621
    if (junction != nullptr) {
3622
        myNet->splitJunction(junction, false, myUndoList);
3623
    }
3624
    // destroy pop-up and set focus in view net
3625
    destroyPopup();
3626
    setFocus();
3627
    return 1;
3628
}
3629

3630

3631
long
3632
GNEViewNet::onCmdSplitJunctionReconnect(FXObject*, FXSelector, void*) {
3633
    GNEJunction* junction = getJunctionAtPopupPosition();
3634
    if (junction != nullptr) {
3635
        myNet->splitJunction(junction, true, myUndoList);
3636
    }
3637
    // destroy pop-up and set focus in view net
3638
    destroyPopup();
3639
    setFocus();
3640
    return 1;
3641
}
3642

3643
long
3644
GNEViewNet::onCmdSelectRoundabout(FXObject*, FXSelector, void*) {
3645
    GNEJunction* junction = getJunctionAtPopupPosition();
3646
    if (junction != nullptr) {
3647
        myNet->selectRoundabout(junction, myUndoList);
3648
    }
3649
    // destroy pop-up and set focus in view net
3650
    destroyPopup();
3651
    setFocus();
3652
    return 1;
3653
}
3654

3655
long
3656
GNEViewNet::onCmdConvertRoundabout(FXObject*, FXSelector, void*) {
3657
    GNEJunction* junction = getJunctionAtPopupPosition();
3658
    if (junction != nullptr) {
3659
        myNet->createRoundabout(junction, myUndoList);
3660
    }
3661
    // destroy pop-up and set focus in view net
3662
    destroyPopup();
3663
    setFocus();
3664
    return 1;
3665
}
3666

3667

3668
long
3669
GNEViewNet::onEnterConvertRoundabout(FXObject*, FXSelector, void*) {
3670
    myDrawPreviewRoundabout = true;
3671
    update();
3672
    return 1;
3673
}
3674

3675

3676
long
3677
GNEViewNet::onLeaveConvertRoundabout(FXObject*, FXSelector, void*) {
3678
    myDrawPreviewRoundabout = false;
3679
    update();
3680
    return 1;
3681
}
3682

3683

3684
long
3685
GNEViewNet::onCmdClearConnections(FXObject*, FXSelector, void*) {
3686
    GNEJunction* junction = getJunctionAtPopupPosition();
3687
    if (junction != nullptr) {
3688
        // make sure we do not inspect the connection will it is being deleted
3689
        if (myInspectedElements.getFirstAC() && (myInspectedElements.getFirstAC()->getTagProperty()->getTag() == SUMO_TAG_CONNECTION)) {
3690
            myViewParent->getInspectorFrame()->clearInspection();
3691
        }
3692
        // make sure that connections isn't the front attribute
3693
        const auto frontElements = myMarkFrontElements.getACs();
3694
        for (const auto& AC : frontElements) {
3695
            if (AC->getTagProperty()->getTag() == SUMO_TAG_CONNECTION) {
3696
                myMarkFrontElements.unmarkAC(AC);
3697
            }
3698
        }
3699
        // check if we're handling a selection
3700
        if (junction->isAttributeCarrierSelected()) {
3701
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3702
            myUndoList->begin(GUIIcon::CONNECTION, TL("clear connections of selected junctions"));
3703
            for (const auto& selectedJunction : selectedJunctions) {
3704
                myNet->clearJunctionConnections(selectedJunction, myUndoList);
3705
            }
3706
            myUndoList->end();
3707
        } else {
3708
            myNet->clearJunctionConnections(junction, myUndoList);
3709
        }
3710
    }
3711
    // destroy pop-up and set focus in view net
3712
    destroyPopup();
3713
    setFocus();
3714
    return 1;
3715
}
3716

3717

3718
long
3719
GNEViewNet::onCmdResetConnections(FXObject*, FXSelector, void*) {
3720
    GNEJunction* junction = getJunctionAtPopupPosition();
3721
    if (junction != nullptr) {
3722
        // make sure we do not inspect the connection will it is being deleted
3723
        if (myInspectedElements.getFirstAC() && (myInspectedElements.getFirstAC()->getTagProperty()->getTag() == SUMO_TAG_CONNECTION)) {
3724
            myViewParent->getInspectorFrame()->clearInspection();
3725
        }
3726
        // make sure that connections isn't the front attribute
3727
        const auto frontElements = myMarkFrontElements.getACs();
3728
        for (const auto& AC : frontElements) {
3729
            if (AC->getTagProperty()->getTag() == SUMO_TAG_CONNECTION) {
3730
                myMarkFrontElements.unmarkAC(AC);
3731
            }
3732
        }
3733
        // check if we're handling a selection
3734
        if (junction->isAttributeCarrierSelected()) {
3735
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3736
            myUndoList->begin(GUIIcon::CONNECTION, TL("reset connections of selected junctions"));
3737
            for (const auto& selectedJunction : selectedJunctions) {
3738
                myNet->resetJunctionConnections(selectedJunction, myUndoList);
3739
            }
3740
            myUndoList->end();
3741
        } else {
3742
            myNet->resetJunctionConnections(junction, myUndoList);
3743
        }
3744
    }
3745
    // destroy pop-up and set focus in view net
3746
    destroyPopup();
3747
    setFocus();
3748
    return 1;
3749
}
3750

3751

3752
long
3753
GNEViewNet::onCmdAddTLS(FXObject*, FXSelector, void*) {
3754
    GNEJunction* junction = getJunctionAtPopupPosition();
3755
    if (junction != nullptr) {
3756
        // check if we're adding TLS in multiple junctions
3757
        if (junction->isAttributeCarrierSelected()) {
3758
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3759
            myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODETLS, TL("add TLS in multiple junctions"));
3760
            for (const auto& selectedJunction : selectedJunctions) {
3761
                selectedJunction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3762
            }
3763
            myNet->getViewNet()->getUndoList()->end();
3764
        } else {
3765
            // change junction type
3766
            junction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3767
            // change to TLS Mode
3768
            myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS, true);
3769
            // set junction in TLS mode
3770
            myViewParent->getTLSEditorFrame()->editJunction(junction);
3771
        }
3772
    }
3773
    // destroy pop-up and set focus in view net
3774
    destroyPopup();
3775
    setFocus();
3776
    return 1;
3777
}
3778

3779

3780
long
3781
GNEViewNet::onCmdAddJoinTLS(FXObject*, FXSelector, void*) {
3782
    GNEJunction* junction = getJunctionAtPopupPosition();
3783
    if (junction != nullptr) {
3784
        // check if we're adding TLS in multiple junctions
3785
        if (junction->isAttributeCarrierSelected()) {
3786
            myNet->getViewNet()->getUndoList()->begin(GUIIcon::MODETLS, TL("add TLS in multiple junctions"));
3787
        }
3788
        // change junction type
3789
        junction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3790
        // if TLS was sucesfully created, apply the same TLID to other selected junctions
3791
        if (junction->getAttribute(SUMO_ATTR_TLID).size() > 0) {
3792
            const auto selectedJunctions = myNet->getAttributeCarriers()->getSelectedJunctions();
3793
            // iterate over all selected junctions
3794
            for (const auto& selectedJunction : selectedJunctions) {
3795
                // check that doesn't have a TL
3796
                if (selectedJunction->getNBNode()->getControllingTLS().empty()) {
3797
                    selectedJunction->setAttribute(SUMO_ATTR_TYPE, "traffic_light", myUndoList);
3798
                    selectedJunction->setAttribute(SUMO_ATTR_TLID, junction->getAttribute(SUMO_ATTR_TLID), myUndoList);
3799
                }
3800
            }
3801
        }
3802
        // rename traffic light
3803
        if (junction->getNBNode()->getControllingTLS().size() > 0) {
3804
            const auto TLSDef = (*junction->getNBNode()->getControllingTLS().begin());
3805
            if (!myNet->getTLLogicCont().exist(TLSDef->getID() + "_joined")) {
3806
                myUndoList->add(new GNEChange_TLS(junction, TLSDef, TLSDef->getID() + "_joined"), true);
3807
            }
3808
        }
3809
        // end undoList
3810
        if (junction->isAttributeCarrierSelected()) {
3811
            myNet->getViewNet()->getUndoList()->end();
3812
        }
3813
        // change to TLS Mode
3814
        myEditModes.setNetworkEditMode(NetworkEditMode::NETWORK_TLS, true);
3815
        // set junction in TLS mode
3816
        myViewParent->getTLSEditorFrame()->editJunction(junction);
3817
    }
3818
    // destroy pop-up and set focus in view net
3819
    destroyPopup();
3820
    setFocus();
3821
    return 1;
3822
}
3823

3824
long
3825
GNEViewNet::onCmdEditConnectionShape(FXObject*, FXSelector, void*) {
3826
    // Obtain connection under mouse
3827
    GNEConnection* connection = getConnectionAtPopupPosition();
3828
    if (connection) {
3829
        myEditNetworkElementShapes.startEditCustomShape(connection);
3830
    }
3831
    // if grid is enabled, show warning
3832
    if (myVisualizationSettings->showGrid) {
3833
        WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3834
    }
3835
    // destroy pop-up and update view Net
3836
    destroyPopup();
3837
    setFocus();
3838
    return 1;
3839
}
3840

3841

3842
long
3843
GNEViewNet::onCmdSmoothConnectionShape(FXObject*, FXSelector, void*) {
3844
    // Obtain connection under mouse
3845
    GNEConnection* connection = getConnectionAtPopupPosition();
3846
    if (connection) {
3847
        connection->smootShape();
3848
    }
3849
    // destroy pop-up and update view Net
3850
    destroyPopup();
3851
    setFocus();
3852
    return 1;
3853
}
3854

3855

3856
long
3857
GNEViewNet::onCmdEditCrossingShape(FXObject*, FXSelector, void*) {
3858
    // Obtain crossing under mouse
3859
    GNECrossing* crossing = getCrossingAtPopupPosition();
3860
    if (crossing) {
3861
        // check if network has to be updated
3862
        if (crossing->getParentJunctions().front()->getNBNode()->getShape().size() == 0) {
3863
            // recompute the whole network
3864
            myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3865
        }
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
        // start edit custom shape
3871
        myEditNetworkElementShapes.startEditCustomShape(crossing);
3872
    }
3873
    // destroy pop-up and update view Net
3874
    destroyPopup();
3875
    setFocus();
3876
    return 1;
3877
}
3878

3879

3880
long
3881
GNEViewNet::onCmdEditWalkingAreaShape(FXObject*, FXSelector, void*) {
3882
    // Obtain walkingArea under mouse
3883
    GNEWalkingArea* walkingArea = getWalkingAreaAtPopupPosition();
3884
    if (walkingArea) {
3885
        // check if network has to be updated
3886
        if (walkingArea->getParentJunctions().front()->getNBNode()->getShape().size() == 0) {
3887
            // recompute the whole network
3888
            myNet->computeAndUpdate(OptionsCont::getOptions(), false);
3889
            // if grid is enabled, show warning
3890
            if (myVisualizationSettings->showGrid) {
3891
                WRITE_WARNING(TL("Grid is still active, press ctrl+g to deactivate"));
3892
            }
3893
        }
3894
        // start edit custom shape
3895
        myEditNetworkElementShapes.startEditCustomShape(walkingArea);
3896
    }
3897
    // destroy pop-up and update view Net
3898
    destroyPopup();
3899
    setFocus();
3900
    return 1;
3901
}
3902

3903

3904
long
3905
GNEViewNet::onCmdToggleSelectEdges(FXObject*, FXSelector sel, void*) {
3906
    // Toggle menuCheckSelectEdges
3907
    if (myNetworkViewOptions.menuCheckSelectEdges->amChecked() == TRUE) {
3908
        myNetworkViewOptions.menuCheckSelectEdges->setChecked(FALSE);
3909
    } else {
3910
        myNetworkViewOptions.menuCheckSelectEdges->setChecked(TRUE);
3911
    }
3912
    myNetworkViewOptions.menuCheckSelectEdges->update();
3913
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3914
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES)) {
3915
        myNetworkViewOptions.menuCheckSelectEdges->setFocus();
3916
    }
3917
    return 1;
3918
}
3919

3920

3921
long
3922
GNEViewNet::onCmdToggleShowConnections(FXObject*, FXSelector sel, void*) {
3923
    // Toggle menuCheckShowConnections
3924
    if (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE) {
3925
        myNetworkViewOptions.menuCheckShowConnections->setChecked(FALSE);
3926
    } else {
3927
        myNetworkViewOptions.menuCheckShowConnections->setChecked(TRUE);
3928
    }
3929
    myNetworkViewOptions.menuCheckShowConnections->update();
3930
    // if show was enabled, init GNEConnections
3931
    if (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE) {
3932
        getNet()->initGNEConnections();
3933
    }
3934
    // change flag "showLane2Lane" in myVisualizationSettings
3935
    myVisualizationSettings->showLane2Lane = (myNetworkViewOptions.menuCheckShowConnections->amChecked() == TRUE);
3936
    // Hide/show connections require recompute
3937
    getNet()->requireRecompute();
3938
    // Update viewNet to show/hide connections
3939
    updateViewNet();
3940
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3941
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS)) {
3942
        myNetworkViewOptions.menuCheckShowConnections->setFocus();
3943
    }
3944
    return 1;
3945
}
3946

3947

3948
long
3949
GNEViewNet::onCmdToggleHideConnections(FXObject*, FXSelector sel, void*) {
3950
    // Toggle menuCheckHideConnections
3951
    if (myNetworkViewOptions.menuCheckHideConnections->amChecked() == TRUE) {
3952
        myNetworkViewOptions.menuCheckHideConnections->setChecked(FALSE);
3953
    } else {
3954
        myNetworkViewOptions.menuCheckHideConnections->setChecked(TRUE);
3955
    }
3956
    myNetworkViewOptions.menuCheckHideConnections->update();
3957
    // Update viewNet to show/hide connections
3958
    updateViewNet();
3959
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3960
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS)) {
3961
        myNetworkViewOptions.menuCheckHideConnections->setFocus();
3962
    }
3963
    return 1;
3964
}
3965

3966

3967
long
3968
GNEViewNet::onCmdToggleShowAdditionalSubElements(FXObject*, FXSelector sel, void*) {
3969
    // Toggle menuCheckShowAdditionalSubElements
3970
    if (myNetworkViewOptions.menuCheckShowAdditionalSubElements->amChecked() == TRUE) {
3971
        myNetworkViewOptions.menuCheckShowAdditionalSubElements->setChecked(FALSE);
3972
    } else {
3973
        myNetworkViewOptions.menuCheckShowAdditionalSubElements->setChecked(TRUE);
3974
    }
3975
    myNetworkViewOptions.menuCheckShowAdditionalSubElements->update();
3976
    // Update viewNet to show/hide sub elements
3977
    updateViewNet();
3978
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3979
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS)) {
3980
        myNetworkViewOptions.menuCheckShowAdditionalSubElements->setFocus();
3981
    }
3982
    return 1;
3983
}
3984

3985

3986
long
3987
GNEViewNet::onCmdToggleShowTAZElements(FXObject*, FXSelector sel, void*) {
3988
    // Toggle menuCheckShowAdditionalSubElements
3989
    if (myNetworkViewOptions.menuCheckShowTAZElements->amChecked() == TRUE) {
3990
        myNetworkViewOptions.menuCheckShowTAZElements->setChecked(FALSE);
3991
    } else {
3992
        myNetworkViewOptions.menuCheckShowTAZElements->setChecked(TRUE);
3993
    }
3994
    myNetworkViewOptions.menuCheckShowTAZElements->update();
3995
    // Update viewNet to show/hide TAZ elements
3996
    updateViewNet();
3997
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
3998
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS)) {
3999
        myNetworkViewOptions.menuCheckShowTAZElements->setFocus();
4000
    }
4001
    return 1;
4002
}
4003

4004

4005
long
4006
GNEViewNet::onCmdToggleExtendSelection(FXObject*, FXSelector sel, void*) {
4007
    // Toggle menuCheckExtendSelection
4008
    if (myNetworkViewOptions.menuCheckExtendSelection->amChecked() == TRUE) {
4009
        myNetworkViewOptions.menuCheckExtendSelection->setChecked(FALSE);
4010
    } else {
4011
        myNetworkViewOptions.menuCheckExtendSelection->setChecked(TRUE);
4012
    }
4013
    myNetworkViewOptions.menuCheckExtendSelection->update();
4014
    // Only update view
4015
    updateViewNet();
4016
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4017
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION)) {
4018
        myNetworkViewOptions.menuCheckExtendSelection->setFocus();
4019
    }
4020
    return 1;
4021
}
4022

4023

4024
long
4025
GNEViewNet::onCmdToggleChangeAllPhases(FXObject*, FXSelector sel, void*) {
4026
    // Toggle menuCheckChangeAllPhases
4027
    if (myNetworkViewOptions.menuCheckChangeAllPhases->amChecked() == TRUE) {
4028
        myNetworkViewOptions.menuCheckChangeAllPhases->setChecked(FALSE);
4029
    } else {
4030
        myNetworkViewOptions.menuCheckChangeAllPhases->setChecked(TRUE);
4031
    }
4032
    myNetworkViewOptions.menuCheckChangeAllPhases->update();
4033
    // Only update view
4034
    updateViewNet();
4035
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4036
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES)) {
4037
        myNetworkViewOptions.menuCheckChangeAllPhases->setFocus();
4038
    }
4039
    return 1;
4040
}
4041

4042

4043
long
4044
GNEViewNet::onCmdToggleShowGrid(FXObject*, FXSelector sel, void*) {
4045
    // show or hide grid depending of myNetworkViewOptions.menuCheckToggleGrid
4046
    if (myVisualizationSettings->showGrid) {
4047
        myVisualizationSettings->showGrid = false;
4048
        myNetworkViewOptions.menuCheckToggleGrid->setChecked(false);
4049
        myDemandViewOptions.menuCheckToggleGrid->setChecked(false);
4050
    } else {
4051
        myVisualizationSettings->showGrid = true;
4052
        myNetworkViewOptions.menuCheckToggleGrid->setChecked(true);
4053
        myDemandViewOptions.menuCheckToggleGrid->setChecked(true);
4054
    }
4055
    myNetworkViewOptions.menuCheckToggleGrid->update();
4056
    myDemandViewOptions.menuCheckToggleGrid->update();
4057
    // update view to show grid
4058
    updateViewNet();
4059
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4060
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID)) {
4061
        myNetworkViewOptions.menuCheckToggleGrid->setFocus();
4062
    } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID)) {
4063
        myDemandViewOptions.menuCheckToggleGrid->setFocus();
4064
    }
4065
    return 1;
4066
}
4067

4068

4069
long
4070
GNEViewNet::onCmdToggleDrawJunctionShape(FXObject*, FXSelector sel, void*) {
4071
    // toggle state
4072
    myVisualizationSettings->drawJunctionShape = !myVisualizationSettings->drawJunctionShape;
4073
    // gui button has 'hide' semantics
4074
    const bool hide = !myVisualizationSettings->drawJunctionShape;
4075
    myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4076
    myDemandViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4077
    myDataViewOptions.menuCheckToggleDrawJunctionShape->setChecked(hide);
4078

4079
    myNetworkViewOptions.menuCheckToggleDrawJunctionShape->update();
4080
    myDemandViewOptions.menuCheckToggleDrawJunctionShape->update();
4081
    myDataViewOptions.menuCheckToggleDrawJunctionShape->update();
4082
    // update view to show DrawJunctionShape
4083
    updateViewNet();
4084
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4085
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4086
        myNetworkViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4087
    } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4088
        myDemandViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4089
    } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE)) {
4090
        myDataViewOptions.menuCheckToggleDrawJunctionShape->setFocus();
4091
    }
4092
    return 1;
4093
}
4094

4095
long
4096
GNEViewNet::onCmdToggleDrawSpreadVehicles(FXObject*, FXSelector sel, void*) {
4097
    // Toggle menuCheckShowDemandElements
4098
    if ((myNetworkViewOptions.menuCheckDrawSpreadVehicles->amChecked() == TRUE) ||
4099
            (myDemandViewOptions.menuCheckDrawSpreadVehicles->amChecked() == TRUE)) {
4100
        myNetworkViewOptions.menuCheckDrawSpreadVehicles->setChecked(FALSE);
4101
        myDemandViewOptions.menuCheckDrawSpreadVehicles->setChecked(FALSE);
4102
    } else {
4103
        myNetworkViewOptions.menuCheckDrawSpreadVehicles->setChecked(TRUE);
4104
        myDemandViewOptions.menuCheckDrawSpreadVehicles->setChecked(TRUE);
4105
    }
4106
    myNetworkViewOptions.menuCheckDrawSpreadVehicles->update();
4107
    myDemandViewOptions.menuCheckDrawSpreadVehicles->update();
4108
    // declare edge set
4109
    std::set<GNEEdge*> edgesToUpdate;
4110
    // compute vehicle geometry
4111
    for (const auto& vehicle : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_VEHICLE)) {
4112
        if (vehicle.second->getParentEdges().size() > 0) {
4113
            edgesToUpdate.insert(vehicle.second->getParentEdges().front());
4114
        } else if (vehicle.second->getChildDemandElements().size() > 0 && (vehicle.second->getChildDemandElements().front()->getTagProperty()->getTag() == GNE_TAG_ROUTE_EMBEDDED)) {
4115
            edgesToUpdate.insert(vehicle.second->getChildDemandElements().front()->getParentEdges().front());
4116
        }
4117
    }
4118
    for (const auto& routeFlow : myNet->getAttributeCarriers()->getDemandElements().at(GNE_TAG_FLOW_ROUTE)) {
4119
        if (routeFlow.second->getParentEdges().size() > 0) {
4120
            edgesToUpdate.insert(routeFlow.second->getParentEdges().front());
4121
        } else if (routeFlow.second->getChildDemandElements().size() > 0 && (routeFlow.second->getChildDemandElements().front()->getTagProperty()->getTag() == GNE_TAG_ROUTE_EMBEDDED)) {
4122
            edgesToUpdate.insert(routeFlow.second->getChildDemandElements().front()->getParentEdges().front());
4123
        }
4124
    }
4125
    for (const auto& trip : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_TRIP)) {
4126
        if (trip.second->getParentEdges().size() > 0) {
4127
            edgesToUpdate.insert(trip.second->getParentEdges().front());
4128
        }
4129
    }
4130
    for (const auto& flow : myNet->getAttributeCarriers()->getDemandElements().at(SUMO_TAG_FLOW)) {
4131
        if (flow.second->getParentEdges().size() > 0) {
4132
            edgesToUpdate.insert(flow.second->getParentEdges().front());
4133
        }
4134
    }
4135
    // update spread geometries of all edges
4136
    for (const auto& edge : edgesToUpdate) {
4137
        edge->updateVehicleSpreadGeometries();
4138
    }
4139
    // update view to show new vehicles positions
4140
    updateViewNet();
4141
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4142
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES)) {
4143
        myNetworkViewOptions.menuCheckDrawSpreadVehicles->setFocus();
4144
    } else if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES)) {
4145
        myDemandViewOptions.menuCheckDrawSpreadVehicles->setFocus();
4146
    }
4147
    return 1;
4148
}
4149

4150

4151
long
4152
GNEViewNet::onCmdToggleMergeAutomatically(FXObject*, FXSelector sel, void*) {
4153
    // Toggle menuCheckWarnAboutMerge
4154
    if (myNetworkViewOptions.menuCheckMergeAutomatically->amChecked() == TRUE) {
4155
        myNetworkViewOptions.menuCheckMergeAutomatically->setChecked(FALSE);
4156
    } else {
4157
        myNetworkViewOptions.menuCheckMergeAutomatically->setChecked(TRUE);
4158
    }
4159
    myNetworkViewOptions.menuCheckMergeAutomatically->update();
4160
    // Only update view
4161
    updateViewNet();
4162
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4163
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY)) {
4164
        myNetworkViewOptions.menuCheckMergeAutomatically->setFocus();
4165
    }
4166
    return 1;
4167
}
4168

4169

4170
long
4171
GNEViewNet::onCmdToggleShowJunctionBubbles(FXObject*, FXSelector sel, void*) {
4172
    // Toggle menuCheckShowJunctionBubble
4173
    if (myNetworkViewOptions.menuCheckShowJunctionBubble->amChecked() == TRUE) {
4174
        myNetworkViewOptions.menuCheckShowJunctionBubble->setChecked(FALSE);
4175
    } else {
4176
        myNetworkViewOptions.menuCheckShowJunctionBubble->setChecked(TRUE);
4177
    }
4178
    myNetworkViewOptions.menuCheckShowJunctionBubble->update();
4179
    // Only update view
4180
    updateViewNet();
4181
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4182
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES)) {
4183
        myNetworkViewOptions.menuCheckShowJunctionBubble->setFocus();
4184
    }
4185
    return 1;
4186
}
4187

4188

4189
long
4190
GNEViewNet::onCmdToggleMoveElevation(FXObject*, FXSelector sel, void*) {
4191
    // Toggle menuCheckMoveElevation
4192
    if (myNetworkViewOptions.menuCheckMoveElevation->amChecked() == TRUE) {
4193
        myNetworkViewOptions.menuCheckMoveElevation->setChecked(FALSE);
4194
    } else {
4195
        myNetworkViewOptions.menuCheckMoveElevation->setChecked(TRUE);
4196
    }
4197
    myNetworkViewOptions.menuCheckMoveElevation->update();
4198
    // Only update view
4199
    updateViewNet();
4200
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4201
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION)) {
4202
        myNetworkViewOptions.menuCheckMoveElevation->setFocus();
4203
    }
4204
    return 1;
4205
}
4206

4207

4208
long
4209
GNEViewNet::onCmdToggleChainEdges(FXObject*, FXSelector sel, void*) {
4210
    // Toggle menuCheckMoveElevation
4211
    if (myNetworkViewOptions.menuCheckChainEdges->amChecked() == TRUE) {
4212
        myNetworkViewOptions.menuCheckChainEdges->setChecked(FALSE);
4213
    } else {
4214
        myNetworkViewOptions.menuCheckChainEdges->setChecked(TRUE);
4215
    }
4216
    myNetworkViewOptions.menuCheckChainEdges->update();
4217
    // Only update view
4218
    updateViewNet();
4219
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4220
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES)) {
4221
        myNetworkViewOptions.menuCheckChainEdges->setFocus();
4222
    }
4223
    return 1;
4224
}
4225

4226

4227
long
4228
GNEViewNet::onCmdToggleAutoOppositeEdge(FXObject*, FXSelector sel, void*) {
4229
    // Toggle menuCheckAutoOppositeEdge
4230
    if (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE) {
4231
        myNetworkViewOptions.menuCheckAutoOppositeEdge->setChecked(FALSE);
4232
    } else {
4233
        myNetworkViewOptions.menuCheckAutoOppositeEdge->setChecked(TRUE);
4234
    }
4235
    myNetworkViewOptions.menuCheckAutoOppositeEdge->update();
4236
    // Only update view
4237
    updateViewNet();
4238
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4239
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES)) {
4240
        myNetworkViewOptions.menuCheckAutoOppositeEdge->setFocus();
4241
    }
4242
    return 1;
4243
}
4244

4245

4246
long
4247
GNEViewNet::onCmdToggleHideNonInspecteDemandElements(FXObject*, FXSelector sel, void*) {
4248
    // Toggle menuCheckHideNonInspectedDemandElements
4249
    if (myDemandViewOptions.menuCheckHideNonInspectedDemandElements->amChecked() == TRUE) {
4250
        myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setChecked(FALSE);
4251
    } else {
4252
        myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setChecked(TRUE);
4253
    }
4254
    myDemandViewOptions.menuCheckHideNonInspectedDemandElements->update();
4255
    // Only update view
4256
    updateViewNet();
4257
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4258
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED)) {
4259
        myDemandViewOptions.menuCheckHideNonInspectedDemandElements->setFocus();
4260
    }
4261
    return 1;
4262
}
4263

4264

4265
long
4266
GNEViewNet::onCmdToggleShowOverlappedRoutes(FXObject*, FXSelector sel, void*) {
4267
    // Toggle menuCheckShowOverlappedRoutes
4268
    if (myDemandViewOptions.menuCheckShowOverlappedRoutes->amChecked() == TRUE) {
4269
        myDemandViewOptions.menuCheckShowOverlappedRoutes->setChecked(FALSE);
4270
    } else {
4271
        myDemandViewOptions.menuCheckShowOverlappedRoutes->setChecked(TRUE);
4272
    }
4273
    myDemandViewOptions.menuCheckShowOverlappedRoutes->update();
4274
    // Only update view
4275
    updateViewNet();
4276
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4277
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES)) {
4278
        myDemandViewOptions.menuCheckShowOverlappedRoutes->setFocus();
4279
    }
4280
    return 1;
4281
}
4282

4283

4284
long
4285
GNEViewNet::onCmdToggleHideShapes(FXObject*, FXSelector sel, void*) {
4286
    // Toggle menuCheckHideShapes
4287
    if (myDemandViewOptions.menuCheckHideShapes->amChecked() == TRUE) {
4288
        myDemandViewOptions.menuCheckHideShapes->setChecked(FALSE);
4289
    } else {
4290
        myDemandViewOptions.menuCheckHideShapes->setChecked(TRUE);
4291
    }
4292
    myDemandViewOptions.menuCheckHideShapes->update();
4293
    // Only update view
4294
    updateViewNet();
4295
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4296
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES)) {
4297
        myDemandViewOptions.menuCheckHideShapes->setFocus();
4298
    }
4299
    return 1;
4300
}
4301

4302

4303
long
4304
GNEViewNet::onCmdToggleShowTrips(FXObject*, FXSelector sel, void*) {
4305
    // Toggle menuCheckHideShapes
4306
    if (myDemandViewOptions.menuCheckShowAllTrips->amChecked() == TRUE) {
4307
        myDemandViewOptions.menuCheckShowAllTrips->setChecked(FALSE);
4308
    } else {
4309
        myDemandViewOptions.menuCheckShowAllTrips->setChecked(TRUE);
4310
    }
4311
    myDemandViewOptions.menuCheckShowAllTrips->update();
4312
    // Only update view
4313
    updateViewNet();
4314
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4315
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS)) {
4316
        myDemandViewOptions.menuCheckShowAllTrips->setFocus();
4317
    }
4318
    return 1;
4319
}
4320

4321

4322
long
4323
GNEViewNet::onCmdToggleShowAllPersonPlans(FXObject*, FXSelector sel, void*) {
4324
    // Toggle menuCheckShowAllPersonPlans
4325
    if (myDemandViewOptions.menuCheckShowAllPersonPlans->amChecked() == TRUE) {
4326
        myDemandViewOptions.menuCheckShowAllPersonPlans->setChecked(FALSE);
4327
    } else {
4328
        myDemandViewOptions.menuCheckShowAllPersonPlans->setChecked(TRUE);
4329
    }
4330
    myDemandViewOptions.menuCheckShowAllPersonPlans->update();
4331
    // Only update view
4332
    updateViewNet();
4333
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4334
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS)) {
4335
        myDemandViewOptions.menuCheckShowAllPersonPlans->setFocus();
4336
    }
4337
    return 1;
4338
}
4339

4340

4341
long
4342
GNEViewNet::onCmdToggleLockPerson(FXObject*, FXSelector sel, void*) {
4343
    // Toggle menuCheckLockPerson
4344
    if (myDemandViewOptions.menuCheckLockPerson->amChecked() == TRUE) {
4345
        myDemandViewOptions.menuCheckLockPerson->setChecked(FALSE);
4346
    } else if (myInspectedElements.getFirstAC() && myInspectedElements.getFirstAC()->getTagProperty()->isPerson()) {
4347
        myDemandViewOptions.menuCheckLockPerson->setChecked(TRUE);
4348
    }
4349
    myDemandViewOptions.menuCheckLockPerson->update();
4350
    // lock or unlock current inspected person depending of menuCheckLockPerson value
4351
    if (myDemandViewOptions.menuCheckLockPerson->amChecked()) {
4352
        // obtain locked person or person plan
4353
        const GNEDemandElement* personOrPersonPlan = dynamic_cast<const GNEDemandElement*>(myInspectedElements.getFirstAC());
4354
        if (personOrPersonPlan) {
4355
            // lock person depending if casted demand element is either a person or a person plan
4356
            if (personOrPersonPlan->getTagProperty()->isPerson()) {
4357
                myDemandViewOptions.lockPerson(personOrPersonPlan);
4358
            } else {
4359
                myDemandViewOptions.lockPerson(personOrPersonPlan->getParentDemandElements().front());
4360
            }
4361
        }
4362
    } else {
4363
        // unlock current person
4364
        myDemandViewOptions.unlockPerson();
4365
    }
4366
    // update view
4367
    updateViewNet();
4368
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4369
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON)) {
4370
        myDemandViewOptions.menuCheckLockPerson->setFocus();
4371
    }
4372
    return 1;
4373
}
4374

4375

4376
long
4377
GNEViewNet::onCmdToggleShowAllContainerPlans(FXObject*, FXSelector sel, void*) {
4378
    // Toggle menuCheckShowAllContainerPlans
4379
    if (myDemandViewOptions.menuCheckShowAllContainerPlans->amChecked() == TRUE) {
4380
        myDemandViewOptions.menuCheckShowAllContainerPlans->setChecked(FALSE);
4381
    } else {
4382
        myDemandViewOptions.menuCheckShowAllContainerPlans->setChecked(TRUE);
4383
    }
4384
    myDemandViewOptions.menuCheckShowAllContainerPlans->update();
4385
    // Only update view
4386
    updateViewNet();
4387
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4388
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS)) {
4389
        myDemandViewOptions.menuCheckShowAllContainerPlans->setFocus();
4390
    }
4391
    return 1;
4392
}
4393

4394

4395
long
4396
GNEViewNet::onCmdToggleLockContainer(FXObject*, FXSelector sel, void*) {
4397
    // Toggle menuCheckLockContainer
4398
    if (myDemandViewOptions.menuCheckLockContainer->amChecked() == TRUE) {
4399
        myDemandViewOptions.menuCheckLockContainer->setChecked(FALSE);
4400
    } else if (myInspectedElements.getFirstAC() && myInspectedElements.getFirstAC()->getTagProperty()->isContainer()) {
4401
        myDemandViewOptions.menuCheckLockContainer->setChecked(TRUE);
4402
    }
4403
    myDemandViewOptions.menuCheckLockContainer->update();
4404
    // lock or unlock current inspected container depending of menuCheckLockContainer value
4405
    if (myDemandViewOptions.menuCheckLockContainer->amChecked()) {
4406
        // obtain locked container or container plan
4407
        const GNEDemandElement* containerOrContainerPlan = dynamic_cast<const GNEDemandElement*>(myInspectedElements.getFirstAC());
4408
        if (containerOrContainerPlan) {
4409
            // lock container depending if casted demand element is either a container or a container plan
4410
            if (containerOrContainerPlan->getTagProperty()->isContainer()) {
4411
                myDemandViewOptions.lockContainer(containerOrContainerPlan);
4412
            } else {
4413
                myDemandViewOptions.lockContainer(containerOrContainerPlan->getParentDemandElements().front());
4414
            }
4415
        }
4416
    } else {
4417
        // unlock current container
4418
        myDemandViewOptions.unlockContainer();
4419
    }
4420
    // update view
4421
    updateViewNet();
4422
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4423
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER)) {
4424
        myDemandViewOptions.menuCheckLockContainer->setFocus();
4425
    }
4426
    return 1;
4427
}
4428

4429

4430
long
4431
GNEViewNet::onCmdToggleShowAdditionals(FXObject*, FXSelector sel, void*) {
4432
    // Toggle menuCheckShowAdditionals
4433
    if (myDataViewOptions.menuCheckShowAdditionals->amChecked() == TRUE) {
4434
        myDataViewOptions.menuCheckShowAdditionals->setChecked(FALSE);
4435
    } else {
4436
        myDataViewOptions.menuCheckShowAdditionals->setChecked(TRUE);
4437
    }
4438
    myDataViewOptions.menuCheckShowAdditionals->update();
4439
    // Only update view
4440
    updateViewNet();
4441
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4442
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS)) {
4443
        myDataViewOptions.menuCheckShowAdditionals->setFocus();
4444
    }
4445
    return 1;
4446
}
4447

4448

4449
long
4450
GNEViewNet::onCmdToggleShowShapes(FXObject*, FXSelector sel, void*) {
4451
    // Toggle menuCheckShowShapes
4452
    if (myDataViewOptions.menuCheckShowShapes->amChecked() == TRUE) {
4453
        myDataViewOptions.menuCheckShowShapes->setChecked(FALSE);
4454
    } else {
4455
        myDataViewOptions.menuCheckShowShapes->setChecked(TRUE);
4456
    }
4457
    myDataViewOptions.menuCheckShowShapes->update();
4458
    // Only update view
4459
    updateViewNet();
4460
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4461
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES)) {
4462
        myDataViewOptions.menuCheckShowShapes->setFocus();
4463
    }
4464
    return 1;
4465
}
4466

4467

4468
long
4469
GNEViewNet::onCmdToggleShowDemandElementsNetwork(FXObject*, FXSelector sel, void*) {
4470
    // Toggle menuCheckShowDemandElements
4471
    if (myNetworkViewOptions.menuCheckShowDemandElements->amChecked() == TRUE) {
4472
        myNetworkViewOptions.menuCheckShowDemandElements->setChecked(FALSE);
4473
    } else {
4474
        myNetworkViewOptions.menuCheckShowDemandElements->setChecked(TRUE);
4475
    }
4476
    myNetworkViewOptions.menuCheckShowDemandElements->update();
4477
    // compute demand elements
4478
    myNet->computeDemandElements(myViewParent->getGNEAppWindows());
4479
    // update view to show demand elements
4480
    updateViewNet();
4481
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4482
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS)) {
4483
        myNetworkViewOptions.menuCheckShowDemandElements->setFocus();
4484
    }
4485
    return 1;
4486
}
4487

4488

4489
long
4490
GNEViewNet::onCmdToggleShowDemandElementsData(FXObject*, FXSelector sel, void*) {
4491
    // Toggle menuCheckShowDemandElements
4492
    if (myDataViewOptions.menuCheckShowDemandElements->amChecked() == TRUE) {
4493
        myDataViewOptions.menuCheckShowDemandElements->setChecked(FALSE);
4494
    } else {
4495
        myDataViewOptions.menuCheckShowDemandElements->setChecked(TRUE);
4496
    }
4497
    myDataViewOptions.menuCheckShowDemandElements->update();
4498
    // compute demand elements
4499
    myNet->computeDemandElements(myViewParent->getGNEAppWindows());
4500
    // update view to show demand elements
4501
    updateViewNet();
4502
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4503
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS)) {
4504
        myDataViewOptions.menuCheckShowDemandElements->setFocus();
4505
    }
4506
    return 1;
4507
}
4508

4509

4510
long
4511
GNEViewNet::onCmdToggleTAZRelDrawing(FXObject*, FXSelector sel, void*) {
4512
    // Toggle menuCheckShowDemandElements
4513
    if (myDataViewOptions.menuCheckToggleTAZRelDrawing->amChecked() == TRUE) {
4514
        myDataViewOptions.menuCheckToggleTAZRelDrawing->setChecked(FALSE);
4515
    } else {
4516
        myDataViewOptions.menuCheckToggleTAZRelDrawing->setChecked(TRUE);
4517
    }
4518
    myDataViewOptions.menuCheckToggleTAZRelDrawing->update();
4519
    // update view to show demand elements
4520
    updateViewNet();
4521
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4522
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING)) {
4523
        myDataViewOptions.menuCheckToggleTAZRelDrawing->setFocus();
4524
    }
4525
    return 1;
4526
}
4527

4528

4529
long
4530
GNEViewNet::onCmdToggleTAZDrawFill(FXObject*, FXSelector sel, void*) {
4531
    // Toggle menuCheckShowDemandElements
4532
    if (myDataViewOptions.menuCheckToggleTAZDrawFill->amChecked() == TRUE) {
4533
        myDataViewOptions.menuCheckToggleTAZDrawFill->setChecked(FALSE);
4534
    } else {
4535
        myDataViewOptions.menuCheckToggleTAZDrawFill->setChecked(TRUE);
4536
    }
4537
    myDataViewOptions.menuCheckToggleTAZDrawFill->update();
4538
    // update view to show demand elements
4539
    updateViewNet();
4540
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4541
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL)) {
4542
        myDataViewOptions.menuCheckToggleTAZDrawFill->setFocus();
4543
    }
4544
    return 1;
4545
}
4546

4547

4548
long
4549
GNEViewNet::onCmdToggleTAZRelOnlyFrom(FXObject*, FXSelector sel, void*) {
4550
    // Toggle menuCheckShowDemandElements
4551
    if (myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->amChecked() == TRUE) {
4552
        myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setChecked(FALSE);
4553
    } else {
4554
        myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setChecked(TRUE);
4555
    }
4556
    myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->update();
4557
    // update view to show demand elements
4558
    updateViewNet();
4559
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4560
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM)) {
4561
        myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->setFocus();
4562
    }
4563
    return 1;
4564
}
4565

4566

4567
long
4568
GNEViewNet::onCmdToggleTAZRelOnlyTo(FXObject*, FXSelector sel, void*) {
4569
    // Toggle menuCheckShowDemandElements
4570
    if (myDataViewOptions.menuCheckToggleTAZRelOnlyTo->amChecked() == TRUE) {
4571
        myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setChecked(FALSE);
4572
    } else {
4573
        myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setChecked(TRUE);
4574
    }
4575
    myDataViewOptions.menuCheckToggleTAZRelOnlyTo->update();
4576
    // update view to show demand elements
4577
    updateViewNet();
4578
    // set focus in menu check again, if this function was called clicking over menu check instead using alt+<key number>
4579
    if (sel == FXSEL(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO)) {
4580
        myDataViewOptions.menuCheckToggleTAZRelOnlyTo->setFocus();
4581
    }
4582
    return 1;
4583
}
4584

4585

4586
long
4587
GNEViewNet::onCmdIntervalBarGenericDataType(FXObject*, FXSelector, void*) {
4588
    myIntervalBar.setGenericDataType();
4589
    return 1;
4590
}
4591

4592

4593
long
4594
GNEViewNet::onCmdIntervalBarDataSet(FXObject*, FXSelector, void*) {
4595
    myIntervalBar.setDataSet();
4596
    return 1;
4597
}
4598

4599

4600
long
4601
GNEViewNet::onCmdIntervalBarLimit(FXObject*, FXSelector, void*) {
4602
    myIntervalBar.setInterval();
4603
    return 1;
4604
}
4605

4606

4607
long
4608
GNEViewNet::onCmdIntervalBarSetBegin(FXObject*, FXSelector, void*) {
4609
    myIntervalBar.setBegin();
4610
    return 1;
4611
}
4612

4613

4614
long
4615
GNEViewNet::onCmdIntervalBarSetEnd(FXObject*, FXSelector, void*) {
4616
    myIntervalBar.setEnd();
4617
    return 1;
4618
}
4619

4620

4621
long
4622
GNEViewNet::onCmdIntervalBarSetParameter(FXObject*, FXSelector, void*) {
4623
    myIntervalBar.setParameter();
4624
    return 1;
4625
}
4626

4627

4628
long
4629
GNEViewNet::onCmdAddSelected(FXObject*, FXSelector, void*) {
4630
    // only select if AC under cursor isn't previously selected
4631
    auto AC = myViewObjectsSelector.getAttributeCarrierFront();
4632
    if (AC && !AC->isAttributeCarrierSelected()) {
4633
        AC->selectAttributeCarrier();
4634
    }
4635
    return 1;
4636
}
4637

4638

4639
long
4640
GNEViewNet::onCmdRemoveSelected(FXObject*, FXSelector, void*) {
4641
    // only unselect if AC under cursor isn't previously selected
4642
    auto AC = myViewObjectsSelector.getAttributeCarrierFront();
4643
    if (AC && AC->isAttributeCarrierSelected()) {
4644
        AC->unselectAttributeCarrier();
4645
    }
4646
    return 1;
4647
}
4648

4649

4650
long
4651
GNEViewNet::onCmdAddEdgeSelected(FXObject*, FXSelector, void*) {
4652
    // only select if edge under cursor isn't previously selected
4653
    auto edge = myViewObjectsSelector.getEdgeFront();
4654
    if (edge && !edge->isAttributeCarrierSelected()) {
4655
        edge->selectAttributeCarrier();
4656
    }
4657
    return 1;
4658
}
4659

4660

4661
long
4662
GNEViewNet::onCmdRemoveEdgeSelected(FXObject*, FXSelector, void*) {
4663
    // only unselect if edge under cursor isn't previously selected
4664
    auto edge = myViewObjectsSelector.getEdgeFront();
4665
    if (edge && edge->isAttributeCarrierSelected()) {
4666
        edge->unselectAttributeCarrier();
4667
    }
4668
    return 1;
4669
}
4670

4671

4672
long
4673
GNEViewNet::onCmdSetNeteditView(FXObject*, FXSelector sel, void*) {
4674
    myEditModes.setView(FXSELID(sel));
4675
    update();
4676
    return 1;
4677
}
4678

4679
// ===========================================================================
4680
// private
4681
// ===========================================================================
4682

4683
void
4684
GNEViewNet::buildEditModeControls() {
4685
    // build supermode buttons
4686
    myEditModes.buildSuperModeButtons();
4687

4688
    // build save elements buttons
4689
    mySaveElements.buildSaveElementsButtons();
4690

4691
    // build time switch buttons
4692
    myTimeFormat.buildTimeFormatButtons();
4693

4694
    // build menu checks for Common checkable buttons
4695
    myCommonCheckableButtons.buildCommonCheckableButtons();
4696

4697
    // build menu checks for Network checkable buttons
4698
    myNetworkCheckableButtons.buildNetworkCheckableButtons();
4699

4700
    // build menu checks for Demand checkable buttons
4701
    myDemandCheckableButtons.buildDemandCheckableButtons();
4702

4703
    // build menu checks of view options Data
4704
    myDataCheckableButtons.buildDataCheckableButtons();
4705

4706
    // Create Vertical separator
4707
    new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4708
    // XXX for some reason the vertical groove is not visible. adding more spacing to emphasize the separation
4709
    new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4710
    new FXVerticalSeparator(myViewParent->getGNEAppWindows()->getToolbarsGrip().modes, GUIDesignVerticalSeparator);
4711

4712
    // build menu checks of view options Network
4713
    myNetworkViewOptions.buildNetworkViewOptionsMenuChecks();
4714

4715
    // build menu checks of view options Demand
4716
    myDemandViewOptions.buildDemandViewOptionsMenuChecks();
4717

4718
    // build menu checks of view options Data
4719
    myDataViewOptions.buildDataViewOptionsMenuChecks();
4720

4721
    // build interval bar
4722
    myIntervalBar.buildIntervalBarElements();
4723
}
4724

4725

4726
void
4727
GNEViewNet::updateNetworkModeSpecificControls() {
4728
    // get menu checks
4729
    auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions;
4730
    // hide all checkbox of view options Network
4731
    myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
4732
    // hide all checkbox of view options Demand
4733
    myDemandViewOptions.hideDemandViewOptionsMenuChecks();
4734
    // hide all checkbox of view options Data
4735
    myDataViewOptions.hideDataViewOptionsMenuChecks();
4736
    // disable all common edit modes
4737
    myCommonCheckableButtons.disableCommonCheckableButtons();
4738
    // disable all network edit modes
4739
    myNetworkCheckableButtons.disableNetworkCheckableButtons();
4740
    // disable all network edit modes
4741
    myDataCheckableButtons.disableDataCheckableButtons();
4742
    // hide interval bar
4743
    myIntervalBar.hideIntervalBar();
4744
    // hide all frames
4745
    myViewParent->hideAllFrames();
4746
    // hide all menuchecks
4747
    myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
4748
    myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
4749
    myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
4750
    // In network mode, always show option "show grid", "draw spread vehicles" and "show demand elements"
4751
    myNetworkViewOptions.menuCheckToggleGrid->show();
4752
    myNetworkViewOptions.menuCheckToggleDrawJunctionShape->show();
4753
    myNetworkViewOptions.menuCheckDrawSpreadVehicles->show();
4754
    myNetworkViewOptions.menuCheckShowDemandElements->show();
4755
    menuChecks.menuCheckToggleGrid->show();
4756
    menuChecks.menuCheckToggleDrawJunctionShape->show();
4757
    menuChecks.menuCheckDrawSpreadVehicles->show();
4758
    menuChecks.menuCheckShowDemandElements->show();
4759
    // show separator
4760
    menuChecks.separator->show();
4761
    // enable selected controls
4762
    switch (myEditModes.networkEditMode) {
4763
        // common modes
4764
        case NetworkEditMode::NETWORK_INSPECT:
4765
            myViewParent->getInspectorFrame()->show();
4766
            myViewParent->getInspectorFrame()->focusUpperElement();
4767
            myCurrentFrame = myViewParent->getInspectorFrame();
4768
            myCommonCheckableButtons.inspectButton->setChecked(true);
4769
            // show view options
4770
            myNetworkViewOptions.menuCheckSelectEdges->show();
4771
            myNetworkViewOptions.menuCheckShowConnections->show();
4772
            myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4773
            myNetworkViewOptions.menuCheckShowTAZElements->show();
4774
            myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4775
            // show menu checks
4776
            menuChecks.menuCheckSelectEdges->show();
4777
            menuChecks.menuCheckShowConnections->show();
4778
            menuChecks.menuCheckShowAdditionalSubElements->show();
4779
            menuChecks.menuCheckShowTAZElements->show();
4780
            menuChecks.menuCheckShowJunctionBubble->show();
4781
            // update lock menu bar
4782
            myLockManager.updateLockMenuBar();
4783
            // show
4784
            break;
4785
        case NetworkEditMode::NETWORK_DELETE:
4786
            myViewParent->getDeleteFrame()->show();
4787
            myViewParent->getDeleteFrame()->focusUpperElement();
4788
            myCurrentFrame = myViewParent->getDeleteFrame();
4789
            myCommonCheckableButtons.deleteButton->setChecked(true);
4790
            myNetworkViewOptions.menuCheckShowConnections->show();
4791
            myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4792
            myNetworkViewOptions.menuCheckShowTAZElements->show();
4793
            myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4794
            // show view options
4795
            myNetworkViewOptions.menuCheckSelectEdges->show();
4796
            myNetworkViewOptions.menuCheckShowConnections->show();
4797
            menuChecks.menuCheckShowAdditionalSubElements->show();
4798
            menuChecks.menuCheckShowTAZElements->show();
4799
            menuChecks.menuCheckShowJunctionBubble->show();
4800
            // show menu checks
4801
            menuChecks.menuCheckSelectEdges->show();
4802
            menuChecks.menuCheckShowConnections->show();
4803
            break;
4804
        case NetworkEditMode::NETWORK_SELECT:
4805
            myViewParent->getSelectorFrame()->show();
4806
            myViewParent->getSelectorFrame()->focusUpperElement();
4807
            myCurrentFrame = myViewParent->getSelectorFrame();
4808
            myCommonCheckableButtons.selectButton->setChecked(true);
4809
            // show view options
4810
            myNetworkViewOptions.menuCheckSelectEdges->show();
4811
            myNetworkViewOptions.menuCheckShowConnections->show();
4812
            myNetworkViewOptions.menuCheckExtendSelection->show();
4813
            myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4814
            myNetworkViewOptions.menuCheckShowTAZElements->show();
4815
            myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4816
            // show menu checks
4817
            menuChecks.menuCheckSelectEdges->show();
4818
            menuChecks.menuCheckShowConnections->show();
4819
            menuChecks.menuCheckExtendSelection->show();
4820
            menuChecks.menuCheckShowAdditionalSubElements->show();
4821
            menuChecks.menuCheckShowTAZElements->show();
4822
            menuChecks.menuCheckShowJunctionBubble->show();
4823
            break;
4824
        // specific modes
4825
        case NetworkEditMode::NETWORK_CREATE_EDGE:
4826
            myViewParent->getCreateEdgeFrame()->show();
4827
            myViewParent->getCreateEdgeFrame()->focusUpperElement();
4828
            myCurrentFrame = myViewParent->getCreateEdgeFrame();
4829
            myNetworkCheckableButtons.createEdgeButton->setChecked(true);
4830
            // show view options
4831
            myNetworkViewOptions.menuCheckChainEdges->show();
4832
            myNetworkViewOptions.menuCheckAutoOppositeEdge->show();
4833
            myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4834
            // show menu checks
4835
            menuChecks.menuCheckChainEdges->show();
4836
            menuChecks.menuCheckAutoOppositeEdge->show();
4837
            menuChecks.menuCheckShowJunctionBubble->show();
4838
            break;
4839
        case NetworkEditMode::NETWORK_MOVE:
4840
            myViewParent->getMoveFrame()->show();
4841
            myViewParent->getMoveFrame()->focusUpperElement();
4842
            myCurrentFrame = myViewParent->getMoveFrame();
4843
            myNetworkCheckableButtons.moveNetworkElementsButton->setChecked(true);
4844
            // show view options
4845
            myNetworkViewOptions.menuCheckMergeAutomatically->show();
4846
            myNetworkViewOptions.menuCheckShowJunctionBubble->show();
4847
            myNetworkViewOptions.menuCheckMoveElevation->show();
4848
            // show menu checks
4849
            menuChecks.menuCheckMergeAutomatically->show();
4850
            menuChecks.menuCheckShowJunctionBubble->show();
4851
            menuChecks.menuCheckMoveElevation->show();
4852
            break;
4853
        case NetworkEditMode::NETWORK_CONNECT:
4854
            myViewParent->getConnectorFrame()->show();
4855
            myViewParent->getConnectorFrame()->focusUpperElement();
4856
            myCurrentFrame = myViewParent->getConnectorFrame();
4857
            myNetworkCheckableButtons.connectionButton->setChecked(true);
4858
            break;
4859
        case NetworkEditMode::NETWORK_TLS:
4860
            myViewParent->getTLSEditorFrame()->show();
4861
            myViewParent->getTLSEditorFrame()->focusUpperElement();
4862
            myCurrentFrame = myViewParent->getTLSEditorFrame();
4863
            myNetworkCheckableButtons.trafficLightButton->setChecked(true);
4864
            // show view options
4865
            myNetworkViewOptions.menuCheckChangeAllPhases->show();
4866
            // show menu checks
4867
            menuChecks.menuCheckChangeAllPhases->show();
4868
            break;
4869
        case NetworkEditMode::NETWORK_ADDITIONAL:
4870
            myViewParent->getAdditionalFrame()->show();
4871
            myViewParent->getAdditionalFrame()->focusUpperElement();
4872
            myCurrentFrame = myViewParent->getAdditionalFrame();
4873
            myNetworkCheckableButtons.additionalButton->setChecked(true);
4874
            // show view options
4875
            myNetworkViewOptions.menuCheckShowAdditionalSubElements->show();
4876
            // show menu checks
4877
            menuChecks.menuCheckShowAdditionalSubElements->show();
4878
            break;
4879
        case NetworkEditMode::NETWORK_CROSSING:
4880
            myViewParent->getCrossingFrame()->show();
4881
            myViewParent->getCrossingFrame()->focusUpperElement();
4882
            myCurrentFrame = myViewParent->getCrossingFrame();
4883
            myNetworkCheckableButtons.crossingButton->setChecked(true);
4884
            break;
4885
        case NetworkEditMode::NETWORK_TAZ:
4886
            myViewParent->getTAZFrame()->show();
4887
            myViewParent->getTAZFrame()->focusUpperElement();
4888
            myCurrentFrame = myViewParent->getTAZFrame();
4889
            myNetworkCheckableButtons.TAZButton->setChecked(true);
4890
            break;
4891
        case NetworkEditMode::NETWORK_SHAPE:
4892
            myViewParent->getShapeFrame()->show();
4893
            myViewParent->getShapeFrame()->focusUpperElement();
4894
            myCurrentFrame = myViewParent->getShapeFrame();
4895
            myNetworkCheckableButtons.shapeButton->setChecked(true);
4896
            break;
4897
        case NetworkEditMode::NETWORK_PROHIBITION:
4898
            myViewParent->getProhibitionFrame()->show();
4899
            myViewParent->getProhibitionFrame()->focusUpperElement();
4900
            myCurrentFrame = myViewParent->getProhibitionFrame();
4901
            myNetworkCheckableButtons.prohibitionButton->setChecked(true);
4902
            break;
4903
        case NetworkEditMode::NETWORK_WIRE:
4904
            myViewParent->getWireFrame()->show();
4905
            myViewParent->getWireFrame()->focusUpperElement();
4906
            myCurrentFrame = myViewParent->getWireFrame();
4907
            myNetworkCheckableButtons.wireButton->setChecked(true);
4908
            break;
4909
        case NetworkEditMode::NETWORK_DECAL:
4910
            myViewParent->getDecalFrame()->show();
4911
            myViewParent->getDecalFrame()->focusUpperElement();
4912
            myCurrentFrame = myViewParent->getDecalFrame();
4913
            myNetworkCheckableButtons.decalButton->setChecked(true);
4914
            break;
4915
        default:
4916
            break;
4917
    }
4918
    // update menuChecks shorcuts
4919
    menuChecks.updateShortcuts();
4920
    // update common Network buttons
4921
    myCommonCheckableButtons.updateCommonCheckableButtons();
4922
    // Update Network buttons
4923
    myNetworkCheckableButtons.updateNetworkCheckableButtons();
4924
    // recalc toolbar
4925
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
4926
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
4927
    // force repaint because different modes draw different things
4928
    onPaint(nullptr, 0, nullptr);
4929
    // finally update view
4930
    updateViewNet();
4931
}
4932

4933

4934
void
4935
GNEViewNet::updateDemandModeSpecificControls() {
4936
    // get menu checks
4937
    auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions;
4938
    // hide all checkbox of view options Network
4939
    myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
4940
    // hide all checkbox of view options Demand
4941
    myDemandViewOptions.hideDemandViewOptionsMenuChecks();
4942
    // hide all checkbox of view options Data
4943
    myDataViewOptions.hideDataViewOptionsMenuChecks();
4944
    // disable all common edit modes
4945
    myCommonCheckableButtons.disableCommonCheckableButtons();
4946
    // disable all Demand edit modes
4947
    myDemandCheckableButtons.disableDemandCheckableButtons();
4948
    // disable all network edit modes
4949
    myDataCheckableButtons.disableDataCheckableButtons();
4950
    // hide interval bar
4951
    myIntervalBar.hideIntervalBar();
4952
    // hide all frames
4953
    myViewParent->hideAllFrames();
4954
    // hide all menuchecks
4955
    myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
4956
    myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
4957
    myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
4958
    // always show "hide shapes", "show grid", "draw spread vehicles", "show overlapped routes" and show/lock persons and containers
4959
    myDemandViewOptions.menuCheckToggleGrid->show();
4960
    myDemandViewOptions.menuCheckToggleDrawJunctionShape->show();
4961
    myDemandViewOptions.menuCheckDrawSpreadVehicles->show();
4962
    myDemandViewOptions.menuCheckHideShapes->show();
4963
    myDemandViewOptions.menuCheckShowAllTrips->show();
4964
    myDemandViewOptions.menuCheckShowAllPersonPlans->show();
4965
    myDemandViewOptions.menuCheckLockPerson->show();
4966
    myDemandViewOptions.menuCheckShowAllContainerPlans->show();
4967
    myDemandViewOptions.menuCheckLockContainer->show();
4968
    myDemandViewOptions.menuCheckShowOverlappedRoutes->show();
4969
    menuChecks.menuCheckToggleGrid->show();
4970
    menuChecks.menuCheckToggleDrawJunctionShape->show();
4971
    menuChecks.menuCheckDrawSpreadVehicles->show();
4972
    menuChecks.menuCheckHideShapes->show();
4973
    menuChecks.menuCheckShowAllTrips->show();
4974
    menuChecks.menuCheckShowAllPersonPlans->show();
4975
    menuChecks.menuCheckLockPerson->show();
4976
    menuChecks.menuCheckShowAllContainerPlans->show();
4977
    menuChecks.menuCheckLockContainer->show();
4978
    menuChecks.menuCheckShowOverlappedRoutes->show();
4979
    // show separator
4980
    menuChecks.separator->show();
4981
    // enable selected controls
4982
    switch (myEditModes.demandEditMode) {
4983
        // common modes
4984
        case DemandEditMode::DEMAND_INSPECT:
4985
            myViewParent->getInspectorFrame()->show();
4986
            myViewParent->getInspectorFrame()->focusUpperElement();
4987
            myCurrentFrame = myViewParent->getInspectorFrame();
4988
            // set checkable button
4989
            myCommonCheckableButtons.inspectButton->setChecked(true);
4990
            // show view options
4991
            myDemandViewOptions.menuCheckHideNonInspectedDemandElements->show();
4992
            // show menu checks
4993
            menuChecks.menuCheckHideNonInspectedDemandElements->show();
4994
            break;
4995
        case DemandEditMode::DEMAND_DELETE:
4996
            myViewParent->getDeleteFrame()->show();
4997
            myViewParent->getDeleteFrame()->focusUpperElement();
4998
            myCurrentFrame = myViewParent->getDeleteFrame();
4999
            // set checkable button
5000
            myCommonCheckableButtons.deleteButton->setChecked(true);
5001
            break;
5002
        case DemandEditMode::DEMAND_SELECT:
5003
            myViewParent->getSelectorFrame()->show();
5004
            myViewParent->getSelectorFrame()->focusUpperElement();
5005
            myCurrentFrame = myViewParent->getSelectorFrame();
5006
            // set checkable button
5007
            myCommonCheckableButtons.selectButton->setChecked(true);
5008
            break;
5009
        case DemandEditMode::DEMAND_MOVE:
5010
            myViewParent->getMoveFrame()->show();
5011
            myViewParent->getMoveFrame()->focusUpperElement();
5012
            myCurrentFrame = myViewParent->getMoveFrame();
5013
            // set checkable button
5014
            myDemandCheckableButtons.moveDemandElementsButton->setChecked(true);
5015
            break;
5016
        // specific modes
5017
        case DemandEditMode::DEMAND_ROUTE:
5018
            myViewParent->getRouteFrame()->show();
5019
            myViewParent->getRouteFrame()->focusUpperElement();
5020
            myCurrentFrame = myViewParent->getRouteFrame();
5021
            // set checkable button
5022
            myDemandCheckableButtons.routeButton->setChecked(true);
5023
            break;
5024
        case DemandEditMode::DEMAND_ROUTEDISTRIBUTION:
5025
            myViewParent->getRouteDistributionFrame()->show();
5026
            myViewParent->getRouteDistributionFrame()->focusUpperElement();
5027
            myCurrentFrame = myViewParent->getRouteDistributionFrame();
5028
            // set checkable button
5029
            myDemandCheckableButtons.routeDistributionButton->setChecked(true);
5030
            break;
5031
        case DemandEditMode::DEMAND_VEHICLE:
5032
            myViewParent->getVehicleFrame()->show();
5033
            myViewParent->getVehicleFrame()->focusUpperElement();
5034
            myCurrentFrame = myViewParent->getVehicleFrame();
5035
            // set checkable button
5036
            myDemandCheckableButtons.vehicleButton->setChecked(true);
5037
            break;
5038
        case DemandEditMode::DEMAND_TYPE:
5039
            myViewParent->getTypeFrame()->show();
5040
            myViewParent->getTypeFrame()->focusUpperElement();
5041
            myCurrentFrame = myViewParent->getTypeFrame();
5042
            // set checkable button
5043
            myDemandCheckableButtons.typeButton->setChecked(true);
5044
            break;
5045
        case DemandEditMode::DEMAND_TYPEDISTRIBUTION:
5046
            myViewParent->getTypeDistributionFrame()->show();
5047
            myViewParent->getTypeDistributionFrame()->focusUpperElement();
5048
            myCurrentFrame = myViewParent->getTypeDistributionFrame();
5049
            // set checkable button
5050
            myDemandCheckableButtons.typeDistributionButton->setChecked(true);
5051
            break;
5052
        case DemandEditMode::DEMAND_STOP:
5053
            myViewParent->getStopFrame()->show();
5054
            myViewParent->getStopFrame()->focusUpperElement();
5055
            myCurrentFrame = myViewParent->getStopFrame();
5056
            // set checkable button
5057
            myDemandCheckableButtons.stopButton->setChecked(true);
5058
            break;
5059
        case DemandEditMode::DEMAND_PERSON:
5060
            myViewParent->getPersonFrame()->show();
5061
            myViewParent->getPersonFrame()->focusUpperElement();
5062
            myCurrentFrame = myViewParent->getPersonFrame();
5063
            // set checkable button
5064
            myDemandCheckableButtons.personButton->setChecked(true);
5065
            break;
5066
        case DemandEditMode::DEMAND_PERSONPLAN:
5067
            myViewParent->getPersonPlanFrame()->show();
5068
            myViewParent->getPersonPlanFrame()->focusUpperElement();
5069
            myCurrentFrame = myViewParent->getPersonPlanFrame();
5070
            // set checkable button
5071
            myDemandCheckableButtons.personPlanButton->setChecked(true);
5072
            break;
5073
        case DemandEditMode::DEMAND_CONTAINER:
5074
            myViewParent->getContainerFrame()->show();
5075
            myViewParent->getContainerFrame()->focusUpperElement();
5076
            myCurrentFrame = myViewParent->getContainerFrame();
5077
            // set checkable button
5078
            myDemandCheckableButtons.containerButton->setChecked(true);
5079
            break;
5080
        case DemandEditMode::DEMAND_CONTAINERPLAN:
5081
            myViewParent->getContainerPlanFrame()->show();
5082
            myViewParent->getContainerPlanFrame()->focusUpperElement();
5083
            myCurrentFrame = myViewParent->getContainerPlanFrame();
5084
            // set checkable button
5085
            myDemandCheckableButtons.containerPlanButton->setChecked(true);
5086
            break;
5087
        default:
5088
            break;
5089
    }
5090
    // update menuChecks shorcuts
5091
    menuChecks.updateShortcuts();
5092
    // update common Network buttons
5093
    myCommonCheckableButtons.updateCommonCheckableButtons();
5094
    // Update Demand buttons
5095
    myDemandCheckableButtons.updateDemandCheckableButtons();
5096
    // recalc toolbar
5097
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
5098
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
5099
    // force repaint because different modes draw different things
5100
    onPaint(nullptr, 0, nullptr);
5101
    // finally update view
5102
    updateViewNet();
5103
}
5104

5105

5106
void
5107
GNEViewNet::updateDataModeSpecificControls() {
5108
    // get menu checks
5109
    auto& menuChecks = myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions;
5110
    // hide all checkbox of view options Network
5111
    myNetworkViewOptions.hideNetworkViewOptionsMenuChecks();
5112
    // hide all checkbox of view options Demand
5113
    myDemandViewOptions.hideDemandViewOptionsMenuChecks();
5114
    // hide all checkbox of view options Data
5115
    myDataViewOptions.hideDataViewOptionsMenuChecks();
5116
    // disable all common edit modes
5117
    myCommonCheckableButtons.disableCommonCheckableButtons();
5118
    // disable all Data edit modes
5119
    myDataCheckableButtons.disableDataCheckableButtons();
5120
    // show interval bar
5121
    myIntervalBar.showIntervalBar();
5122
    // hide all frames
5123
    myViewParent->hideAllFrames();
5124
    // hide all menuchecks
5125
    myViewParent->getGNEAppWindows()->getEditMenuCommands().networkViewOptions.hideNetworkViewOptionsMenuChecks();
5126
    myViewParent->getGNEAppWindows()->getEditMenuCommands().demandViewOptions.hideDemandViewOptionsMenuChecks();
5127
    myViewParent->getGNEAppWindows()->getEditMenuCommands().dataViewOptions.hideDataViewOptionsMenuChecks();
5128
    // In data mode, always show options for show elements
5129
    myDataViewOptions.menuCheckToggleDrawJunctionShape->show();
5130
    myDataViewOptions.menuCheckShowAdditionals->show();
5131
    myDataViewOptions.menuCheckShowShapes->show();
5132
    myDataViewOptions.menuCheckShowDemandElements->show();
5133
    menuChecks.menuCheckToggleDrawJunctionShape->show();
5134
    menuChecks.menuCheckShowAdditionals->show();
5135
    menuChecks.menuCheckShowShapes->show();
5136
    menuChecks.menuCheckShowDemandElements->show();
5137
    // show separator
5138
    menuChecks.separator->show();
5139
    // enable selected controls
5140
    switch (myEditModes.dataEditMode) {
5141
        // common modes
5142
        case DataEditMode::DATA_INSPECT:
5143
            myViewParent->getInspectorFrame()->show();
5144
            myViewParent->getInspectorFrame()->focusUpperElement();
5145
            myCurrentFrame = myViewParent->getInspectorFrame();
5146
            // set checkable button
5147
            myCommonCheckableButtons.inspectButton->setChecked(true);
5148
            // show view option
5149
            myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5150
            myDataViewOptions.menuCheckToggleTAZDrawFill->show();
5151
            myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5152
            myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5153
            // show menu check
5154
            menuChecks.menuCheckToggleTAZRelDrawing->show();
5155
            menuChecks.menuCheckToggleTAZDrawFill->show();
5156
            menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5157
            menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5158
            break;
5159
        case DataEditMode::DATA_DELETE:
5160
            myViewParent->getDeleteFrame()->show();
5161
            myViewParent->getDeleteFrame()->focusUpperElement();
5162
            myCurrentFrame = myViewParent->getDeleteFrame();
5163
            // set checkable button
5164
            myCommonCheckableButtons.deleteButton->setChecked(true);
5165
            // show toggle TAZRel drawing view option
5166
            myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5167
            myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5168
            myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5169
            // show toggle TAZRel drawing menu check
5170
            menuChecks.menuCheckToggleTAZRelDrawing->show();
5171
            menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5172
            menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5173
            break;
5174
        case DataEditMode::DATA_SELECT:
5175
            myViewParent->getSelectorFrame()->show();
5176
            myViewParent->getSelectorFrame()->focusUpperElement();
5177
            myCurrentFrame = myViewParent->getSelectorFrame();
5178
            // set checkable button
5179
            myCommonCheckableButtons.selectButton->setChecked(true);
5180
            // show toggle TAZRel drawing view option
5181
            myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5182
            myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5183
            myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5184
            // show toggle TAZRel drawing menu check
5185
            menuChecks.menuCheckToggleTAZRelDrawing->show();
5186
            menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5187
            menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5188
            break;
5189
        case DataEditMode::DATA_EDGEDATA:
5190
            myViewParent->getEdgeDataFrame()->show();
5191
            myViewParent->getEdgeDataFrame()->focusUpperElement();
5192
            myCurrentFrame = myViewParent->getEdgeDataFrame();
5193
            // set checkable button
5194
            myDataCheckableButtons.edgeDataButton->setChecked(true);
5195
            break;
5196
        case DataEditMode::DATA_EDGERELDATA:
5197
            myViewParent->getEdgeRelDataFrame()->show();
5198
            myViewParent->getEdgeRelDataFrame()->focusUpperElement();
5199
            myCurrentFrame = myViewParent->getEdgeRelDataFrame();
5200
            // set checkable button
5201
            myDataCheckableButtons.edgeRelDataButton->setChecked(true);
5202
            break;
5203
        case DataEditMode::DATA_TAZRELDATA:
5204
            myViewParent->getTAZRelDataFrame()->show();
5205
            myViewParent->getTAZRelDataFrame()->focusUpperElement();
5206
            myCurrentFrame = myViewParent->getTAZRelDataFrame();
5207
            // set checkable button
5208
            myDataCheckableButtons.TAZRelDataButton->setChecked(true);
5209
            // show view option
5210
            myDataViewOptions.menuCheckToggleTAZRelDrawing->show();
5211
            myDataViewOptions.menuCheckToggleTAZDrawFill->show();
5212
            myDataViewOptions.menuCheckToggleTAZRelOnlyFrom->show();
5213
            myDataViewOptions.menuCheckToggleTAZRelOnlyTo->show();
5214
            // show menu check
5215
            menuChecks.menuCheckToggleTAZRelDrawing->show();
5216
            menuChecks.menuCheckToggleTAZDrawFill->show();
5217
            menuChecks.menuCheckToggleTAZRelOnlyFrom->show();
5218
            menuChecks.menuCheckToggleTAZRelOnlyTo->show();
5219
            break;
5220
        case DataEditMode::DATA_MEANDATA:
5221
            myViewParent->getMeanDataFrame()->show();
5222
            myViewParent->getMeanDataFrame()->focusUpperElement();
5223
            myCurrentFrame = myViewParent->getMeanDataFrame();
5224
            // set checkable button
5225
            myDataCheckableButtons.meanDataButton->setChecked(true);
5226
            break;
5227
        default:
5228
            break;
5229
    }
5230
    // update menuChecks shorcuts
5231
    menuChecks.updateShortcuts();
5232
    // update common Network buttons
5233
    myCommonCheckableButtons.updateCommonCheckableButtons();
5234
    // Update Data buttons
5235
    myDataCheckableButtons.updateDataCheckableButtons();
5236
    // recalc toolbar
5237
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->recalc();
5238
    myViewParent->getGNEAppWindows()->getToolbarsGrip().modes->repaint();
5239
    // force repaint because different modes draw different things
5240
    onPaint(nullptr, 0, nullptr);
5241
    // finally update view
5242
    updateViewNet();
5243
}
5244

5245

5246
void
5247
GNEViewNet::deleteNetworkAttributeCarrier(const GNEAttributeCarrier* AC) {
5248
    if (AC->getTagProperty()->getTag() == SUMO_TAG_JUNCTION) {
5249
        // get junction (note: could be already removed if is a child, then hardfail=false)
5250
        GNEJunction* junction = myNet->getAttributeCarriers()->retrieveJunction(AC->getID(), false);
5251
        // if exist, remove it
5252
        if (junction) {
5253
            myNet->deleteJunction(junction, myUndoList);
5254
        }
5255
    } else if (AC->getTagProperty()->getTag() == SUMO_TAG_CROSSING) {
5256
        // get crossing (note: could be already removed if is a child, then hardfail=false)
5257
        GNECrossing* crossing = myNet->getAttributeCarriers()->retrieveCrossing(AC->getGUIGlObject(), false);
5258
        // if exist, remove it
5259
        if (crossing) {
5260
            myNet->deleteCrossing(crossing, myUndoList);
5261
        }
5262
    } else if (AC->getTagProperty()->getTag() == SUMO_TAG_EDGE) {
5263
        // get edge (note: could be already removed if is a child, then hardfail=false)
5264
        GNEEdge* edge = myNet->getAttributeCarriers()->retrieveEdge(AC->getID(), false);
5265
        // if exist, remove it
5266
        if (edge) {
5267
            myNet->deleteEdge(edge, myUndoList, false);
5268
        }
5269
    } else if (AC->getTagProperty()->getTag() == SUMO_TAG_LANE) {
5270
        // get lane (note: could be already removed if is a child, then hardfail=false)
5271
        GNELane* lane = myNet->getAttributeCarriers()->retrieveLane(AC->getGUIGlObject(), false);
5272
        // if exist, remove it
5273
        if (lane) {
5274
            myNet->deleteLane(lane, myUndoList, false);
5275
        }
5276
    } else if (AC->getTagProperty()->getTag() == SUMO_TAG_CONNECTION) {
5277
        // get connection (note: could be already removed if is a child, then hardfail=false)
5278
        GNEConnection* connection = myNet->getAttributeCarriers()->retrieveConnection(AC->getGUIGlObject(), false);
5279
        // if exist, remove it
5280
        if (connection) {
5281
            myNet->deleteConnection(connection, myUndoList);
5282
        }
5283
    } else if ((AC->getTagProperty()->getTag() == SUMO_TAG_TAZSOURCE) || (AC->getTagProperty()->getTag() == SUMO_TAG_TAZSINK)) {
5284
        // get TAZ SourceSink Element (note: could be already removed if is a child, then hardfail=false)
5285
        GNETAZSourceSink* TAZSourceSink = myNet->getAttributeCarriers()->retrieveTAZSourceSink(AC, false);
5286
        // if exist, remove it
5287
        if (TAZSourceSink) {
5288
            myNet->deleteTAZSourceSink(TAZSourceSink, myUndoList);
5289
        }
5290
    } else if (AC->getTagProperty()->isAdditionalElement()) {
5291
        // get additional Element (note: could be already removed if is a child, then hardfail=false)
5292
        GNEAdditional* additionalElement = myNet->getAttributeCarriers()->retrieveAdditional(AC->getGUIGlObject(), false);
5293
        // if exist, remove it
5294
        if (additionalElement) {
5295
            myNet->deleteAdditional(additionalElement, myUndoList);
5296
        }
5297
    }
5298
}
5299

5300

5301
void
5302
GNEViewNet::deleteDemandAttributeCarrier(const GNEAttributeCarrier* AC) {
5303
    // get demand Element (note: could be already removed if is a child, then hardfail=false)
5304
    GNEDemandElement* demandElement = myNet->getAttributeCarriers()->retrieveDemandElement(AC->getGUIGlObject(), false);
5305
    // if exist, remove it
5306
    if (demandElement) {
5307
        myNet->deleteDemandElement(demandElement, myUndoList);
5308
    }
5309
}
5310

5311

5312
void
5313
GNEViewNet::deleteDataAttributeCarrier(const GNEAttributeCarrier* AC) {
5314
    if (AC->getTagProperty()->getTag() == SUMO_TAG_DATASET) {
5315
        // get data set (note: could be already removed if is a child, then hardfail=false)
5316
        GNEDataSet* dataSet = myNet->getAttributeCarriers()->retrieveDataSet(AC->getID(), false);
5317
        // if exist, remove it
5318
        if (dataSet) {
5319
            myNet->deleteDataSet(dataSet, myUndoList);
5320
        }
5321
    } else if (AC->getTagProperty()->getTag() == SUMO_TAG_DATAINTERVAL) {
5322
        // get data interval (note: could be already removed if is a child, then hardfail=false)
5323
        GNEDataInterval* dataInterval = myNet->getAttributeCarriers()->retrieveDataInterval(AC, false);
5324
        // if exist, remove it
5325
        if (dataInterval) {
5326
            myNet->deleteDataInterval(dataInterval, myUndoList);
5327
        }
5328
    } else {
5329
        // get generic data (note: could be already removed if is a child, then hardfail=false)
5330
        GNEGenericData* genericData = myNet->getAttributeCarriers()->retrieveGenericData(AC->getGUIGlObject(), false);
5331
        // if exist, remove it
5332
        if (genericData) {
5333
            myNet->deleteGenericData(genericData, myUndoList);
5334
        }
5335
    }
5336
}
5337

5338

5339
void
5340
GNEViewNet::updateControls() {
5341
    if (myEditModes.isCurrentSupermodeNetwork()) {
5342
        switch (myEditModes.networkEditMode) {
5343
            case NetworkEditMode::NETWORK_INSPECT:
5344
                myViewParent->getInspectorFrame()->update();
5345
                break;
5346
            default:
5347
                break;
5348
        }
5349
    }
5350
    if (myEditModes.isCurrentSupermodeDemand()) {
5351
        switch (myEditModes.demandEditMode) {
5352
            case DemandEditMode::DEMAND_INSPECT:
5353
                myViewParent->getInspectorFrame()->update();
5354
                break;
5355
            case DemandEditMode::DEMAND_VEHICLE:
5356
                myViewParent->getVehicleFrame()->show();
5357
                break;
5358
            case DemandEditMode::DEMAND_TYPE:
5359
                myViewParent->getTypeFrame()->show();
5360
                break;
5361
            case DemandEditMode::DEMAND_TYPEDISTRIBUTION:
5362
                myViewParent->getTypeDistributionFrame()->getDistributionSelector()->refreshDistributionSelector();
5363
                break;
5364
            case DemandEditMode::DEMAND_ROUTEDISTRIBUTION:
5365
                myViewParent->getRouteDistributionFrame()->getDistributionSelector()->refreshDistributionSelector();
5366
                break;
5367
            case DemandEditMode::DEMAND_PERSON:
5368
                myViewParent->getPersonFrame()->show();
5369
                break;
5370
            case DemandEditMode::DEMAND_PERSONPLAN:
5371
                myViewParent->getPersonPlanFrame()->show();
5372
                break;
5373
            case DemandEditMode::DEMAND_CONTAINER:
5374
                myViewParent->getContainerFrame()->show();
5375
                break;
5376
            case DemandEditMode::DEMAND_CONTAINERPLAN:
5377
                myViewParent->getContainerPlanFrame()->show();
5378
                break;
5379
            case DemandEditMode::DEMAND_STOP:
5380
                myViewParent->getStopFrame()->show();
5381
                break;
5382
            default:
5383
                break;
5384
        }
5385
    }
5386
    if (myEditModes.isCurrentSupermodeData()) {
5387
        switch (myEditModes.dataEditMode) {
5388
            case DataEditMode::DATA_INSPECT:
5389
                myViewParent->getInspectorFrame()->update();
5390
                break;
5391
            default:
5392
                break;
5393
        }
5394
        // update data interval
5395
        myIntervalBar.markForUpdate();
5396
    }
5397
    // update view
5398
    updateViewNet();
5399
}
5400

5401
// ---------------------------------------------------------------------------
5402
// Private methods
5403
// ---------------------------------------------------------------------------
5404

5405
void
5406
GNEViewNet::drawTemporalDrawingShape() const {
5407
    PositionVector temporalShape;
5408
    bool deleteLastCreatedPoint = false;
5409
    // obtain temporal shape and delete last created point flag
5410
    if (myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
5411
        temporalShape = myViewParent->getShapeFrame()->getDrawingShapeModule()->getTemporalShape();
5412
        deleteLastCreatedPoint = myViewParent->getShapeFrame()->getDrawingShapeModule()->getDeleteLastCreatedPoint();
5413
    } else if (myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
5414
        temporalShape = myViewParent->getTAZFrame()->getDrawingShapeModule()->getTemporalShape();
5415
        deleteLastCreatedPoint = myViewParent->getTAZFrame()->getDrawingShapeModule()->getDeleteLastCreatedPoint();
5416
    }
5417
    // check if we're in drawing mode
5418
    if (temporalShape.size() > 0) {
5419
        // draw blue line with the current drawed shape
5420
        GLHelper::pushMatrix();
5421
        glLineWidth(2);
5422
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5423
        GLHelper::setColor(RGBColor::BLUE);
5424
        GLHelper::drawLine(temporalShape);
5425
        GLHelper::popMatrix();
5426
        // draw red line from the last point of shape to the current mouse position
5427
        GLHelper::pushMatrix();
5428
        glLineWidth(2);
5429
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5430
        // draw last line depending if shift key (delete last created point) is pressed
5431
        if (deleteLastCreatedPoint) {
5432
            GLHelper::setColor(RGBColor::RED);
5433
        } else {
5434
            GLHelper::setColor(RGBColor::GREEN);
5435
        }
5436
        GLHelper::drawLine(temporalShape.back(), snapToActiveGrid(getPositionInformation()));
5437
        GLHelper::popMatrix();
5438
    }
5439
}
5440

5441

5442
void
5443
GNEViewNet::drawTemporalJunction() const {
5444
    // first check if we're in correct mode
5445
    if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) &&
5446
            !myMouseButtonKeyPressed.controlKeyPressed() &&
5447
            !myMouseButtonKeyPressed.shiftKeyPressed() &&
5448
            !myMouseButtonKeyPressed.altKeyPressed()) {
5449
        // get mouse position
5450
        const Position mousePosition = snapToActiveGrid(getPositionInformation());
5451
        // get junction exaggeration
5452
        const double junctionExaggeration = myVisualizationSettings->junctionSize.getExaggeration(*myVisualizationSettings, nullptr, 4);
5453
        // get bubble color
5454
        RGBColor bubbleColor = myVisualizationSettings->junctionColorer.getScheme().getColor(1);
5455
        // change alpha
5456
        bubbleColor.setAlpha(200);
5457
        // push layer matrix
5458
        GLHelper::pushMatrix();
5459
        // translate to temporal shape layer
5460
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5461
        // push junction matrix
5462
        GLHelper::pushMatrix();
5463
        // move matrix junction center
5464
        glTranslated(mousePosition.x(), mousePosition.y(), 0.1);
5465
        // set color
5466
        GLHelper::setColor(bubbleColor);
5467
        // draw outline circle
5468
        const double circleWidth = myVisualizationSettings->neteditSizeSettings.junctionBubbleRadius * junctionExaggeration;
5469
        GLHelper::drawOutlineCircle(circleWidth, circleWidth * 0.75, 32);
5470
        // pop junction matrix
5471
        GLHelper::popMatrix();
5472
        // draw temporal edge
5473
        if (myViewParent->getCreateEdgeFrame()->getJunctionSource() && (mousePosition.distanceSquaredTo(myViewParent->getCreateEdgeFrame()->getJunctionSource()->getPositionInView()) > 1)) {
5474
            // set temporal edge color
5475
            RGBColor temporalEdgeColor = RGBColor::BLACK;
5476
            temporalEdgeColor.setAlpha(200);
5477
            // declare temporal edge geometry
5478
            GUIGeometry temporalEdgeGeometry;
5479
            // calculate geometry between source junction and mouse position
5480
            PositionVector temporalEdge = {mousePosition, myViewParent->getCreateEdgeFrame()->getJunctionSource()->getPositionInView()};
5481
            // move temporal edge 2 side
5482
            temporalEdge.move2side(-1);
5483
            // update geometry
5484
            temporalEdgeGeometry.updateGeometry(temporalEdge);
5485
            // push temporal edge matrix
5486
            GLHelper::pushMatrix();
5487
            // set color
5488
            GLHelper::setColor(temporalEdgeColor);
5489
            // draw temporal edge
5490
            GUIGeometry::drawGeometry(GUIVisualizationSettings::Detail::Level0, temporalEdgeGeometry, 0.75);
5491
            // check if we have to draw opposite edge
5492
            if (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE) {
5493
                // move temporal edge to opposite edge
5494
                temporalEdge.move2side(2);
5495
                // update geometry
5496
                temporalEdgeGeometry.updateGeometry(temporalEdge);
5497
                // draw temporal edge
5498
                GUIGeometry::drawGeometry(GUIVisualizationSettings::Detail::Level0, temporalEdgeGeometry, 0.75);
5499
            }
5500
            // pop temporal edge matrix
5501
            GLHelper::popMatrix();
5502
        }
5503
        // pop layer matrix
5504
        GLHelper::popMatrix();
5505
    }
5506
}
5507

5508

5509
void
5510
GNEViewNet::drawTemporalSplitJunction() const {
5511
    // first check if we're in correct mode
5512
    if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_CREATE_EDGE) &&
5513
            !myMouseButtonKeyPressed.controlKeyPressed() &&
5514
            myMouseButtonKeyPressed.shiftKeyPressed() &&
5515
            !myMouseButtonKeyPressed.altKeyPressed() &&
5516
            (gViewObjectsHandler.markedEdge != nullptr)) {
5517
        // calculate split position
5518
        const auto lane = gViewObjectsHandler.markedEdge->getChildLanes().back();
5519
        auto shape = lane->getLaneShape();
5520
        // move shape to side
5521
        shape.move2side(lane->getDrawingConstants()->getDrawingWidth() * -1);
5522
        const auto offset = shape.nearest_offset_to_point2D(snapToActiveGrid(getPositionInformation()));
5523
        const auto splitPosition = shape.positionAtOffset2D(offset);
5524
        // get junction exaggeration
5525
        const double junctionExaggeration = myVisualizationSettings->junctionSize.getExaggeration(*myVisualizationSettings, nullptr, 4);
5526
        // get bubble color
5527
        RGBColor bubbleColor = myVisualizationSettings->junctionColorer.getScheme().getColor(1);
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(splitPosition.x(), splitPosition.y(), 0.1);
5536
        // set color
5537
        GLHelper::setColor(bubbleColor);
5538
        // draw outline circle
5539
        const double circleWidth = myVisualizationSettings->neteditSizeSettings.junctionBubbleRadius * junctionExaggeration;
5540
        GLHelper::drawOutlineCircle(circleWidth, circleWidth * 0.75, 32);
5541
        // draw filled circle
5542
        GLHelper::drawFilledCircle(0.5, 32);
5543
        // pop junction matrix
5544
        GLHelper::popMatrix();
5545
        // pop layer matrix
5546
        GLHelper::popMatrix();
5547
    }
5548
}
5549

5550

5551
void
5552
GNEViewNet::drawTemporalRoundabout() const {
5553
    // check conditions
5554
    if ((myCurrentObjectsDialog.size() > 0) && (myCurrentObjectsDialog.front()->getType() == GLO_JUNCTION) && myDrawPreviewRoundabout) {
5555
        // get junction
5556
        const auto junction = myNet->getAttributeCarriers()->retrieveJunction(myCurrentObjectsDialog.front()->getMicrosimID());
5557
        // push layer matrix
5558
        GLHelper::pushMatrix();
5559
        // translate to temporal shape layer
5560
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5561
        // push junction matrix
5562
        GLHelper::pushMatrix();
5563
        // move matrix junction center
5564
        glTranslated(junction->getNBNode()->getPosition().x(), junction->getNBNode()->getPosition().y(), 0.1);
5565
        // set color
5566
        GLHelper::setColor(RGBColor::GREEN);
5567
        // draw outline circle
5568
        const double circleWidth = (junction->getNBNode()->getRadius() < 0) ? 4.0 : junction->getNBNode()->getRadius();
5569
        GLHelper::drawOutlineCircle(circleWidth * 1.30, circleWidth, 32);
5570
        // pop junction matrix
5571
        GLHelper::popMatrix();
5572
        // pop layer matrix
5573
        GLHelper::popMatrix();
5574
    }
5575
}
5576

5577

5578
void
5579
GNEViewNet::drawTemporalE1TLSLines() const {
5580
    // check conditions
5581
    if (selectingDetectorsTLSMode() && (myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction() != nullptr)) {
5582
        // get junction
5583
        const auto junctionPos = myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction()->getNBNode()->getPosition();
5584
        // push layer matrix
5585
        GLHelper::pushMatrix();
5586
        // translate to TLLogic
5587
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5588
        // iterate over all E1 detectors
5589
        for (const auto& E1ID : myViewParent->getTLSEditorFrame()->getTLSAttributes()->getE1Detectors()) {
5590
            // first check if E1 exists
5591
            const auto E1 = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_INDUCTION_LOOP, E1ID.second, false);
5592
            if (E1) {
5593
                // push line matrix
5594
                GLHelper::pushMatrix();
5595
                // draw line between junction and E1
5596
                GUIGeometry::drawChildLine(*myVisualizationSettings, junctionPos, E1->getPositionInView(),
5597
                                           myVisualizationSettings->additionalSettings.TLSConnectionColor, true, 0.25);
5598
                // pop line matrix
5599
                GLHelper::popMatrix();
5600
            }
5601
        }
5602
        // pop layer matrix
5603
        GLHelper::popMatrix();
5604
    }
5605
}
5606

5607

5608
void
5609
GNEViewNet::drawTemporalJunctionTLSLines() const {
5610
    // check conditions
5611
    if (selectingJunctionsTLSMode() && (myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction() != nullptr)) {
5612
        // get junction
5613
        const auto junctionPos = myViewParent->getTLSEditorFrame()->getTLSJunction()->getCurrentJunction()->getNBNode()->getPosition();
5614
        // push layer matrix
5615
        GLHelper::pushMatrix();
5616
        // translate to TLLogic
5617
        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5618
        // iterate over all Junction detectors
5619
        for (const auto& selectedJunctionID : myViewParent->getTLSEditorFrame()->getTLSJunction()->getSelectedJunctionIDs()) {
5620
            // get junction
5621
            const auto selectedJunction = myNet->getAttributeCarriers()->retrieveJunction(selectedJunctionID);
5622
            // push line matrix
5623
            GLHelper::pushMatrix();
5624
            // draw line between junction and Junction
5625
            GUIGeometry::drawChildLine(*myVisualizationSettings, junctionPos, selectedJunction->getPositionInView(),
5626
                                       myVisualizationSettings->additionalSettings.TLSConnectionColor, true, 0.25);
5627
            // pop line matrix
5628
            GLHelper::popMatrix();
5629
        }
5630
        // pop layer matrix
5631
        GLHelper::popMatrix();
5632
    }
5633
}
5634

5635

5636
void
5637
GNEViewNet::drawNeteditAttributesReferences() {
5638
    if (myEditModes.isCurrentSupermodeNetwork() && (myEditModes.networkEditMode == NetworkEditMode::NETWORK_ADDITIONAL)) {
5639
        /*
5640
                myViewParent->getAdditionalFrame()->getNeteditAttributesEditor()->drawLaneReference(gViewObjectsHandler.markedLane);
5641
                // get element length
5642
                const double elementLength = getElementLength();
5643
                // check lane
5644
                if (lane && shown() && myReferencePointComboBox->shown() && (myReferencePoint != ReferencePoint::INVALID) &&
5645
                        (elementLength != INVALID_DOUBLE)) {
5646
                    // Obtain position of the mouse over lane (limited over grid)
5647
                    const double mousePosOverLane = lane->getLaneShape().nearest_offset_to_point2D(myFrameParent->getViewNet()->snapToActiveGrid(myFrameParent->getViewNet()->getPositionInformation())) / lane->getLengthGeometryFactor();
5648
                    // continue depending of mouse pos over lane
5649
                    if (mousePosOverLane >= 0) {
5650
                        // set start and end position
5651
                        const double startPos = setStartPosition(mousePosOverLane, elementLength);
5652
                        const double endPos = setEndPosition(mousePosOverLane, elementLength, lane->getLaneShape().length2D());
5653
                        // get lane geometry
5654
                        const auto laneShape = lane->getLaneGeometry().getShape();
5655
                        // difference between start-end position and elementLength
5656
                        const auto lengthDifference = (endPos - startPos) - elementLength;
5657
                        // set color
5658
                        RGBColor segmentColor;
5659
                        // check if force length
5660
                        if (myForceLengthFrame->shown() && (myForceLengthCheckButton->getCheck() == TRUE) && abs(lengthDifference) >= 0.1) {
5661
                            segmentColor = RGBColor::RED;
5662
                        } else {
5663
                            segmentColor = RGBColor::ORANGE;
5664
                        }
5665
                        // declare geometries
5666
                        GUIGeometry geometry;
5667
                        // trim geomtry
5668
                        geometry.updateGeometry(laneShape,
5669
                                                (startPos == INVALID_DOUBLE) ? -1 : startPos,
5670
                                                Position::INVALID,
5671
                                                (endPos == INVALID_DOUBLE) ? -1 : endPos,
5672
                                                Position::INVALID);
5673
                        // push layer matrix
5674
                        GLHelper::pushMatrix();
5675
                        // translate to temporal shape layer
5676
                        glTranslated(0, 0, GLO_TEMPORALSHAPE);
5677
                        // set color
5678
                        GLHelper::setColor(segmentColor);
5679
                        // draw temporal edge
5680
                        GUIGeometry::drawGeometry(lane->getDrawingConstants()->getDetail(), geometry, 0.45);
5681
                        // check if draw starPos
5682
                        if (startPos != INVALID_DOUBLE) {
5683
                            // cut start pos
5684
                            geometry.updateGeometry(laneShape, startPos, Position::INVALID, startPos + 0.5, Position::INVALID);
5685
                            // draw startPos
5686
                            GUIGeometry::drawGeometry(lane->getDrawingConstants()->getDetail(), geometry, 1);
5687
                        } else {
5688
                            // push circle matrix
5689
                            GLHelper::pushMatrix();
5690
                            // translate to test layer, but under magenta square
5691
                            glTranslated(laneShape.front().x(), laneShape.front().y(), 0);
5692
                            // draw circle
5693
                            GLHelper::drawFilledCircle(0.8, 8);
5694
                            // pop circle matrix
5695
                            GLHelper::popMatrix();
5696
                        }
5697
                        // check if draw endPos
5698
                        if (endPos != INVALID_DOUBLE) {
5699
                            // cut endPos
5700
                            geometry.updateGeometry(laneShape, endPos - 0.5, Position::INVALID, endPos, Position::INVALID);
5701
                            // draw endPos
5702
                            GUIGeometry::drawGeometry(lane->getDrawingConstants()->getDetail(), geometry, 1);
5703
                        } else {
5704
                            // push circle matrix
5705
                            GLHelper::pushMatrix();
5706
                            // translate to test layer, but under magenta square
5707
                            glTranslated(laneShape.back().x(), laneShape.back().y(), 0);
5708
                            // draw circle
5709
                            GLHelper::drawFilledCircle(0.8, 8);
5710
                            // pop circle matrix
5711
                            GLHelper::popMatrix();
5712
                        }
5713
                        // set color
5714
                        GLHelper::setColor(segmentColor.changedBrightness(-32));
5715
                        // translate to front
5716
                        glTranslated(0, 0, 2);
5717
                        // check if draw at end, or over circle
5718
                        if (endPos == INVALID_DOUBLE) {
5719
                            // cut endPos
5720
                            geometry.updateGeometry(laneShape, laneShape.length() - 0.5, Position::INVALID, laneShape.length(), Position::INVALID);
5721
                            // draw triangle at end
5722
                            GLHelper::drawTriangleAtEnd(geometry.getShape().front(), geometry.getShape().back(), (double) 0.45, (double) 0.3, 0.3);
5723
                        } else {
5724
                            // draw triangle at end
5725
                            GLHelper::drawTriangleAtEnd(geometry.getShape().front(), geometry.getShape().back(), (double) 0.45, (double) 0.3, -0.1);
5726
                        }
5727
                        // pop layer matrix
5728
                        GLHelper::popMatrix();
5729
                    }
5730
                }
5731
        */
5732
    }
5733
}
5734

5735

5736
void
5737
GNEViewNet::drawTestsCircle() const {
5738
    if (myVisualizationSettings->showGrid && OptionsCont::getOptions().getBool("gui-testing")) {
5739
        // get mouse position
5740
        const Position mousePosition = snapToActiveGrid(getPositionInformation());
5741
        // push layer matrix
5742
        GLHelper::pushMatrix();
5743
        // translate to test layer, but under magenta square
5744
        glTranslated(mousePosition.x(), mousePosition.y(), GLO_TESTELEMENT - 1);
5745
        // set color
5746
        GLHelper::setColor(RGBColor::ORANGE);
5747
        // draw circle
5748
        GLHelper::drawFilledCircle(1, 8);
5749
        // pop layer matrix
5750
        GLHelper::popMatrix();
5751
    }
5752
}
5753

5754

5755
void
5756
GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
5757
    // reset moving selected edge
5758
    myMoveMultipleElements.resetMovingSelectedEdge();
5759
    // decide what to do based on mode
5760
    switch (myEditModes.networkEditMode) {
5761
        case NetworkEditMode::NETWORK_INSPECT: {
5762
            // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5763
            if (checkSelectEdges()) {
5764
                myViewObjectsSelector.filterLanes();
5765
            } else {
5766
                myViewObjectsSelector.filterEdges();
5767
            }
5768
            // now filter locked elements
5769
            myViewObjectsSelector.filterLockedElements();
5770
            // check if we're selecting a new parent for the current inspected element
5771
            if (myViewParent->getInspectorFrame()->getAttributesEditor()->isReparenting()) {
5772
                myViewParent->getInspectorFrame()->getAttributesEditor()->setNewParent(myViewObjectsSelector.getAttributeCarrierFront());
5773
            } else {
5774
                // inspect clicked elements
5775
                myViewParent->getInspectorFrame()->inspectClickedElements(myViewObjectsSelector, getPositionInformation(), myMouseButtonKeyPressed.shiftKeyPressed());
5776
            }
5777
            // process click
5778
            processClick(eventData);
5779
            break;
5780
        }
5781
        case NetworkEditMode::NETWORK_DELETE: {
5782
            // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5783
            if (checkSelectEdges()) {
5784
                myViewObjectsSelector.filterLanes();
5785
            } else {
5786
                myViewObjectsSelector.filterEdges();
5787
            }
5788
            // now filter locked elements forcing excluding walkingAreas
5789
            myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
5790
            // continue depending of AC
5791
            if (myViewObjectsSelector.getAttributeCarrierFront()) {
5792
                // now check if we want only delete geometry points
5793
                if (myViewParent->getDeleteFrame()->getDeleteOptions()->deleteOnlyGeometryPoints()) {
5794
                    // only remove geometry point
5795
                    myViewParent->getDeleteFrame()->removeGeometryPoint(myViewObjectsSelector);
5796
                } else if (myViewObjectsSelector.getAttributeCarrierFront()->isAttributeCarrierSelected()) {
5797
                    // remove all selected attribute carriers
5798
                    if (!myViewObjectsSelector.getAttributeCarrierFront()->getGUIGlObject()->isGLObjectLocked()) {
5799
                        myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
5800
                    }
5801
                } else {
5802
                    // remove attribute carrier under cursor
5803
                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
5804
                }
5805
            } else {
5806
                // process click
5807
                processClick(eventData);
5808
            }
5809
            break;
5810
        }
5811
        case NetworkEditMode::NETWORK_SELECT:
5812
            // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
5813
            if (checkSelectEdges()) {
5814
                myViewObjectsSelector.filterLanes();
5815
            } else {
5816
                myViewObjectsSelector.filterEdges();
5817
            }
5818
            // now filter locked elements
5819
            myViewObjectsSelector.filterLockedElements();
5820
            // avoid to select if control key is pressed
5821
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5822
                // check if a rect for selecting is being created
5823
                if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5824
                    // begin rectangle selection
5825
                    mySelectingArea.beginRectangleSelection();
5826
                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
5827
                    // process click
5828
                    processClick(eventData);
5829
                }
5830
            } else {
5831
                // process click
5832
                processClick(eventData);
5833
            }
5834
            break;
5835
        case NetworkEditMode::NETWORK_CREATE_EDGE: {
5836
            // check what buttons are pressed
5837
            if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5838
                // get edge under cursor
5839
                GNEEdge* edge = myViewObjectsSelector.getEdgeFront();
5840
                if (edge) {
5841
                    // obtain reverse edge
5842
                    const auto oppositeEdges = edge->getOppositeEdges();
5843
                    // check if we're split one or both edges
5844
                    if (myMouseButtonKeyPressed.altKeyPressed()) {
5845
                        myNet->splitEdge(edge, edge->getSplitPos(getPositionInformation()), myUndoList);
5846
                    } else if (oppositeEdges.size() > 0) {
5847
                        myNet->splitEdgesBidi(edge, oppositeEdges.front(), edge->getSplitPos(getPositionInformation()), myUndoList);
5848
                    } else {
5849
                        myNet->splitEdge(edge, edge->getSplitPos(getPositionInformation()), myUndoList);
5850
                    }
5851
                }
5852
            } else if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5853
                // process left click in create edge frame Frame
5854
                myViewParent->getCreateEdgeFrame()->processClick(getPositionInformation(),
5855
                        myViewObjectsSelector,
5856
                        (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE),
5857
                        (myNetworkViewOptions.menuCheckChainEdges->amChecked() == TRUE));
5858
            }
5859
            // process click
5860
            processClick(eventData);
5861
            break;
5862
        }
5863
        case NetworkEditMode::NETWORK_MOVE: {
5864
            // editing lane shapes in move mode isn't finished, then always filter lanes
5865
            myViewObjectsSelector.filterLanes();
5866
            // filter locked elements
5867
            myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
5868
            // check if we're editing a shape
5869
            if (myEditNetworkElementShapes.getEditedNetworkElement()) {
5870
                // check if we're removing a geometry point
5871
                if (myMouseButtonKeyPressed.shiftKeyPressed()) {
5872
                    // remove geometry point
5873
                    if (myViewObjectsSelector.getNetworkElementFront() == myEditNetworkElementShapes.getEditedNetworkElement()) {
5874
                        myViewObjectsSelector.getNetworkElementFront()->removeGeometryPoint(getPositionInformation(), myUndoList);
5875
                    }
5876
                } else if (!myMoveSingleElement.beginMoveNetworkElementShape()) {
5877
                    // process click  if there isn't movable elements (to move camera using drag an drop)
5878
                    processClick(eventData);
5879
                }
5880
            } else {
5881
                // filter connections and crossings, because are moved setting custom shape
5882
                myViewObjectsSelector.filterConnections();
5883
                myViewObjectsSelector.filterCrossings();
5884
                // get AC under cursor
5885
                auto AC = myViewObjectsSelector.getAttributeCarrierFront();
5886
                // check that AC is an network or additional element
5887
                if (AC && (AC->getTagProperty()->isNetworkElement() || AC->getTagProperty()->isAdditionalElement())) {
5888
                    // check if we're moving a set of selected items
5889
                    if (AC->isAttributeCarrierSelected()) {
5890
                        // move selected ACs
5891
                        myMoveMultipleElements.beginMoveSelection();
5892
                    } else if (!myMoveSingleElement.beginMoveSingleElementNetworkMode()) {
5893
                        // process click  if there isn't movable elements (to move camera using drag an drop)
5894
                        processClick(eventData);
5895
                    }
5896
                } else {
5897
                    // process click  if there isn't movable elements (to move camera using drag an drop)
5898
                    processClick(eventData);
5899
                }
5900
            }
5901
            break;
5902
        }
5903
        case NetworkEditMode::NETWORK_CONNECT: {
5904
            // check if we're clicked over a non locked lane
5905
            if (myViewObjectsSelector.getLaneFrontNonLocked()) {
5906
                // Handle laneclick (shift key may pass connections, Control key allow conflicts)
5907
                myViewParent->getConnectorFrame()->handleLaneClick(myViewObjectsSelector);
5908
                updateViewNet();
5909
            }
5910
            // process click
5911
            processClick(eventData);
5912
            break;
5913
        }
5914
        case NetworkEditMode::NETWORK_TLS: {
5915
            // edit TLS in TLSEditor frame
5916
            myViewParent->getTLSEditorFrame()->editTLS(myViewObjectsSelector, getPositionInformation(), myMouseButtonKeyPressed.shiftKeyPressed());
5917
            // process click
5918
            processClick(eventData);
5919
            break;
5920
        }
5921
        case NetworkEditMode::NETWORK_ADDITIONAL: {
5922
            // avoid create additionals if control key is pressed
5923
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5924
                if (myViewParent->getAdditionalFrame()->addAdditional(myViewObjectsSelector)) {
5925
                    updateViewNet();
5926
                }
5927
            }
5928
            // process click
5929
            processClick(eventData);
5930
            break;
5931
        }
5932
        case NetworkEditMode::NETWORK_CROSSING: {
5933
            // filter elements over junctions
5934
            myViewObjectsSelector.filterCrossings();
5935
            myViewObjectsSelector.filterWalkingAreas();
5936
            myViewObjectsSelector.filterConnections();
5937
            // call function addCrossing from crossing frame
5938
            myViewParent->getCrossingFrame()->addCrossing(myViewObjectsSelector);
5939
            // process click
5940
            processClick(eventData);
5941
            break;
5942
        }
5943
        case NetworkEditMode::NETWORK_TAZ: {
5944
            // avoid create TAZs if control key is pressed
5945
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5946
                // check if we want to create a rect for selecting edges
5947
                if (myMouseButtonKeyPressed.shiftKeyPressed() && (myViewParent->getTAZFrame()->getCurrentTAZModule()->getTAZ() != nullptr)) {
5948
                    // begin rectangle selection
5949
                    mySelectingArea.beginRectangleSelection();
5950
                } else {
5951
                    // check if process click was successfully
5952
                    if (myViewParent->getTAZFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector)) {
5953
                        updateViewNet();
5954
                    }
5955
                    // process click
5956
                    processClick(eventData);
5957
                }
5958
            } else {
5959
                // process click
5960
                processClick(eventData);
5961
            }
5962
            break;
5963
        }
5964
        case NetworkEditMode::NETWORK_SHAPE: {
5965
            // avoid create shapes if control key is pressed
5966
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5967
                if (!myViewObjectsSelector.getPOIFront()) {
5968
                    // declare processClick flag
5969
                    bool updateTemporalShape = false;
5970
                    // process click
5971
                    myViewParent->getShapeFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector, updateTemporalShape);
5972
                    updateViewNet();
5973
                    // process click depending of the result of "process click"
5974
                    if (!updateTemporalShape) {
5975
                        // process click
5976
                        processClick(eventData);
5977
                    }
5978
                }
5979
            } else {
5980
                // process click
5981
                processClick(eventData);
5982
            }
5983
            break;
5984
        }
5985
        case NetworkEditMode::NETWORK_PROHIBITION: {
5986
            if (myViewObjectsSelector.getConnectionFront()) {
5987
                // shift key may pass connections, Control key allow conflicts.
5988
                myViewParent->getProhibitionFrame()->handleProhibitionClick(myViewObjectsSelector);
5989
                updateViewNet();
5990
            }
5991
            // process click
5992
            processClick(eventData);
5993
            break;
5994
        }
5995
        case NetworkEditMode::NETWORK_WIRE: {
5996
            // avoid create wires if control key is pressed
5997
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
5998
                myViewParent->getWireFrame()->addWire(myViewObjectsSelector);
5999
                updateViewNet();
6000
            }
6001
            // process click
6002
            processClick(eventData);
6003
            break;
6004
        }
6005
        case NetworkEditMode::NETWORK_DECAL: {
6006
            // process click
6007
            processClick(eventData);
6008
            break;
6009
        }
6010
        default: {
6011
            // process click
6012
            processClick(eventData);
6013
        }
6014
    }
6015
}
6016

6017

6018
void
6019
GNEViewNet::processLeftButtonReleaseNetwork() {
6020
    // check moved items
6021
    if (myMoveMultipleElements.isMovingSelection()) {
6022
        myMoveMultipleElements.finishMoveSelection();
6023
    } else if (mySelectingArea.selectingUsingRectangle) {
6024
        // check if we're creating a rectangle selection or we want only to select a lane
6025
        if (mySelectingArea.startDrawing) {
6026
            // check if we're selecting all type of elements o we only want a set of edges for TAZ
6027
            if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_SELECT) {
6028
                mySelectingArea.processRectangleSelection();
6029
            } else if (myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) {
6030
                // process edge selection
6031
                myViewParent->getTAZFrame()->processEdgeSelection(mySelectingArea.processEdgeRectangleSelection());
6032
            }
6033
        } else if (myMouseButtonKeyPressed.shiftKeyPressed()) {
6034
            // check if there is a lane in objects under cursor
6035
            if (myViewObjectsSelector.getLaneFront()) {
6036
                // if we clicked over an lane with shift key pressed, select or unselect it
6037
                if (myViewObjectsSelector.getLaneFront()->isAttributeCarrierSelected()) {
6038
                    myViewObjectsSelector.getLaneFront()->unselectAttributeCarrier();
6039
                } else {
6040
                    myViewObjectsSelector.getLaneFront()->selectAttributeCarrier();
6041
                }
6042
            }
6043
        }
6044
        // finish selection
6045
        mySelectingArea.finishRectangleSelection();
6046
    } else {
6047
        // finish moving of single elements
6048
        myMoveSingleElement.finishMoveSingleElement();
6049
    }
6050
}
6051

6052

6053
void
6054
GNEViewNet::processMoveMouseNetwork(const bool mouseLeftButtonPressed) {
6055
    // change "delete last created point" depending if during movement shift key is pressed
6056
    if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_SHAPE) && myViewParent->getShapeFrame()->getDrawingShapeModule()->isDrawing()) {
6057
        myViewParent->getShapeFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
6058
    } else if ((myEditModes.networkEditMode == NetworkEditMode::NETWORK_TAZ) && myViewParent->getTAZFrame()->getDrawingShapeModule()->isDrawing()) {
6059
        myViewParent->getTAZFrame()->getDrawingShapeModule()->setDeleteLastCreatedPoint(myMouseButtonKeyPressed.shiftKeyPressed());
6060
    }
6061
    // check what type of additional is moved
6062
    if (myMoveMultipleElements.isMovingSelection()) {
6063
        // move entire selection
6064
        myMoveMultipleElements.moveSelection(mouseLeftButtonPressed);
6065
    } else if (mySelectingArea.selectingUsingRectangle) {
6066
        // update selection corner of selecting area
6067
        mySelectingArea.moveRectangleSelection();
6068
    } else {
6069
        // move single elements
6070
        myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
6071
    }
6072
}
6073

6074

6075
void
6076
GNEViewNet::processLeftButtonPressDemand(void* eventData) {
6077
    // filter shapes (because POIs and polygons doesn't interact in demand mode)
6078
    myViewObjectsSelector.filterShapes();
6079
    // decide what to do based on mode
6080
    switch (myEditModes.demandEditMode) {
6081
        case DemandEditMode::DEMAND_INSPECT: {
6082
            // filter locked elements
6083
            myViewObjectsSelector.filterLockedElements();
6084
            // inspect clicked elements
6085
            myViewParent->getInspectorFrame()->inspectClickedElements(myViewObjectsSelector, getPositionInformation(), myMouseButtonKeyPressed.shiftKeyPressed());
6086
            // process click
6087
            processClick(eventData);
6088
            break;
6089
        }
6090
        case DemandEditMode::DEMAND_DELETE: {
6091
            // filter locked elements
6092
            myViewObjectsSelector.filterLockedElements();
6093
            // get front AC
6094
            const auto markAC = myViewObjectsSelector.getAttributeCarrierFront();
6095
            // check conditions
6096
            if (markAC) {
6097
                // check if we are deleting a selection or an single attribute carrier
6098
                if (markAC->isAttributeCarrierSelected()) {
6099
                    myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
6100
                } else {
6101
                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
6102
                }
6103
            } else {
6104
                // process click
6105
                processClick(eventData);
6106
            }
6107
            break;
6108
        }
6109
        case DemandEditMode::DEMAND_SELECT:
6110
            // filter locked elements
6111
            myViewObjectsSelector.filterLockedElements();
6112
            // avoid to select if control key is pressed
6113
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6114
                // check if a rect for selecting is being created
6115
                if (myMouseButtonKeyPressed.shiftKeyPressed()) {
6116
                    // begin rectangle selection
6117
                    mySelectingArea.beginRectangleSelection();
6118
                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
6119
                    // process click
6120
                    processClick(eventData);
6121
                }
6122
            } else {
6123
                // process click
6124
                processClick(eventData);
6125
            }
6126
            break;
6127
        case DemandEditMode::DEMAND_MOVE: {
6128
            // filter locked elements
6129
            myViewObjectsSelector.filterLockedElements();
6130
            // get front AC
6131
            const auto markAC = myViewObjectsSelector.getAttributeCarrierFront();
6132
            // check that AC under cursor is a demand element
6133
            if (markAC) {
6134
                // check if we're moving a set of selected items
6135
                if (markAC->isAttributeCarrierSelected()) {
6136
                    // move selected ACs
6137
                    myMoveMultipleElements.beginMoveSelection();
6138
                } else if (!myMoveSingleElement.beginMoveSingleElementDemandMode()) {
6139
                    // process click  if there isn't movable elements (to move camera using drag an drop)
6140
                    processClick(eventData);
6141
                }
6142
            } else {
6143
                // process click  if there isn't movable elements (to move camera using drag an drop)
6144
                processClick(eventData);
6145
            }
6146
            break;
6147
        }
6148
        case DemandEditMode::DEMAND_ROUTE: {
6149
            // check if we clicked over a lane
6150
            if (myViewObjectsSelector.getLaneFront()) {
6151
                // Handle edge click
6152
                myViewParent->getRouteFrame()->addEdgeRoute(myViewObjectsSelector.getLaneFront()->getParentEdge(), myMouseButtonKeyPressed);
6153
            }
6154
            // process click
6155
            processClick(eventData);
6156
            break;
6157
        }
6158
        case DemandEditMode::DEMAND_VEHICLE: {
6159
            // filter additionals (except TAZs) and demands (except routes)
6160
            myViewObjectsSelector.filterAdditionals(true, false);
6161
            myViewObjectsSelector.filterDemandElements(false);
6162
            // Handle click
6163
            myViewParent->getVehicleFrame()->addVehicle(myViewObjectsSelector, myMouseButtonKeyPressed);
6164
            // process click
6165
            processClick(eventData);
6166
            break;
6167
        }
6168
        case DemandEditMode::DEMAND_STOP: {
6169
            // filter additionals (except stoppingPlaces) and demands
6170
            myViewObjectsSelector.filterAdditionals(false, true);
6171
            myViewObjectsSelector.filterDemandElements(true);
6172
            // Handle click
6173
            if (myViewParent->getStopFrame()->addStop(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6174
                updateViewNet();
6175
            }
6176
            // process click
6177
            processClick(eventData);
6178
            break;
6179
        }
6180
        case DemandEditMode::DEMAND_PERSON: {
6181
            // filter additionals (except stoppingPlaces and TAZs)
6182
            myViewObjectsSelector.filterAdditionals(false, false);
6183
            if (myViewParent->getPersonFrame()->getPlanSelector()->getCurrentPlanTagProperties()) {
6184
                // special case if we're creating person over walk routes
6185
                if (myViewParent->getPersonFrame()->getPlanSelector()->getCurrentPlanTagProperties()->planRoute()) {
6186
                    myViewObjectsSelector.filterDemandElements(false);
6187
                } else {
6188
                    myViewObjectsSelector.filterDemandElements(true);
6189
                }
6190
                // Handle click
6191
                myViewParent->getPersonFrame()->addPerson(myViewObjectsSelector);
6192
            }
6193
            // process click
6194
            processClick(eventData);
6195
            break;
6196
        }
6197
        case DemandEditMode::DEMAND_PERSONPLAN: {
6198
            // filter additionals (except stoppingPlaces and TAZs)
6199
            myViewObjectsSelector.filterAdditionals(false, false);
6200
            if (myViewParent->getPersonPlanFrame()->getPlanSelector()->getCurrentPlanTagProperties()) {
6201
                // special case if we're creating person over walk routes
6202
                if (myViewParent->getPersonPlanFrame()->getPlanSelector()->getCurrentPlanTagProperties()->planRoute()) {
6203
                    myViewObjectsSelector.filterDemandElements(false);
6204
                } else {
6205
                    myViewObjectsSelector.filterDemandElements(true);
6206
                }
6207
                // Handle person plan click
6208
                myViewParent->getPersonPlanFrame()->addPersonPlanElement(myViewObjectsSelector);
6209
            }
6210
            // process click
6211
            processClick(eventData);
6212
            break;
6213
        }
6214
        case DemandEditMode::DEMAND_CONTAINER: {
6215
            // filter additionals (except stoppingPlaces and TAZs) and demands
6216
            myViewObjectsSelector.filterAdditionals(false, false);
6217
            myViewObjectsSelector.filterDemandElements(true);
6218
            // Handle click
6219
            myViewParent->getContainerFrame()->addContainer(myViewObjectsSelector);
6220
            // process click
6221
            processClick(eventData);
6222
            break;
6223
        }
6224
        case DemandEditMode::DEMAND_CONTAINERPLAN: {
6225
            // filter additionals (except stoppingPlaces and TAZs) and demands
6226
            myViewObjectsSelector.filterAdditionals(false, false);
6227
            myViewObjectsSelector.filterDemandElements(true);
6228
            // Handle container plan click
6229
            myViewParent->getContainerPlanFrame()->addContainerPlanElement(myViewObjectsSelector);
6230
            // process click
6231
            processClick(eventData);
6232
            break;
6233
        }
6234
        default: {
6235
            // process click
6236
            processClick(eventData);
6237
        }
6238
    }
6239
}
6240

6241

6242
void
6243
GNEViewNet::processLeftButtonReleaseDemand() {
6244
    // check moved items
6245
    if (myMoveMultipleElements.isMovingSelection()) {
6246
        myMoveMultipleElements.finishMoveSelection();
6247
    } else if (mySelectingArea.selectingUsingRectangle) {
6248
        // check if we're creating a rectangle selection or we want only to select a lane
6249
        if (mySelectingArea.startDrawing) {
6250
            mySelectingArea.processRectangleSelection();
6251
        }
6252
        // finish selection
6253
        mySelectingArea.finishRectangleSelection();
6254
    } else {
6255
        // finish moving of single elements
6256
        myMoveSingleElement.finishMoveSingleElement();
6257
    }
6258
}
6259

6260

6261
void
6262
GNEViewNet::processMoveMouseDemand(const bool mouseLeftButtonPressed) {
6263
    if (mySelectingArea.selectingUsingRectangle) {
6264
        // update selection corner of selecting area
6265
        mySelectingArea.moveRectangleSelection();
6266
    } else {
6267
        // move single elements
6268
        myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
6269
    }
6270
}
6271

6272

6273
void
6274
GNEViewNet::processLeftButtonPressData(void* eventData) {
6275
    // get AC
6276
    const auto AC = myViewObjectsSelector.getAttributeCarrierFront();
6277
    // decide what to do based on mode
6278
    switch (myEditModes.dataEditMode) {
6279
        case DataEditMode::DATA_INSPECT: {
6280
            // filter locked elements
6281
            myViewObjectsSelector.filterLockedElements();
6282
            // process left click in Inspector Frame
6283
            if (AC && AC->getTagProperty()->getTag() == SUMO_TAG_TAZ) {
6284
                myViewParent->getInspectorFrame()->inspectElement(AC);
6285
            } else {
6286
                // inspect clicked elements
6287
                myViewParent->getInspectorFrame()->inspectClickedElements(myViewObjectsSelector, getPositionInformation(), myMouseButtonKeyPressed.shiftKeyPressed());
6288
            }
6289
            // process click
6290
            processClick(eventData);
6291
            break;
6292
        }
6293
        case DataEditMode::DATA_DELETE: {
6294
            // check conditions
6295
            if (AC) {
6296
                // check if we are deleting a selection or an single attribute carrier
6297
                if (AC->isAttributeCarrierSelected()) {
6298
                    if (!AC->getGUIGlObject()->isGLObjectLocked()) {
6299
                        myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
6300
                    }
6301
                } else {
6302
                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
6303
                }
6304
            } else {
6305
                // process click
6306
                processClick(eventData);
6307
            }
6308
            break;
6309
        }
6310
        case DataEditMode::DATA_SELECT:
6311
            // filter locked elements
6312
            myViewObjectsSelector.filterLockedElements();
6313
            // avoid to select if control key is pressed
6314
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6315
                // check if a rect for selecting is being created
6316
                if (myMouseButtonKeyPressed.shiftKeyPressed()) {
6317
                    // begin rectangle selection
6318
                    mySelectingArea.beginRectangleSelection();
6319
                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
6320
                    // process click
6321
                    processClick(eventData);
6322
                }
6323
            } else {
6324
                // process click
6325
                processClick(eventData);
6326
            }
6327
            break;
6328
        case DataEditMode::DATA_EDGEDATA:
6329
            // avoid create edgeData if control key is pressed
6330
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6331
                if (myViewParent->getEdgeDataFrame()->addEdgeData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6332
                    updateViewNet();
6333
                }
6334
            }
6335
            // process click
6336
            processClick(eventData);
6337
            break;
6338
        case DataEditMode::DATA_EDGERELDATA:
6339
            // avoid create edgeData if control key is pressed
6340
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6341
                if (myViewParent->getEdgeRelDataFrame()->addEdgeRelationData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
6342
                    updateViewNet();
6343
                }
6344
            }
6345
            // process click
6346
            processClick(eventData);
6347
            break;
6348
        case DataEditMode::DATA_TAZRELDATA:
6349
            // avoid create TAZData if control key is pressed
6350
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6351
                if (myViewParent->getTAZRelDataFrame()->setTAZ(myViewObjectsSelector)) {
6352
                    updateViewNet();
6353
                }
6354
            }
6355
            // process click
6356
            processClick(eventData);
6357
            break;
6358
        case DataEditMode::DATA_MEANDATA:
6359
            // avoid create TAZData if control key is pressed
6360
            if (!myMouseButtonKeyPressed.controlKeyPressed()) {
6361
                //
6362
            }
6363
            // process click
6364
            processClick(eventData);
6365
            break;
6366
        default: {
6367
            // process click
6368
            processClick(eventData);
6369
        }
6370
    }
6371
}
6372

6373

6374
void
6375
GNEViewNet::processLeftButtonReleaseData() {
6376
    // check moved items
6377
    if (myMoveMultipleElements.isMovingSelection()) {
6378
        myMoveMultipleElements.finishMoveSelection();
6379
    } else if (mySelectingArea.selectingUsingRectangle) {
6380
        // check if we're creating a rectangle selection or we want only to select a lane
6381
        if (mySelectingArea.startDrawing) {
6382
            mySelectingArea.processRectangleSelection();
6383
        }
6384
        // finish selection
6385
        mySelectingArea.finishRectangleSelection();
6386
    } else {
6387
        // finish moving of single elements
6388
        myMoveSingleElement.finishMoveSingleElement();
6389
    }
6390
}
6391

6392

6393
void
6394
GNEViewNet::processMoveMouseData(const bool mouseLeftButtonPressed) {
6395
    if (mySelectingArea.selectingUsingRectangle) {
6396
        // update selection corner of selecting area
6397
        mySelectingArea.moveRectangleSelection();
6398
    } else {
6399
        // move single elements
6400
        myMoveSingleElement.moveSingleElement(mouseLeftButtonPressed);
6401
    }
6402
}
6403

6404
/****************************************************************************/
6405

6406
Product

Resources

Company
