CoCalc -- GNEApplicationWindow.cpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/netedit/GNEApplicationWindow.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    GNEApplicationWindow.cpp
15
/// @author  Pablo Alvarez Lopez
16
/// @author  Mirko Barthauer
17
/// @date    mar 2020
18
///
19
// Functions from main window of netedit
20
/****************************************************************************/
21

22
#include <gui/dialogs/GUIDialog_Feedback.h>
23
#include <netbuild/NBFrame.h>
24
#include <netedit/changes/GNEChange_EdgeType.h>
25
#include <netedit/dialogs/basic/GNEQuestionBasicDialog.h>
26
#include <netedit/dialogs/fix/GNEFixNetworkElements.h>
27
#include <netedit/dialogs/GNEAboutDialog.h>
28
#include <netedit/dialogs/GNEUndoListDialog.h>
29
#include <netedit/dialogs/options/GNENeteditOptionsDialog.h>
30
#include <netedit/dialogs/options/GNENetgenerateOptionsDialog.h>
31
#include <netedit/dialogs/options/GNESumoOptionsDialog.h>
32
#include <netedit/dialogs/run/GNERunNetgenerateDialog.h>
33
#include <netedit/dialogs/tools/GNENetgenerateDialog.h>
34
#include <netedit/elements/data/GNEDataHandler.h>
35
#include <netedit/elements/data/GNEDataSet.h>
36
#include <netedit/elements/data/GNEMeanData.h>
37
#include <netedit/elements/GNEGeneralHandler.h>
38
#include <netedit/elements/network/GNECrossing.h>
39
#include <netedit/elements/network/GNEEdgeType.h>
40
#include <netedit/elements/network/GNELaneType.h>
41
#include <netedit/frames/common/GNEInspectorFrame.h>
42
#include <netedit/frames/common/GNESelectorFrame.h>
43
#include <netedit/frames/demand/GNEContainerFrame.h>
44
#include <netedit/frames/demand/GNEPersonFrame.h>
45
#include <netedit/frames/demand/GNEVehicleFrame.h>
46
#include <netedit/frames/GNEAttributesEditor.h>
47
#include <netedit/frames/network/GNECreateEdgeFrame.h>
48
#include <netedit/frames/network/GNETAZFrame.h>
49
#include <netedit/frames/network/GNETLSEditorFrame.h>
50
#include <netedit/GNETagPropertiesDatabase.h>
51
#include <netedit/templates.h>
52
#include <netimport/NIFrame.h>
53
#include <netimport/NITypeLoader.h>
54
#include <netimport/NIXMLTypesHandler.h>
55
#include <netwrite/NWFrame.h>
56
#include <utils/common/SystemFrame.h>
57
#include <utils/foxtools/MFXLinkLabel.h>
58
#include <utils/foxtools/MFXMenuCheckIcon.h>
59
#include <utils/gui/cursors/GUICursorSubSys.h>
60
#include <utils/gui/div/GLHelper.h>
61
#include <utils/gui/div/GUIDialog_GLChosenEditor.h>
62
#include <utils/gui/div/GUIGlobalSelection.h>
63
#include <utils/gui/div/GUIUserIO.h>
64
#include <utils/gui/events/GUIEvent_Message.h>
65
#include <utils/gui/settings/GUICompleteSchemeStorage.h>
66
#include <utils/gui/settings/GUISettingsHandler.h>
67
#include <utils/gui/shortcuts/GUIShortcutsSubSys.h>
68
#include <utils/gui/windows/GUIPerspectiveChanger.h>
69
#include <utils/handlers/TemplateHandler.h>
70
#include <utils/xml/XMLSubSys.h>
71

72
#include "GNEApplicationWindow.h"
73
#include "GNEEvent_NetworkLoaded.h"
74
#include "GNEInternalTest.h"
75
#include "GNELoadThread.h"
76
#include "GNENet.h"
77
#include "GNEUndoList.h"
78
#include "GNEViewParent.h"
79

80
#ifdef HAVE_VERSION_H
81
#include <version.h>
82
#endif
83

84
// ===========================================================================
85
// FOX-declarations
86
// ===========================================================================
87

88
FXDEFMAP(GNEApplicationWindow) GNEApplicationWindowMap[] = {
89
    // quit calls
90
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_Q_CLOSE,    GNEApplicationWindow::onCmdQuit),
91
    FXMAPFUNC(SEL_SIGNAL,   MID_HOTKEY_CTRL_Q_CLOSE,    GNEApplicationWindow::onCmdQuit),
92
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_F4_CLOSE,    GNEApplicationWindow::onCmdQuit),
93
    FXMAPFUNC(SEL_CLOSE,    MID_WINDOW,                 GNEApplicationWindow::onCmdQuit),
94
    // toolbar file
95
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_N_OPENNETWORK_NEWNETWORK,   GNEApplicationWindow::onCmdNewNetwork),
96
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_N_OPENNETWORK_NEWNETWORK,   GNEApplicationWindow::onUpdOpen),
97
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_N_NEWWINDOW,          GNEApplicationWindow::onCmdNewWindow),
98
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_NETGENERATE,                        GNEApplicationWindow::onCmdOpenNetgenerateDialog),
99
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_NETGENERATEOPTIONS,                 GNEApplicationWindow::onCmdOpenNetgenerateOptionsDialog),
100
    FXMAPFUNC(SEL_COMMAND,  MID_RECENTFILE,                             GNEApplicationWindow::onCmdOpenRecent),
101
    FXMAPFUNC(SEL_UPDATE,   MID_RECENTFILE,                             GNEApplicationWindow::onUpdOpen),
102
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_R_RELOAD,                   GNEApplicationWindow::onCmdSmartReload),
103
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_R_RELOAD,                   GNEApplicationWindow::onUpdSmartReload),
104
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOADNETWORK,          GNEApplicationWindow::onCmdReloadNetwork),
105
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOADNETWORK,          GNEApplicationWindow::onUpdReloadNetwork),
106
    // network
107
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_O_OPENSIMULATION_OPENNETWORK,   GNEApplicationWindow::onCmdOpenNetwork),
108
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_O_OPENSIMULATION_OPENNETWORK,   GNEApplicationWindow::onUpdOpen),
109
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_O_OPENNETCONVERTFILE,     GNEApplicationWindow::onCmdOpenNetconvertConfig),
110
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_O_OPENNETCONVERTFILE,     GNEApplicationWindow::onUpdOpen),
111
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_OPENFOREIGN,                GNEApplicationWindow::onCmdOpenForeign),
112
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_OPENFOREIGN,                GNEApplicationWindow::onUpdOpen),
113
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK,   GNEApplicationWindow::onCmdSaveNetwork),
114
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_S_STOPSIMULATION_SAVENETWORK,   GNEApplicationWindow::onUpdSaveNetwork),
115
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVENETWORK_AS,             GNEApplicationWindow::onCmdSaveNetworkAs),
116
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVENETWORK_AS,             GNEApplicationWindow::onUpdNeedsNetwork),
117
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_L_SAVEASPLAINXML,               GNEApplicationWindow::onCmdSavePlainXMLAs),
118
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_L_SAVEASPLAINXML,               GNEApplicationWindow::onUpdNeedsNetwork),
119
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_SAVEJOINEDJUNCTIONS,                    GNEApplicationWindow::onCmdSaveJoinedJunctionsAs),
120
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_SAVEJOINEDJUNCTIONS,                    GNEApplicationWindow::onUpdNeedsNetwork),
121
    // NeteditConfig
122
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_E_EDITSELECTION_LOADNETEDITCONFIG,  GNEApplicationWindow::onCmdOpenNeteditConfig),
123
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_NETEDITCONFIG,           GNEApplicationWindow::onCmdReloadNeteditConfig),
124
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_NETEDITCONFIG,           GNEApplicationWindow::onUpdReloadNeteditConfig),
125
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_E_SAVENETEDITCONFIG,          GNEApplicationWindow::onCmdSaveNeteditConfig),
126
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_E_SAVENETEDITCONFIG,          GNEApplicationWindow::onUpdSaveNeteditConfig),
127
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVENETEDITCONFIG_AS,           GNEApplicationWindow::onCmdSaveNeteditConfigAs),
128
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVENETEDITCONFIG_AS,           GNEApplicationWindow::onUpdNeedsNetwork),
129
    // SumoConfig
130
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_M_OPENSUMOCONFIG,       GNEApplicationWindow::onCmdOpenSumoConfig),
131
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_SUMOCONFIG,  GNEApplicationWindow::onCmdReloadSumoConfig),
132
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_SUMOCONFIG,  GNEApplicationWindow::onUpdReloadSumoConfig),
133
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_S_SAVESUMOCONFIG, GNEApplicationWindow::onCmdSaveSumoConfig),
134
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_S_SAVESUMOCONFIG, GNEApplicationWindow::onUpdSaveSumoConfig),
135
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVESUMOCONFIG_AS,  GNEApplicationWindow::onCmdSaveSumoConfigAs),
136
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVESUMOCONFIG_AS,  GNEApplicationWindow::onUpdNeedsNetwork),
137
    // TLS
138
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_K_OPENTLSPROGRAMS,      GNEApplicationWindow::onCmdOpenTLSPrograms),
139
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_K_OPENTLSPROGRAMS,      GNEApplicationWindow::onUpdNeedsNetwork),
140
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_TLSPROGRAMS, GNEApplicationWindow::onCmdReloadTLSPrograms),
141
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_TLSPROGRAMS, GNEApplicationWindow::onUpdReloadTLSPrograms),
142
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_K_SAVETLS,        GNEApplicationWindow::onCmdSaveTLSPrograms),
143
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_K_SAVETLS,        GNEApplicationWindow::onUpdSaveTLSPrograms),
144
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVETLSPROGRAMS_AS, GNEApplicationWindow::onCmdSaveTLSProgramsAs),
145
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVETLSPROGRAMS_AS, GNEApplicationWindow::onUpdSaveTLSPrograms),
146
    // edge types
147
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_H_APPSETTINGS_OPENEDGETYPES,    GNEApplicationWindow::onCmdOpenEdgeTypes),
148
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_H_APPSETTINGS_OPENEDGETYPES,    GNEApplicationWindow::onUpdNeedsNetwork),
149
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_EDGETYPES,           GNEApplicationWindow::onCmdReloadEdgeTypes),
150
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_EDGETYPES,           GNEApplicationWindow::onUpdReloadEdgeTypes),
151
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_H_SAVEEDGETYPES,          GNEApplicationWindow::onCmdSaveEdgeTypes),
152
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_H_SAVEEDGETYPES,          GNEApplicationWindow::onUpdSaveEdgeTypes),
153
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEEDGETYPES_AS,           GNEApplicationWindow::onCmdSaveEdgeTypesAs),
154
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEEDGETYPES_AS,           GNEApplicationWindow::onUpdSaveEdgeTypes),
155
    // additionals
156
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_A_STARTSIMULATION_OPENADDITIONALELEMENTS,   GNEApplicationWindow::onCmdOpenAdditionalElements),
157
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_A_STARTSIMULATION_OPENADDITIONALELEMENTS,   GNEApplicationWindow::onUpdNeedsNetwork),
158
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_ADDITIONALELEMENTS,              GNEApplicationWindow::onCmdReloadAdditionalElements),
159
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_ADDITIONALELEMENTS,              GNEApplicationWindow::onUpdReloadAdditionalElements),
160
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALELEMENTS,             GNEApplicationWindow::onCmdSaveAdditionalElements),
161
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_A_SAVEADDITIONALELEMENTS,             GNEApplicationWindow::onUpdSaveAdditionalElements),
162
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEADDITIONALELEMENTS_UNIFIED,         GNEApplicationWindow::onCmdSaveAdditionalElementsUnified),
163
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEADDITIONALELEMENTS_UNIFIED,         GNEApplicationWindow::onUpdSaveAdditionalElementsUnified),
164
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEJUPEDSIMELEMENTS_AS,                GNEApplicationWindow::onCmdSaveJuPedSimElementsAs),
165
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEJUPEDSIMELEMENTS_AS,                GNEApplicationWindow::onUpdSaveJuPedSimElementsAs),
166
    // demand elements
167
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_D_SINGLESIMULATIONSTEP_OPENDEMANDELEMENTS,  GNEApplicationWindow::onCmdOpenDemandElements),
168
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_D_SINGLESIMULATIONSTEP_OPENDEMANDELEMENTS,  GNEApplicationWindow::onUpdNeedsNetwork),
169
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_DEMANDELEMENTS,                  GNEApplicationWindow::onCmdReloadDemandElements),
170
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_DEMANDELEMENTS,                  GNEApplicationWindow::onUpdReloadDemandElements),
171
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS,                 GNEApplicationWindow::onCmdSaveDemandElements),
172
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_D_SAVEDEMANDELEMENTS,                 GNEApplicationWindow::onUpdSaveDemandElements),
173
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEDEMANDELEMENTS_UNIFIED,             GNEApplicationWindow::onCmdSaveDemandElementsUnified),
174
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEDEMANDELEMENTS_UNIFIED,             GNEApplicationWindow::onUpdSaveDemandElementsUnified),
175
    // data elements
176
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_B_EDITBREAKPOINT_OPENDATAELEMENTS,  GNEApplicationWindow::onCmdOpenDataElements),
177
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_B_EDITBREAKPOINT_OPENDATAELEMENTS,  GNEApplicationWindow::onUpdNeedsNetwork),
178
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_DATAELEMENTS,            GNEApplicationWindow::onCmdReloadDataElements),
179
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_DATAELEMENTS,            GNEApplicationWindow::onUpdReloadDataElements),
180
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS,           GNEApplicationWindow::onCmdSaveDataElements),
181
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_B_SAVEDATAELEMENTS,           GNEApplicationWindow::onUpdSaveDataElements),
182
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEDATAELEMENTS_UNIFIED,       GNEApplicationWindow::onCmdSaveDataElementsUnified),
183
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEDATAELEMENTS_UNIFIED,       GNEApplicationWindow::onUpdSaveDataElementsUnified),
184
    // meanDatas
185
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_OPENMEANDATAELEMENTS,           GNEApplicationWindow::onCmdOpenMeanDataElements),
186
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_OPENMEANDATAELEMENTS,           GNEApplicationWindow::onUpdNeedsNetwork),
187
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_RELOAD_MEANDATAELEMENTS,        GNEApplicationWindow::onCmdReloadMeanDataElements),
188
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_RELOAD_MEANDATAELEMENTS,        GNEApplicationWindow::onUpdReloadMeanDataElements),
189
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_SHIFT_M_SAVEMEANDATAELEMENTS,       GNEApplicationWindow::onCmdSaveMeanDataElements),
190
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_SHIFT_M_SAVEMEANDATAELEMENTS,       GNEApplicationWindow::onUpdSaveMeanDataElements),
191
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVEMEANDATAELEMENTS_UNIFIED,   GNEApplicationWindow::onCmdSaveMeanDataElementsUnified),
192
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVEMEANDATAELEMENTS_UNIFIED,   GNEApplicationWindow::onUpdSaveMeanDataElementsUnified),
193
    // other
194
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBARFILE_SAVETLSPROGRAMS_AS, GNEApplicationWindow::onCmdSaveTLSProgramsAs),
195
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBARFILE_SAVETLSPROGRAMS_AS, GNEApplicationWindow::onUpdSaveTLSPrograms),
196
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_W_CLOSESIMULATION,      GNEApplicationWindow::onCmdClose),
197
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_W_CLOSESIMULATION,      GNEApplicationWindow::onUpdNeedsNetwork),
198
    // Toolbar supermode
199
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F2_SUPERMODE_NETWORK,    GNEApplicationWindow::onCmdSetSuperMode),
200
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F3_SUPERMODE_DEMAND,     GNEApplicationWindow::onCmdSetSuperMode),
201
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F4_SUPERMODE_DATA,       GNEApplicationWindow::onCmdSetSuperMode),
202
    // Toolbar modes
203
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_A_MODE_STARTSIMULATION_ADDITIONALS_STOPS,    GNEApplicationWindow::onCmdSetMode),
204
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_C_MODE_CONNECT_CONTAINER,                    GNEApplicationWindow::onCmdSetMode),
205
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_D_MODE_SINGLESIMULATIONSTEP_DELETE,          GNEApplicationWindow::onCmdSetMode),
206
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_E_MODE_EDGE_EDGEDATA,                        GNEApplicationWindow::onCmdSetMode),
207
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_H_MODE_PROHIBITION_CONTAINERPLAN,            GNEApplicationWindow::onCmdSetMode),
208
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_I_MODE_INSPECT,                              GNEApplicationWindow::onCmdSetMode),
209
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_L_MODE_PERSONPLAN,                           GNEApplicationWindow::onCmdSetMode),
210
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_M_MODE_MOVE_MEANDATA,                        GNEApplicationWindow::onCmdSetMode),
211
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_P_MODE_POLYGON_PERSON,                       GNEApplicationWindow::onCmdSetMode),
212
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_R_MODE_CROSSING_ROUTE_EDGERELDATA,           GNEApplicationWindow::onCmdSetMode),
213
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_S_MODE_STOPSIMULATION_SELECT,                GNEApplicationWindow::onCmdSetMode),
214
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_T_MODE_TLS_TYPE,                             GNEApplicationWindow::onCmdSetMode),
215
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_U_MODE_DECAL_TYPEDISTRIBUTION,               GNEApplicationWindow::onCmdSetMode),
216
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_V_MODE_VEHICLE,                              GNEApplicationWindow::onCmdSetMode),
217
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_W_MODE_WIRE_ROUTEDISTRIBUTION,               GNEApplicationWindow::onCmdSetMode),
218
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_Z_MODE_TAZ_TAZREL,                           GNEApplicationWindow::onCmdSetMode),
219
    // Toolbar edit
220
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_Z_UNDO,                     GNEApplicationWindow::onCmdUndo),
221
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_Z_UNDO,                     GNEApplicationWindow::onUpdUndo),
222
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_Y_REDO,                     GNEApplicationWindow::onCmdRedo),
223
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_Y_REDO,                     GNEApplicationWindow::onUpdRedo),
224
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_UNDOLISTDIALOG,                     GNEApplicationWindow::onCmdOpenUndoListDialog),
225
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_UNDOLISTDIALOG,                     GNEApplicationWindow::onUpdOpenUndoListDialog),
226
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOOLBAREDIT_COMPUTEPATHMANAGER,     GNEApplicationWindow::onCmdComputePathManager),
227
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_TOOLBAREDIT_COMPUTEPATHMANAGER,     GNEApplicationWindow::onUpdComputePathManager),
228
    // Network view options
229
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID,               GNEApplicationWindow::onCmdToggleViewOption),
230
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID,               GNEApplicationWindow::onUpdToggleViewOption),
231
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,  GNEApplicationWindow::onCmdToggleViewOption),
232
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,  GNEApplicationWindow::onUpdToggleViewOption),
233
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES,       GNEApplicationWindow::onCmdToggleViewOption),
234
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES,       GNEApplicationWindow::onUpdToggleViewOption),
235
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS,       GNEApplicationWindow::onCmdToggleViewOption),
236
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS,       GNEApplicationWindow::onUpdToggleViewOption),
237
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES,              GNEApplicationWindow::onCmdToggleViewOption),
238
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES,              GNEApplicationWindow::onUpdToggleViewOption),
239
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS,          GNEApplicationWindow::onCmdToggleViewOption),
240
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS,          GNEApplicationWindow::onUpdToggleViewOption),
241
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS,          GNEApplicationWindow::onCmdToggleViewOption),
242
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS,          GNEApplicationWindow::onUpdToggleViewOption),
243
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS,       GNEApplicationWindow::onCmdToggleViewOption),
244
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS,       GNEApplicationWindow::onUpdToggleViewOption),
245
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS,          GNEApplicationWindow::onCmdToggleViewOption),
246
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS,          GNEApplicationWindow::onUpdToggleViewOption),
247
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION,          GNEApplicationWindow::onCmdToggleViewOption),
248
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION,          GNEApplicationWindow::onUpdToggleViewOption),
249
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES,          GNEApplicationWindow::onCmdToggleViewOption),
250
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES,          GNEApplicationWindow::onUpdToggleViewOption),
251
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY,       GNEApplicationWindow::onCmdToggleViewOption),
252
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY,       GNEApplicationWindow::onUpdToggleViewOption),
253
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES,              GNEApplicationWindow::onCmdToggleViewOption),
254
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES,              GNEApplicationWindow::onUpdToggleViewOption),
255
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION,            GNEApplicationWindow::onCmdToggleViewOption),
256
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION,            GNEApplicationWindow::onUpdToggleViewOption),
257
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES,               GNEApplicationWindow::onCmdToggleViewOption),
258
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES,               GNEApplicationWindow::onUpdToggleViewOption),
259
    FXMAPFUNC(SEL_COMMAND, MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES,        GNEApplicationWindow::onCmdToggleViewOption),
260
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES,        GNEApplicationWindow::onUpdToggleViewOption),
261
    // Demand view options
262
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID,                  GNEApplicationWindow::onCmdToggleViewOption),
263
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID,                  GNEApplicationWindow::onUpdToggleViewOption),
264
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,   GNEApplicationWindow::onCmdToggleViewOption),
265
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,   GNEApplicationWindow::onUpdToggleViewOption),
266
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES,        GNEApplicationWindow::onCmdToggleViewOption),
267
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES,        GNEApplicationWindow::onUpdToggleViewOption),
268
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED,          GNEApplicationWindow::onCmdToggleViewOption),
269
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED,          GNEApplicationWindow::onUpdToggleViewOption),
270
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES,                GNEApplicationWindow::onCmdToggleViewOption),
271
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES,                GNEApplicationWindow::onUpdToggleViewOption),
272
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS,                 GNEApplicationWindow::onCmdToggleViewOption),
273
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS,                 GNEApplicationWindow::onUpdToggleViewOption),
274
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS,        GNEApplicationWindow::onCmdToggleViewOption),
275
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS,        GNEApplicationWindow::onUpdToggleViewOption),
276
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON,                GNEApplicationWindow::onCmdToggleViewOption),
277
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON,                GNEApplicationWindow::onUpdToggleViewOption),
278
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS,     GNEApplicationWindow::onCmdToggleViewOption),
279
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS,     GNEApplicationWindow::onUpdToggleViewOption),
280
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER,             GNEApplicationWindow::onCmdToggleViewOption),
281
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER,             GNEApplicationWindow::onUpdToggleViewOption),
282
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES,      GNEApplicationWindow::onCmdToggleViewOption),
283
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES,      GNEApplicationWindow::onUpdToggleViewOption),
284
    // Data view options
285
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,     GNEApplicationWindow::onCmdToggleViewOption),
286
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE,     GNEApplicationWindow::onUpdToggleViewOption),
287
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS,             GNEApplicationWindow::onCmdToggleViewOption),
288
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS,             GNEApplicationWindow::onUpdToggleViewOption),
289
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES,                  GNEApplicationWindow::onCmdToggleViewOption),
290
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES,                  GNEApplicationWindow::onUpdToggleViewOption),
291
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS,          GNEApplicationWindow::onCmdToggleViewOption),
292
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS,          GNEApplicationWindow::onUpdToggleViewOption),
293
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING,               GNEApplicationWindow::onCmdToggleViewOption),
294
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING,               GNEApplicationWindow::onUpdToggleViewOption),
295
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL,                 GNEApplicationWindow::onCmdToggleViewOption),
296
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL,                 GNEApplicationWindow::onUpdToggleViewOption),
297
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM,              GNEApplicationWindow::onCmdToggleViewOption),
298
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM,              GNEApplicationWindow::onUpdToggleViewOption),
299
    FXMAPFUNC(SEL_COMMAND, MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO,                GNEApplicationWindow::onCmdToggleViewOption),
300
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO,                GNEApplicationWindow::onUpdToggleViewOption),
301
    // view
302
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F9_EDIT_VIEWSCHEME,              GNEApplicationWindow::onCmdEditViewScheme),
303
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F9_EDIT_VIEWSCHEME,              GNEApplicationWindow::onUpdNeedsNetwork),
304
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_I_EDITVIEWPORT,             GNEApplicationWindow::onCmdEditViewport),
305
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_I_EDITVIEWPORT,             GNEApplicationWindow::onUpdNeedsNetwork),
306
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_G_GAMINGMODE_TOGGLEGRID,    GNEApplicationWindow::onCmdToggleGrid),
307
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_G_GAMINGMODE_TOGGLEGRID,    GNEApplicationWindow::onUpdNeedsNetwork),
308
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_J_TOGGLEDRAWJUNCTIONSHAPE,  GNEApplicationWindow::onCmdToggleDrawJunctionShape),
309
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_J_TOGGLEDRAWJUNCTIONSHAPE,  GNEApplicationWindow::onUpdNeedsNetwork),
310
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F11_FRONTELEMENT,                GNEApplicationWindow::onCmdSetFrontElement),
311
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F11_FRONTELEMENT,                GNEApplicationWindow::onUpdNeedsFrontElement),
312
    FXMAPFUNC(SEL_COMMAND,  MID_TOOLBAREDIT_LOADADDITIONALS,            GNEApplicationWindow::onCmdLoadAdditionalsInSUMOGUI),
313
    FXMAPFUNC(SEL_UPDATE,   MID_TOOLBAREDIT_LOADADDITIONALS,            GNEApplicationWindow::onUpdNeedsNetwork),
314
    FXMAPFUNC(SEL_COMMAND,  MID_TOOLBAREDIT_LOADDEMAND,                 GNEApplicationWindow::onCmdLoadDemandInSUMOGUI),
315
    FXMAPFUNC(SEL_UPDATE,   MID_TOOLBAREDIT_LOADDEMAND,                 GNEApplicationWindow::onUpdNeedsNetwork),
316
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_T_OPENNETEDIT_OPENSUMO,     GNEApplicationWindow::onCmdOpenSUMOGUI),
317
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_CTRL_T_OPENNETEDIT_OPENSUMO,     GNEApplicationWindow::onUpdNeedsNetworkElement),
318
    /* Prepared for #6042
319
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_X_CUT,      GNEApplicationWindow::onCmdCut),
320
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_C_COPY,     GNEApplicationWindow::onCmdCopy),
321
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_CTRL_V_PASTE,    GNEApplicationWindow::onCmdPaste),
322
    */
323
    // toolbar lock
324
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_ELEMENT,           GNEApplicationWindow::onCmdLockElements),
325
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_JUNCTION,          GNEApplicationWindow::onCmdLockElements),
326
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_EDGE,              GNEApplicationWindow::onCmdLockElements),
327
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_LANE,              GNEApplicationWindow::onCmdLockElements),
328
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_CONNECTION,        GNEApplicationWindow::onCmdLockElements),
329
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_CROSSING,          GNEApplicationWindow::onCmdLockElements),
330
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_WALKINGAREA,       GNEApplicationWindow::onCmdLockElements),
331
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_ADDITIONALELEMENT, GNEApplicationWindow::onCmdLockElements),
332
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_WIRE,              GNEApplicationWindow::onCmdLockElements),
333
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_TAZ,               GNEApplicationWindow::onCmdLockElements),
334
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_POLYGON,           GNEApplicationWindow::onCmdLockElements),
335
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_POI,               GNEApplicationWindow::onCmdLockElements),
336
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_JPS_WALKABLEAREA,  GNEApplicationWindow::onCmdLockElements),
337
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_JPS_OBSTACLE,      GNEApplicationWindow::onCmdLockElements),
338
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_ROUTE,             GNEApplicationWindow::onCmdLockElements),
339
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_VEHICLE,           GNEApplicationWindow::onCmdLockElements),
340
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_PERSON,            GNEApplicationWindow::onCmdLockElements),
341
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_PERSONTRIP,        GNEApplicationWindow::onCmdLockElements),
342
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_WALK,              GNEApplicationWindow::onCmdLockElements),
343
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_RIDE,              GNEApplicationWindow::onCmdLockElements),
344
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_CONTAINER,         GNEApplicationWindow::onCmdLockElements),
345
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_TRANSPORT,         GNEApplicationWindow::onCmdLockElements),
346
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_TRANSHIP,          GNEApplicationWindow::onCmdLockElements),
347
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_STOP,              GNEApplicationWindow::onCmdLockElements),
348
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_EDGEDATA,          GNEApplicationWindow::onCmdLockElements),
349
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_EDGERELDATA,       GNEApplicationWindow::onCmdLockElements),
350
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_TAZRELDATA,        GNEApplicationWindow::onCmdLockElements),
351
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_ALLELEMENTS,       GNEApplicationWindow::onCmdLockAllElements),
352
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_UNLOCK_ALLELEMENTS,     GNEApplicationWindow::onCmdUnlockAllElements),
353
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_LOCK_SELECTEDELEMENTS,  GNEApplicationWindow::onCmdLockSelectElements),
354
    FXMAPFUNC(SEL_UPDATE,   MID_GNE_LOCK_MENUTITLE,         GNEApplicationWindow::onUpdLockMenuTitle),
355
    // Toolbar processing
356
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND,                   GNEApplicationWindow::onCmdProcessButton),
357
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND,                   GNEApplicationWindow::onUpdNeedsNetwork),
358
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F5_COMPUTEJUNCTIONS_VOLATILE,          GNEApplicationWindow::onCmdProcessButton),
359
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_F5_COMPUTEJUNCTIONS_VOLATILE,          GNEApplicationWindow::onUpdNeedsNetwork),
360
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES,     GNEApplicationWindow::onCmdProcessButton),
361
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES,     GNEApplicationWindow::onUpdNeedsNetwork),
362
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES,            GNEApplicationWindow::onCmdProcessButton),
363
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES,            GNEApplicationWindow::onUpdNeedsNetwork),
364
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F7_ADJUST_PERSON_PLANS,                GNEApplicationWindow::onCmdProcessButton),
365
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_F7_ADJUST_PERSON_PLANS,                GNEApplicationWindow::onUpdNeedsNetwork),
366
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS,    GNEApplicationWindow::onCmdProcessButton),
367
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS,    GNEApplicationWindow::onUpdNeedsNetwork),
368
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOGGLE_COMPUTE_NETWORK_DATA,                    GNEApplicationWindow::onCmdToggleComputeNetworkData),
369
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOGGLE_UNDOREDO,                                GNEApplicationWindow::onCmdToggleUndoRedo),
370
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_TOGGLE_UNDOREDO_LOADING,                        GNEApplicationWindow::onCmdToggleUndoRedoLoading),
371
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F10_SUMOOPTIONSMENU,                   GNEApplicationWindow::onCmdOpenSumoOptionsDialog),
372
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_F10_SUMOOPTIONSMENU,                   GNEApplicationWindow::onUpdNeedsNetwork),
373
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F10_OPTIONSMENU,                             GNEApplicationWindow::onCmdOpenOptionsDialog),
374
    // Toolbar locate
375
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_J_LOCATEJUNCTION,      GNEApplicationWindow::onCmdLocate),
376
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_J_LOCATEJUNCTION,      GNEApplicationWindow::onUpdNeedsNetwork),
377
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_E_LOCATEEDGE,          GNEApplicationWindow::onCmdLocate),
378
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_E_LOCATEEDGE,          GNEApplicationWindow::onUpdNeedsNetwork),
379
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA,   GNEApplicationWindow::onCmdLocate),
380
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_W_LOCATEWALKINGAREA,   GNEApplicationWindow::onUpdNeedsNetwork),
381
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_V_LOCATEVEHICLE,       GNEApplicationWindow::onCmdLocate),
382
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_V_LOCATEVEHICLE,       GNEApplicationWindow::onUpdNeedsNetwork),
383
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_P_LOCATEPERSON,        GNEApplicationWindow::onCmdLocate),
384
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_P_LOCATEPERSON,        GNEApplicationWindow::onUpdNeedsNetwork),
385
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_C_LOCATECONTAINER,     GNEApplicationWindow::onCmdLocate),
386
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_C_LOCATECONTAINER,     GNEApplicationWindow::onUpdNeedsNetwork),
387
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_R_LOCATEROUTE,         GNEApplicationWindow::onCmdLocate),
388
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_R_LOCATEROUTE,         GNEApplicationWindow::onUpdNeedsNetwork),
389
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_S_LOCATESTOP,          GNEApplicationWindow::onCmdLocate),
390
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_S_LOCATESTOP,          GNEApplicationWindow::onUpdNeedsNetwork),
391
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_T_LOCATETLS,           GNEApplicationWindow::onCmdLocate),
392
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_T_LOCATETLS,           GNEApplicationWindow::onUpdNeedsNetwork),
393
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL,    GNEApplicationWindow::onCmdLocate),
394
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL,    GNEApplicationWindow::onUpdNeedsNetwork),
395
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_O_LOCATEPOI,           GNEApplicationWindow::onCmdLocate),
396
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_O_LOCATEPOI,           GNEApplicationWindow::onUpdNeedsNetwork),
397
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_L_LOCATEPOLY,          GNEApplicationWindow::onCmdLocate),
398
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_SHIFT_L_LOCATEPOLY,          GNEApplicationWindow::onUpdNeedsNetwork),
399
    // toolbar python tools
400
    FXMAPFUNC(SEL_COMMAND, MID_GNE_OPENPYTHONTOOLDIALOG,        GNEApplicationWindow::onCmdOpenPythonToolDialog),
401
    FXMAPFUNC(SEL_UPDATE,  MID_GNE_OPENPYTHONTOOLDIALOG,        GNEApplicationWindow::onUpdPythonTool),
402
    FXMAPFUNC(SEL_COMMAND, MID_GNE_RUNPYTHONTOOL,               GNEApplicationWindow::onCmdRunPythonTool),
403
    FXMAPFUNC(SEL_COMMAND, MID_GNE_POSTPROCESSINGPYTHONTOOL,    GNEApplicationWindow::onCmdPostProcessingPythonTool),
404
    // toolbar windows
405
    FXMAPFUNC(SEL_COMMAND,  MID_CLEARMESSAGEWINDOW, GNEApplicationWindow::onCmdClearMsgWindow),
406
    // toolbar help
407
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F1_ONLINEDOCUMENTATION,  GNEApplicationWindow::onCmdHelp),
408
    FXMAPFUNC(SEL_COMMAND,  MID_CHANGELOG,                      GNEApplicationWindow::onCmdChangelog),
409
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEYS,                        GNEApplicationWindow::onCmdHotkeys),
410
    FXMAPFUNC(SEL_COMMAND,  MID_TUTORIAL,                       GNEApplicationWindow::onCmdTutorial),
411
    FXMAPFUNC(SEL_COMMAND,  MID_FEEDBACK,                       GNEApplicationWindow::onCmdFeedback),
412
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_F12_ABOUT,               GNEApplicationWindow::onCmdAbout),
413
    // alt + <number>
414
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_0_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
415
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_0_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
416
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_1_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
417
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_1_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
418
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_2_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
419
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_2_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
420
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_3_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
421
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_3_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
422
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_4_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
423
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_4_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
424
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_5_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
425
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_5_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
426
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_6_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
427
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_6_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
428
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_7_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
429
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_7_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
430
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_8_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
431
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_8_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
432
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_ALT_9_TOGGLEEDITOPTION,  GNEApplicationWindow::onCmdToggleEditOptions),
433
    FXMAPFUNC(SEL_UPDATE,   MID_HOTKEY_ALT_9_TOGGLEEDITOPTION,  GNEApplicationWindow::onUpdNeedsNetwork),
434
    // key events
435
    FXMAPFUNC(SEL_KEYPRESS,     0,                      GNEApplicationWindow::onKeyPress),
436
    FXMAPFUNC(SEL_KEYRELEASE,   0,                      GNEApplicationWindow::onKeyRelease),
437
    FXMAPFUNC(SEL_COMMAND,      MID_HOTKEY_ESC,         GNEApplicationWindow::onCmdAbort),
438
    FXMAPFUNC(SEL_COMMAND,      MID_HOTKEY_DEL,         GNEApplicationWindow::onCmdDel),
439
    FXMAPFUNC(SEL_COMMAND,      MID_HOTKEY_ENTER,       GNEApplicationWindow::onCmdEnter),
440
    FXMAPFUNC(SEL_COMMAND,      MID_HOTKEY_BACKSPACE,   GNEApplicationWindow::onCmdBackspace),
441
    // threads events
442
    FXMAPFUNC(FXEX::SEL_THREAD_EVENT,   ID_LOADTHREAD_EVENT,    GNEApplicationWindow::onLoadThreadEvent),
443
    FXMAPFUNC(FXEX::SEL_THREAD,         ID_LOADTHREAD_EVENT,    GNEApplicationWindow::onLoadThreadEvent),
444
    // edge template functions
445
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F1_TEMPLATE_SET,       GNEApplicationWindow::onCmdSetTemplate),
446
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F2_TEMPLATE_COPY,      GNEApplicationWindow::onCmdCopyTemplate),
447
    FXMAPFUNC(SEL_COMMAND,  MID_HOTKEY_SHIFT_F3_TEMPLATE_CLEAR,     GNEApplicationWindow::onCmdClearTemplate),
448
    // languages
449
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_EN,    GNEApplicationWindow::onCmdChangeLanguage),
450
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_EN,    GNEApplicationWindow::onUpdChangeLanguage),
451
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_DE,    GNEApplicationWindow::onCmdChangeLanguage),
452
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_DE,    GNEApplicationWindow::onUpdChangeLanguage),
453
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_ES,    GNEApplicationWindow::onCmdChangeLanguage),
454
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_ES,    GNEApplicationWindow::onUpdChangeLanguage),
455
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_PT,    GNEApplicationWindow::onCmdChangeLanguage),
456
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_PT,    GNEApplicationWindow::onUpdChangeLanguage),
457
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_FR,    GNEApplicationWindow::onCmdChangeLanguage),
458
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_FR,    GNEApplicationWindow::onUpdChangeLanguage),
459
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_IT,    GNEApplicationWindow::onCmdChangeLanguage),
460
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_IT,    GNEApplicationWindow::onUpdChangeLanguage),
461
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_ZH,    GNEApplicationWindow::onCmdChangeLanguage),
462
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_ZH,    GNEApplicationWindow::onUpdChangeLanguage),
463
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_ZHT,   GNEApplicationWindow::onCmdChangeLanguage),
464
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_ZHT,   GNEApplicationWindow::onUpdChangeLanguage),
465
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_TR,    GNEApplicationWindow::onCmdChangeLanguage),
466
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_TR,    GNEApplicationWindow::onUpdChangeLanguage),
467
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_HU,    GNEApplicationWindow::onCmdChangeLanguage),
468
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_HU,    GNEApplicationWindow::onUpdChangeLanguage),
469
    FXMAPFUNC(SEL_COMMAND,  MID_LANGUAGE_JA,    GNEApplicationWindow::onCmdChangeLanguage),
470
    FXMAPFUNC(SEL_UPDATE,   MID_LANGUAGE_JA,    GNEApplicationWindow::onUpdChangeLanguage),
471
    // tools
472
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_RUNNETGENERATE,             GNEApplicationWindow::onCmdRunNetgenerate),
473
    FXMAPFUNC(SEL_COMMAND,  MID_GNE_POSTPROCESSINGNETGENERATE,  GNEApplicationWindow::onCmdPostprocessingNetgenerate),
474
    // other
475
    FXMAPFUNC(SEL_CLIPBOARD_REQUEST,    0,                                          GNEApplicationWindow::onClipboardRequest),
476
    FXMAPFUNC(SEL_COMMAND,              MID_HOTKEY_SHIFT_ESC_CLEARSELECTION,        GNEApplicationWindow::onCmdClearSelectionShortcut),
477
    FXMAPFUNC(SEL_COMMAND,              MID_HOTKEY_SHIFT_F12_FOCUSUPPERELEMENT,     GNEApplicationWindow::onCmdFocusFrame),
478
    FXMAPFUNC(SEL_UPDATE,               MID_GNE_MODESMENUTITLE,                     GNEApplicationWindow::onUpdRequireViewNet),
479
    FXMAPFUNC(SEL_UPDATE,               MID_GNE_RECOMPUTINGNEEDED,                  GNEApplicationWindow::onUpdRequireRecomputing),
480
    FXMAPFUNC(SEL_COMMAND,              MID_GNE_TOGGLE_TIMEFORMAT,                  GNEApplicationWindow::onCmdToggleTimeFormat),
481
    FXMAPFUNC(SEL_UPDATE,               MID_GNE_TOGGLE_TIMEFORMAT,                  GNEApplicationWindow::onUpdToggleTimeFormat),
482
    FXMAPFUNC(SEL_COMMAND,              MID_RUNTESTS,                               GNEApplicationWindow::onCmdRunTests),
483
};
484

485
// Object implementation
486
FXIMPLEMENT(GNEApplicationWindow, FXMainWindow, GNEApplicationWindowMap, ARRAYNUMBER(GNEApplicationWindowMap))
487

488
// ===========================================================================
489
// GNEApplicationWindow method definitions
490
// ===========================================================================
491
#ifdef _MSC_VER
492
#pragma warning(push)
493
#pragma warning(disable: 4355) // mask warning about "this" in initializers
494
#endif
495
GNEApplicationWindow::GNEApplicationWindow(FXApp* app, const GNETagPropertiesDatabase* tagPropertiesDatabase, const std::string& configPattern) :
496
    GUIMainWindow(app),
497
    myTagPropertiesDatabase(tagPropertiesDatabase),
498
    myUndoList(new GNEUndoList(this)),
499
    myConfigPattern(configPattern),
500
    myToolbarsGrip(this),
501
    myMenuBarFile(this),
502
    myFileMenuCommands(this),
503
    myModesMenuCommands(this),
504
    myEditMenuCommands(this),
505
    myLockMenuCommands(this),
506
    myProcessingMenuCommands(this),
507
    myLocateMenuCommands(this),
508
    myToolsMenuCommands(this),
509
    myWindowsMenuCommands(this),
510
    myHelpMenuCommands(this),
511
    mySupermodeCommands(this),
512
    myTitlePrefix("netedit " VERSION_STRING),
513
    myAllowUndoRedo(getApp()->reg().readBoolEntry("NETEDIT", "AllowUndoRedo", true) == TRUE),
514
    myAllowUndoRedoLoading(getApp()->reg().readBoolEntry("NETEDIT", "AllowUndoRedoLoading", true) == TRUE) {
515
    // init icons
516
    GUIIconSubSys::initIcons(app);
517
    // init Textures
518
    GUITextureSubSys::initTextures(app);
519
    // init cursors
520
    GUICursorSubSys::initCursors(app);
521
    // set tooltip options
522
    app->setTooltipTime(1000000000);
523
    app->setTooltipPause(1000000000);
524
    // set SUMO Options descriptions
525
    mySumoOptions.setApplicationDescription(TL("A microscopic, multi-modal traffic simulation."));
526
    mySumoOptions.setApplicationName("sumo", "Eclipse SUMO sumo " VERSION_STRING);
527
    // set default netedit options
528
    GNELoadThread::fillOptions(myOriginalNeteditOptions);
529
    GNELoadThread::setDefaultOptions(myOriginalNeteditOptions);
530
    // parse options
531
    TemplateHandler::parseTemplate(mySumoOptions, sumoTemplate);
532
    TemplateHandler::parseTemplate(myOriginalSumoOptions, sumoTemplate);
533
    TemplateHandler::parseTemplate(myNetgenerateOptions, netgenerateTemplate);
534
    TemplateHandler::parseTemplate(myOriginalNetgenerateOptions, netgenerateTemplate);
535
}
536
#ifdef _MSC_VER
537
#pragma warning(pop)
538
#endif
539

540

541
void
542
GNEApplicationWindow::dependentBuild() {
543
    // do this not twice
544
    if (myHadDependentBuild) {
545
        // do not translate debug messages
546
        WRITE_ERROR("DEBUG: GNEApplicationWindow::dependentBuild called twice");
547
        return;
548
    }
549
    myHadDependentBuild = true;
550
    setTarget(this);
551
    setSelector(MID_WINDOW);
552
    // build toolbar menu
553
    getToolbarsGrip().buildMenuToolbarsGrip();
554
    // build the thread - io
555
    myLoadThreadEvent.setTarget(this);
556
    myLoadThreadEvent.setSelector(ID_LOADTHREAD_EVENT);
557
    // build the status bar
558
    myStatusbar = new FXStatusBar(this, GUIDesignStatusBar);
559
    // build geo coordinates label
560
    auto requireRecomputingFrame = new FXHorizontalFrame(myStatusbar, GUIDesignHorizontalFrameStatusBar);
561
    myRequireRecomputingButton = new MFXButtonTooltip(requireRecomputingFrame, myStaticTooltipMenu,
562
            TL("Recomputing"), nullptr, this, MID_GNE_RECOMPUTINGNEEDED, GUIDesignButtonStatusBarFixed);
563
    myRequireRecomputingButton->setHelpText(TL("Recomputing is needed"));
564
    // build geo coordinates label
565
    myGeoFrame = new FXHorizontalFrame(myStatusbar, GUIDesignHorizontalFrameStatusBar);
566
    myGeoCoordinate = new FXLabel(myGeoFrame, TL("N/A"), nullptr, GUIDesignLabelStatusBar);
567
    myGeoCoordinate->setHelpText(TL("Original coordinate (before coordinate transformation in netconvert)"));
568
    // build cartesian coordinates label
569
    myCartesianFrame = new FXHorizontalFrame(myStatusbar, GUIDesignHorizontalFrameStatusBar);
570
    myCartesianCoordinate = new FXLabel(myCartesianFrame, TL("N/A"), nullptr, GUIDesignLabelStatusBar);
571
    myCartesianCoordinate->setHelpText(TL("Network coordinate"));
572
    // build test coordinates label (only if gui-testing is enabled)
573
    myTestFrame = new FXHorizontalFrame(myStatusbar, GUIDesignHorizontalFrameStatusBar);
574
    myTestCoordinate = new FXLabel(myTestFrame, TL("N/A"), nullptr, GUIDesignLabelStatusBar);
575
    myTestCoordinate->setHelpText(TL("Test coordinate"));
576
    myTestCoordinate->setTextColor(GUIDesignTextColorRed);
577
    myTestFrame->hide();
578
    // make the window a mdi-window
579
    myMainSplitter = new FXSplitter(this, GUIDesignSplitter | SPLITTER_VERTICAL | SPLITTER_REVERSED);
580
    myMDIClient = new FXMDIClient(myMainSplitter, GUIDesignSplitterMDI);
581
    myMDIMenu = new FXMDIMenu(this, myMDIClient);
582
    // build the message window
583
    myMessageWindow = new GUIMessageWindow(myMainSplitter, this);
584
    myMainSplitter->setSplit(1, 65);
585
    // fill menu and tool bar
586
    fillMenuBar();
587
    // build additional threads
588
    myLoadThread = new GNELoadThread(this, myThreadEvents, myLoadThreadEvent);
589
    // check if create internal test system
590
    if (OptionsCont::getOptions().getString("test-file").size() > 0) {
591
        myInternalTest = new GNEInternalTest(OptionsCont::getOptions().getString("test-file"));
592
    }
593
    // set the status bar
594
    setStatusBarText(TL("Ready."));
595
    // set the caption
596
    setTitle(myTitlePrefix);
597
    // set Netedit ICON
598
    setIcon(GUIIconSubSys::getIcon(GUIIcon::NETEDIT));
599
    setMiniIcon(GUIIconSubSys::getIcon(GUIIcon::NETEDIT_MINI));
600
    // build netedit Accelerators (hotkeys)
601
    GUIShortcutsSubSys::buildAccelerators(getAccelTable(), this, false);
602
}
603

604

605
void
606
GNEApplicationWindow::create() {
607
    // set windows size and position
608
    setWindowSizeAndPos();
609
    // set current folder
610
    gCurrentFolder = getApp()->reg().readStringEntry("SETTINGS", "basedir", "");
611
    // Create main window
612
    FXMainWindow::create();
613
    // get text width
614
    const auto textWidth = getApp()->getNormalFont()->getTextWidth("8", 1) * 22;
615
    // adjust cartesian and geo frame
616
    myCartesianFrame->setWidth(textWidth);
617
    myGeoFrame->setWidth(textWidth);
618
    // fill online maps
619
    if (myOnlineMaps.empty()) {
620
        myOnlineMaps["GeoHack"] = "https://geohack.toolforge.org/geohack.php?params=%lat;%lon_scale:1000";
621
        myOnlineMaps["Google Maps"] = "https://www.google.com/maps?ll=%lat,%lon&t=h&z=18";
622
        myOnlineMaps["OSM"] = "https://www.openstreetmap.org/?mlat=%lat&mlon=%lon&zoom=18&layers=M";
623
    }
624
    // show application windows
625
    show(PLACEMENT_DEFAULT);
626
    // check if maximice
627
    if (!OptionsCont::getOptions().isSet("window-size")) {
628
        if (getApp()->reg().readIntEntry("SETTINGS", "maximized", 0) == 1) {
629
            maximize();
630
        }
631
    }
632
}
633

634

635
GNEApplicationWindow::~GNEApplicationWindow() {
636
    closeAllWindows();
637
    // Close icons
638
    GUIIconSubSys::close();
639
    // Close gifs (Textures)
640
    GUITextureSubSys::close();
641
    GUICursorSubSys::close();
642
    // delete visuals
643
    delete myGLVisual;
644
    // must delete menus to avoid segfault on removing accelerators
645
    // (http://www.fox-toolkit.net/faq#TOC-What-happens-when-the-application-s)
646
    delete myFileMenuNeteditConfig;
647
    delete myFileMenuSumoConfig;
648
    delete myFileMenuTLS;
649
    delete myFileMenuEdgeTypes;
650
    delete myFileMenuAdditionals;
651
    delete myFileMenuDemandElements;
652
    delete myFileMenuMeanDataElements;
653
    delete myFileMenuDataElements;
654
    delete myFileMenuRecentNetworks;
655
    delete myFileMenuRecentConfigs;
656
    delete myFileMenu;
657
    delete myModesMenu;
658
    delete myEditMenu;
659
    delete myLockMenu;
660
    delete myProcessingMenu;
661
    delete myLocatorMenu;
662
    delete myToolsMenu;
663
    delete myToolsDetectorMenu;
664
    delete myToolsDistrictMenu;
665
    delete myToolsDRTMenu;
666
    delete myToolsEmissionsMenu;
667
    delete myToolsImportMenu;
668
    delete myToolsImportCityBrainMenu;
669
    delete myToolsImportGTFSMenu;
670
    delete myToolsImportVissim;
671
    delete myToolsImportVisum;
672
    delete myToolsNetMenu;
673
    delete myToolsRouteMenu;
674
    delete myToolsOutputMenu;
675
    delete myToolsShapes;
676
    delete myToolsTLS;
677
    delete myToolsTurnDefs;
678
    delete myToolsVisualizationMenu;
679
    delete myToolsXML;
680
    delete myWindowMenu;
681
    delete myHelpMenu;
682
    delete myLanguageMenu;
683
    // Delete load thread
684
    delete myLoadThread;
685
    if (myInternalTest) {
686
        delete myInternalTest;
687
    }
688
    // drop all events
689
    while (!myThreadEvents.empty()) {
690
        // get the next event
691
        GUIEvent* e = myThreadEvents.top();
692
        myThreadEvents.pop();
693
        delete e;
694
    }
695
    // delete undoList and dialog
696
    delete myUndoList;
697
}
698

699

700
long
701
GNEApplicationWindow::onCmdQuit(FXObject*, FXSelector, void*) {
702
    if (askSaveElements()) {
703
        storeWindowSizeAndPos();
704
        getApp()->reg().writeStringEntry("SETTINGS", "basedir", gCurrentFolder.text());
705
        if (isMaximized()) {
706
            getApp()->reg().writeIntEntry("SETTINGS", "maximized", 1);
707
        } else {
708
            getApp()->reg().writeIntEntry("SETTINGS", "maximized", 0);
709
        }
710
        getApp()->exit(0);
711
    }
712
    return 1;
713
}
714

715

716
long
717
GNEApplicationWindow::onCmdEditChosen(FXObject*, FXSelector, void*) {
718
    GUIDialog_GLChosenEditor* chooser =
719
        new GUIDialog_GLChosenEditor(this, &gSelected);
720
    chooser->create();
721
    chooser->show();
722
    return 1;
723
}
724

725

726
long
727
GNEApplicationWindow::onCmdNewNetwork(FXObject*, FXSelector, void*) {
728
    // check if close current simulation
729
    if (onCmdClose(0, 0, 0) == 1) {
730
        // create new network
731
        createNewNetwork();
732
    }
733
    return 1;
734
}
735

736

737
long
738
GNEApplicationWindow::onCmdOpenNetconvertConfig(FXObject*, FXSelector, void*) {
739
    // get netconvert file dialog
740
    const auto netConvertFileDialog = GNEFileDialog(this, TL("netconvert config file"),
741
                                      SUMOXMLDefinitions::NetconvertConfigFileExtensions.getStrings(),
742
                                      GNEFileDialog::OpenMode::LOAD_SINGLE,
743
                                      GNEFileDialog::ConfigType::NETEDIT);
744
    // continue depending of netConvertFileDialog
745
    if ((netConvertFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
746
        // load configuration
747
        loadConfiguration(netConvertFileDialog.getFilename());
748
    }
749
    return 1;
750
}
751

752

753
long
754
GNEApplicationWindow::onCmdOpenNetwork(FXObject*, FXSelector, void*) {
755
    // get netconvert filename
756
    const auto networkFileDialog = GNEFileDialog(this, TL("network file"),
757
                                   SUMOXMLDefinitions::NetFileExtensions.getStrings(),
758
                                   GNEFileDialog::OpenMode::LOAD_SINGLE,
759
                                   GNEFileDialog::ConfigType::NETEDIT);
760
    // continue depending of netconvertFile
761
    if ((networkFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
762
        // load network
763
        loadNetwork(networkFileDialog.getFilename());
764
    }
765
    return 0;
766
}
767

768

769
long
770
GNEApplicationWindow::onCmdOpenForeign(FXObject*, FXSelector, void*) {
771
    // get OSM file dilaog
772
    const auto OSMFileDialog = GNEFileDialog(this, TL("OpenStreetMap file"),
773
                               SUMOXMLDefinitions::OSMFileExtensions.getStrings(),
774
                               GNEFileDialog::OpenMode::LOAD_SINGLE,
775
                               GNEFileDialog::ConfigType::NETEDIT);
776
    // continue depending of netconvertFile
777
    if ((OSMFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
778
        loadOSM(OSMFileDialog.getFilename());
779
    }
780
    return 1;
781
}
782

783

784
long
785
GNEApplicationWindow::onCmdOpenNeteditConfig(FXObject*, FXSelector, void*) {
786
    auto& neteditOptions = OptionsCont::getOptions();
787
    // get netconvert filename
788
    const auto neteditConfigFileDialog = GNEFileDialog(this, TL("netedit config file"),
789
                                         SUMOXMLDefinitions::NeteditConfigFileExtensions.getStrings(),
790
                                         GNEFileDialog::OpenMode::LOAD_SINGLE,
791
                                         GNEFileDialog::ConfigType::NETEDIT);
792
    // continue depending of netconvertFile
793
    if ((neteditConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
794
        // stop test before calling load thread
795
        if (myInternalTest) {
796
            myInternalTest->stopTests();
797
        }
798
        // reset netedit options
799
        myLoadThread->fillOptions(neteditOptions);
800
        myLoadThread->setDefaultOptions(neteditOptions);
801
        // set netedit configuration file to load
802
        neteditOptions.resetWritable();
803
        neteditOptions.set("configuration-file", neteditConfigFileDialog.getFilename());
804
        // run load thread
805
        myLoadThread->loadNetworkOrConfig();
806
        // update view
807
        update();
808
    }
809
    return 1;
810
}
811

812

813
long
814
GNEApplicationWindow::onCmdOpenSumoConfig(FXObject*, FXSelector, void*) {
815
    auto& neteditOptions = OptionsCont::getOptions();
816
    // get netconvert filename
817
    const auto sumoConfigFileDialog = GNEFileDialog(this, TL("sumo config file"),
818
                                      SUMOXMLDefinitions::SumoConfigFileExtensions.getStrings(),
819
                                      GNEFileDialog::OpenMode::LOAD_SINGLE,
820
                                      GNEFileDialog::ConfigType::NETEDIT);
821
    // continue depending of netconvertFile
822
    if ((sumoConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
823
        // stop test before calling load thread
824
        if (myInternalTest) {
825
            myInternalTest->stopTests();
826
        }
827
        // reset options
828
        myLoadThread->fillOptions(neteditOptions);
829
        myLoadThread->setDefaultOptions(neteditOptions);
830
        // set sumo configuration file to load
831
        neteditOptions.resetWritable();
832
        neteditOptions.set("sumocfg-file", sumoConfigFileDialog.getFilename());
833
        // run load thread
834
        myLoadThread->loadNetworkOrConfig();
835
        // update view
836
        update();
837
    }
838
    return 1;
839
}
840

841

842
long
843
GNEApplicationWindow::onCmdReloadNeteditConfig(FXObject*, FXSelector, void*) {
844
    // check if close current simulation
845
    if (onCmdClose(0, 0, 0) == 1) {
846
        // stop test before calling load thread
847
        if (myInternalTest) {
848
            myInternalTest->stopTests();
849
        }
850
        auto& neteditOptions = OptionsCont::getOptions();
851
        // get existent configuration file
852
        const auto neteditConfigFile = neteditOptions.getString("configuration-file");
853
        // reset options
854
        myLoadThread->fillOptions(neteditOptions);
855
        myLoadThread->setDefaultOptions(neteditOptions);
856
        // set configuration file to load
857
        neteditOptions.resetWritable();
858
        neteditOptions.set("configuration-file", neteditConfigFile);
859
        // run load thread
860
        myLoadThread->loadNetworkOrConfig();
861
        // update view
862
        update();
863
    }
864
    return 1;
865
}
866

867

868
long
869
GNEApplicationWindow::onCmdReloadSumoConfig(FXObject*, FXSelector, void*) {
870
    auto& neteditOptions = OptionsCont::getOptions();
871
    // check if close current simulation
872
    if (onCmdClose(0, 0, 0) == 1) {
873
        // stop test before calling load thread
874
        if (myInternalTest) {
875
            myInternalTest->stopTests();
876
        }
877
        const auto sumoConfigFile = neteditOptions.getString("sumocfg-file");
878
        // reset options
879
        myLoadThread->fillOptions(neteditOptions);
880
        myLoadThread->setDefaultOptions(neteditOptions);
881
        // set configuration file to load
882
        neteditOptions.resetWritable();
883
        neteditOptions.set("sumocfg-file", sumoConfigFile);
884
        // run load thread
885
        myLoadThread->loadNetworkOrConfig();
886
        // update view
887
        update();
888
    }
889
    return 1;
890
}
891

892

893
long
894
GNEApplicationWindow::onUpdReloadNeteditConfig(FXObject* sender, FXSelector, void*) {
895
    // check if file exist
896
    if (myViewNet && !OptionsCont::getOptions().getString("configuration-file").empty()) {
897
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
898
    } else {
899
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
900
    }
901
}
902

903

904
long
905
GNEApplicationWindow::onUpdReloadSumoConfig(FXObject* sender, FXSelector, void*) {
906
    // check if file exist
907
    if (myViewNet && !OptionsCont::getOptions().getString("sumocfg-file").empty()) {
908
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
909
    } else {
910
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
911
    }
912
}
913

914

915
long
916
GNEApplicationWindow::onCmdOpenTLSPrograms(FXObject*, FXSelector, void*) {
917
    auto& neteditOptions = OptionsCont::getOptions();
918
    // get netconvert filename
919
    const auto TLSfileDialog = GNEFileDialog(this, TL("Traffic Light definitions file"),
920
                               SUMOXMLDefinitions::TLSFileExtensions.getStrings(),
921
                               GNEFileDialog::OpenMode::LOAD_SINGLE,
922
                               GNEFileDialog::ConfigType::NETEDIT);
923
    // continue depending of netconvertFile
924
    if (TLSfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
925
        // set file to load
926
        neteditOptions.resetWritable();
927
        neteditOptions.set("tls-file", TLSfileDialog.getFilename());
928
        // load traffic lights
929
        loadTrafficLights(false);
930
    }
931
    return 1;
932
}
933

934

935
long
936
GNEApplicationWindow::onCmdReloadTLSPrograms(FXObject*, FXSelector, void*) {
937
    // load traffic lights
938
    loadTrafficLights(true);
939
    return 1;
940
}
941

942

943
long
944
GNEApplicationWindow::onUpdReloadTLSPrograms(FXObject* sender, FXSelector, void*) {
945
    // check if file exist
946
    if (myViewNet && OptionsCont::getOptions().getString("tls-file").empty()) {
947
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
948
    } else {
949
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
950
    }
951
}
952

953

954
long
955
GNEApplicationWindow::onCmdOpenEdgeTypes(FXObject*, FXSelector, void*) {
956
    auto& neteditOptions = OptionsCont::getOptions();
957
    // get netconvert filename
958
    const auto edgeTypesFileDialog = GNEFileDialog(this, TL("EdgeTypes file"),
959
                                     SUMOXMLDefinitions::EdgeTypeFileExtensions.getStrings(),
960
                                     GNEFileDialog::OpenMode::LOAD_SINGLE,
961
                                     GNEFileDialog::ConfigType::NETEDIT);
962
    // continue depending of netconvertFile
963
    if (edgeTypesFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
964
        // set file to load
965
        neteditOptions.resetWritable();
966
        neteditOptions.set("edgetypes-file", edgeTypesFileDialog.getFilename());
967
        // load edge types
968
        loadEdgeTypes(false);
969
    }
970
    return 1;
971
}
972

973

974
long
975
GNEApplicationWindow::onCmdReloadEdgeTypes(FXObject*, FXSelector, void*) {
976
    // load edge types
977
    loadEdgeTypes(true);
978
    return 0;
979
}
980

981

982
long
983
GNEApplicationWindow::onUpdReloadEdgeTypes(FXObject* sender, FXSelector, void*) {
984
    // check if file exist
985
    if (myViewNet && OptionsCont::getOptions().getString("edgetypes-file").empty()) {
986
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
987
    } else {
988
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
989
    }
990
}
991

992

993
long
994
GNEApplicationWindow::onCmdSmartReload(FXObject*, FXSelector, void*) {
995
    auto& neteditOptions = OptionsCont::getOptions();
996
    // check if close current file
997
    if (onCmdClose(0, 0, 0) == 1) {
998
        // stop test before calling load thread
999
        if (myInternalTest) {
1000
            myInternalTest->stopTests();
1001
        }
1002
        // store size, position and viewport
1003
        storeWindowSizeAndPos();
1004
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1005
        // set flag
1006
        myAmLoading = true;
1007
        // get files
1008
        const auto neteditConfig = neteditOptions.getString("configuration-file");
1009
        const auto sumoConfig = neteditOptions.getString("sumocfg-file");
1010
        const auto networkFile = neteditOptions.getString("net-file");
1011
        // fill (reset) all options
1012
        myLoadThread->fillOptions(neteditOptions);
1013
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1014
        myLoadThread->setDefaultOptions(neteditOptions);
1015
        // set file to load
1016
        neteditOptions.resetWritable();
1017
        if (neteditConfig.size() > 0) {
1018
            neteditOptions.set("configuration-file", neteditConfig);
1019
            // set status bar
1020
            setStatusBarText(TL("Reloading netedit config file '") + neteditConfig + "'");
1021
        } else if (sumoConfig.size() > 0) {
1022
            neteditOptions.set("sumocfg-file", sumoConfig);
1023
            // set status bar
1024
            setStatusBarText(TL("Reloading sumo config file '") + sumoConfig + "'");
1025
        } else if (networkFile.size() > 0) {
1026
            neteditOptions.set("net-file", networkFile);
1027
            // set status bar
1028
            setStatusBarText(TL("Reloading network file '") + networkFile + "'");
1029
        } else {
1030
            // nothing to load
1031
            return 0;
1032
        }
1033
        // load network
1034
        myLoadThread->loadNetworkOrConfig();
1035
    }
1036
    return 1;
1037
}
1038

1039

1040
long
1041
GNEApplicationWindow::onUpdSmartReload(FXObject* sender, FXSelector, void*) {
1042
    auto& neteditOptions = OptionsCont::getOptions();
1043
    // declare strings
1044
    FXString neteditConfig = TL("&Reload Netedit config");
1045
    FXString sumoConfig = TL("&Reload Sumo config");
1046
    FXString netFile = TL("&Reload Network");
1047
    FXString reload = TL("&Reload");
1048
    // check options
1049
    if (myNet == nullptr) {
1050
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1051
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &reload);
1052
    } else if (neteditOptions.getString("configuration-file").size() > 0) {
1053
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1054
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &neteditConfig);
1055
    } else if (neteditOptions.getString("sumocfg-file").size() > 0) {
1056
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1057
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &sumoConfig);
1058
    } else if (neteditOptions.getString("net-file").size() > 0) {
1059
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1060
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &netFile);
1061
    } else {
1062
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1063
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &reload);
1064
    }
1065
    return 1;
1066
}
1067

1068

1069
long
1070
GNEApplicationWindow::onCmdReloadNetwork(FXObject*, FXSelector, void*) {
1071
    auto& neteditOptions = OptionsCont::getOptions();
1072
    // check if close current file
1073
    if (onCmdClose(0, 0, 0) == 1) {
1074
        // stop test before calling load thread
1075
        if (myInternalTest) {
1076
            myInternalTest->stopTests();
1077
        }
1078
        // store size, position and viewport
1079
        storeWindowSizeAndPos();
1080
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1081
        // set flag
1082
        myAmLoading = true;
1083
        // get network
1084
        const auto networkFile = neteditOptions.getString("net-file");
1085
        // fill (reset) all options
1086
        myLoadThread->fillOptions(neteditOptions);
1087
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1088
        myLoadThread->setDefaultOptions(neteditOptions);
1089
        // set file to load
1090
        neteditOptions.resetWritable();
1091
        neteditOptions.set("net-file", networkFile);
1092
        // set status bar
1093
        setStatusBarText(TL("Reloading network file '") + networkFile + "'");
1094
        // loaad network
1095
        myLoadThread->loadNetworkOrConfig();
1096
    }
1097
    return 1;
1098
}
1099

1100

1101
long
1102
GNEApplicationWindow::onUpdReloadNetwork(FXObject* sender, FXSelector, void*) {
1103
    auto& neteditOptions = OptionsCont::getOptions();
1104
    if (myNet == nullptr) {
1105
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1106
        sender->handle(this, FXSEL(SEL_COMMAND, ID_HIDE), nullptr);
1107
    } else if ((neteditOptions.getString("net-file").size() > 0) &&
1108
               ((neteditOptions.getString("configuration-file").size() > 0) || (neteditOptions.getString("sumocfg-file").size() > 0))) {
1109
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1110
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SHOW), nullptr);
1111
    } else {
1112
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1113
        sender->handle(this, FXSEL(SEL_COMMAND, ID_HIDE), nullptr);
1114
    }
1115
    return 1;
1116
}
1117

1118

1119
long
1120
GNEApplicationWindow::onCmdOpenRecent(FXObject*, FXSelector, void* fileData) {
1121
    // first check that current edited Net can be closed (und therefore the undo-list cleared, see #5753)
1122
    if (myAmLoading) {
1123
        myStatusbar->getStatusLine()->setText(TL("Already loading!"));
1124
    } else if (onCmdClose(0, 0, 0) == 1) {
1125
        // get filedata
1126
        const std::string recentFile = ((const char*)fileData);
1127
        // check if we're loading a network o a config
1128
        if ((recentFile.find(".neteditcfg") != std::string::npos) ||    // neteditcfg deprecated
1129
                (recentFile.find(".netecfg") != std::string::npos) ||
1130
                (recentFile.find(".sumocfg") != std::string::npos) ||
1131
                (recentFile.find(".netccfg") != std::string::npos)) {
1132
            // load config
1133
            loadConfiguration(recentFile);
1134
        } else {
1135
            // load network
1136
            loadNetwork(recentFile);
1137
        }
1138
    }
1139
    return 1;
1140
}
1141

1142

1143
long
1144
GNEApplicationWindow::onCmdClose(FXObject*, FXSelector, void*) {
1145
    if (myViewNet == nullptr) {
1146
        return 1;
1147
    } else if (askSaveElements()) {
1148
        closeAllWindows();
1149
        // add a separator to the log
1150
        myMessageWindow->addSeparator();
1151
        // hide all menu commands
1152
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
1153
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
1154
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
1155
        // hide view options
1156
        myEditMenuCommands.networkViewOptions.hideNetworkViewOptionsMenuChecks();
1157
        myEditMenuCommands.demandViewOptions.hideDemandViewOptionsMenuChecks();
1158
        myEditMenuCommands.dataViewOptions.hideDataViewOptionsMenuChecks();
1159
        // reset files
1160
        auto& neteditOptions = OptionsCont::getOptions();
1161
        neteditOptions.resetWritable();
1162
        neteditOptions.set("configuration-file", "");
1163
        neteditOptions.set("sumocfg-file", "");
1164
        neteditOptions.set("net-file", "");
1165
        neteditOptions.set("tls-file", "");
1166
        neteditOptions.set("edgetypes-file", "");
1167
        neteditOptions.set("additional-files", "");
1168
        neteditOptions.set("route-files", "");
1169
        neteditOptions.set("meandata-files", "");
1170
        neteditOptions.set("data-files", "");
1171
        // also in sumoConfig
1172
        mySumoOptions.resetWritable();
1173
        mySumoOptions.set("configuration-file", "");
1174
        mySumoOptions.set("net-file", "");
1175
        mySumoOptions.set("additional-files", "");
1176
        mySumoOptions.set("route-files", "");
1177
        mySumoOptions.set("data-files", "");
1178
        return 1;
1179
    } else {
1180
        return 0;
1181
    }
1182
}
1183

1184

1185
long
1186
GNEApplicationWindow::onCmdLocate(FXObject*, FXSelector sel, void*) {
1187
    if (myMDIClient->numChildren() > 0) {
1188
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
1189
        if (w != nullptr) {
1190
            w->onCmdLocate(nullptr, sel, nullptr);
1191
        }
1192
    }
1193
    return 1;
1194
}
1195

1196

1197
long
1198
GNEApplicationWindow::onCmdOpenPythonToolDialog(FXObject* obj, FXSelector, void*) {
1199
    return myToolsMenuCommands.showTool(obj);
1200
}
1201

1202

1203
long
1204
GNEApplicationWindow::onCmdRunPythonTool(FXObject* obj, FXSelector, void*) {
1205
    return myToolsMenuCommands.runToolDialog(obj);
1206
}
1207

1208

1209
long
1210
GNEApplicationWindow::onCmdPostProcessingPythonTool(FXObject* obj, FXSelector, void*) {
1211
    return myToolsMenuCommands.postProcessing(obj);
1212
}
1213

1214

1215
long
1216
GNEApplicationWindow::onUpdPythonTool(FXObject*, FXSelector, void*) {
1217
    // currently always enabled
1218
    return 1;
1219
}
1220

1221

1222
long
1223
GNEApplicationWindow::onUpdOpen(FXObject* sender, FXSelector, void*) {
1224
    sender->handle(this, myAmLoading ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1225
    return 1;
1226
}
1227

1228

1229
long
1230
GNEApplicationWindow::onCmdClearMsgWindow(FXObject*, FXSelector, void*) {
1231
    myMessageWindow->clear();
1232
    return 1;
1233
}
1234

1235

1236
long
1237
GNEApplicationWindow::onCmdLoadAdditionalsInSUMOGUI(FXObject*, FXSelector, void*) {
1238
    return 1;
1239
}
1240

1241

1242
long
1243
GNEApplicationWindow::onCmdLoadDemandInSUMOGUI(FXObject*, FXSelector, void*) {
1244
    return 1;
1245
}
1246

1247

1248
long
1249
GNEApplicationWindow::onCmdAbout(FXObject*, FXSelector, void*) {
1250
    // create and open about dialog
1251
    GNEAboutDialog(this);
1252
    return 1;
1253
}
1254

1255

1256
long GNEApplicationWindow::onClipboardRequest(FXObject*, FXSelector, void* ptr) {
1257
    FXEvent* event = (FXEvent*)ptr;
1258
    FXString string = GUIUserIO::clipped.c_str();
1259
    setDNDData(FROM_CLIPBOARD, event->target, string);
1260
    return 1;
1261
}
1262

1263

1264
long
1265
GNEApplicationWindow::onLoadThreadEvent(FXObject*, FXSelector, void*) {
1266
    eventOccurred();
1267
    return 1;
1268
}
1269

1270

1271
void
1272
GNEApplicationWindow::eventOccurred() {
1273
    // load events
1274
    while (!myThreadEvents.empty()) {
1275
        // get the next event
1276
        GUIEvent* e = myThreadEvents.top();
1277
        myThreadEvents.pop();
1278
        // process
1279
        switch (e->getOwnType()) {
1280
            case GUIEventType::SIMULATION_LOADED:
1281
                handleEvent_NetworkLoaded(e);
1282
                break;
1283
            case GUIEventType::MESSAGE_OCCURRED:
1284
            case GUIEventType::WARNING_OCCURRED:
1285
            case GUIEventType::ERROR_OCCURRED:
1286
            case GUIEventType::DEBUG_OCCURRED:
1287
            case GUIEventType::GLDEBUG_OCCURRED:
1288
                handleEvent_Message(e);
1289
                break;
1290
            default:
1291
                break;
1292
        }
1293
        delete e;
1294
    }
1295
}
1296

1297

1298
void
1299
GNEApplicationWindow::handleEvent_NetworkLoaded(GUIEvent* e) {
1300
    myAmLoading = false;
1301
    GNEEvent_NetworkLoaded* ec = static_cast<GNEEvent_NetworkLoaded*>(e);
1302
    // get option container
1303
    auto& neteditOptions = OptionsCont::getOptions();
1304
    // check whether the loading was successful
1305
    if (ec->net == nullptr) {
1306
        // report failure
1307
        setStatusBarText(TLF("Loading of network '%' failed", ec->file));
1308
    } else {
1309
        // set new Net
1310
        myNet = ec->net;
1311
        // report success
1312
        setStatusBarText(TLF("Network '%' loaded", ec->file));
1313
        setWindowSizeAndPos();
1314
        // build viewparent toolbar grips before creating view parent
1315
        getToolbarsGrip().buildViewParentToolbarsGrips();
1316
        // initialise netedit View
1317
        GNEViewParent* viewParent = new GNEViewParent(myMDIClient, myMDIMenu, "netedit VIEW", this, nullptr, myNet, myUndoList, nullptr, MDI_TRACKING, 10, 10, 300, 200);
1318
        // create it maximized
1319
        viewParent->maximize();
1320
        // mark it as Active child
1321
        myMDIClient->setActiveChild(viewParent);
1322
        // cast pointer myViewNet
1323
        myViewNet = dynamic_cast<GNEViewNet*>(viewParent->getView());
1324
        // set settings in view
1325
        if (viewParent->getView() && ec->settingsFile != "") {
1326
            GUISettingsHandler settings(ec->settingsFile, true, true);
1327
            settings.addSettings(viewParent->getView());
1328
            viewParent->getView()->addDecals(settings.getDecals());
1329
            settings.applyViewport(viewParent->getView());
1330
            settings.setSnapshots(viewParent->getView());
1331
        }
1332
        // set network name on the caption
1333
        setTitle(MFXUtils::getTitleText(myTitlePrefix, ec->file.c_str()));
1334
        // force supermode network
1335
        if (myViewNet) {
1336
            myViewNet->forceSupemodeNetwork();
1337
        }
1338
        if (myViewNet && ec->viewportFromRegistry) {
1339
            Position off;
1340
            off.set(getApp()->reg().readRealEntry("viewport", "x"), getApp()->reg().readRealEntry("viewport", "y"), getApp()->reg().readRealEntry("viewport", "z"));
1341
            Position p(off.x(), off.y(), 0);
1342
            myViewNet->setViewportFromToRot(off, p, 0);
1343
        }
1344
        // if we're loading a sumo config, update netedit options
1345
        if ((mySumoOptions.getStringVector("additional-files").size() > 0) && neteditOptions.getStringVector("additional-files").empty()) {
1346
            neteditOptions.resetWritable();
1347
            neteditOptions.set("additional-files", mySumoOptions.getValueString("additional-files"));
1348
        }
1349
        if ((mySumoOptions.getStringVector("route-files").size() > 0) && neteditOptions.getStringVector("route-files").empty()) {
1350
            neteditOptions.resetWritable();
1351
            neteditOptions.set("route-files", mySumoOptions.getValueString("route-files"));
1352
        }
1353
        // load elements
1354
        loadAdditionalElements();
1355
        loadDemandElements();
1356
        loadDataElements();
1357
        loadMeanDataElements();
1358
        // load selection
1359
        if (!OptionsCont::getOptions().isDefault("selection-file")) {
1360
            myViewNet->getViewParent()->getSelectorFrame()->getSelectionOperationModul()->loadFromFile(OptionsCont::getOptions().getString("selection-file"));
1361
        }
1362
        myNet->getSavingStatus()->networkSaved();
1363
    }
1364
    myMessageWindow->registerMsgHandlers();
1365
    // update app
1366
    update();
1367
    // restore focus
1368
    setFocus();
1369
}
1370

1371

1372
void
1373
GNEApplicationWindow::handleEvent_Message(GUIEvent* e) {
1374
    GUIEvent_Message* ec = static_cast<GUIEvent_Message*>(e);
1375
    myMessageWindow->appendMsg(ec->getOwnType(), ec->getMsg());
1376
}
1377

1378
// ---------------------------------------------------------------------------
1379
// private methods
1380
// ---------------------------------------------------------------------------
1381

1382
void
1383
GNEApplicationWindow::fillMenuBar() {
1384
    // build file menu
1385
    myFileMenu = new FXMenuPane(this, LAYOUT_FIX_HEIGHT);
1386
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&File"), nullptr, myFileMenu);
1387
    myFileMenuNeteditConfig = new FXMenuPane(this);
1388
    myFileMenuSumoConfig = new FXMenuPane(this);
1389
    myFileMenuTLS = new FXMenuPane(this);
1390
    myFileMenuEdgeTypes = new FXMenuPane(this);
1391
    myFileMenuAdditionals = new FXMenuPane(this);
1392
    myFileMenuDemandElements = new FXMenuPane(this);
1393
    myFileMenuDataElements = new FXMenuPane(this);
1394
    myFileMenuMeanDataElements = new FXMenuPane(this);
1395
    myFileMenuRecentNetworks = new FXMenuPane(this);
1396
    myFileMenuRecentConfigs = new FXMenuPane(this);
1397
    myFileMenuCommands.buildFileMenuCommands(myFileMenu, myFileMenuNeteditConfig, myFileMenuSumoConfig,
1398
            myFileMenuTLS, myFileMenuEdgeTypes, myFileMenuAdditionals, myFileMenuDemandElements,
1399
            myFileMenuDataElements, myFileMenuMeanDataElements);
1400
    // add separator for recent files
1401
    new FXMenuSeparator(myFileMenu);
1402
    // build recent files
1403
    myMenuBarFile.buildRecentNetworkFiles(myFileMenu, myFileMenuRecentNetworks);
1404
    myMenuBarFile.buildRecentConfigFiles(myFileMenu, myFileMenuRecentConfigs);
1405
    new FXMenuSeparator(myFileMenu);
1406
    GUIDesigns::buildFXMenuCommandShortcut(myFileMenu, TL("&Quit"), "Ctrl+Q", TL("Quit the Application."),
1407
                                           nullptr, this, MID_HOTKEY_CTRL_Q_CLOSE);
1408
    // build modes menu
1409
    myModesMenu = new FXMenuPane(this);
1410
    myModesMenuTitle = GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Modes"), nullptr, myModesMenu);
1411
    myModesMenuTitle->setTarget(this);
1412
    myModesMenuTitle->setSelector(MID_GNE_MODESMENUTITLE);
1413
    // build Supermode commands and hide it
1414
    mySupermodeCommands.buildSupermodeCommands(myModesMenu);
1415
    // add separator
1416
    new FXSeparator(myModesMenu);
1417
    // build modes menu commands
1418
    myModesMenuCommands.buildModesMenuCommands(myModesMenu);
1419
    // build edit menu
1420
    myEditMenu = new FXMenuPane(this);
1421
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Edit"), nullptr, myEditMenu);
1422
    // build edit menu commands
1423
    myEditMenuCommands.buildUndoRedoMenuCommands(myEditMenu);
1424
    // build separator
1425
    new FXMenuSeparator(myEditMenu);
1426
    // build view options
1427
    myEditMenuCommands.networkViewOptions.buildNetworkViewOptionsMenuChecks(myEditMenu);
1428
    myEditMenuCommands.demandViewOptions.buildDemandViewOptionsMenuChecks(myEditMenu);
1429
    myEditMenuCommands.dataViewOptions.buildDataViewOptionsMenuChecks(myEditMenu);
1430
    // hide view options
1431
    myEditMenuCommands.networkViewOptions.hideNetworkViewOptionsMenuChecks();
1432
    myEditMenuCommands.demandViewOptions.hideDemandViewOptionsMenuChecks();
1433
    myEditMenuCommands.dataViewOptions.hideDataViewOptionsMenuChecks();
1434
    // build view menu commands
1435
    myEditMenuCommands.buildViewMenuCommands(myEditMenu);
1436
    // build separator
1437
    new FXMenuSeparator(myEditMenu);
1438
    // build front element menu commands
1439
    myEditMenuCommands.buildFrontElementMenuCommand(myEditMenu);
1440
    // build separator
1441
    new FXMenuSeparator(myEditMenu);
1442
    // build open in sumo menu commands
1443
    myEditMenuCommands.buildOpenSUMOMenuCommands(myEditMenu);
1444
    // build lock menu
1445
    myLockMenu = new FXMenuPane(this);
1446
    myLockMenuTitle = GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("L&ock"), nullptr, myLockMenu);
1447
    myLockMenuTitle->setTarget(this);
1448
    myLockMenuTitle->setSelector(MID_GNE_LOCK_MENUTITLE);
1449
    // build lock menu commands
1450
    myLockMenuCommands.buildLockMenuCommands(myLockMenu);
1451
    // build processing menu (trigger netbuild computations)
1452
    myProcessingMenu = new FXMenuPane(this);
1453
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Processing"), nullptr, myProcessingMenu);
1454
    myProcessingMenuCommands.buildProcessingMenuCommands(myProcessingMenu);
1455
    // build locate menu
1456
    myLocatorMenu = new FXMenuPane(this);
1457
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Locate"), nullptr, myLocatorMenu);
1458
    myLocateMenuCommands.buildLocateMenuCommands(myLocatorMenu);
1459
    // build tools menu
1460
    myToolsMenu = new FXMenuPane(this);
1461
    myToolsAssignMenu = new FXMenuPane(this);
1462
    myToolsDetectorMenu = new FXMenuPane(this);
1463
    myToolsDistrictMenu = new FXMenuPane(this);
1464
    myToolsDRTMenu = new FXMenuPane(this);
1465
    myToolsEmissionsMenu = new FXMenuPane(this);
1466
    myToolsImportMenu = new FXMenuPane(this);
1467
    myToolsImportCityBrainMenu = new FXMenuPane(this);
1468
    myToolsImportGTFSMenu = new FXMenuPane(this);
1469
    myToolsImportVissim = new FXMenuPane(this);
1470
    myToolsImportVisum = new FXMenuPane(this);
1471
    myToolsNetMenu = new FXMenuPane(this);
1472
    myToolsRouteMenu = new FXMenuPane(this);
1473
    myToolsOutputMenu = new FXMenuPane(this);
1474
    myToolsShapes = new FXMenuPane(this);
1475
    myToolsTLS = new FXMenuPane(this);
1476
    myToolsTriggerMenu = new FXMenuPane(this);
1477
    myToolsTurnDefs = new FXMenuPane(this);
1478
    myToolsVisualizationMenu = new FXMenuPane(this);
1479
    myToolsXML = new FXMenuPane(this);
1480
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Tools"), nullptr, myToolsMenu);
1481
    // build tools menu cascasde
1482
    new FXMenuCascade(myToolsMenu, TL("Assign"), nullptr, myToolsAssignMenu);
1483
    new FXMenuCascade(myToolsMenu, TL("Detectors"), GUIIconSubSys::getIcon(GUIIcon::E1), myToolsDetectorMenu);
1484
    new FXMenuCascade(myToolsMenu, TL("Districts"), GUIIconSubSys::getIcon(GUIIcon::TAZ), myToolsDistrictMenu);
1485
    new FXMenuCascade(myToolsMenu, TL("DRT"), GUIIconSubSys::getIcon(GUIIcon::VCLASS_SMALL_TAXI), myToolsDRTMenu);
1486
    //new FXMenuCascade(myToolsMenu, TL("Emissions"), GUIIconSubSys::getIcon(GUIIcon::TOOL_EMISSIONS), myToolsEmissionsMenu);
1487
    new FXMenuCascade(myToolsImportMenu, TL("CityBrain"), GUIIconSubSys::getIcon(GUIIcon::TOOL_CITYBRAIN), myToolsImportCityBrainMenu);
1488
    new FXMenuCascade(myToolsImportMenu, TL("GTFS"), GUIIconSubSys::getIcon(GUIIcon::TOOL_GTFS), myToolsImportGTFSMenu);
1489
    new FXMenuCascade(myToolsImportMenu, TL("Vissim"), GUIIconSubSys::getIcon(GUIIcon::TOOL_VISSIM), myToolsImportVissim);
1490
    new FXMenuCascade(myToolsImportMenu, TL("Visum"), GUIIconSubSys::getIcon(GUIIcon::TOOL_VISUM), myToolsImportVisum);
1491
    new FXMenuCascade(myToolsMenu, TL("Import"), GUIIconSubSys::getIcon(GUIIcon::TOOL_IMPORT), myToolsImportMenu);
1492
    new FXMenuCascade(myToolsMenu, TL("Net"), GUIIconSubSys::getIcon(GUIIcon::MODECREATEEDGE), myToolsNetMenu);
1493
    new FXMenuCascade(myToolsMenu, TL("Output"), GUIIconSubSys::getIcon(GUIIcon::TOOL_OUTPUT), myToolsOutputMenu);
1494
    new FXMenuCascade(myToolsMenu, TL("Route"), GUIIconSubSys::getIcon(GUIIcon::MODEADDITIONAL), myToolsRouteMenu);
1495
    //new FXMenuCascade(myToolsMenu, TL("Shapes"), GUIIconSubSys::getIcon(GUIIcon::MODESHAPE), myToolsShapes);
1496
    new FXMenuCascade(myToolsMenu, TL("TLS"), GUIIconSubSys::getIcon(GUIIcon::MODETLS), myToolsTLS);
1497
    new FXMenuCascade(myToolsMenu, TL("Trigger"), nullptr, myToolsTriggerMenu);
1498
    new FXMenuCascade(myToolsMenu, TL("Turn-defs"), GUIIconSubSys::getIcon(GUIIcon::TOOL_TURNDEFS), myToolsTurnDefs);
1499
    new FXMenuCascade(myToolsMenu, TL("Visualization"), GUIIconSubSys::getIcon(GUIIcon::COLORWHEEL), myToolsVisualizationMenu);
1500
    new FXMenuCascade(myToolsMenu, TL("XML"), GUIIconSubSys::getIcon(GUIIcon::TOOL_XML), myToolsXML);
1501
    // add separators between folders
1502
    new FXMenuSeparator(myToolsMenu);
1503
    new FXMenuSeparator(myToolsImportMenu);
1504
    // create map with tool Menu panes and their associated folder
1505
    myMenuPaneToolMaps["assign"] = myToolsAssignMenu;
1506
    myMenuPaneToolMaps["detector"] = myToolsDetectorMenu;
1507
    myMenuPaneToolMaps["district"] = myToolsDistrictMenu;
1508
    myMenuPaneToolMaps["drt"] = myToolsDRTMenu;
1509
    myMenuPaneToolMaps["emissions"] = myToolsEmissionsMenu;
1510
    myMenuPaneToolMaps["import"] = myToolsImportMenu;
1511
    myMenuPaneToolMaps["import/citybrain"] = myToolsImportCityBrainMenu;
1512
    myMenuPaneToolMaps["import/gtfs"] = myToolsImportGTFSMenu;
1513
    myMenuPaneToolMaps["import/vissim"] = myToolsImportVissim;
1514
    myMenuPaneToolMaps["import/visum"] = myToolsImportVisum;
1515
    myMenuPaneToolMaps["net"] = myToolsNetMenu;
1516
    myMenuPaneToolMaps["route"] = myToolsRouteMenu;
1517
    myMenuPaneToolMaps["output"] = myToolsOutputMenu;
1518
    myMenuPaneToolMaps["shapes"] = myToolsShapes;
1519
    myMenuPaneToolMaps["tls"] = myToolsTLS;
1520
    myMenuPaneToolMaps["trigger"] = myToolsTriggerMenu;
1521
    myMenuPaneToolMaps["turn-defs"] = myToolsTurnDefs;
1522
    myMenuPaneToolMaps["visualization"] = myToolsVisualizationMenu;
1523
    myMenuPaneToolMaps["xml"] = myToolsXML;
1524
    // build tools
1525
    myToolsMenuCommands.buildTools(myToolsMenu, myMenuPaneToolMaps);
1526
    // build windows menu
1527
    myWindowMenu = new FXMenuPane(this);
1528
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Window"), nullptr, myWindowMenu);
1529
    myWindowsMenuCommands.buildWindowsMenuCommands(myWindowMenu, myStatusbar, myMessageWindow);
1530
    // build language menu
1531
    buildLanguageMenu(myToolbarsGrip.menu);
1532
    // build help menu
1533
    myHelpMenu = new FXMenuPane(this);
1534
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Help"), nullptr, myHelpMenu);
1535
    myHelpMenuCommands.buildHelpMenuCommands(myHelpMenu);
1536
}
1537

1538

1539
FXGLCanvas*
1540
GNEApplicationWindow::getBuildGLCanvas() const {
1541
    // netedit uses only a single View, then return nullptr
1542
    return nullptr;
1543
}
1544

1545

1546
SUMOTime
1547
GNEApplicationWindow::getCurrentSimTime() const {
1548
    return 0;
1549
}
1550

1551

1552
double
1553
GNEApplicationWindow::getTrackerInterval() const {
1554
    return 1;
1555
}
1556

1557

1558
const GNETagPropertiesDatabase*
1559
GNEApplicationWindow::getTagPropertiesDatabase() const {
1560
    return myTagPropertiesDatabase;
1561
}
1562

1563

1564
GNEUndoList*
1565
GNEApplicationWindow::getUndoList() {
1566
    return myUndoList;
1567
}
1568

1569

1570
GNEViewNet*
1571
GNEApplicationWindow::getViewNet() {
1572
    return myViewNet;
1573
}
1574

1575

1576
GNEApplicationWindowHelper::ToolbarsGrip&
1577
GNEApplicationWindow::getToolbarsGrip() {
1578
    return myToolbarsGrip;
1579
}
1580

1581

1582
void
1583
GNEApplicationWindow::updateRecomputingLabel() {
1584
    if (myViewNet && myViewNet->getNet()) {
1585
        // show
1586
        myRequireRecomputingButton->show();
1587
        // set label depending of recomputing
1588
        if (myNet->getAttributeCarriers()->getJunctions().empty() || myNet->isNetRecomputed()) {
1589
            myRequireRecomputingButton->setText("");
1590
            myRequireRecomputingButton->setTipText(TL("Network computed"));
1591
            myRequireRecomputingButton->setIcon(GUIIconSubSys::getIcon(GUIIcon::OK));
1592
            myRequireRecomputingButton->setBackColor(FXRGBA(240, 255, 205, 255));
1593
        } else {
1594
            myRequireRecomputingButton->setText(TL("Press F5"));
1595
            myRequireRecomputingButton->setTipText(TL("Network requires recomputing"));
1596
            myRequireRecomputingButton->setIcon(GUIIconSubSys::getIcon(GUIIcon::WARNING));
1597
            myRequireRecomputingButton->setBackColor(FXRGBA(253, 255, 206, 255));
1598
        }
1599
    } else {
1600
        // hide
1601
        myRequireRecomputingButton->hide();
1602
    }
1603
}
1604

1605

1606
void
1607
GNEApplicationWindow::closeAllWindows() {
1608
    // first check if net must be deleted
1609
    if (myNet != nullptr) {
1610
        delete myNet;
1611
        myNet = nullptr;
1612
        GeoConvHelper::resetLoaded();
1613
    }
1614
    // check if view has to be saved
1615
    if (myViewNet) {
1616
        myViewNet->saveVisualizationSettings();
1617
        // clear decals
1618
        myViewNet->getDecals().clear();
1619
    }
1620
    // lock tracker
1621
    myTrackerLock.lock();
1622
    // remove trackers and other external windows
1623
    while (!myGLWindows.empty()) {
1624
        delete myGLWindows.front();
1625
    }
1626
    myViewNet = nullptr;
1627
    for (FXMainWindow* const window : myTrackerWindows) {
1628
        window->destroy();
1629
        delete window;
1630
    }
1631
    myTrackerWindows.clear();
1632
    // reset the caption
1633
    setTitle(myTitlePrefix);
1634
    // unlock tracker
1635
    myTrackerLock.unlock();
1636
    // remove coordinate information
1637
    myGeoCoordinate->setText(TL("N/A"));
1638
    myCartesianCoordinate->setText(TL("N/A"));
1639
    myTestCoordinate->setText(TL("N/A"));
1640
    myTestFrame->hide();
1641
    myMessageWindow->unregisterMsgHandlers();
1642
    // Reset textures
1643
    GUITextureSubSys::resetTextures();
1644
    // reset fonts
1645
    GLHelper::resetFont();
1646
}
1647

1648

1649
FXCursor*
1650
GNEApplicationWindow::getDefaultCursor() {
1651
    return getApp()->getDefaultCursor(DEF_ARROW_CURSOR);
1652
}
1653

1654

1655
void
1656
GNEApplicationWindow::loadOptionOnStartup() {
1657
    auto& neteditOptions = OptionsCont::getOptions();
1658
    if (neteditOptions.getBool("new")) {
1659
        // save output file
1660
        const auto outputFile = neteditOptions.getString("output-file");
1661
        // create new network reset all options
1662
        createNewNetwork();
1663
        // check if define output file
1664
        if (!outputFile.empty()) {
1665
            neteditOptions.resetWritable();
1666
            neteditOptions.set("net-file", outputFile);
1667
        }
1668
    } else {
1669
        // set flag
1670
        myAmLoading = true;
1671
        // set status bar
1672
        setStatusBarText(TL("Loading console arguments."));
1673
        // load console arguments
1674
        myLoadThread->loadNetworkOrConfig();
1675
        // add it into recent networks and configs
1676
        if (neteditOptions.getString("net-file").size() > 0) {
1677
            myMenuBarFile.myRecentNetworks.appendFile(neteditOptions.getString("net-file").c_str());
1678
        }
1679
        if (neteditOptions.getString("configuration-file").size() > 0) {
1680
            myMenuBarFile.myRecentConfigs.appendFile(neteditOptions.getString("configuration-file").c_str());
1681
        }
1682
    }
1683
}
1684

1685

1686
void
1687
GNEApplicationWindow::createNewNetwork() {
1688
    auto& neteditOptions = OptionsCont::getOptions();
1689
    // save windows size and position
1690
    storeWindowSizeAndPos();
1691
    // enable loading flag and disable reloading flag
1692
    myAmLoading = true;
1693
    // recenter view
1694
    gSchemeStorage.saveViewport(0, 0, -1, 0);
1695
    // fill (reset) all options
1696
    GNELoadThread::fillOptions(neteditOptions);
1697
    // set default options defined in GNELoadThread::setDefaultOptions(...)
1698
    GNELoadThread::setDefaultOptions(neteditOptions);
1699
    // update status bar
1700
    setStatusBarText(TL("Creating new network."));
1701
    // create new network
1702
    myLoadThread->newNetwork();
1703
    // update window
1704
    update();
1705
}
1706

1707

1708
void
1709
GNEApplicationWindow::loadNetwork(const std::string& networkFile) {
1710
    if (networkFile.empty()) {
1711
        WRITE_ERROR(TL("Trying to load an empty network."));
1712
    } else {
1713
        auto& neteditOptions = OptionsCont::getOptions();
1714
        // stop test before calling load thread
1715
        if (myInternalTest) {
1716
            myInternalTest->stopTests();
1717
        }
1718
        // store size, position and viewport
1719
        storeWindowSizeAndPos();
1720
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1721
        // set flag
1722
        myAmLoading = true;
1723
        // fill (reset) all options
1724
        myLoadThread->fillOptions(neteditOptions);
1725
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1726
        myLoadThread->setDefaultOptions(neteditOptions);
1727
        // set file to load
1728
        neteditOptions.resetWritable();
1729
        neteditOptions.set("net-file", networkFile);
1730
        // set status bar
1731
        setStatusBarText(TLF("Loading network file '%'.", networkFile));
1732
        // load network
1733
        myLoadThread->loadNetworkOrConfig();
1734
        // add it into recent nets
1735
        myMenuBarFile.myRecentNetworks.appendFile(networkFile.c_str());
1736
    }
1737
}
1738

1739

1740
void
1741
GNEApplicationWindow::loadConfiguration(const std::string& configurationFile) {
1742
    if (configurationFile.empty()) {
1743
        WRITE_ERROR(TL("Trying to load an empty configuration."));
1744
    } else {
1745
        auto& neteditOptions = OptionsCont::getOptions();
1746
        // store size, position and viewport
1747
        storeWindowSizeAndPos();
1748
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1749
        // set flag
1750
        myAmLoading = true;
1751
        // fill (reset) all options
1752
        myLoadThread->fillOptions(neteditOptions);
1753
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1754
        myLoadThread->setDefaultOptions(neteditOptions);
1755
        // set file to load
1756
        neteditOptions.resetWritable();
1757
        neteditOptions.set("configuration-file", configurationFile);
1758
        // set status bar
1759
        setStatusBarText(TLF("Loading configuration file '%'.", configurationFile));
1760
        // load config
1761
        myLoadThread->loadNetworkOrConfig();
1762
        // add it into recent configs
1763
        myMenuBarFile.myRecentConfigs.appendFile(configurationFile.c_str());
1764
    }
1765
}
1766

1767

1768
void
1769
GNEApplicationWindow::loadOSM(const std::string& OSMFile) {
1770
    auto& neteditOptions = OptionsCont::getOptions();
1771
    // store size, position and viewport
1772
    storeWindowSizeAndPos();
1773
    gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1774
    // set flag
1775
    myAmLoading = true;
1776
    // fill (reset) all options
1777
    myLoadThread->fillOptions(neteditOptions);
1778
    // set default options defined in GNELoadThread::setDefaultOptions(...)
1779
    myLoadThread->setDefaultOptions(neteditOptions);
1780
    // recommended osm options
1781
    // https://sumo.dlr.de/wiki/Networks/Import/OpenStreetMap#Recommended_NETCONVERT_Options
1782
    neteditOptions.set("osm-files", OSMFile);
1783
    neteditOptions.set("geometry.remove", "true");
1784
    neteditOptions.set("ramps.guess", "true");
1785
    neteditOptions.set("junctions.join", "true");
1786
    neteditOptions.set("tls.guess-signals", "true");
1787
    neteditOptions.set("tls.discard-simple", "true");
1788
    // open netedit options dialog
1789
    const auto neteditOptionsDialog = GNENeteditOptionsDialog(this, neteditOptions, myOriginalNeteditOptions);
1790
    // open wizard dialog
1791
    if (neteditOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) {
1792
        // needed to set projection parameters
1793
        NIFrame::checkOptions(neteditOptions);
1794
        // set file to load
1795
        neteditOptions.resetWritable();
1796
        neteditOptions.set("configuration-file", OSMFile);
1797
        // set status bar
1798
        setStatusBarText(TLF("Loading OSM file '%'.", OSMFile));
1799
        // load config
1800
        myLoadThread->loadNetworkOrConfig();
1801
    }
1802
}
1803

1804
void
1805
GNEApplicationWindow::setStatusBarText(const std::string& statusBarText) {
1806
    myStatusbar->getStatusLine()->setText(statusBarText.c_str());
1807
    myStatusbar->getStatusLine()->setNormalText(statusBarText.c_str());
1808
}
1809

1810

1811
long
1812
GNEApplicationWindow::computeJunctionWithVolatileOptions() {
1813
    // open question dialog box
1814
    const auto questionDialog = GNEQuestionBasicDialog(this, GNEDialog::Buttons::YES_NO,
1815
                                TL("Recompute with volatile options"),
1816
                                TL("Changes produced in the net due a recomputing with"),
1817
                                TL("volatile options cannot be undone. Continue?"));
1818
    // check result
1819
    if (questionDialog.getResult() == GNEDialog::Result::ACCEPT) {
1820
        // save all elements
1821
        onCmdSaveAdditionalElements(nullptr, 0, nullptr);
1822
        onCmdSaveDemandElements(nullptr, 0, nullptr);
1823
        onCmdSaveDataElements(nullptr, 0, nullptr);
1824
        onCmdSaveMeanDataElements(nullptr, 0, nullptr);
1825
        // compute with volatile options
1826
        myNet->computeNetwork(this, true, true);
1827
        updateControls();
1828
    }
1829
    return 1;
1830
}
1831

1832

1833
bool
1834
GNEApplicationWindow::consoleOptionsLoaded() {
1835
    if (myConsoleOptionsLoaded) {
1836
        myConsoleOptionsLoaded = false;
1837
        return true;
1838
    } else {
1839
        return false;
1840
    }
1841
}
1842

1843

1844
GNEExternalRunner*
1845
GNEApplicationWindow::getExternalRunner() const {
1846
    return myExternalRunner;
1847
}
1848

1849

1850
void
1851
GNEApplicationWindow::setExternalRunner(GNEExternalRunner* externalRunner) {
1852
    myExternalRunner = externalRunner;
1853
}
1854

1855

1856
long
1857
GNEApplicationWindow::onCmdSetSuperMode(FXObject* sender, FXSelector sel, void* ptr) {
1858
    // check that currently there is a View
1859
    if (myViewNet) {
1860
        myViewNet->onCmdSetSupermode(sender, sel, ptr);
1861
    }
1862
    return 1;
1863
}
1864

1865

1866
long
1867
GNEApplicationWindow::onCmdSetMode(FXObject* sender, FXSelector sel, void* ptr) {
1868
    // check that currently there is a View
1869
    if (myViewNet) {
1870
        myViewNet->onCmdSetMode(sender, sel, ptr);
1871
    }
1872
    return 1;
1873
}
1874

1875

1876
long
1877
GNEApplicationWindow::onCmdLockElements(FXObject*, FXSelector sel, void*) {
1878
    if (myViewNet) {
1879
        // check if we're calling the functions using internal test
1880
        switch (FXSELID(sel)) {
1881
            case MID_GNE_LOCK_JUNCTION:
1882
                myLockMenuCommands.menuCheckLockJunctions->toggleCheck();
1883
                break;
1884
            case MID_GNE_LOCK_EDGE:
1885
                myLockMenuCommands.menuCheckLockEdges->toggleCheck();
1886
                break;
1887
            case MID_GNE_LOCK_LANE:
1888
                myLockMenuCommands.menuCheckLockLanes->toggleCheck();
1889
                break;
1890
            case MID_GNE_LOCK_CONNECTION:
1891
                myLockMenuCommands.menuCheckLockConnections->toggleCheck();
1892
                break;
1893
            case MID_GNE_LOCK_CROSSING:
1894
                myLockMenuCommands.menuCheckLockCrossings->toggleCheck();
1895
                break;
1896
            case MID_GNE_LOCK_WALKINGAREA:
1897
                myLockMenuCommands.menuCheckLockWalkingAreas->toggleCheck();
1898
                break;
1899
            case MID_GNE_LOCK_ADDITIONALELEMENT:
1900
                myLockMenuCommands.menuCheckLockAdditionals->toggleCheck();
1901
                break;
1902
            case MID_GNE_LOCK_WIRE:
1903
                myLockMenuCommands.menuCheckLockWires->toggleCheck();
1904
                break;
1905
            case MID_GNE_LOCK_TAZ:
1906
                myLockMenuCommands.menuCheckLockTAZs->toggleCheck();
1907
                break;
1908
            case MID_GNE_LOCK_POLYGON:
1909
                myLockMenuCommands.menuCheckLockPolygons->toggleCheck();
1910
                break;
1911
            case MID_GNE_LOCK_POI:
1912
                myLockMenuCommands.menuCheckLockPOIs->toggleCheck();
1913
                break;
1914
            case MID_GNE_LOCK_JPS_WALKABLEAREA:
1915
                myLockMenuCommands.menuCheckLockJpsWalkableAreas->toggleCheck();
1916
                break;
1917
            case MID_GNE_LOCK_JPS_OBSTACLE:
1918
                myLockMenuCommands.menuCheckLockJpsObstacles->toggleCheck();
1919
                break;
1920
            case MID_GNE_LOCK_ROUTE:
1921
                myLockMenuCommands.menuCheckLockRoutes->toggleCheck();
1922
                break;
1923
            case MID_GNE_LOCK_VEHICLE:
1924
                myLockMenuCommands.menuCheckLockVehicles->toggleCheck();
1925
                break;
1926
            case MID_GNE_LOCK_PERSON:
1927
                myLockMenuCommands.menuCheckLockPersons->toggleCheck();
1928
                break;
1929
            case MID_GNE_LOCK_PERSONTRIP:
1930
                myLockMenuCommands.menuCheckLockPersonTrips->toggleCheck();
1931
                break;
1932
            case MID_GNE_LOCK_WALK:
1933
                myLockMenuCommands.menuCheckLockWalks->toggleCheck();
1934
                break;
1935
            case MID_GNE_LOCK_RIDE:
1936
                myLockMenuCommands.menuCheckLockRides->toggleCheck();
1937
                break;
1938
            case MID_GNE_LOCK_CONTAINER:
1939
                myLockMenuCommands.menuCheckLockContainers->toggleCheck();
1940
                break;
1941
            case MID_GNE_LOCK_TRANSPORT:
1942
                myLockMenuCommands.menuCheckLockTransports->toggleCheck();
1943
                break;
1944
            case MID_GNE_LOCK_TRANSHIP:
1945
                myLockMenuCommands.menuCheckLockTranships->toggleCheck();
1946
                break;
1947
            case MID_GNE_LOCK_STOP:
1948
                myLockMenuCommands.menuCheckLockStops->toggleCheck();
1949
                break;
1950
            case MID_GNE_LOCK_EDGEDATA:
1951
                myLockMenuCommands.menuCheckLockEdgeDatas->toggleCheck();
1952
                break;
1953
            case MID_GNE_LOCK_EDGERELDATA:
1954
                myLockMenuCommands.menuCheckLockEdgeRelDatas->toggleCheck();
1955
                break;
1956
            case MID_GNE_LOCK_TAZRELDATA:
1957
                myLockMenuCommands.menuCheckLockEdgeTAZRels->toggleCheck();
1958
                break;
1959
            default:
1960
                break;
1961
        }
1962
        myViewNet->getLockManager().updateFlags();
1963
    }
1964
    return 1;
1965
}
1966

1967

1968
long
1969
GNEApplicationWindow::onCmdLockAllElements(FXObject*, FXSelector, void*) {
1970
    // lock all
1971
    myLockMenuCommands.lockAll();
1972
    myViewNet->getLockManager().updateFlags();
1973
    return 1;
1974
}
1975

1976

1977
long
1978
GNEApplicationWindow::onCmdUnlockAllElements(FXObject*, FXSelector, void*) {
1979
    // unlock all
1980
    myLockMenuCommands.unlockAll();
1981
    myViewNet->getLockManager().updateFlags();
1982
    return 1;
1983
}
1984

1985

1986
long
1987
GNEApplicationWindow::onCmdLockSelectElements(FXObject*, FXSelector, void*) {
1988
    if (myViewNet) {
1989
        myViewNet->update();
1990
    }
1991
    return 1;
1992
}
1993

1994

1995
long
1996
GNEApplicationWindow::onUpdLockMenuTitle(FXObject*, FXSelector, void*) {
1997
    if (myViewNet) {
1998
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
1999
            // supermode network
2000
            if ((myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_INSPECT) ||
2001
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_SELECT) ||
2002
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_DELETE) ||
2003
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_CONNECT) ||
2004
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_MOVE)) {
2005
                myLockMenuTitle->enable();
2006
            } else {
2007
                myLockMenuTitle->disable();
2008
            }
2009
        } else if (myViewNet->getEditModes().isCurrentSupermodeDemand()) {
2010
            // supermode demand
2011
            if ((myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_INSPECT) ||
2012
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_SELECT) ||
2013
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_DELETE) ||
2014
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_MOVE)) {
2015
                myLockMenuTitle->enable();
2016
            } else {
2017
                myLockMenuTitle->disable();
2018
            }
2019
        } else if (myViewNet->getEditModes().isCurrentSupermodeData()) {
2020
            // supermode data
2021
            if ((myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_INSPECT) ||
2022
                    (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_SELECT) ||
2023
                    (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_DELETE)) {
2024
                myLockMenuTitle->enable();
2025
            } else {
2026
                myLockMenuTitle->disable();
2027
            }
2028
        } else {
2029
            myLockMenuTitle->disable();
2030
        }
2031
    } else {
2032
        myLockMenuTitle->disable();
2033
    }
2034
    return 1;
2035
}
2036

2037

2038
long
2039
GNEApplicationWindow::onCmdProcessButton(FXObject*, FXSelector sel, void*) {
2040
    // first check if there is a view
2041
    if (myViewNet) {
2042
        // process depending of supermode
2043
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
2044
            // check what FXMenuCommand was called
2045
            switch (FXSELID(sel)) {
2046
                case MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND:
2047
                    myNet->computeNetwork(this, true, false);
2048
                    updateControls();
2049
                    break;
2050
                case MID_HOTKEY_SHIFT_F5_COMPUTEJUNCTIONS_VOLATILE:
2051
                    computeJunctionWithVolatileOptions();
2052
                    break;
2053
                case MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES:
2054
                    myNet->removeSolitaryJunctions(myUndoList);
2055
                    break;
2056
                case MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES:
2057
                    myNet->joinSelectedJunctions(myUndoList);
2058
                    break;
2059
                case MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS:
2060
                    myNet->cleanInvalidCrossings(myUndoList);
2061
                    break;
2062
                default:
2063
                    break;
2064
            }
2065
        } else if (myViewNet->getEditModes().isCurrentSupermodeDemand()) {
2066
            // check what FXMenuCommand was called
2067
            switch (FXSELID(sel)) {
2068
                case MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND:
2069
                    myNet->computeDemandElements(this);
2070
                    updateControls();
2071
                    break;
2072
                case MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES:
2073
                    myNet->cleanUnusedRoutes(myUndoList);
2074
                    break;
2075
                case MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES:
2076
                    myNet->joinRoutes(myUndoList);
2077
                    break;
2078
                case MID_HOTKEY_SHIFT_F7_ADJUST_PERSON_PLANS:
2079
                    myNet->adjustPersonPlans(myUndoList);
2080
                    break;
2081
                case MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS:
2082
                    myNet->cleanInvalidDemandElements(myUndoList);
2083
                    break;
2084
                default:
2085
                    break;
2086
            }
2087
        }
2088
        // refresh to update undo-redo button
2089
        myViewNet->getViewParent()->getGNEAppWindows()->forceRefresh();
2090
    }
2091
    return 1;
2092
}
2093

2094

2095
long
2096
GNEApplicationWindow::onCmdNewWindow(FXObject*, FXSelector sel, void* /*ptr*/) {
2097
    // get extra arguments
2098
    std::string extraArg;
2099
    if (sel == MID_GNE_POSTPROCESSINGNETGENERATE) {
2100
        extraArg = " -s " + myNetgenerateOptions.getValueString("output-file");
2101
    }
2102
    FXRegistry reg("SUMO netedit", "netedit");
2103
    std::string netedit = "netedit";
2104
    const char* sumoPath = getenv("SUMO_HOME");
2105
    if (sumoPath != nullptr) {
2106
#ifdef DEBUG
2107
        std::string newPath = std::string(sumoPath) + "/bin/neteditD";
2108
#else
2109
        std::string newPath = std::string(sumoPath) + "/bin/netedit";
2110
#endif
2111
        if (FileHelpers::isReadable(newPath) || FileHelpers::isReadable(newPath + ".exe")) {
2112
            netedit = "\"" + newPath + "\"";
2113
        }
2114
    }
2115
    std::string cmd = netedit + extraArg;
2116
    // start in background
2117
#ifndef WIN32
2118
    cmd = cmd + " &";
2119
#else
2120
    // see "help start" for the parameters
2121
    cmd = "start /B \"\" " + cmd;
2122
#endif
2123
    WRITE_MESSAGE(TLF("Running '%'.", cmd));
2124
    // yay! fun with dangerous commands... Never use this over the internet
2125
    SysUtils::runHiddenCommand(cmd);
2126
    return 1;
2127
}
2128

2129

2130
long
2131
GNEApplicationWindow::onCmdOpenSUMOGUI(FXObject* obj, FXSelector sel, void* ptr) {
2132
    // get option container
2133
    auto& neteditOptions = OptionsCont::getOptions();
2134
    // input parameters
2135
    std::string inputParameters;
2136
    // if we have only a network, then load directly without creating a SumoConfig
2137
    if ((myNet->getAttributeCarriers()->getNumberOfAdditionals() == 0 && myNet->getAttributeCarriers()->getNumberOfDemandElements() == 0) ||
2138
            ((myEditMenuCommands.loadAdditionalsInSUMOGUI->getCheck() == FALSE) && (myEditMenuCommands.loadDemandInSUMOGUI->getCheck() == FALSE))) {
2139
        // force save network
2140
        if (onCmdSaveNetwork(obj, sel, ptr) == 0) {
2141
            // network wasn't saved, then stop
2142
            return 0;
2143
        }
2144
        inputParameters = " --registry-viewport -n \"" + neteditOptions.getString("net-file") + "\"";
2145
        // write info
2146
        WRITE_MESSAGE(TLF("Loading network '%' in SUMO-GUI.", neteditOptions.getString("net-file")));
2147
    } else {
2148
        // force save SumoConfig
2149
        if (onCmdSaveSumoConfig(obj, sel, ptr) == 0) {
2150
            // SumoConfig wasn't saved, then stop
2151
            return 0;
2152
        }
2153
        inputParameters = " --registry-viewport -c \"" + neteditOptions.getString("sumocfg-file") + "\"";
2154
        // write info
2155
        WRITE_MESSAGE(TLF("Loading sumo config '%' in SUMO-GUI.", neteditOptions.getString("sumocfg-file")));
2156
    }
2157
    // save current viewport in registry
2158
    FXRegistry reg("SUMO GUI", "sumo-gui");
2159
    reg.read();
2160
    reg.writeRealEntry("viewport", "x", myViewNet->getChanger().getXPos());
2161
    reg.writeRealEntry("viewport", "y", myViewNet->getChanger().getYPos());
2162
    reg.writeRealEntry("viewport", "z", myViewNet->getChanger().getZPos());
2163
    reg.write();
2164
    // declare executable
2165
    std::string sumoGuiExecutable = "sumo-gui";
2166
    // if SUMO_HOME is defined, update executable
2167
    const char* sumoHome = getenv("SUMO_HOME");
2168
    if (sumoHome != nullptr) {
2169
        std::string newPath = std::string(sumoHome) + "/bin/sumo-gui";
2170
        if (FileHelpers::isReadable(newPath) || FileHelpers::isReadable(newPath + ".exe")) {
2171
            sumoGuiExecutable = "\"" + newPath + "\"";
2172
        }
2173
    }
2174
    // declare command
2175
    std::string cmd = sumoGuiExecutable + inputParameters;
2176
    // start in background
2177
#ifndef WIN32
2178
    cmd = cmd + " &";
2179
#else
2180
    // see "help start" for the parameters
2181
    cmd = "start /B \"\" " + cmd;
2182
#endif
2183
    WRITE_MESSAGE(TLF("Running '%'.", cmd));
2184
    // yay! fun with dangerous commands... Never use this over the internet
2185
    SysUtils::runHiddenCommand(cmd);
2186
    return 1;
2187
}
2188

2189

2190
long
2191
GNEApplicationWindow::onCmdAbort(FXObject*, FXSelector, void*) {
2192
    // check that view exists
2193
    if (myViewNet) {
2194
        // first check if we're selecting a subset of edges in TAZ Frame
2195
        if (myViewNet->getViewParent()->getTAZFrame()->getTAZSelectionStatisticsModule()->getEdgeAndTAZChildrenSelected().size() > 0) {
2196
            // clear current selection
2197
            myViewNet->getViewParent()->getTAZFrame()->getTAZSelectionStatisticsModule()->clearSelectedEdges();
2198
        } else if (myViewNet->getViewParent()->getInspectorFrame()->shown()) {
2199
            // check if stop select parent
2200
            if (myViewNet->getViewParent()->getInspectorFrame()->getAttributesEditor()->isReparenting()) {
2201
                // and stop select paretn
2202
                myViewNet->getViewParent()->getInspectorFrame()->getAttributesEditor()->abortReparenting();
2203
            } else {
2204
                // clear inspected elements
2205
                myViewNet->getViewParent()->getInspectorFrame()->clearInspection();
2206
            }
2207
        } else {
2208
            // abort current operation
2209
            myViewNet->abortOperation();
2210
        }
2211
    }
2212
    return 1;
2213
}
2214

2215

2216
long
2217
GNEApplicationWindow::onCmdDel(FXObject*, FXSelector, void*) {
2218
    // check that view exists
2219
    if (myViewNet) {
2220
        myViewNet->hotkeyDel();
2221
    }
2222
    return 1;
2223
}
2224

2225

2226
long
2227
GNEApplicationWindow::onCmdEnter(FXObject*, FXSelector, void*) {
2228
    // check that view exists
2229
    if (myViewNet) {
2230
        myViewNet->hotkeyEnter();
2231
    }
2232
    return 1;
2233
}
2234

2235

2236
long
2237
GNEApplicationWindow::onCmdBackspace(FXObject*, FXSelector, void*) {
2238
    // check that view exists
2239
    if (myViewNet) {
2240
        myViewNet->hotkeyBackSpace();
2241
    }
2242
    return 1;
2243
}
2244

2245

2246
long
2247
GNEApplicationWindow::onCmdFocusFrame(FXObject*, FXSelector, void*) {
2248
    // check that view exists
2249
    if (myViewNet) {
2250
        myViewNet->hotkeyFocusFrame();
2251
    }
2252
    return 1;
2253
}
2254

2255

2256
long
2257
GNEApplicationWindow::onCmdClearSelectionShortcut(FXObject*, FXSelector, void*) {
2258
    // check that view exists
2259
    if (myViewNet) {
2260
        myViewNet->getViewParent()->getSelectorFrame()->clearCurrentSelection();
2261
    }
2262
    return 1;
2263
}
2264

2265

2266
long
2267
GNEApplicationWindow::onCmdToggleTimeFormat(FXObject*, FXSelector, void*) {
2268
    // check that view exists
2269
    if (myViewNet) {
2270
        myViewNet->getTimeFormat().switchTimeFormat();
2271
        // refresh flow frames
2272
        if (myViewNet->getViewParent()->getVehicleFrame()->shown()) {
2273
            myViewNet->getViewParent()->getVehicleFrame()->getVehicleAttributesEditor()->refreshAttributesEditor();
2274
        }
2275
        if (myViewNet->getViewParent()->getPersonFrame()->shown()) {
2276
            myViewNet->getViewParent()->getPersonFrame()->getPersonAttributesEditor()->refreshAttributesEditor();
2277
        }
2278
        if (myViewNet->getViewParent()->getContainerFrame()->shown()) {
2279
            myViewNet->getViewParent()->getContainerFrame()->getContainerAttributesEditor()->refreshAttributesEditor();
2280
        }
2281
        // refresh inspector frame
2282
        if (myViewNet->getViewParent()->getInspectorFrame()->shown()) {
2283
            myViewNet->getViewParent()->getInspectorFrame()->refreshInspection();
2284
        }
2285
    }
2286
    return 1;
2287
}
2288

2289

2290
long
2291
GNEApplicationWindow::onUpdToggleTimeFormat(FXObject*, FXSelector, void*) {
2292
    // check that view exists
2293
    if (myViewNet) {
2294
        myViewNet->getTimeFormat().updateButtonLabel();
2295
    }
2296
    return 1;
2297
}
2298

2299

2300
long
2301
GNEApplicationWindow::onCmdRunTests(FXObject*, FXSelector, void*) {
2302
    if (myInternalTest && !myInternalTest->isRunning()) {
2303
        myInternalTest->runNeteditInternalTests(this);
2304
    }
2305
    return 1;
2306
}
2307

2308

2309
long
2310
GNEApplicationWindow::onUpdRequireViewNet(FXObject* sender, FXSelector, void*) {
2311
    // enable or disable sender element depending of viewNet
2312
    return sender->handle(this, myViewNet ? FXSEL(SEL_COMMAND, ID_ENABLE) : FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2313
}
2314

2315

2316
long
2317
GNEApplicationWindow::onUpdRequireRecomputing(FXObject*, FXSelector, void*) {
2318
    updateRecomputingLabel();
2319
    return 1;
2320
}
2321

2322

2323
long
2324
GNEApplicationWindow::onCmdRunNetgenerate(FXObject*, FXSelector, void*) {
2325
    GNERunNetgenerateDialog netgenerateDialog(this, &myNetgenerateOptions);
2326
    return 1;
2327
}
2328

2329

2330
long
2331
GNEApplicationWindow::onCmdPostprocessingNetgenerate(FXObject* obj, FXSelector, void* ptr) {
2332
    return onCmdNewWindow(obj, MID_GNE_POSTPROCESSINGNETGENERATE, ptr);
2333
}
2334

2335

2336
long
2337
GNEApplicationWindow::onCmdEditViewport(FXObject*, FXSelector, void*) {
2338
    // check that view exists
2339
    if (myViewNet) {
2340
        myViewNet->showViewportEditor();
2341
    }
2342
    return 1;
2343
}
2344

2345

2346
long
2347
GNEApplicationWindow::onCmdEditViewScheme(FXObject*, FXSelector, void*) {
2348
    // check that view exists
2349
    if (myViewNet) {
2350
        myViewNet->showViewschemeEditor();
2351
    }
2352
    return 1;
2353
}
2354

2355

2356
long
2357
GNEApplicationWindow::onCmdToggleGrid(FXObject* sender, FXSelector sel, void* ptr) {
2358
    // check that view exists
2359
    if (myViewNet) {
2360
        // Call manually toggle grid function
2361
        myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
2362
    }
2363
    return 1;
2364
}
2365

2366

2367
long
2368
GNEApplicationWindow::onCmdToggleDrawJunctionShape(FXObject* sender, FXSelector sel, void* ptr) {
2369
    // check that view exists
2370
    if (myViewNet) {
2371
        // Call manually toggle junction shape function
2372
        myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
2373
    }
2374
    return 1;
2375
}
2376

2377

2378
long
2379
GNEApplicationWindow::onCmdSetFrontElement(FXObject*, FXSelector, void*) {
2380
    if (myViewNet) {
2381
        // get first inspected AC
2382
        auto inspectedAC = myViewNet->getInspectedElements().getFirstAC();
2383
        if (inspectedAC) {
2384
            // set or clear front attribute
2385
            if (inspectedAC->isMarkedForDrawingFront()) {
2386
                inspectedAC->unmarkForDrawingFront();
2387
            } else {
2388
                inspectedAC->markForDrawingFront();
2389
            }
2390
        } else {
2391
            myViewNet->getMarkFrontElements().unmarkAll();
2392
        }
2393
        myViewNet->update();
2394
    }
2395
    return 1;
2396
}
2397

2398

2399
long
2400
GNEApplicationWindow::onCmdToggleEditOptions(FXObject* sender, FXSelector sel, void* /* ptr */) {
2401
    // first check that we have a ViewNet
2402
    if (myViewNet) {
2403
        // first check what selector was called
2404
        int numericalKeyPressed = sel - FXSEL(SEL_COMMAND, MID_HOTKEY_ALT_0_TOGGLEEDITOPTION) - 1;
2405
        // check that numericalKeyPressed is valid
2406
        if ((numericalKeyPressed < 0) || (numericalKeyPressed > 10)) {
2407
            return 0;
2408
        }
2409
        // declare a vector in which save visible menu commands
2410
        std::vector<MFXCheckableButton*> visibleMenuCommands;
2411
        // get common, network and demand visible menu commands
2412
        myViewNet->getNetworkViewOptions().getVisibleNetworkMenuCommands(visibleMenuCommands);
2413
        myViewNet->getDemandViewOptions().getVisibleDemandMenuCommands(visibleMenuCommands);
2414
        myViewNet->getDataViewOptions().getVisibleDataMenuCommands(visibleMenuCommands);
2415
        // now check that numericalKeyPressed isn't greater than visible view options
2416
        if (numericalKeyPressed >= (int)visibleMenuCommands.size()) {
2417
            return 0;
2418
        }
2419
        // toggle edit options
2420
        if (GNEApplicationWindowHelper::toggleEditOptionsNetwork(myViewNet,
2421
                visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2422
            return 1;
2423
        } else if (GNEApplicationWindowHelper::toggleEditOptionsDemand(myViewNet,
2424
                   visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2425
            return 1;
2426
        } else if (GNEApplicationWindowHelper::toggleEditOptionsData(myViewNet,
2427
                   visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2428
            return 1;
2429
        }
2430
    }
2431
    return 0;
2432
}
2433

2434

2435
long
2436
GNEApplicationWindow::onCmdHelp(FXObject*, FXSelector, void*) {
2437
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/netedit.html");
2438
    return 1;
2439
}
2440

2441

2442
long
2443
GNEApplicationWindow::onCmdChangelog(FXObject*, FXSelector, void*) {
2444
    // update in every version
2445
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/ChangeLog.html");
2446
    return 1;
2447
}
2448

2449

2450
long
2451
GNEApplicationWindow::onCmdHotkeys(FXObject*, FXSelector, void*) {
2452
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/Netedit/shortcuts.html");
2453
    return 1;
2454
}
2455

2456

2457
long
2458
GNEApplicationWindow::onCmdToggleComputeNetworkData(FXObject*, FXSelector, void*) {
2459
    if (myProcessingMenuCommands.menuCheckRecomputeDataMode->getCheck() == TRUE) {
2460
        return getApp()->reg().writeBoolEntry("NETEDIT", "RecomputeData", true);
2461
    } else {
2462
        return getApp()->reg().writeBoolEntry("NETEDIT", "RecomputeData", false);
2463
    }
2464
}
2465

2466

2467
long
2468
GNEApplicationWindow::onCmdToggleUndoRedo(FXObject*, FXSelector, void*) {
2469
    if (myEditMenuCommands.menuCheckAllowUndoRedo->getCheck() == TRUE) {
2470
        myAllowUndoRedo = true;
2471
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedo", true);
2472
    } else {
2473
        myAllowUndoRedo = false;
2474
        // drop undo-redo list after changing flag
2475
        myUndoList->clear();
2476
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedo", false);
2477
    }
2478
}
2479

2480

2481
long
2482
GNEApplicationWindow::onCmdToggleUndoRedoLoading(FXObject*, FXSelector, void*) {
2483
    if (myFileMenuCommands.menuCheckAllowUndoRedoLoading->getCheck() == TRUE) {
2484
        myAllowUndoRedoLoading = true;
2485
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedoLoading", true);
2486
    } else {
2487
        myAllowUndoRedoLoading = false;
2488
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedoLoading", false);
2489
    }
2490
}
2491

2492

2493
long
2494
GNEApplicationWindow::onCmdTutorial(FXObject*, FXSelector, void*) {
2495
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/Tutorials/index.html");
2496
    return 1;
2497
}
2498

2499

2500
long
2501
GNEApplicationWindow::onCmdFeedback(FXObject*, FXSelector, void*) {
2502
    // create and open feedback dialog
2503
    GUIDialog_Feedback* feedback = new GUIDialog_Feedback(this);
2504
    feedback->create();
2505
    feedback->show(PLACEMENT_OWNER);
2506
    return 1;
2507
}
2508

2509

2510
long
2511
GNEApplicationWindow::onCmdOpenOptionsDialog(FXObject*, FXSelector, void*) {
2512
    auto& neteditOptions = OptionsCont::getOptions();
2513
    // open netedit option dialog
2514
    const auto neteditOptionsDialog = GNENeteditOptionsDialog(this, neteditOptions, myOriginalNeteditOptions);
2515
    // continue depending of result
2516
    if (neteditOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) {
2517
        NIFrame::checkOptions(neteditOptions); // needed to set projection parameters
2518
        NBFrame::checkOptions(neteditOptions);
2519
        NWFrame::checkOptions(neteditOptions);
2520
        SystemFrame::checkOptions(neteditOptions); // needed to set precision
2521
        // check if mark netedit config as unsaved
2522
        if (neteditOptionsDialog.isOptionModified() && myNet) {
2523
            myNet->getSavingStatus()->requireSaveNeteditConfig();
2524
        }
2525
    }
2526
    return 1;
2527
}
2528

2529

2530
long
2531
GNEApplicationWindow::onCmdOpenSumoOptionsDialog(FXObject*, FXSelector, void*) {
2532
    // open sumo option dialog
2533
    const auto sumoOptionsDialog = GNESumoOptionsDialog(this, mySumoOptions, myOriginalSumoOptions);
2534
    // continue depending of result
2535
    if ((sumoOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) && sumoOptionsDialog.isOptionModified() && myNet) {
2536
        myNet->getSavingStatus()->requireSaveSumoConfig();
2537
    }
2538
    return 1;
2539
}
2540

2541

2542
long
2543
GNEApplicationWindow::onCmdOpenNetgenerateDialog(FXObject*, FXSelector, void*) {
2544
    GNENetgenerateDialog(this);
2545
    return 1;
2546
}
2547

2548

2549
long
2550
GNEApplicationWindow::onCmdOpenNetgenerateOptionsDialog(FXObject*, FXSelector, void*) {
2551
    // open netgenerate options dialog
2552
    GNENetgenerateOptionsDialog(this, myNetgenerateOptions, myOriginalNetgenerateOptions);
2553
    return 1;
2554
}
2555

2556

2557
long
2558
GNEApplicationWindow::onCmdUndo(FXObject* sender, FXSelector, void*) {
2559
    // Check conditions
2560
    if (myViewNet == nullptr) {
2561
        return 0;
2562
    } else if ((myInternalTest != sender) && !myEditMenuCommands.undoLastChange->isEnabled()) {
2563
        return 0;
2564
    } else {
2565
        // check supermode (currently ignore supermode data)
2566
        if ((myViewNet->getUndoList()->getUndoSupermode() != Supermode::DATA) &&
2567
                (myViewNet->getUndoList()->getUndoSupermode() != myViewNet->getEditModes().currentSupermode)) {
2568
            // abort if user doesn't press "yes"
2569
            if (!myViewNet->aksChangeSupermode(TL("Undo"), myViewNet->getUndoList()->getUndoSupermode())) {
2570
                return 0;
2571
            }
2572
        }
2573
        myViewNet->getUndoList()->undo();
2574
        // update current show frame after undo
2575
        if (myViewNet->getViewParent()->getCurrentShownFrame()) {
2576
            myViewNet->getViewParent()->getCurrentShownFrame()->updateFrameAfterUndoRedo();
2577
        }
2578
        // update manually undo/redo menu commands (see #6005)
2579
        onUpdUndo(myEditMenuCommands.undoLastChange, 0, 0);
2580
        onUpdRedo(myEditMenuCommands.redoLastChange, 0, 0);
2581
        // update toolbar undo-redo buttons
2582
        myViewNet->getViewParent()->updateUndoRedoButtons();
2583
        return 1;
2584
    }
2585
}
2586

2587

2588
long
2589
GNEApplicationWindow::onCmdRedo(FXObject* sender, FXSelector, void*) {
2590
    // Check conditions
2591
    if (myViewNet == nullptr) {
2592
        return 0;
2593
    } else if ((myInternalTest != sender) && !myEditMenuCommands.redoLastChange->isEnabled()) {
2594
        return 0;
2595
    } else {
2596
        // check supermode (currently ignore supermode data)
2597
        if ((myViewNet->getUndoList()->getRedoSupermode() != Supermode::DATA) &&
2598
                (myViewNet->getUndoList()->getRedoSupermode() != myViewNet->getEditModes().currentSupermode)) {
2599
            // abort if user doesn't press "yes"
2600
            if (!myViewNet->aksChangeSupermode(TL("Redo"), myViewNet->getUndoList()->getRedoSupermode())) {
2601
                return 0;
2602
            }
2603
        }
2604
        myViewNet->getUndoList()->redo();
2605
        // update current show frame after redo
2606
        if (myViewNet->getViewParent()->getCurrentShownFrame()) {
2607
            myViewNet->getViewParent()->getCurrentShownFrame()->updateFrameAfterUndoRedo();
2608
        }
2609
        // update manually undo/redo menu commands (see #6005)
2610
        onUpdUndo(myEditMenuCommands.undoLastChange, 0, 0);
2611
        onUpdRedo(myEditMenuCommands.redoLastChange, 0, 0);
2612
        // update toolbar undo-redo buttons
2613
        myViewNet->getViewParent()->updateUndoRedoButtons();
2614
        return 1;
2615
    }
2616
}
2617

2618

2619
long
2620
GNEApplicationWindow::onCmdOpenUndoListDialog(FXObject*, FXSelector, void*) {
2621
    // open UndoList Dialog
2622
    GNEUndoListDialog(this);
2623
    return 1;
2624
}
2625

2626

2627
long
2628
GNEApplicationWindow::onUpdOpenUndoListDialog(FXObject* sender, FXSelector, void*) {
2629
    // check if net exist and there is something to undo/redo
2630
    if (myNet && (myEditMenuCommands.undoLastChange->isEnabled() || myEditMenuCommands.redoLastChange->isEnabled())) {
2631
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2632
    } else {
2633
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2634
    }
2635
    return 1;
2636
}
2637

2638

2639
long
2640
GNEApplicationWindow::onCmdComputePathManager(FXObject*, FXSelector, void*) {
2641
    // first check viewNet
2642
    if (myViewNet && !myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2643
        // update demand path calculator
2644
        myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->updatePathCalculator();
2645
    }
2646
    return 1;
2647
}
2648

2649

2650
long
2651
GNEApplicationWindow::onCmdCut(FXObject*, FXSelector, void*) {
2652
    // Prepared for #6042
2653
    return 1;
2654
}
2655

2656

2657
long
2658
GNEApplicationWindow::onCmdCopy(FXObject*, FXSelector, void*) {
2659
    // Prepared for #6042
2660
    return 1;
2661
}
2662

2663

2664
long
2665
GNEApplicationWindow::onCmdPaste(FXObject*, FXSelector, void*) {
2666
    // Prepared for #6042
2667
    return 1;
2668
}
2669

2670

2671
long
2672
GNEApplicationWindow::onCmdSetTemplate(FXObject*, FXSelector, void*) {
2673
    // first check if myViewNet exist
2674
    if (myViewNet) {
2675
        // call set template in inspector frame
2676
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->setTemplate();
2677
    }
2678
    return 1;
2679
}
2680

2681

2682
long
2683
GNEApplicationWindow::onCmdCopyTemplate(FXObject*, FXSelector, void*) {
2684
    // first check if myViewNet exist
2685
    if (myViewNet) {
2686
        // call copy template in inspector frame
2687
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->copyTemplate();
2688
    }
2689
    return 1;
2690
}
2691

2692

2693
long
2694
GNEApplicationWindow::onCmdClearTemplate(FXObject*, FXSelector, void*) {
2695
    // first check if myViewNet exist
2696
    if (myViewNet) {
2697
        // call clear template in inspector frame
2698
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->clearTemplate();
2699
    }
2700
    return 1;
2701
}
2702

2703

2704
long
2705
GNEApplicationWindow::onUpdNeedsNetwork(FXObject* sender, FXSelector, void*) {
2706
    // check if net exist
2707
    if (myNet) {
2708
        myFileMenuCommands.enableMenuCascades();
2709
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2710
    } else {
2711
        myFileMenuCommands.disableMenuCascades();
2712
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2713
    }
2714
}
2715

2716

2717
long
2718
GNEApplicationWindow::onUpdNeedsNetworkElement(FXObject* sender, FXSelector, void*) {
2719
    // check if at least there is one edge in the network
2720
    if (myNet && (myNet->getAttributeCarriers()->getEdges().size() > 0)) {
2721
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2722
    } else {
2723
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2724
    }
2725
}
2726

2727

2728
long
2729
GNEApplicationWindow::onUpdNeedsFrontElement(FXObject* sender, FXSelector, void*) {
2730
    // check if net, viewnet and front attribute exist
2731
    if (myViewNet && (myViewNet->getMarkFrontElements().getACs().size() > 0)) {
2732
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2733
    } else {
2734
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2735
    }
2736
}
2737

2738

2739
long
2740
GNEApplicationWindow::onUpdSaveNetwork(FXObject* sender, FXSelector, void*) {
2741
    if (myNet == nullptr) {
2742
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2743
    } else if (myNet->getSavingStatus()->isNetworkSaved()) {
2744
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2745
    } else {
2746
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2747
    }
2748
}
2749

2750

2751
long
2752
GNEApplicationWindow::onUpdSaveAdditionalElements(FXObject* sender, FXSelector, void*) {
2753
    if (myNet == nullptr) {
2754
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2755
    } else if (myNet->getViewNet()->getViewParent()->getTAZFrame()->getTAZSaveChangesModule()->isChangesPending()) {
2756
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2757
    } else {
2758
        return sender->handle(this, myNet->getSavingStatus()->isAdditionalsSaved() ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2759
    }
2760
}
2761

2762

2763
long
2764
GNEApplicationWindow::onUpdSaveAdditionalElementsUnified(FXObject* sender, FXSelector, void*) {
2765
    if (myNet == nullptr) {
2766
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2767
    } else if (myNet->getAttributeCarriers()->getNumberOfAdditionals() == 0) {
2768
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2769
    } else {
2770
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2771
    }
2772
}
2773

2774

2775
long
2776
GNEApplicationWindow::onUpdSaveJuPedSimElementsAs(FXObject* sender, FXSelector, void*) {
2777
    if (myNet == nullptr) {
2778
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2779
    } else if (myNet->getAttributeCarriers()->getAdditionals().at(GNE_TAG_JPS_WALKABLEAREA).size() > 0) {
2780
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2781
    } else if (myNet->getAttributeCarriers()->getAdditionals().at(GNE_TAG_JPS_OBSTACLE).size() > 0) {
2782
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2783
    } else {
2784
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2785
    }
2786
}
2787

2788

2789
long
2790
GNEApplicationWindow::onUpdSaveDemandElements(FXObject* sender, FXSelector, void*) {
2791
    if (myNet == nullptr) {
2792
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2793
    } else if (myNet->getSavingStatus()->isDemandElementsSaved()) {
2794
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2795
    } else {
2796
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2797
    }
2798

2799
}
2800

2801

2802
long
2803
GNEApplicationWindow::onUpdSaveDemandElementsUnified(FXObject* sender, FXSelector, void*) {
2804
    if (myNet == nullptr) {
2805
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2806
    } else if (myNet->getAttributeCarriers()->getNumberOfDemandElements() == 0) {
2807
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2808
    } else {
2809
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2810
    }
2811
}
2812

2813

2814
long
2815
GNEApplicationWindow::onUpdSaveDataElements(FXObject* sender, FXSelector, void*) {
2816
    if (myNet == nullptr) {
2817
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2818
    } else if (myNet->getSavingStatus()->isDataElementsSaved()) {
2819
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2820
    } else {
2821
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2822
    }
2823

2824
}
2825

2826

2827
long
2828
GNEApplicationWindow::onUpdSaveDataElementsUnified(FXObject* sender, FXSelector, void*) {
2829
    if (myNet == nullptr) {
2830
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2831
    } else if (myNet->getAttributeCarriers()->getDataSets().size() == 0) {
2832
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2833
    } else {
2834
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2835
    }
2836

2837
}
2838

2839

2840
long
2841
GNEApplicationWindow::onUpdSaveMeanDataElements(FXObject* sender, FXSelector, void*) {
2842
    if (myNet == nullptr) {
2843
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2844
    } else if (myNet->getSavingStatus()->isMeanDatasSaved()) {
2845
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2846
    } else {
2847
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2848
    }
2849
}
2850

2851

2852
long
2853
GNEApplicationWindow::onUpdSaveMeanDataElementsUnified(FXObject* sender, FXSelector, void*) {
2854
    if (myNet == nullptr) {
2855
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2856
    } else if (myNet->getAttributeCarriers()->getNumberOfMeanDatas() == 0) {
2857
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2858
    } else {
2859
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2860
    }
2861

2862
}
2863

2864

2865
long
2866
GNEApplicationWindow::onUpdUndo(FXObject* sender, FXSelector sel, void* ptr) {
2867
    return myUndoList->onUpdUndo(sender, sel, ptr);
2868
}
2869

2870

2871
long
2872
GNEApplicationWindow::onUpdRedo(FXObject* sender, FXSelector sel, void* ptr) {
2873
    return myUndoList->onUpdRedo(sender, sel, ptr);
2874
}
2875

2876

2877
long
2878
GNEApplicationWindow::onUpdComputePathManager(FXObject* sender, FXSelector /*sel*/, void* /*ptr*/) {
2879
    // first check viewNet
2880
    if (myViewNet) {
2881
        // check supermode network
2882
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
2883
            // disable
2884
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2885
        } else if (myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2886
            // disable
2887
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2888
        } else {
2889
            // enable
2890
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2891
        }
2892
    } else {
2893
        // disable
2894
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2895
    }
2896
}
2897

2898

2899
long
2900
GNEApplicationWindow::onCmdToggleViewOption(FXObject* sender, FXSelector sel, void* ptr) {
2901
    // check viewNet
2902
    if (myViewNet) {
2903
        // continue depending of selector
2904
        switch (FXSELID(sel)) {
2905
            // Network
2906
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID:
2907
                return myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
2908
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
2909
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
2910
            case MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES:
2911
                return myViewNet->onCmdToggleDrawSpreadVehicles(sender, sel, ptr);
2912
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS:
2913
                return myViewNet->onCmdToggleShowDemandElementsNetwork(sender, sel, ptr);
2914
            case MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES:
2915
                return myViewNet->onCmdToggleSelectEdges(sender, sel, ptr);
2916
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS:
2917
                return myViewNet->onCmdToggleShowConnections(sender, sel, ptr);
2918
            case MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS:
2919
                return myViewNet->onCmdToggleHideConnections(sender, sel, ptr);
2920
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS:
2921
                return myViewNet->onCmdToggleShowAdditionalSubElements(sender, sel, ptr);
2922
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS:
2923
                return myViewNet->onCmdToggleShowTAZElements(sender, sel, ptr);
2924
            case MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION:
2925
                return myViewNet->onCmdToggleExtendSelection(sender, sel, ptr);
2926
            case MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES:
2927
                return myViewNet->onCmdToggleChangeAllPhases(sender, sel, ptr);
2928
            case MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY:
2929
                return myViewNet->onCmdToggleMergeAutomatically(sender, sel, ptr);
2930
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES:
2931
                return myViewNet->onCmdToggleShowJunctionBubbles(sender, sel, ptr);
2932
            case MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION:
2933
                return myViewNet->onCmdToggleMoveElevation(sender, sel, ptr);
2934
            case MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES:
2935
                return myViewNet->onCmdToggleChainEdges(sender, sel, ptr);
2936
            case MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES:
2937
                return myViewNet->onCmdToggleAutoOppositeEdge(sender, sel, ptr);
2938
            // Demand
2939
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID:
2940
                return myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
2941
            case MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
2942
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
2943
            case MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES:
2944
                return myViewNet->onCmdToggleDrawSpreadVehicles(sender, sel, ptr);
2945
            case MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED:
2946
                return myViewNet->onCmdToggleHideNonInspecteDemandElements(sender, sel, ptr);
2947
            case MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES:
2948
                return myViewNet->onCmdToggleHideShapes(sender, sel, ptr);
2949
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS:
2950
                return myViewNet->onCmdToggleShowTrips(sender, sel, ptr);
2951
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS:
2952
                return myViewNet->onCmdToggleShowAllPersonPlans(sender, sel, ptr);
2953
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON:
2954
                return myViewNet->onCmdToggleLockPerson(sender, sel, ptr);
2955
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS:
2956
                return myViewNet->onCmdToggleShowAllContainerPlans(sender, sel, ptr);
2957
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER:
2958
                return myViewNet->onCmdToggleLockContainer(sender, sel, ptr);
2959
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES:
2960
                return myViewNet->onCmdToggleShowOverlappedRoutes(sender, sel, ptr);
2961
            // Data
2962
            case MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
2963
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
2964
            case MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS:
2965
                return myViewNet->onCmdToggleShowAdditionals(sender, sel, ptr);
2966
            case MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES:
2967
                return myViewNet->onCmdToggleShowShapes(sender, sel, ptr);
2968
            case MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS:
2969
                return myViewNet->onCmdToggleShowDemandElementsData(sender, sel, ptr);
2970
            case MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING:
2971
                return myViewNet->onCmdToggleTAZRelDrawing(sender, sel, ptr);
2972
            case MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL:
2973
                return myViewNet->onCmdToggleTAZRelDrawing(sender, sel, ptr);
2974
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM:
2975
                return myViewNet->onCmdToggleTAZRelOnlyFrom(sender, sel, ptr);
2976
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO:
2977
                return myViewNet->onCmdToggleTAZRelOnlyTo(sender, sel, ptr);
2978
            default:
2979
                return 0;
2980
        }
2981
    } else {
2982
        return 0;
2983
    }
2984
}
2985

2986

2987
long
2988
GNEApplicationWindow::onUpdToggleViewOption(FXObject* sender, FXSelector sel, void* /*ptr*/) {
2989
    // get menuCheck
2990
    MFXMenuCheckIcon* menuCheck = dynamic_cast<MFXMenuCheckIcon*>(sender);
2991
    // check viewNet
2992
    if (myViewNet && menuCheck) {
2993
        // continue depending of selector
2994
        switch (FXSELID(sel)) {
2995
            // Network
2996
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID:
2997
                if (myViewNet->getNetworkViewOptions().menuCheckToggleGrid->amChecked()) {
2998
                    menuCheck->setCheck(TRUE);
2999
                } else {
3000
                    menuCheck->setCheck(FALSE);
3001
                }
3002
                break;
3003
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3004
                if (myViewNet->getNetworkViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3005
                    menuCheck->setCheck(TRUE);
3006
                } else {
3007
                    menuCheck->setCheck(FALSE);
3008
                }
3009
                break;
3010
            case MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES:
3011
                if (myViewNet->getNetworkViewOptions().menuCheckDrawSpreadVehicles->amChecked()) {
3012
                    menuCheck->setCheck(TRUE);
3013
                } else {
3014
                    menuCheck->setCheck(FALSE);
3015
                }
3016
                break;
3017
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS:
3018
                if (myViewNet->getNetworkViewOptions().menuCheckShowDemandElements->amChecked()) {
3019
                    menuCheck->setCheck(TRUE);
3020
                } else {
3021
                    menuCheck->setCheck(FALSE);
3022
                }
3023
                break;
3024
            case MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES:
3025
                if (myViewNet->getNetworkViewOptions().menuCheckSelectEdges->amChecked()) {
3026
                    menuCheck->setCheck(TRUE);
3027
                } else {
3028
                    menuCheck->setCheck(FALSE);
3029
                }
3030
                break;
3031
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS:
3032
                if (myViewNet->getNetworkViewOptions().menuCheckShowConnections->amChecked()) {
3033
                    menuCheck->setCheck(TRUE);
3034
                } else {
3035
                    menuCheck->setCheck(FALSE);
3036
                }
3037
                break;
3038
            case MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS:
3039
                if (myViewNet->getNetworkViewOptions().menuCheckHideConnections->amChecked()) {
3040
                    menuCheck->setCheck(TRUE);
3041
                } else {
3042
                    menuCheck->setCheck(FALSE);
3043
                }
3044
                break;
3045
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS:
3046
                if (myViewNet->getNetworkViewOptions().menuCheckShowAdditionalSubElements->amChecked()) {
3047
                    menuCheck->setCheck(TRUE);
3048
                } else {
3049
                    menuCheck->setCheck(FALSE);
3050
                }
3051
                break;
3052
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS:
3053
                if (myViewNet->getNetworkViewOptions().menuCheckShowTAZElements->amChecked()) {
3054
                    menuCheck->setCheck(TRUE);
3055
                } else {
3056
                    menuCheck->setCheck(FALSE);
3057
                }
3058
                break;
3059
            case MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION:
3060
                if (myViewNet->getNetworkViewOptions().menuCheckExtendSelection->amChecked()) {
3061
                    menuCheck->setCheck(TRUE);
3062
                } else {
3063
                    menuCheck->setCheck(FALSE);
3064
                }
3065
                break;
3066
            case MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES:
3067
                if (myViewNet->getNetworkViewOptions().menuCheckChangeAllPhases->amChecked()) {
3068
                    menuCheck->setCheck(TRUE);
3069
                } else {
3070
                    menuCheck->setCheck(FALSE);
3071
                }
3072
                break;
3073
            case MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY:
3074
                if (myViewNet->getNetworkViewOptions().menuCheckMergeAutomatically->amChecked()) {
3075
                    menuCheck->setCheck(TRUE);
3076
                } else {
3077
                    menuCheck->setCheck(FALSE);
3078
                }
3079
                break;
3080
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES:
3081
                if (myViewNet->getNetworkViewOptions().menuCheckShowJunctionBubble->amChecked()) {
3082
                    menuCheck->setCheck(TRUE);
3083
                } else {
3084
                    menuCheck->setCheck(FALSE);
3085
                }
3086
                break;
3087
            case MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION:
3088
                if (myViewNet->getNetworkViewOptions().menuCheckMoveElevation->amChecked()) {
3089
                    menuCheck->setCheck(TRUE);
3090
                } else {
3091
                    menuCheck->setCheck(FALSE);
3092
                }
3093
                break;
3094
            case MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES:
3095
                if (myViewNet->getNetworkViewOptions().menuCheckChainEdges->amChecked()) {
3096
                    menuCheck->setCheck(TRUE);
3097
                } else {
3098
                    menuCheck->setCheck(FALSE);
3099
                }
3100
                break;
3101
            case MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES:
3102
                if (myViewNet->getNetworkViewOptions().menuCheckAutoOppositeEdge->amChecked()) {
3103
                    menuCheck->setCheck(TRUE);
3104
                } else {
3105
                    menuCheck->setCheck(FALSE);
3106
                }
3107
                break;
3108
            // Demand
3109
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID:
3110
                if (myViewNet->getDemandViewOptions().menuCheckToggleGrid->amChecked()) {
3111
                    menuCheck->setCheck(TRUE);
3112
                } else {
3113
                    menuCheck->setCheck(FALSE);
3114
                }
3115
                break;
3116
            case MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3117
                if (myViewNet->getDemandViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3118
                    menuCheck->setCheck(TRUE);
3119
                } else {
3120
                    menuCheck->setCheck(FALSE);
3121
                }
3122
                break;
3123
            case MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES:
3124
                if (myViewNet->getDemandViewOptions().menuCheckDrawSpreadVehicles->amChecked()) {
3125
                    menuCheck->setCheck(TRUE);
3126
                } else {
3127
                    menuCheck->setCheck(FALSE);
3128
                }
3129
                break;
3130
            case MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES:
3131
                if (myViewNet->getDemandViewOptions().menuCheckHideShapes->amChecked()) {
3132
                    menuCheck->setCheck(TRUE);
3133
                } else {
3134
                    menuCheck->setCheck(FALSE);
3135
                }
3136
                break;
3137
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS:
3138
                if (myViewNet->getDemandViewOptions().menuCheckShowAllTrips->amChecked()) {
3139
                    menuCheck->setCheck(TRUE);
3140
                } else {
3141
                    menuCheck->setCheck(FALSE);
3142
                }
3143
                break;
3144
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS:
3145
                if (myViewNet->getDemandViewOptions().menuCheckShowAllPersonPlans->amChecked()) {
3146
                    menuCheck->setCheck(TRUE);
3147
                } else {
3148
                    menuCheck->setCheck(FALSE);
3149
                }
3150
                break;
3151
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON:
3152
                if (myViewNet->getDemandViewOptions().menuCheckLockPerson->amChecked()) {
3153
                    menuCheck->setCheck(TRUE);
3154
                } else {
3155
                    menuCheck->setCheck(FALSE);
3156
                }
3157
                // special case for lock persons
3158
                if (myViewNet->getDemandViewOptions().menuCheckLockPerson->isEnabled()) {
3159
                    menuCheck->enable();
3160
                } else {
3161
                    menuCheck->disable();
3162
                }
3163
                break;
3164
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS:
3165
                if (myViewNet->getDemandViewOptions().menuCheckShowAllContainerPlans->amChecked()) {
3166
                    menuCheck->setCheck(TRUE);
3167
                } else {
3168
                    menuCheck->setCheck(FALSE);
3169
                }
3170
                break;
3171
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER:
3172
                if (myViewNet->getDemandViewOptions().menuCheckLockContainer->amChecked()) {
3173
                    menuCheck->setCheck(TRUE);
3174
                } else {
3175
                    menuCheck->setCheck(FALSE);
3176
                }
3177
                // special case for lock containers
3178
                if (myViewNet->getDemandViewOptions().menuCheckLockContainer->isEnabled()) {
3179
                    menuCheck->enable();
3180
                } else {
3181
                    menuCheck->disable();
3182
                }
3183
                break;
3184
            case MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED:
3185
                if (myViewNet->getDemandViewOptions().menuCheckHideNonInspectedDemandElements->amChecked()) {
3186
                    menuCheck->setCheck(TRUE);
3187
                } else {
3188
                    menuCheck->setCheck(FALSE);
3189
                }
3190
                break;
3191
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES:
3192
                if (myViewNet->getDemandViewOptions().menuCheckShowOverlappedRoutes->amChecked()) {
3193
                    menuCheck->setCheck(TRUE);
3194
                } else {
3195
                    menuCheck->setCheck(FALSE);
3196
                }
3197
                break;
3198
            // Data
3199
            case MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3200
                if (myViewNet->getDataViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3201
                    menuCheck->setCheck(TRUE);
3202
                } else {
3203
                    menuCheck->setCheck(FALSE);
3204
                }
3205
                break;
3206
            case MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS:
3207
                if (myViewNet->getDataViewOptions().menuCheckShowAdditionals->amChecked()) {
3208
                    menuCheck->setCheck(TRUE);
3209
                } else {
3210
                    menuCheck->setCheck(FALSE);
3211
                }
3212
                break;
3213
            case MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES:
3214
                if (myViewNet->getDataViewOptions().menuCheckShowShapes->amChecked()) {
3215
                    menuCheck->setCheck(TRUE);
3216
                } else {
3217
                    menuCheck->setCheck(FALSE);
3218
                }
3219
                break;
3220
            case MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS:
3221
                if (myViewNet->getDataViewOptions().menuCheckShowDemandElements->amChecked()) {
3222
                    menuCheck->setCheck(TRUE);
3223
                } else {
3224
                    menuCheck->setCheck(FALSE);
3225
                }
3226
                break;
3227
            case MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING:
3228
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelDrawing->amChecked()) {
3229
                    menuCheck->setCheck(TRUE);
3230
                } else {
3231
                    menuCheck->setCheck(FALSE);
3232
                }
3233
                break;
3234
            case MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL:
3235
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZDrawFill->amChecked()) {
3236
                    menuCheck->setCheck(TRUE);
3237
                } else {
3238
                    menuCheck->setCheck(FALSE);
3239
                }
3240
                break;
3241

3242
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM:
3243
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelOnlyFrom->amChecked()) {
3244
                    menuCheck->setCheck(TRUE);
3245
                } else {
3246
                    menuCheck->setCheck(FALSE);
3247
                }
3248
                break;
3249
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO:
3250
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelOnlyTo->amChecked()) {
3251
                    menuCheck->setCheck(TRUE);
3252
                } else {
3253
                    menuCheck->setCheck(FALSE);
3254
                }
3255
                break;
3256
            default:
3257
                break;
3258
        }
3259
    }
3260
    return 0;
3261
}
3262

3263

3264
long
3265
GNEApplicationWindow::onCmdSaveNetwork(FXObject* sender, FXSelector sel, void* ptr) {
3266
    auto& neteditOptions = OptionsCont::getOptions();
3267
    if (myNet->getSavingStatus()->isNetworkSaved() && !neteditOptions.getBool("force-saving")) {
3268
        // nothing to save
3269
        return 1;
3270
    }
3271
    // first check if we have to set the output filename
3272
    if ((sel == MID_GNE_AUTOMATICFILENAME) && neteditOptions.getString("net-file").empty()) {
3273
        neteditOptions.set("net-file", *(static_cast<std::string*>(ptr)) + ".net.xml");
3274
    }
3275
    // function onCmdSaveNetworkAs must be executed if this is the first save
3276
    if (neteditOptions.getString("net-file").empty()) {
3277
        return onCmdSaveNetworkAs(sender, sel, ptr);
3278
    } else {
3279
        // always recompute before saving
3280
        myNet->computeNetwork(this);
3281
        // se net file in SUMO options
3282
        mySumoOptions.resetWritable();
3283
        mySumoOptions.set("net-file", neteditOptions.getString("net-file"));
3284
        bool saved = false;
3285
        try {
3286
            // obtain invalid networkElements (currently only edges or crossings
3287
            std::vector<GNENetworkElement*> invalidNetworkElements;
3288
            // iterate over crossings and edges
3289
            for (const auto& edge : myViewNet->getNet()->getAttributeCarriers()->getEdges()) {
3290
                if (!edge.second->isNetworkElementValid()) {
3291
                    invalidNetworkElements.push_back(edge.second);
3292
                }
3293
            }
3294
            for (const auto& crossing : myViewNet->getNet()->getAttributeCarriers()->getCrossings()) {
3295
                if (!crossing.second->isNetworkElementValid()) {
3296
                    invalidNetworkElements.push_back(crossing.second);
3297
                }
3298
            }
3299
            // if there are invalid network elements, open GNEFixNetworkElements
3300
            if (invalidNetworkElements.size() > 0) {
3301
                // create fix network elements dialog
3302
                const auto fixNetworkElementsDialog = GNEFixNetworkElements(this, invalidNetworkElements);
3303
                // continue depending of result
3304
                if (fixNetworkElementsDialog.getResult() == GNEDialog::Result::ACCEPT) {
3305
                    // Save network
3306
                    myNet->saveNetwork();
3307
                    saved = true;
3308
                } else {
3309
                    // stop
3310
                    return 0;
3311
                }
3312
            } else {
3313
                // Save network
3314
                myNet->saveNetwork();
3315
                saved = true;
3316
            }
3317
        } catch (IOError& e) {
3318
            // open error message box
3319
            GNEErrorBasicDialog(this, TL("Saving network failed"), e.what());
3320
        }
3321
        if (saved) {
3322
            // write info
3323
            WRITE_MESSAGE(TLF("Network saved in '%'.", neteditOptions.getString("net-file")));
3324
            // After saving a net successfully, add it into Recent Nets list.
3325
            myMenuBarFile.myRecentNetworks.appendFile(neteditOptions.getString("net-file").c_str());
3326
            myMessageWindow->addSeparator();
3327
        } else {
3328
            PROGRESS_FAILED_MESSAGE();
3329
            WRITE_ERROR(TLF("Could not save network in '%'.", neteditOptions.getString("net-file")));
3330
            return 0;
3331
        }
3332
        return 1;
3333
    }
3334
}
3335

3336

3337
long
3338
GNEApplicationWindow::onCmdSaveNetworkAs(FXObject*, FXSelector, void*) {
3339
    // get network file file
3340
    const auto networkFileDialog = GNEFileDialog(this, TL("network file"),
3341
                                   SUMOXMLDefinitions::NetFileExtensions.getStrings(),
3342
                                   GNEFileDialog::OpenMode::SAVE,
3343
                                   GNEFileDialog::ConfigType::NETEDIT);
3344
    if (networkFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3345
        // set ouput file in netedit configs
3346
        auto& neteditOptions = OptionsCont::getOptions();
3347
        neteditOptions.resetWritable();
3348
        neteditOptions.set("net-file", networkFileDialog.getFilename());
3349
        // update netedit title with the network name
3350
        setTitle(MFXUtils::getTitleText(myTitlePrefix, networkFileDialog.getFilename().c_str()));
3351
        // enable save network
3352
        myNet->getSavingStatus()->requireSaveNetwork();
3353
        // save network
3354
        return onCmdSaveNetwork(nullptr, 0, nullptr);
3355
    } else {
3356
        return 0;
3357
    }
3358
}
3359

3360

3361
long
3362
GNEApplicationWindow::onCmdSavePlainXMLAs(FXObject*, FXSelector, void*) {
3363
    // get neteditConfig filename
3364
    const auto plainXMLFileDialog = GNEFileDialog(this, TL("plain XML file"),
3365
                                    SUMOXMLDefinitions::XMLFileExtensions.getStrings(),
3366
                                    GNEFileDialog::OpenMode::SAVE,
3367
                                    GNEFileDialog::ConfigType::NETEDIT);
3368
    // Remove extension
3369
    if (plainXMLFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3370
        auto plainXMLFile = plainXMLFileDialog.getFilename();
3371
        // adjust file
3372
        if (plainXMLFile.back() == '.') {
3373
            plainXMLFile.pop_back();
3374
        } else {
3375
            plainXMLFile = StringUtils::replace(plainXMLFile, ".edg.xml", "");
3376
            plainXMLFile = StringUtils::replace(plainXMLFile, ".nod.xml", "");
3377
            plainXMLFile = StringUtils::replace(plainXMLFile, ".con.xml", "");
3378
            plainXMLFile = StringUtils::replace(plainXMLFile, ".typ.xml", "");
3379
            plainXMLFile = StringUtils::replace(plainXMLFile, ".tll.xml", "");
3380
            plainXMLFile = StringUtils::replace(plainXMLFile, ".xml", "");
3381
        }
3382
        // continue depending of file
3383
        if (!plainXMLFile.empty()) {
3384
            // start saving plain XML
3385
            getApp()->beginWaitCursor();
3386
            try {
3387
                myNet->savePlain(plainXMLFile);
3388
                // write info
3389
                WRITE_MESSAGE(TLF("Plain XML saved with prefix '%'.", plainXMLFile));
3390
            } catch (IOError& e) {
3391
                // open message box
3392
                GNEErrorBasicDialog(this, TL("Saving plain xml failed"), e.what());
3393
            }
3394
            // end saving plain XML
3395
            getApp()->endWaitCursor();
3396
            // set focus again in viewNet
3397
            myViewNet->setFocus();
3398
        }
3399
    }
3400
    return 1;
3401
}
3402

3403

3404
long
3405
GNEApplicationWindow::onCmdSaveJoinedJunctionsAs(FXObject*, FXSelector, void*) {
3406
    // get neteditConfig filename
3407
    const auto joinedJunctionsFileDialog = GNEFileDialog(this, TL("joined junctions file"),
3408
                                           SUMOXMLDefinitions::JunctionFileExtensions.getStrings(),
3409
                                           GNEFileDialog::OpenMode::SAVE,
3410
                                           GNEFileDialog::ConfigType::NETEDIT);
3411
    // continue depending of file
3412
    if (joinedJunctionsFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3413
        getApp()->beginWaitCursor();
3414
        try {
3415
            myNet->saveJoined(joinedJunctionsFileDialog.getFilename());
3416
            // write info
3417
            WRITE_MESSAGE(TLF("Joined junctions saved to '%'.", joinedJunctionsFileDialog.getFilename()));
3418
        } catch (IOError& e) {
3419
            // opening error message
3420
            GNEErrorBasicDialog(this, TL("Saving joined junctions failed"), e.what());
3421
        }
3422
        getApp()->endWaitCursor();
3423
        // set focus again in viewNet
3424
        myViewNet->setFocus();
3425
    }
3426
    return 1;
3427
}
3428

3429

3430
long
3431
GNEApplicationWindow::onCmdSaveNeteditConfig(FXObject*, FXSelector, void*) {
3432
    // obtain netedit option container
3433
    auto& neteditOptions = OptionsCont::getOptions();
3434
    neteditOptions.resetWritable();
3435
    // Check if configuration file was already set at start of netedit or with a previous save
3436
    if (neteditOptions.getString("configuration-file").empty()) {
3437
        return onCmdSaveNeteditConfigAs(nullptr, 0, nullptr);
3438
    } else {
3439
        // get config file
3440
        const auto neteditConfigFile = neteditOptions.getString("configuration-file");
3441
        // get file path
3442
        const auto filePath = FileHelpers::getFilePath(neteditConfigFile);
3443
        // get patter file
3444
        auto patterFile = StringUtils::replace(neteditConfigFile, ".netecfg", "");
3445
        // update netedit config
3446
        myNet->getSavingFilesHandler()->updateNeteditConfig();
3447
        // save all elements giving automatic names based on patter if their file isn't defined
3448
        if (onCmdSaveNetwork(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3449
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted."));
3450
            return 0;
3451
        }
3452
        if (onCmdSaveAdditionalElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3453
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted."));
3454
            return 0;
3455
        }
3456
        if (onCmdSaveDemandElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3457
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted."));
3458
            return 0;
3459
        }
3460
        if (onCmdSaveDataElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3461
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted."));
3462
            return 0;
3463
        }
3464
        if (onCmdSaveMeanDataElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3465
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted."));
3466
            return 0;
3467
        }
3468
        // configuration
3469
        std::ofstream out(StringUtils::transcodeToLocal(neteditConfigFile));
3470
        if (out.good()) {
3471
            // write netedit config
3472
            neteditOptions.writeConfiguration(out, true, false, false, filePath, true);
3473
            // write info
3474
            WRITE_MESSAGE(TLF("Netedit configuration saved in '%'.", neteditConfigFile));
3475
            // config saved
3476
            myNet->getSavingStatus()->neteditConfigSaved();
3477
            // After saving a config successfully, add it into recent configs
3478
            myMenuBarFile.myRecentConfigs.appendFile(neteditOptions.getString("configuration-file").c_str());
3479
        } else {
3480
            WRITE_ERROR(TLF("Could not save netedit configuration in '%'.", neteditConfigFile));
3481
        }
3482
        out.close();
3483
        return 1;
3484
    }
3485
}
3486

3487

3488
long
3489
GNEApplicationWindow::onCmdSaveNeteditConfigAs(FXObject* sender, FXSelector sel, void* ptr) {
3490
    auto& neteditOptions = OptionsCont::getOptions();
3491
    // get neteditConfig filename
3492
    const auto neteditConfigFileDialog = GNEFileDialog(this, TL("netedit config file"),
3493
                                         SUMOXMLDefinitions::NeteditConfigFileExtensions.getStrings(),
3494
                                         GNEFileDialog::OpenMode::SAVE,
3495
                                         GNEFileDialog::ConfigType::NETEDIT);
3496
    // continue depending of file
3497
    if (neteditConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3498
        neteditOptions.resetWritable();
3499
        neteditOptions.set("configuration-file", neteditConfigFileDialog.getFilename());
3500
        // continue saving netedit config
3501
        return onCmdSaveNeteditConfig(sender, sel, ptr);
3502
    } else {
3503
        return 0;
3504
    }
3505
}
3506

3507

3508
long
3509
GNEApplicationWindow::onUpdSaveNeteditConfig(FXObject* sender, FXSelector, void*) {
3510
    // check if enable or disable save netedit config button
3511
    if (myNet == nullptr) {
3512
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3513
    } else if (OptionsCont::getOptions().getString("configuration-file").empty()) {
3514
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3515
    } else if (!myNet->getSavingStatus()->isNeteditConfigSaved()) {
3516
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3517
    } else {
3518
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3519
    }
3520
    // check if enable/disable save individual files
3521
    if (myNet) {
3522
        if (myNet->getSavingStatus()->isAdditionalsSaved() && myNet->getSavingStatus()->isDemandElementsSaved() &&
3523
                myNet->getSavingStatus()->isDataElementsSaved() && myNet->getSavingStatus()->isMeanDatasSaved()) {
3524
            myViewNet->getSaveElements().setSaveIndividualFiles(false);
3525
        } else {
3526
            myViewNet->getSaveElements().setSaveIndividualFiles(true);
3527
        }
3528
    }
3529
    return 1;
3530
}
3531

3532

3533
long
3534
GNEApplicationWindow::onCmdSaveSumoConfig(FXObject* sender, FXSelector sel, void* ptr) {
3535
    // obtain netedit option container
3536
    auto& neteditOptions = OptionsCont::getOptions();
3537
    // reset containers
3538
    neteditOptions.resetWritable();
3539
    mySumoOptions.resetWritable();
3540
    // Check if configuration file was already set at start of netedit or with a previous save
3541
    if (neteditOptions.getString("sumocfg-file").empty()) {
3542
        return onCmdSaveSumoConfigAs(sender, sel, ptr);
3543
    } else {
3544
        // check if ignore additionals and demand elements (only used open SUMO-GUI from netedit)
3545
        const FXSelector openSUMO = FXSEL(SEL_COMMAND, MID_HOTKEY_CTRL_T_OPENNETEDIT_OPENSUMO);
3546
        const bool ignoreAdditionals = (sel == openSUMO) ? (myEditMenuCommands.loadAdditionalsInSUMOGUI->getCheck() == FALSE) : false;
3547
        const bool ignoreDemandElements = (sel == openSUMO) ? (myEditMenuCommands.loadDemandInSUMOGUI->getCheck() == FALSE) : false;
3548
        // get SumoConfig file
3549
        const auto sumoConfigFile = neteditOptions.getString("sumocfg-file");
3550
        // get config file without extension
3551
        auto patterFile = StringUtils::replace(sumoConfigFile, ".sumocfg", "");
3552
        // update netedit config
3553
        myNet->getSavingFilesHandler()->updateNeteditConfig();
3554
        // save all elements giving automatic names based on patter in their file isn't defined
3555
        if (onCmdSaveNetwork(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3556
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3557
            return 0;
3558
        }
3559
        if (onCmdSaveAdditionalElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3560
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3561
            return 0;
3562
        }
3563
        if (onCmdSaveDemandElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3564
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3565
            return 0;
3566
        }
3567
        if (onCmdSaveDataElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3568
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3569
            return 0;
3570
        }
3571
        if (onCmdSaveMeanDataElements(nullptr, MID_GNE_AUTOMATICFILENAME, &patterFile) != 1) {
3572
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3573
            return 0;
3574
        }
3575
        // set input in sumo options
3576
        setInputInSumoOptions(ignoreAdditionals, ignoreDemandElements);
3577
        // if we have trips or flow over junctions, add option junction-taz
3578
        if ((myNet->getAttributeCarriers()->getDemandElements().at(GNE_TAG_TRIP_JUNCTIONS).size() > 0) ||
3579
                (myNet->getAttributeCarriers()->getDemandElements().at(GNE_TAG_FLOW_JUNCTIONS).size() > 0)) {
3580
            mySumoOptions.set("junction-taz", "true");
3581
        }
3582
        std::ofstream out(StringUtils::transcodeToLocal(sumoConfigFile));
3583
        if (out.good()) {
3584
            // write SUMO config
3585
            mySumoOptions.writeConfiguration(out, true, false, false, sumoConfigFile, true);
3586
            // write info
3587
            WRITE_MESSAGE(TLF("SUMO configuration saved in '%'.", sumoConfigFile));
3588
            // if ignoreAdditionals or ignoreDemandElements is enabled, don't mark SumoConfig as saved
3589
            if (!ignoreAdditionals && !ignoreDemandElements) {
3590
                myNet->getSavingStatus()->SumoConfigSaved();
3591
            }
3592
            // After saving a config successfully, add it into recent configs
3593
            myMenuBarFile.myRecentConfigs.appendFile(neteditOptions.getString("sumocfg-file").c_str());
3594
        } else {
3595
            WRITE_MESSAGE(TLF("Could not save SUMO configuration in '%'.", sumoConfigFile));
3596
        }
3597
        out.close();
3598
        return 1;
3599
    }
3600
}
3601

3602

3603
long
3604
GNEApplicationWindow::onCmdSaveSumoConfigAs(FXObject* sender, FXSelector sel, void* ptr) {
3605
    auto& neteditOptions = OptionsCont::getOptions();
3606
    // get sumoConfig filename
3607
    const auto sumoConfigFileDialog = GNEFileDialog(this, TL("sumo config file"),
3608
                                      SUMOXMLDefinitions::SumoConfigFileExtensions.getStrings(),
3609
                                      GNEFileDialog::OpenMode::SAVE,
3610
                                      GNEFileDialog::ConfigType::NETEDIT);
3611
    // continue depending of file
3612
    if (sumoConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3613
        // save file in netedit options
3614
        neteditOptions.resetWritable();
3615
        neteditOptions.set("sumocfg-file", sumoConfigFileDialog.getFilename());
3616
        // continue saving SUMO Config
3617
        return onCmdSaveSumoConfig(sender, sel, ptr);
3618
    } else {
3619
        return 0;
3620
    }
3621
}
3622

3623

3624
long
3625
GNEApplicationWindow::onUpdSaveSumoConfig(FXObject* sender, FXSelector, void*) {
3626
    if (myNet == nullptr) {
3627
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3628
    } else if (OptionsCont::getOptions().getString("sumocfg-file").empty()) {
3629
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3630
    } else if (!myNet->getSavingStatus()->isSumoConfigSaved()) {
3631
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3632
    } else {
3633
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3634
    }
3635
}
3636

3637

3638
long
3639
GNEApplicationWindow::onCmdSaveTLSPrograms(FXObject* obj, FXSelector sel, void* ptr) {
3640
    // get option container
3641
    auto& neteditOptions = OptionsCont::getOptions();
3642
    // Check if TLS Programs file was already set at start of netedit or with a previous save
3643
    if (neteditOptions.getString("tls-file").empty()) {
3644
        return onCmdSaveTLSProgramsAs(obj, sel, ptr);
3645
    } else {
3646
        // Start saving TLS Programs
3647
        getApp()->beginWaitCursor();
3648
        try {
3649
            myNet->computeNetwork(this, true); // GNEChange_TLS does not triggere GNENet:requireRecompute
3650
            myNet->saveTLSPrograms(neteditOptions.getString("tls-file"));
3651
            // write info
3652
            WRITE_MESSAGE(TLF("TLS Programs saved in '%'.", neteditOptions.getString("tls-file")));
3653
        } catch (IOError& e) {
3654
            // open error message box
3655
            GNEErrorBasicDialog(this, TL("Saving TLS Programs failed"), e.what());
3656
        }
3657
        myMessageWindow->addSeparator();
3658
        getApp()->endWaitCursor();
3659
        // set focus again in viewNet
3660
        myViewNet->setFocus();
3661
    }
3662
    return 1;
3663
}
3664

3665

3666
long
3667
GNEApplicationWindow::onUpdSaveTLSPrograms(FXObject* sender, FXSelector, void*) {
3668
    if (myNet == nullptr) {
3669
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3670
    } else {
3671
        // check if there is at least one TLS
3672
        for (const auto& junction : myNet->getAttributeCarriers()->getJunctions()) {
3673
            if (junction.second->getNBNode()->getControllingTLS().size() > 0) {
3674
                return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3675
            }
3676
        }
3677
        // no TLS, then disable
3678
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3679
    }
3680
}
3681

3682

3683
long
3684
GNEApplicationWindow::onCmdSaveEdgeTypes(FXObject* obj, FXSelector sel, void* ptr) {
3685
    // get option container
3686
    auto& neteditOptions = OptionsCont::getOptions();
3687
    // Check if edgeType file was already set at start of netedit or with a previous save
3688
    if (neteditOptions.getString("edgetypes-file").empty()) {
3689
        return onCmdSaveEdgeTypesAs(obj, sel, ptr);
3690
    } else {
3691
        // Start saving edgeTypes
3692
        getApp()->beginWaitCursor();
3693
        try {
3694
            myNet->saveEdgeTypes(neteditOptions.getString("edgetypes-file"));
3695
            // write info
3696
            WRITE_MESSAGE(TLF("EdgeType saved in '%'.", neteditOptions.getString("edgetypes-file")));
3697
        } catch (IOError& e) {
3698
            // open error message box
3699
            GNEErrorBasicDialog(this, TL("Saving edgeTypes failed"), e.what());
3700
        }
3701
        myMessageWindow->addSeparator();
3702
        getApp()->endWaitCursor();
3703
    }
3704
    return 1;
3705
}
3706

3707

3708
long
3709
GNEApplicationWindow::onUpdSaveEdgeTypes(FXObject* sender, FXSelector, void*) {
3710
    // check if net exist and there are edge types
3711
    if (myNet && (myNet->getAttributeCarriers()->getEdgeTypes().size() > 0)) {
3712
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3713
    } else {
3714
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3715
    }
3716
    return 1;
3717
}
3718

3719

3720
long
3721
GNEApplicationWindow::onCmdSaveTLSProgramsAs(FXObject*, FXSelector, void*) {
3722
    // get option container
3723
    auto& neteditOptions = OptionsCont::getOptions();
3724
    // get TLS file
3725
    const auto TLSfileDialog = GNEFileDialog(this, TL("Traffic Light definitions file"),
3726
                               SUMOXMLDefinitions::TLSFileExtensions.getStrings(),
3727
                               GNEFileDialog::OpenMode::SAVE,
3728
                               GNEFileDialog::ConfigType::NETEDIT);
3729
    // check tat file is valid
3730
    if (TLSfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3731
        // change value of "tls-file"
3732
        neteditOptions.resetWritable();
3733
        neteditOptions.set("tls-file", TLSfileDialog.getFilename());
3734
        // enable save netedit config
3735
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3736
        // set focus again in viewNet
3737
        myViewNet->setFocus();
3738
        // save TLS Programs
3739
        return onCmdSaveTLSPrograms(nullptr, 0, nullptr);
3740
    } else {
3741
        return 1;
3742
    }
3743
}
3744

3745

3746
long
3747
GNEApplicationWindow::onCmdSaveEdgeTypesAs(FXObject*, FXSelector, void*) {
3748
    // get option container
3749
    auto& neteditOptions = OptionsCont::getOptions();
3750
    // get network file file
3751
    const auto edgeTypeFileDialog = GNEFileDialog(this, TL("EdgeTypes file"),
3752
                                    SUMOXMLDefinitions::EdgeTypeFileExtensions.getStrings(),
3753
                                    GNEFileDialog::OpenMode::SAVE,
3754
                                    GNEFileDialog::ConfigType::NETEDIT);
3755
    // check tat file is valid
3756
    if (edgeTypeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3757
        // change value of "edgetypes-file"
3758
        neteditOptions.resetWritable();
3759
        neteditOptions.set("edgetypes-file", edgeTypeFileDialog.getFilename());
3760
        // enable save netedit config
3761
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3762
        // set focus again in viewNet
3763
        myViewNet->setFocus();
3764
        // save edgeTypes
3765
        return onCmdSaveEdgeTypes(nullptr, 0, nullptr);
3766
    } else {
3767
        return 1;
3768
    }
3769
}
3770

3771

3772
long
3773
GNEApplicationWindow::onCmdOpenAdditionalElements(FXObject*, FXSelector, void*) {
3774
    // get file
3775
    const auto additionalFileDialog = GNEFileDialog(this, TL("Additional elements file"),
3776
                                      SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
3777
                                      GNEFileDialog::OpenMode::LOAD_SINGLE,
3778
                                      GNEFileDialog::ConfigType::NETEDIT);
3779
    // check file
3780
    if (additionalFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3781
        // flag for save current saving status
3782
        const auto previouslySaved = myNet->getSavingStatus()->isAdditionalsSaved();
3783
        // disable validation for additionals
3784
        XMLSubSys::setValidation("never", "auto", "auto");
3785
        // Create additional handler
3786
        GNEGeneralHandler generalHandler(myNet, additionalFileDialog.getFilename(), myAllowUndoRedoLoading ? myAllowUndoRedo : false);
3787
        // begin undoList operation
3788
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TLF("load additionals from '%'", additionalFileDialog.getFilename()));
3789
        // Run parser
3790
        if (!generalHandler.parse()) {
3791
            // write error
3792
            WRITE_ERROR(TLF("Loading of additional file '%' failed.", additionalFileDialog.getFilename()));
3793
        } else {
3794
            // write info
3795
            WRITE_MESSAGE(TLF("Loading of additional file '%' successfully.", additionalFileDialog.getFilename()));
3796
            // enable save if there is errors loading additionals
3797
            if (previouslySaved && !generalHandler.isErrorCreatingElement()) {
3798
                myNet->getSavingStatus()->additionalsSaved();
3799
            }
3800
        }
3801
        // end undoList operation
3802
        myUndoList->end();
3803
        // restore validation for additionals
3804
        XMLSubSys::setValidation("auto", "auto", "auto");
3805
        // check if clear undoList
3806
        if (!myAllowUndoRedoLoading) {
3807
            myUndoList->clear();
3808
        }
3809
        update();
3810
    }
3811
    return 1;
3812
}
3813

3814

3815
long
3816
GNEApplicationWindow::onCmdReloadAdditionalElements(FXObject*, FXSelector, void*) {
3817
    // disable validation for additionals
3818
    XMLSubSys::setValidation("never", "auto", "auto");
3819
    // begin undoList operation
3820
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODENETWORK, TL("reloading additionals"));
3821
    // clear additionals
3822
    myNet->clearAdditionalElements(myUndoList);
3823
    // iterate over all additional files
3824
    for (const auto& additionalFileName : myViewNet->getNet()->getSavingFilesHandler()->getAdditionalFilenames()) {
3825
        // Create general handler
3826
        GNEGeneralHandler generalHandler(myNet, additionalFileName, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
3827
        // force overwritte elements
3828
        generalHandler.forceOverwriteElements();
3829
        // Run parser
3830
        if (!generalHandler.parse()) {
3831
            WRITE_ERROR(TLF("Reloading of additional file '%' failed.", additionalFileName));
3832
        } else {
3833
            WRITE_MESSAGE(TLF("Reloading of additional file '%' successfully.", additionalFileName));
3834
        }
3835
    }
3836
    // end undoList operation
3837
    myUndoList->end();
3838
    // restore validation for additionals
3839
    XMLSubSys::setValidation("auto", "auto", "auto");
3840
    // check if clear undoList
3841
    if (!myAllowUndoRedoLoading) {
3842
        myUndoList->clear();
3843
    }
3844
    update();
3845
    return 1;
3846
}
3847

3848

3849
long
3850
GNEApplicationWindow::onUpdReloadAdditionalElements(FXObject* sender, FXSelector, void*) {
3851
    if (myViewNet == nullptr) {
3852
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3853
    } else if (myViewNet->getNet()->getSavingFilesHandler()->getAdditionalFilenames().empty()) {
3854
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3855
    } else {
3856
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3857
    }
3858
}
3859

3860

3861
long
3862
GNEApplicationWindow::onCmdSaveAdditionalElements(FXObject* sender, FXSelector sel, void* ptr) {
3863
    const auto savingFileHandler = myViewNet->getNet()->getSavingFilesHandler();
3864
    // get option container
3865
    auto& neteditOptions = OptionsCont::getOptions();
3866
    if (myNet->getSavingStatus()->isAdditionalsSaved() && !neteditOptions.getBool("force-saving")) {
3867
        // nothing to save
3868
        return 1;
3869
    }
3870
    // check if we have to set the output filename
3871
    if ((sel == MID_GNE_AUTOMATICFILENAME) && savingFileHandler->getAdditionalFilenames().empty()) {
3872
        savingFileHandler->updateAdditionalEmptyFilenames(*(static_cast<std::string*>(ptr)) + ".add.xml");
3873
    }
3874
    // check if we have to open save as dialog
3875
    if (savingFileHandler->getAdditionalFilenames().empty()) {
3876
        // choose file to save
3877
        return onCmdSaveAdditionalElementsUnified(sender, sel, ptr);
3878
    } else {
3879
        // always recompute before saving
3880
        myNet->computeNetwork(this);
3881
        try {
3882
            // compute before saving (for detectors positions)
3883
            myNet->computeNetwork(this);
3884
            // save additionals
3885
            const bool savingResult = myNet->saveAdditionals();
3886
            // show info
3887
            if (savingResult) {
3888
                WRITE_MESSAGE(TL("Additionals saved."));
3889
                return 1;
3890
            } else {
3891
                WRITE_MESSAGE(TL("Saving additional aborted."));
3892
                return 0;
3893
            }
3894
        } catch (IOError& e) {
3895
            // open error message box
3896
            GNEErrorBasicDialog(this, TL("Saving additional elements failed"), e.what());
3897
        }
3898
        return 0;
3899
    }
3900
}
3901

3902

3903
long
3904
GNEApplicationWindow::onCmdSaveAdditionalElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
3905
    // get option container
3906
    auto& neteditOptions = OptionsCont::getOptions();
3907
    // declare current folder
3908
    FXString currentFolder = gCurrentFolder;
3909
    // set current folder
3910
    if (neteditOptions.getString("configuration-file").size() > 0) {
3911
        currentFolder = getFolder(neteditOptions.getString("configuration-file"));
3912
    } else if (neteditOptions.getString("net-file").size() > 0) {
3913
        currentFolder = getFolder(neteditOptions.getString("net-file"));
3914
    }
3915
    // get additional file
3916
    const auto additionalFileDialog = GNEFileDialog(this, TL("Additional elements file"),
3917
                                      SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
3918
                                      GNEFileDialog::OpenMode::SAVE,
3919
                                      GNEFileDialog::ConfigType::NETEDIT);
3920
    // check that file is valid
3921
    if (additionalFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3922
        // begin undoList operation
3923
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TLF("saving of unified additional elements in '%'", additionalFileDialog.getFilename()));
3924
        // iterate over all demand elementes and change file
3925
        for (const auto& additionalElementTag : myNet->getAttributeCarriers()->getAdditionals()) {
3926
            for (const auto& additionalElement : additionalElementTag.second) {
3927
                additionalElement.second->setAttribute(GNE_ATTR_ADDITIONAL_FILE, additionalFileDialog.getFilename(), myUndoList);
3928
            }
3929
        }
3930
        // end undoList operation
3931
        myUndoList->end();
3932
        // save additionals
3933
        return onCmdSaveAdditionalElements(sender, sel, ptr);
3934
    } else {
3935
        return 0;
3936
    }
3937
}
3938

3939

3940
long
3941
GNEApplicationWindow::onCmdSaveJuPedSimElementsAs(FXObject*, FXSelector, void*) {
3942
    // get juPedSim file
3943
    const auto juPedSimfileDialog = GNEFileDialog(this, TL("JuPedSim elements file"),
3944
                                    SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
3945
                                    GNEFileDialog::OpenMode::SAVE,
3946
                                    GNEFileDialog::ConfigType::NETEDIT);
3947
    // check that file is valid
3948
    if (juPedSimfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3949
        try {
3950
            // get all jupedsims
3951
            std::unordered_set<const GNEAttributeCarrier*> juPedSimElements;
3952
            for (const auto& additionalTag : myNet->getAttributeCarriers()->getAdditionals()) {
3953
                if (myTagPropertiesDatabase->getTagProperty(additionalTag.first, true)->isJuPedSimElement()) {
3954
                    for (const auto& additional : additionalTag.second) {
3955
                        juPedSimElements.insert(additional.second);
3956
                    }
3957
                }
3958
            }
3959
            // save additionals
3960
            const bool savingResult = myNet->saveJuPedSimElements(juPedSimElements, juPedSimfileDialog.getFilename());
3961
            // set focus again in viewNet
3962
            myViewNet->setFocus();
3963
            // show info
3964
            if (savingResult) {
3965
                WRITE_MESSAGE(TL("JuPedSim elements saved."));
3966
                return 1;
3967
            } else {
3968
                WRITE_MESSAGE(TL("Saving JuPedSim elements aborted."));
3969

3970
                return 0;
3971
            }
3972
        } catch (IOError& e) {
3973
            // open error message box
3974
            GNEErrorBasicDialog(this, TL("Saving JuPedSim elements failed"), e.what());
3975
        }
3976
    }
3977
    return 0;
3978
}
3979

3980

3981
long
3982
GNEApplicationWindow::onCmdOpenDemandElements(FXObject*, FXSelector, void*) {
3983
    // get file
3984
    const auto routeFileDialog = GNEFileDialog(this, TL("Route elements file"),
3985
                                 SUMOXMLDefinitions::RouteFileExtensions.getStrings(),
3986
                                 GNEFileDialog::OpenMode::LOAD_SINGLE,
3987
                                 GNEFileDialog::ConfigType::NETEDIT);
3988
    // check file
3989
    if (routeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3990
        // save previous demand element status saving
3991
        const auto previouslySaved = myNet->getSavingStatus()->isDemandElementsSaved();
3992
        // disable validation for additionals
3993
        XMLSubSys::setValidation("never", "auto", "auto");
3994
        // Create generic handler
3995
        GNEGeneralHandler handler(myNet, routeFileDialog.getFilename(), myAllowUndoRedoLoading ? myAllowUndoRedo : false);
3996
        // begin undoList operation
3997
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("loading demand elements from '%'", routeFileDialog.getFilename()));
3998
        // Run parser for additionals
3999
        if (!handler.parse()) {
4000
            // write error
4001
            WRITE_ERROR(TLF("Loading of route file '%' failed.", routeFileDialog.getFilename()));
4002
        } else {
4003
            // show info
4004
            WRITE_MESSAGE(TLF("Loading of route file '%' successfully.", routeFileDialog.getFilename()));
4005
            // enable demand elements if there is an error creating element
4006
            if (previouslySaved && !handler.isErrorCreatingElement()) {
4007
                myNet->getSavingStatus()->demandElementsSaved();
4008
            }
4009
        }
4010
        // end undoList operation
4011
        myUndoList->end();
4012
        // restore validation
4013
        XMLSubSys::setValidation("auto", "auto", "auto");
4014
        // check if clear undoList
4015
        if (!myAllowUndoRedoLoading) {
4016
            myUndoList->clear();
4017
        }
4018
        update();
4019
    }
4020
    return 1;
4021
}
4022

4023

4024
long
4025
GNEApplicationWindow::onCmdReloadDemandElements(FXObject*, FXSelector, void*) {
4026
    // disable validation for additionals
4027
    XMLSubSys::setValidation("never", "auto", "auto");
4028
    // begin undoList operation
4029
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TL("reloading demand elements"));
4030
    // clear demand elements
4031
    myNet->clearDemandElements(myUndoList);
4032
    // iterate over all demand elements
4033
    for (const auto& demandFileName : myNet->getSavingFilesHandler()->getDemandFilenames()) {
4034
        // Create handler
4035
        GNEGeneralHandler generalHandler(myNet, demandFileName, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4036
        // force overwritte elements
4037
        generalHandler.forceOverwriteElements();
4038
        // Run parser for additionals
4039
        if (!generalHandler.parse()) {
4040
            WRITE_ERROR(TLF("Reloading of route file '%' failed.", demandFileName));
4041
        } else {
4042
            WRITE_MESSAGE(TLF("Reloading of route file '%' successfully.", demandFileName));
4043
        }
4044
    }
4045
    // end undoList operation and update view
4046
    myUndoList->end();
4047
    // restore validation for demand
4048
    XMLSubSys::setValidation("auto", "auto", "auto");
4049
    // check if clear undoList
4050
    if (!myAllowUndoRedoLoading) {
4051
        myUndoList->clear();
4052
    }
4053
    update();
4054
    return 1;
4055
}
4056

4057

4058
long
4059
GNEApplicationWindow::onUpdReloadDemandElements(FXObject* sender, FXSelector, void*) {
4060
    if (myViewNet == nullptr) {
4061
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4062
    } else if (myViewNet->getNet()->getSavingFilesHandler()->getDemandFilenames().empty()) {
4063
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4064
    } else {
4065
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4066
    }
4067
}
4068

4069

4070
long
4071
GNEApplicationWindow::onCmdSaveDemandElements(FXObject* sender, FXSelector sel, void* ptr) {
4072
    const auto savingFileHandler = myViewNet->getNet()->getSavingFilesHandler();
4073
    // get option container
4074
    auto& neteditOptions = OptionsCont::getOptions();
4075
    // check saving conditions
4076
    if (myNet->getSavingStatus()->isDemandElementsSaved() && !neteditOptions.getBool("force-saving")) {
4077
        // nothing to save
4078
        return 1;
4079
    }
4080
    // check if we have to set the output filename
4081
    if ((sel == MID_GNE_AUTOMATICFILENAME) && savingFileHandler->getDemandFilenames().empty()) {
4082
        savingFileHandler->updateDemandEmptyFilenames(*(static_cast<std::string*>(ptr)) + ".rou.xml");
4083
    }
4084
    // check if we have to open save as dialog
4085
    if (savingFileHandler->getDemandFilenames().empty()) {
4086
        // choose file to save
4087
        return onCmdSaveDemandElementsUnified(sender, sel, ptr);
4088
    } else {
4089
        // always recompute before saving
4090
        myNet->computeNetwork(this);
4091
        try {
4092
            // save demand elements
4093
            const bool savingResult = myNet->saveDemandElements();
4094
            // show info
4095
            if (savingResult) {
4096
                WRITE_MESSAGE(TL("Demand elements saved."));
4097
                return 1;
4098
            } else {
4099
                WRITE_MESSAGE(TL("Saving demand elements aborted."));
4100
                return 0;
4101
            }
4102
        } catch (IOError& e) {
4103
            // open error message box
4104
            GNEErrorBasicDialog(this, TL("Saving demand elements failed"), e.what());
4105
        }
4106
    }
4107
    return 0;
4108
}
4109

4110

4111
long
4112
GNEApplicationWindow::onCmdSaveDemandElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4113
    // get option container
4114
    auto& neteditOptions = OptionsCont::getOptions();
4115
    // declare current folder
4116
    FXString currentFolder = gCurrentFolder;
4117
    // set current folder
4118
    if (neteditOptions.getString("configuration-file").size() > 0) {
4119
        currentFolder = getFolder(neteditOptions.getString("configuration-file"));
4120
    } else if (neteditOptions.getString("net-file").size() > 0) {
4121
        currentFolder = getFolder(neteditOptions.getString("net-file"));
4122
    }
4123
    // get route file
4124
    const auto routeFileDialog = GNEFileDialog(this, TL("Route elements file"),
4125
                                 SUMOXMLDefinitions::RouteFileExtensions.getStrings(),
4126
                                 GNEFileDialog::OpenMode::SAVE,
4127
                                 GNEFileDialog::ConfigType::NETEDIT);
4128
    // check that file is correct
4129
    if (routeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4130
        // begin undoList operation
4131
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("saving of unified demand elements in '%'.", routeFileDialog.getFilename()));
4132
        // iterate over all demand elementes and change file
4133
        for (const auto& demandElementTag : myNet->getAttributeCarriers()->getDemandElements()) {
4134
            for (const auto& demandElement : demandElementTag.second) {
4135
                demandElement.second->setAttribute(GNE_ATTR_DEMAND_FILE, routeFileDialog.getFilename(), myUndoList);
4136
            }
4137
        }
4138
        // end undoList operation
4139
        myUndoList->end();
4140
        // save demand elements
4141
        return onCmdSaveDemandElements(sender, sel, ptr);
4142
    } else {
4143
        return 0;
4144
    }
4145
}
4146

4147

4148
long
4149
GNEApplicationWindow::onCmdOpenDataElements(FXObject*, FXSelector, void*) {
4150
    // get file
4151
    const auto dataFileDialog = GNEFileDialog(this, TL("Data elements file"),
4152
                                SUMOXMLDefinitions::EdgeDataFileExtensions.getStrings(),
4153
                                GNEFileDialog::OpenMode::LOAD_SINGLE,
4154
                                GNEFileDialog::ConfigType::NETEDIT);
4155
    // check file
4156
    if (dataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4157
        // save previous demand element status saving
4158
        const auto previouslySaved = myNet->getSavingStatus()->isDataElementsSaved();
4159
        // disable update data
4160
        myViewNet->getNet()->disableUpdateData();
4161
        // disable validation for data elements
4162
        XMLSubSys::setValidation("never", "auto", "auto");
4163
        // Create data handler
4164
        GNEDataHandler dataHandler(myNet, dataFileDialog.getFilename(), myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4165
        // begin undoList operation
4166
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("loading data elements from '%'.", dataFileDialog.getFilename()));
4167
        // Run data parser
4168
        if (!dataHandler.parse()) {
4169
            // write error
4170
            WRITE_ERROR(TLF("Loading of data file '%' failed.", dataFileDialog.getFilename()));
4171
        } else {
4172
            // show info
4173
            WRITE_MESSAGE(TLF("Loading of data file '%' successfully.", dataFileDialog.getFilename()));
4174
            // enable demand elements if there is an error creating element
4175
            if (previouslySaved && !dataHandler.isErrorCreatingElement()) {
4176
                myNet->getSavingStatus()->dataElementsSaved();
4177
            }
4178
        }
4179
        // end undoList operation
4180
        myUndoList->end();
4181
        // enable update data
4182
        myViewNet->getNet()->enableUpdateData();
4183
        // restore validation for data
4184
        XMLSubSys::setValidation("auto", "auto", "auto");
4185
        // check if clear undoList
4186
        if (!myAllowUndoRedoLoading) {
4187
            myUndoList->clear();
4188
        }
4189
        update();
4190
    }
4191
    return 1;
4192
}
4193

4194

4195
long
4196
GNEApplicationWindow::onCmdReloadDataElements(FXObject*, FXSelector, void*) {
4197
    // disable update data
4198
    myViewNet->getNet()->disableUpdateData();
4199
    // disable validation for additionals
4200
    XMLSubSys::setValidation("never", "auto", "auto");
4201
    // begin undoList operation
4202
    myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TL("reloading data elements"));
4203
    // clear data elements
4204
    myNet->clearDataElements(myUndoList);
4205
    // iterate over all data elements
4206
    for (const auto& dataFileName : myViewNet->getNet()->getSavingFilesHandler()->getDataFilenames()) {
4207
        // Create additional handler
4208
        GNEDataHandler dataHandler(myNet, dataFileName, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4209
        // force overwritte elements
4210
        dataHandler.forceOverwriteElements();
4211
        // Run data parser
4212
        if (!dataHandler.parse()) {
4213
            WRITE_ERROR(TLF("Reloading of data file '%' failed.", dataFileName));
4214
        } else {
4215
            WRITE_MESSAGE(TLF("Reloading of data file '%' successfully.", dataFileName));
4216
        }
4217
    }
4218
    // restore validation for data
4219
    XMLSubSys::setValidation("auto", "auto", "auto");
4220
    // end undoList operation and update view
4221
    myUndoList->end();
4222
    // enable update data
4223
    myViewNet->getNet()->enableUpdateData();
4224
    // check if clear undoList
4225
    if (!myAllowUndoRedoLoading) {
4226
        myUndoList->clear();
4227
    }
4228
    update();
4229
    return 1;
4230
}
4231

4232

4233
long
4234
GNEApplicationWindow::onUpdReloadDataElements(FXObject* sender, FXSelector, void*) {
4235
    if (myViewNet == nullptr) {
4236
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4237
    } else if (myViewNet->getNet()->getSavingFilesHandler()->getDataFilenames().empty()) {
4238
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4239
    } else {
4240
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4241
    }
4242
}
4243

4244

4245
long
4246
GNEApplicationWindow::onCmdSaveDataElements(FXObject* sender, FXSelector sel, void* ptr) {
4247
    const auto savingFileHandler = myViewNet->getNet()->getSavingFilesHandler();
4248
    // get option container
4249
    auto& neteditOptions = OptionsCont::getOptions();
4250
    // check saving conditions
4251
    if (myNet->getSavingStatus()->isDataElementsSaved() && !neteditOptions.getBool("force-saving")) {
4252
        // nothing to save
4253
        return 1;
4254
    }
4255
    // check if we have to set the output filename
4256
    if ((sel == MID_GNE_AUTOMATICFILENAME) && savingFileHandler->getDataFilenames().empty()) {
4257
        savingFileHandler->updateDataEmptyFilenames(*(static_cast<std::string*>(ptr)) + ".xml");
4258
    }
4259
    // check if we have to open save as dialog
4260
    if (savingFileHandler->getDataFilenames().empty()) {
4261
        return onCmdSaveDataElementsUnified(sender, sel, ptr);
4262
    } else {
4263
        try {
4264
            // save data elements
4265
            const bool savingResult = myNet->saveDataElements();
4266
            // show info
4267
            if (savingResult) {
4268
                WRITE_MESSAGE(TL("Data elements saved."));
4269
                return 1;
4270
            } else {
4271
                WRITE_MESSAGE(TL("Saving demand elements aborted."));
4272
                return 0;
4273
            }
4274
        } catch (IOError& e) {
4275
            // open error message box
4276
            GNEErrorBasicDialog(this, TL("Saving data elements failed"), e.what());
4277
        }
4278
    }
4279
    return 0;
4280
}
4281

4282

4283
long
4284
GNEApplicationWindow::onCmdSaveDataElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4285
    // get option container
4286
    auto& neteditOptions = OptionsCont::getOptions();
4287
    // declare current folder
4288
    FXString currentFolder = gCurrentFolder;
4289
    // set current folder
4290
    if (neteditOptions.getString("configuration-file").size() > 0) {
4291
        currentFolder = getFolder(neteditOptions.getString("configuration-file"));
4292
    } else if (neteditOptions.getString("net-file").size() > 0) {
4293
        currentFolder = getFolder(neteditOptions.getString("net-file"));
4294
    }
4295
    // get data file
4296
    const auto dataFileDialog = GNEFileDialog(this, TL("Data elements file"),
4297
                                SUMOXMLDefinitions::EdgeDataFileExtensions.getStrings(),
4298
                                GNEFileDialog::OpenMode::SAVE,
4299
                                GNEFileDialog::ConfigType::NETEDIT);
4300
    // check that file is correct
4301
    if (dataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4302
        // begin undoList operation
4303
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("saving of unified data elements in '%'", dataFileDialog.getFilename()));
4304
        // iterate over all demand elementes and change file
4305
        for (const auto& dataSet : myNet->getAttributeCarriers()->getDataSets()) {
4306
            dataSet.second->setAttribute(GNE_ATTR_DATA_FILE, dataFileDialog.getFilename(), myUndoList);
4307
        }
4308
        // end undoList operation
4309
        myUndoList->end();
4310
        // save data elements
4311
        return onCmdSaveDataElements(sender, sel, ptr);
4312
    } else {
4313
        return 0;
4314
    }
4315
}
4316

4317

4318
long
4319
GNEApplicationWindow::onCmdOpenMeanDataElements(FXObject*, FXSelector, void*) {
4320
    // get file
4321
    const auto meanDataFileDialog = GNEFileDialog(this, TL("MeanData elements file"),
4322
                                    SUMOXMLDefinitions::MeanDataFileExtensions.getStrings(),
4323
                                    GNEFileDialog::OpenMode::LOAD_SINGLE,
4324
                                    GNEFileDialog::ConfigType::NETEDIT);
4325
    // check file
4326
    if (meanDataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4327
        // save previous demand element status saving
4328
        const auto previouslySaved = myNet->getSavingStatus()->isMeanDatasSaved();
4329
        // disable validation for meanDatas
4330
        XMLSubSys::setValidation("never", "auto", "auto");
4331
        // Create meanData handler
4332
        GNEGeneralHandler generalHandler(myNet, meanDataFileDialog.getFilename(), myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4333
        // begin undoList operation
4334
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("load meanDatas from '%'", meanDataFileDialog.getFilename()));
4335
        // Run parser
4336
        if (!generalHandler.parse()) {
4337
            // write error
4338
            WRITE_ERROR(TLF("Loading of meandata file '%' failed.", meanDataFileDialog.getFilename()));
4339
        } else {
4340
            // show info
4341
            WRITE_MESSAGE(TLF("Loading of meandata file '%' successfully.", meanDataFileDialog.getFilename()));
4342
            // enable demand elements if there is an error creating element
4343
            if (previouslySaved && !generalHandler.isErrorCreatingElement()) {
4344
                myNet->getSavingStatus()->meanDatasSaved();
4345
            }
4346
        }
4347
        // end undoList operation
4348
        myUndoList->end();
4349
        // restore validation for meanDatas
4350
        XMLSubSys::setValidation("auto", "auto", "auto");
4351
        // check if clear undoList
4352
        if (!myAllowUndoRedoLoading) {
4353
            myUndoList->clear();
4354
        }
4355
        update();
4356
    }
4357
    return 1;
4358
}
4359

4360

4361
long
4362
GNEApplicationWindow::onCmdReloadMeanDataElements(FXObject*, FXSelector, void*) {
4363
    // disable validation for meanDatas
4364
    XMLSubSys::setValidation("never", "auto", "auto");
4365
    // begin undoList operation
4366
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODENETWORK, TL("reloading meanDatas"));
4367
    // clear meanDatas
4368
    myNet->clearMeanDataElements(myUndoList);
4369
    // iterate over all data elements
4370
    for (const auto& meanDataFileName : myViewNet->getNet()->getSavingFilesHandler()->getMeanDataFilenames()) {
4371
        // Create general handler
4372
        GNEGeneralHandler generalHandler(myNet, meanDataFileName, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4373
        // force overwritte elements
4374
        generalHandler.forceOverwriteElements();
4375
        // Run parser
4376
        if (!generalHandler.parse()) {
4377
            WRITE_ERROR(TLF("Reloading of meanData file '%' failed.", meanDataFileName));
4378
        } else {
4379
            WRITE_MESSAGE(TLF("Reloading of meanData file '%' successfully.", meanDataFileName));
4380
        }
4381
    }
4382
    // end undoList operation and update view
4383
    myUndoList->end();
4384
    // restore validation for meanDatas
4385
    XMLSubSys::setValidation("auto", "auto", "auto");
4386
    // check if clear undoList
4387
    if (!myAllowUndoRedoLoading) {
4388
        myUndoList->clear();
4389
    }
4390
    update();
4391
    return 1;
4392
}
4393

4394

4395
long
4396
GNEApplicationWindow::onUpdReloadMeanDataElements(FXObject* sender, FXSelector, void*) {
4397
    if (myViewNet == nullptr) {
4398
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4399
    } else if (myViewNet->getNet()->getSavingFilesHandler()->getMeanDataFilenames().empty()) {
4400
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4401
    } else {
4402
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4403
    }
4404
}
4405

4406

4407
long
4408
GNEApplicationWindow::onCmdSaveMeanDataElements(FXObject* sender, FXSelector sel, void* ptr) {
4409
    const auto savingFileHandler = myViewNet->getNet()->getSavingFilesHandler();
4410
    // get option container
4411
    auto& neteditOptions = OptionsCont::getOptions();
4412
    // check saving conditions
4413
    if (myNet->getSavingStatus()->isMeanDatasSaved() && !neteditOptions.getBool("force-saving")) {
4414
        // nothing to save
4415
        return 1;
4416
    }
4417
    // check if we have to set the output filename
4418
    if ((sel == MID_GNE_AUTOMATICFILENAME) && savingFileHandler->getMeanDataFilenames().empty()) {
4419
        savingFileHandler->updateMeanDataEmptyFilenames(*(static_cast<std::string*>(ptr)) + ".dat.add.xml");
4420
    }
4421
    // check if we have to open save as dialog
4422
    if (savingFileHandler->getMeanDataFilenames().empty()) {
4423
        return onCmdSaveMeanDataElementsUnified(sender, sel, ptr);
4424
    } else {
4425
        try {
4426
            // compute before saving
4427
            myNet->computeNetwork(this);
4428
            // save demand elements
4429
            const bool savingResult = myNet->saveMeanDatas();
4430
            // show info
4431
            if (savingResult) {
4432
                WRITE_MESSAGE(TL("MeanDatas elements saved"));
4433
                return 1;
4434
            } else {
4435
                WRITE_MESSAGE(TL("Saving MeanData elements aborted"));
4436
                return 0;
4437
            }
4438
        } catch (IOError& e) {
4439
            // open error message box
4440
            GNEErrorBasicDialog(this, TL("Saving demand elements failed!"), e.what());
4441
        }
4442
    }
4443
    return 0;
4444
}
4445

4446

4447
long
4448
GNEApplicationWindow::onCmdSaveMeanDataElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4449
    // get option container
4450
    auto& neteditOptions = OptionsCont::getOptions();
4451
    // declare current folder
4452
    FXString currentFolder = gCurrentFolder;
4453
    // set current folder
4454
    if (neteditOptions.getString("configuration-file").size() > 0) {
4455
        currentFolder = getFolder(neteditOptions.getString("configuration-file"));
4456
    } else if (neteditOptions.getString("net-file").size() > 0) {
4457
        currentFolder = getFolder(neteditOptions.getString("net-file"));
4458
    }
4459
    // get meanData file
4460
    const auto meanDataFileDialog = GNEFileDialog(this, TL("MeanData elements file"),
4461
                                    SUMOXMLDefinitions::MeanDataFileExtensions.getStrings(),
4462
                                    GNEFileDialog::OpenMode::SAVE,
4463
                                    GNEFileDialog::ConfigType::NETEDIT);
4464
    // check that file is valid
4465
    if (meanDataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4466
        // begin undoList operation
4467
        myUndoList->begin(Supermode::DATA, GUIIcon::MODEMEANDATA, TLF("saving of unified mean data elements in '%'", meanDataFileDialog.getFilename()));
4468
        // iterate over all demand elementes and change file
4469
        for (const auto& meanDataTag : myNet->getAttributeCarriers()->getMeanDatas()) {
4470
            for (const auto& meanData : meanDataTag.second) {
4471
                meanData.second->setAttribute(GNE_ATTR_MEANDATA_FILE, meanDataFileDialog.getFilename(), myUndoList);
4472
            }
4473
        }
4474
        // end undoList operation
4475
        myUndoList->end();
4476
        // save meanDatas
4477
        return onCmdSaveMeanDataElements(sender, sel, ptr);
4478
    } else {
4479
        return 0;
4480
    }
4481
}
4482

4483

4484
bool
4485
GNEApplicationWindow::askSaveElements() {
4486
    if (myNet) {
4487
        bool abortSaving = false;
4488
        const auto saveNetwork = myNet->getSavingStatus()->askSaveNetwork(abortSaving);
4489
        const auto saveAdditionalElements = myNet->getSavingStatus()->askSaveAdditionalElements(abortSaving);
4490
        const auto saveDemandElements = myNet->getSavingStatus()->askSaveDemandElements(abortSaving);
4491
        const auto saveDataElements = myNet->getSavingStatus()->askSaveDataElements(abortSaving);
4492
        const auto saveMeanDataElements = myNet->getSavingStatus()->askSaveMeanDataElements(abortSaving);
4493
        // first check if abort saving
4494
        if (abortSaving) {
4495
            return false;
4496
        }
4497
        // save every type of file
4498
        if ((saveNetwork == GNEDialog::Result::ACCEPT) &&
4499
                (onCmdSaveNetwork(nullptr, 0, nullptr) != 1)) {
4500
            return false;
4501
        }
4502
        if ((saveAdditionalElements == GNEDialog::Result::ACCEPT) &&
4503
                (onCmdSaveAdditionalElements(nullptr, 0, nullptr) != 1)) {
4504
            return false;
4505
        }
4506
        if ((saveDemandElements == GNEDialog::Result::ACCEPT) &&
4507
                (onCmdSaveDemandElements(nullptr, 0, nullptr) != 1)) {
4508
            return false;
4509
        }
4510
        if ((saveDataElements == GNEDialog::Result::ACCEPT) &&
4511
                (onCmdSaveDataElements(nullptr, 0, nullptr) != 1)) {
4512
            return false;
4513
        }
4514
        if ((saveMeanDataElements == GNEDialog::Result::ACCEPT) &&
4515
                (onCmdSaveMeanDataElements(nullptr, 0, nullptr) != 1)) {
4516
            return false;
4517
        }
4518
        // restore focus in viewNet
4519
        myViewNet->setFocus();
4520
        // clear undo list
4521
        clearUndoList();
4522
        // all saved, then continue
4523
        return true;
4524
    } else {
4525
        // nothing to do, then continue
4526
        return true;
4527
    }
4528
}
4529

4530

4531
void
4532
GNEApplicationWindow::setInputInSumoOptions(const bool ignoreAdditionals, const bool ignoreRoutes) {
4533
    // obtain netedit option container
4534
    auto& neteditOptions = OptionsCont::getOptions();
4535
    mySumoOptions.resetWritable();
4536
    // set network
4537
    mySumoOptions.set("net-file", neteditOptions.getString("net-file"));
4538
    // set routes
4539
    if (ignoreRoutes || neteditOptions.getString("route-files").empty()) {
4540
        mySumoOptions.resetDefault("route-files");
4541
    } else {
4542
        mySumoOptions.set("route-files", neteditOptions.getString("route-files"));
4543
    }
4544
    // set SumoOptions depending of additionalFiles and meanData files
4545
    if (ignoreAdditionals) {
4546
        if (neteditOptions.getString("meandata-files").empty()) {
4547
            mySumoOptions.resetDefault("additional-files");
4548
        } else {
4549
            mySumoOptions.set("additional-files", neteditOptions.getString("meandata-files"));
4550
        }
4551
    } else {
4552
        if ((neteditOptions.getString("additional-files").size() > 0) && (neteditOptions.getString("meandata-files").size())) {
4553
            mySumoOptions.set("additional-files", neteditOptions.getString("additional-files") + "," + neteditOptions.getString("meandata-files"));
4554
        } else if (neteditOptions.getString("additional-files").size() > 0) {
4555
            mySumoOptions.set("additional-files", neteditOptions.getString("additional-files"));
4556
        } else if (neteditOptions.getString("meandata-files").size() > 0) {
4557
            mySumoOptions.set("additional-files", neteditOptions.getString("meandata-files"));
4558
        } else {
4559
            mySumoOptions.resetDefault("additional-files");
4560
        }
4561
    }
4562
}
4563

4564

4565
FXString
4566
GNEApplicationWindow::getFolder(const std::string& folder) const {
4567
    // declare folder
4568
    std::string newFolder = folder;
4569
    // declare stop flag
4570
    bool stop = false;
4571
    // continue while stop is false
4572
    while (!stop) {
4573
        if (newFolder.empty()) {
4574
            // new folder empty, then stop
4575
            stop = true;
4576
        } else if ((newFolder.back() == '\'') || (newFolder.back() == '\\') ||
4577
                   (newFolder.back() == '/') /* || (newFolder.back() == '//') */) {
4578
            // removed file, then stop
4579
            stop = true;
4580
        } else {
4581
            newFolder.pop_back();
4582
        }
4583
    }
4584
    // if is empty, return gCurrentFolder
4585
    if (newFolder.empty()) {
4586
        return gCurrentFolder;
4587
    }
4588
    return FXString(newFolder.c_str());
4589
}
4590

4591

4592
void
4593
GNEApplicationWindow::updateControls() {
4594
    // check that view exists
4595
    if (myViewNet) {
4596
        myViewNet->updateControls();
4597
    }
4598
    // update require recomputing
4599
    updateRecomputingLabel();
4600
}
4601

4602

4603
void
4604
GNEApplicationWindow::updateSuperModeMenuCommands(const Supermode supermode) {
4605
    // remove lock hotkeys
4606
    myLockMenuCommands.removeHotkeys();
4607
    // check supermode
4608
    if (supermode == Supermode::NETWORK) {
4609
        // menu commands
4610
        myModesMenuCommands.networkMenuCommands.showNetworkMenuCommands();
4611
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4612
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4613
        // lock
4614
        myLockMenuCommands.showNetworkLockMenuCommands();
4615
        myLockMenuCommands.hideDemandLockMenuCommands();
4616
        myLockMenuCommands.hideDataLockMenuCommands();
4617
        // processing
4618
        myProcessingMenuCommands.showNetworkProcessingMenuCommands();
4619
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4620
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4621
        myProcessingMenuCommands.showSeparator();
4622
    } else if (supermode == Supermode::DEMAND) {
4623
        // menu commands
4624
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4625
        myModesMenuCommands.demandMenuCommands.showDemandMenuCommands();
4626
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4627
        // lock
4628
        myLockMenuCommands.hideNetworkLockMenuCommands();
4629
        myLockMenuCommands.showDemandLockMenuCommands();
4630
        myLockMenuCommands.hideDataLockMenuCommands();
4631
        // processing
4632
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4633
        myProcessingMenuCommands.showDemandProcessingMenuCommands();
4634
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4635
        myProcessingMenuCommands.showSeparator();
4636
    } else if (supermode == Supermode::DATA) {
4637
        // menu commands
4638
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4639
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4640
        myModesMenuCommands.dataMenuCommands.showDataMenuCommands();
4641
        // lock
4642
        myLockMenuCommands.hideNetworkLockMenuCommands();
4643
        myLockMenuCommands.hideDemandLockMenuCommands();
4644
        myLockMenuCommands.showDataLockMenuCommands();
4645
        // processing
4646
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4647
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4648
        myProcessingMenuCommands.showDataProcessingMenuCommands();
4649
        myProcessingMenuCommands.hideSeparator();
4650
    } else {
4651
        // menu commands
4652
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4653
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4654
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4655
        myProcessingMenuCommands.hideSeparator();
4656
        // lock
4657
        myLockMenuCommands.hideNetworkLockMenuCommands();
4658
        myLockMenuCommands.hideDemandLockMenuCommands();
4659
        myLockMenuCommands.hideDataLockMenuCommands();
4660
        // processing
4661
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4662
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4663
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4664
    }
4665
    // continue depending of view
4666
    if (myViewNet) {
4667
        if (myViewNet->getEditModes().isDefaultView()) {
4668
            mySupermodeCommands.setDefaultView();
4669
            myModesMenuCommands.setDefaultView(supermode);
4670
        } else if (myViewNet->getEditModes().isJuPedSimView()) {
4671
            mySupermodeCommands.setJuPedSimView();
4672
            myModesMenuCommands.setJuPedSimView(supermode);
4673
        }
4674
    }
4675
}
4676

4677

4678
bool
4679
GNEApplicationWindow::isUndoRedoAllowed() const {
4680
    return myAllowUndoRedo;
4681
}
4682

4683

4684
void
4685
GNEApplicationWindow::enableUndoRedoTemporally() {
4686
    myUndoRedoListEnabled.clear();
4687
}
4688

4689

4690
void
4691
GNEApplicationWindow::disableUndoRedoTemporally(const std::string& reason) {
4692
    myUndoRedoListEnabled = reason;
4693
}
4694

4695

4696
const std::string&
4697
GNEApplicationWindow::isUndoRedoEnabledTemporally() const {
4698
    return myUndoRedoListEnabled;
4699
}
4700

4701

4702
void
4703
GNEApplicationWindow::clearUndoList() {
4704
    if (myViewNet) {
4705
        // destroy Popup (to avoid crashes)
4706
        myViewNet->destroyPopup();
4707
    }
4708
    // clear undo list and return true to continue with closing/reload
4709
    myUndoList->clear();
4710
}
4711

4712

4713
GNEApplicationWindowHelper::FileMenuCommands&
4714
GNEApplicationWindow::getFileMenuCommands() {
4715
    return myFileMenuCommands;
4716
}
4717

4718

4719
GNEApplicationWindowHelper::ModesMenuCommands&
4720
GNEApplicationWindow::getModesMenuCommands() {
4721
    return myModesMenuCommands;
4722
}
4723

4724

4725
GNEApplicationWindowHelper::EditMenuCommands&
4726
GNEApplicationWindow::getEditMenuCommands() {
4727
    return myEditMenuCommands;
4728
}
4729

4730

4731
GNEApplicationWindowHelper::LockMenuCommands&
4732
GNEApplicationWindow::getLockMenuCommands() {
4733
    return myLockMenuCommands;
4734
}
4735

4736

4737
const GNEApplicationWindowHelper::ProcessingMenuCommands&
4738
GNEApplicationWindow::getProcessingMenuCommands() const {
4739
    return myProcessingMenuCommands;
4740
}
4741

4742

4743
OptionsCont&
4744
GNEApplicationWindow::getSumoOptions() {
4745
    return mySumoOptions;
4746
}
4747

4748

4749
OptionsCont&
4750
GNEApplicationWindow::getNetgenerateOptions() {
4751
    return myNetgenerateOptions;
4752
}
4753

4754

4755
void
4756
GNEApplicationWindow::loadAdditionalElements() {
4757
    // get option container
4758
    auto& neteditOptions = OptionsCont::getOptions();
4759
    // get additional files
4760
    const auto& additionalFiles = neteditOptions.getStringVector("additional-files");
4761
    // check if ignore loading of additional files
4762
    const auto ignoreLoadAdditionalFiles = neteditOptions.getBool("ignore.additionalelements");
4763
    // check conditions
4764
    if (ignoreLoadAdditionalFiles) {
4765
        // reset flag
4766
        neteditOptions.resetWritable();
4767
        neteditOptions.set("ignore.additionalelements", "false");
4768
        // also reset route files in both containers
4769
        neteditOptions.resetDefault("additional-files");
4770
        mySumoOptions.resetDefault("additional-files");
4771
    } else if (myNet && (additionalFiles.size() > 0)) {
4772
        // update saving files handler
4773
        myNet->getSavingFilesHandler()->updateAdditionalEmptyFilenames(additionalFiles.front());
4774
        // disable validation for additionals
4775
        XMLSubSys::setValidation("never", "auto", "auto");
4776
        // begin undolist
4777
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TL("loading additional elements from '") + toString(additionalFiles) + "'");
4778
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4779
        bool setSaved = additionalFiles.size() == 1;
4780
        // iterate over every additional file
4781
        for (const auto& file : additionalFiles) {
4782
            // check if ignore missing inputs
4783
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4784
                WRITE_MESSAGE(TLF("loading additionals from '%'.", file));
4785
                // declare general handler
4786
                GNEGeneralHandler handler(myNet, file, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4787
                // Run parser
4788
                if (!handler.parse()) {
4789
                    WRITE_ERROR(TLF("Loading of '%' failed.", file));
4790
                }
4791
                setSaved &= !handler.isErrorCreatingElement();
4792
                // set additionals in SumoConfig
4793
                setInputInSumoOptions(false, false);
4794
            }
4795
        }
4796
        // end undo list
4797
        myUndoList->end();
4798
        // disable validation for additionals
4799
        XMLSubSys::setValidation("auto", "auto", "auto");
4800
        if (setSaved) {
4801
            myNet->getSavingStatus()->additionalsSaved();
4802
        }
4803
        // check if clear undoList
4804
        if (!myAllowUndoRedoLoading) {
4805
            myUndoList->clear();
4806
        }
4807
    }
4808
}
4809

4810

4811
void
4812
GNEApplicationWindow::loadDemandElements() {
4813
    // get option container
4814
    auto& neteditOptions = OptionsCont::getOptions();
4815
    // get demand files
4816
    const auto& demandFiles = neteditOptions.getStringVector("route-files");
4817
    // check if ignore loading of additional files
4818
    const auto ignoreLoadDemandFiles = neteditOptions.getBool("ignore.routeelements");
4819
    // check conditions
4820
    if (ignoreLoadDemandFiles) {
4821
        // reset flag
4822
        neteditOptions.resetWritable();
4823
        neteditOptions.set("ignore.routeelements", "false");
4824
        // also reset route files in both containers
4825
        neteditOptions.resetDefault("route-files");
4826
        mySumoOptions.resetDefault("route-files");
4827
    } else if (myNet && (demandFiles.size() > 0)) {
4828
        // update saving files handler
4829
        myNet->getSavingFilesHandler()->updateDemandEmptyFilenames(demandFiles.front());
4830
        // disable validation for additionals
4831
        XMLSubSys::setValidation("never", "auto", "auto");
4832
        // begin undolist
4833
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TL("loading demand elements from '") + toString(demandFiles) + "'");
4834
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4835
        bool setSaved = demandFiles.size() == 1;
4836
        // iterate over every demand file
4837
        for (const auto& file : demandFiles) {
4838
            // check if ignore missing inputs
4839
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4840
                WRITE_MESSAGE(TLF("loading demand elements from '%'.", file));
4841
                // declare general handler
4842
                GNEGeneralHandler handler(myNet, file, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4843
                // Run parser
4844
                if (!handler.parse()) {
4845
                    WRITE_ERROR(TLF("Loading of '%' failed.", file));
4846
                }
4847
                setSaved &= !handler.isErrorCreatingElement();
4848
                // set additionals in SumoConfig
4849
                setInputInSumoOptions(false, false);
4850
            }
4851
        }
4852
        // end undo list
4853
        myUndoList->end();
4854
        // disable validation for additionals
4855
        XMLSubSys::setValidation("auto", "auto", "auto");
4856
        if (setSaved) {
4857
            myNet->getSavingStatus()->demandElementsSaved();
4858
        }
4859
        // check if clear undoList
4860
        if (!myAllowUndoRedoLoading) {
4861
            myUndoList->clear();
4862
        }
4863
    }
4864
}
4865

4866

4867
void
4868
GNEApplicationWindow::loadDataElements() {
4869
    // get option container
4870
    auto& neteditOptions = OptionsCont::getOptions();
4871
    // get data files
4872
    const auto& dataFiles = neteditOptions.getStringVector("data-files");
4873
    if (myNet && (dataFiles.size() > 0)) {
4874
        // update saving files handler
4875
        myNet->getSavingFilesHandler()->updateDataEmptyFilenames(dataFiles.front());
4876
        // disable validation for additionals
4877
        XMLSubSys::setValidation("never", "auto", "auto");
4878
        // begin undolist
4879
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TL("loading data elements from '") + toString(dataFiles) + "'");
4880
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4881
        bool setSaved = dataFiles.size() == 1;
4882
        // iterate over every data file
4883
        for (const auto& file : dataFiles) {
4884
            // check if ignore missing inputs
4885
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4886
                WRITE_MESSAGE(TLF("loading data elements from '%'.", file));
4887
                // declare general handler
4888
                GNEDataHandler handler(myNet, file, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4889
                // Run parser
4890
                if (!handler.parse()) {
4891
                    WRITE_ERROR(TLF("Loading of % failed.", file));
4892
                }
4893
                setSaved &= !handler.isErrorCreatingElement();
4894
                // set additionals in SumoConfig
4895
                setInputInSumoOptions(false, false);
4896
            }
4897
        }
4898
        // end undo list
4899
        myUndoList->end();
4900
        // disable validation for additionals
4901
        XMLSubSys::setValidation("auto", "auto", "auto");
4902
        if (setSaved) {
4903
            myNet->getSavingStatus()->dataElementsSaved();
4904
        }
4905
        // check if clear undoList
4906
        if (!myAllowUndoRedoLoading) {
4907
            myUndoList->clear();
4908
        }
4909
    }
4910
}
4911

4912

4913
void
4914
GNEApplicationWindow::loadMeanDataElements() {
4915
    // get option container
4916
    auto& neteditOptions = OptionsCont::getOptions();
4917
    // get meanData files
4918
    const auto& meanDataFiles = neteditOptions.getStringVector("meandata-files");
4919
    if (myNet && (meanDataFiles.size() > 0)) {
4920
        // update saving files handler
4921
        myNet->getSavingFilesHandler()->updateMeanDataEmptyFilenames(meanDataFiles.front());
4922
        // disable validation for additionals
4923
        XMLSubSys::setValidation("never", "auto", "auto");
4924
        // begin undolist
4925
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TL("loading meanData elements from '") + toString(meanDataFiles) + "'");
4926
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4927
        bool setSaved = meanDataFiles.size() == 1;
4928
        // iterate over every meanData file
4929
        for (const auto& file : meanDataFiles) {
4930
            // check if ignore missing inputs
4931
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4932
                WRITE_MESSAGE(TLF("loading meanData elements from '%'.", file));
4933
                // declare general handler
4934
                GNEGeneralHandler handler(myNet, file, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4935
                // Run parser
4936
                if (!handler.parse()) {
4937
                    WRITE_ERROR(TLF("Loading of % failed.", file));
4938
                }
4939
                setSaved &= !handler.isErrorCreatingElement();
4940
                // set additionals in SumoConfig
4941
                setInputInSumoOptions(false, false);
4942
            }
4943
        }
4944
        // end undo list
4945
        myUndoList->end();
4946
        // disable validation for additionals
4947
        XMLSubSys::setValidation("auto", "auto", "auto");
4948
        if (setSaved) {
4949
            myNet->getSavingStatus()->meanDatasSaved();
4950
        }
4951
        // check if clear undoList
4952
        if (!myAllowUndoRedoLoading) {
4953
            myUndoList->clear();
4954
        }
4955
    }
4956
}
4957

4958

4959
void
4960
GNEApplicationWindow::loadTrafficLights(const bool reloading) {
4961
    // get TLS file
4962
    const auto tlsFile = OptionsCont::getOptions().getString("tls-file");
4963
    // check if file exist
4964
    if (tlsFile.size() > 0) {
4965
        // Run parser
4966
        if (reloading) {
4967
            WRITE_MESSAGE(TL("Reloading TLS programs"));
4968
            myUndoList->begin(Supermode::NETWORK, GUIIcon::MODETLS, TLF("reloading TLS Programs from '%'", tlsFile));
4969
        } else {
4970
            WRITE_MESSAGE(TLF("Loading TLS programs from '%'", tlsFile));
4971
            myUndoList->begin(Supermode::NETWORK, GUIIcon::MODETLS, TLF("loading TLS Programs from '%'", tlsFile));
4972
        }
4973
        myNet->computeNetwork(this);
4974
        if (myNet->getViewNet()->getViewParent()->getTLSEditorFrame()->parseTLSPrograms(tlsFile) == false) {
4975
            // Abort undo/redo
4976
            myUndoList->abortAllChangeGroups();
4977
        } else {
4978
            // commit undo/redo operation
4979
            myUndoList->end();
4980
            update();
4981
        }
4982
    }
4983
}
4984

4985

4986
void
4987
GNEApplicationWindow::loadEdgeTypes(const bool reloading) {
4988
    // get edgeType file
4989
    const auto edgeTypeFile = OptionsCont::getOptions().getString("edgetypes-file");
4990
    // check if file exist
4991
    if (edgeTypeFile.size() > 0) {
4992
        // declare type container
4993
        NBTypeCont typeContainerAux;
4994
        // declare type handler
4995
        NIXMLTypesHandler handler(typeContainerAux);
4996
        // load edge types
4997
        NITypeLoader::load(handler, {edgeTypeFile}, toString(SUMO_TAG_TYPES));
4998
        // now create GNETypes based on typeContainerAux
4999
        if (reloading) {
5000
            WRITE_MESSAGE(TL("Reloading edge types"));
5001
            myViewNet->getUndoList()->begin(Supermode::NETWORK, GUIIcon::EDGE, TLF("loading edge types from '%'", edgeTypeFile));
5002
        } else {
5003
            WRITE_MESSAGE(TLF("Loading edge types from '%'", edgeTypeFile));
5004
            myViewNet->getUndoList()->begin(Supermode::NETWORK, GUIIcon::EDGE, TLF("reloading edge types from '%'", edgeTypeFile));
5005
        }
5006
        // iterate over typeContainerAux
5007
        for (const auto& auxEdgeType : typeContainerAux) {
5008
            // create new edge type
5009
            GNEEdgeType* edgeType = new GNEEdgeType(myNet, auxEdgeType.first, auxEdgeType.second);
5010
            // add lane types
5011
            for (const auto& laneType : auxEdgeType.second->laneTypeDefinitions) {
5012
                edgeType->addLaneType(new GNELaneType(edgeType, laneType));
5013
            }
5014
            // add it using undoList
5015
            myViewNet->getUndoList()->add(new GNEChange_EdgeType(edgeType, true), true);
5016

5017
        }
5018
        // end undo list
5019
        myViewNet->getUndoList()->end();
5020
        // refresh edge type selector
5021
        myViewNet->getViewParent()->getCreateEdgeFrame()->getEdgeTypeSelector()->refreshEdgeTypeSelector();
5022
    }
5023
}
5024

5025

5026
GNEInternalTest*
5027
GNEApplicationWindow::getInternalTest() const {
5028
    return myInternalTest;
5029
}
5030

5031

5032
bool
5033
GNEApplicationWindow::allowInputSignals(FXObject* obj) const {
5034
    if (myInternalTest == nullptr) {
5035
        return true;
5036
    } else if (obj == myInternalTest) {
5037
        return true;
5038
    } else {
5039
        return false;
5040
    }
5041
}
5042

5043
// ---------------------------------------------------------------------------
5044
// GNEApplicationWindow - protected methods
5045
// ---------------------------------------------------------------------------
5046
#ifdef _MSC_VER
5047
#pragma warning(push)
5048
#pragma warning(disable: 4355) // mask warning about "this" in initializers
5049
#endif
5050
GNEApplicationWindow::GNEApplicationWindow() :
5051
    myToolbarsGrip(this),
5052
    myMenuBarFile(this),
5053
    myFileMenuCommands(this),
5054
    myModesMenuCommands(this),
5055
    myEditMenuCommands(this),
5056
    myLockMenuCommands(this),
5057
    myProcessingMenuCommands(this),
5058
    myLocateMenuCommands(this),
5059
    myToolsMenuCommands(this),
5060
    myWindowsMenuCommands(this),
5061
    myHelpMenuCommands(this),
5062
    mySupermodeCommands(this) {
5063
}
5064
#ifdef _MSC_VER
5065
#pragma warning(pop)
5066
#endif
5067

5068

5069
long
5070
GNEApplicationWindow::onKeyPress(FXObject* o, FXSelector sel, void* eventData) {
5071
    const long handled = FXMainWindow::onKeyPress(o, sel, eventData);
5072
    if (handled == 0 && myMDIClient->numChildren() > 0) {
5073
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
5074
        if (w != nullptr) {
5075
            w->onKeyPress(nullptr, sel, eventData);
5076
        }
5077
    }
5078
    return 0;
5079
}
5080

5081

5082
long
5083
GNEApplicationWindow::onKeyRelease(FXObject* o, FXSelector sel, void* eventData) {
5084
    const long handled = FXMainWindow::onKeyRelease(o, sel, eventData);
5085
    if (handled == 0 && myMDIClient->numChildren() > 0) {
5086
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
5087
        if (w != nullptr) {
5088
            w->onKeyRelease(nullptr, sel, eventData);
5089
        }
5090
    }
5091
    return 0;
5092
}
5093

5094

5095
/****************************************************************************/
5096

5097
Product

Resources

Company
