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-2026 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/images/GUITextureSubSys.h>
66
#include <utils/gui/settings/GUICompleteSchemeStorage.h>
67
#include <utils/gui/settings/GUISettingsHandler.h>
68
#include <utils/gui/shortcuts/GUIShortcutsSubSys.h>
69
#include <utils/gui/windows/GUIPerspectiveChanger.h>
70
#include <utils/handlers/TemplateHandler.h>
71
#include <utils/xml/XMLSubSys.h>
72

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

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

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

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

496
// Object implementation
497
FXIMPLEMENT(GNEApplicationWindow, FXMainWindow, GNEApplicationWindowMap, ARRAYNUMBER(GNEApplicationWindowMap))
498

499
// ===========================================================================
500
// GNEApplicationWindow method definitions
501
// ===========================================================================
502
#ifdef _MSC_VER
503
#pragma warning(push)
504
#pragma warning(disable: 4355) // mask warning about "this" in initializers
505
#endif
506
GNEApplicationWindow::GNEApplicationWindow(FXApp* app, const GNETagPropertiesDatabase* tagPropertiesDatabase, const std::string& configPattern) :
507
    GUIMainWindow(app),
508
    myTagPropertiesDatabase(tagPropertiesDatabase),
509
    myUndoList(new GNEUndoList(this)),
510
    myConfigPattern(configPattern),
511
    myToolbarsGrip(this),
512
    myMenuBarFile(this),
513
    myFileMenuCommands(this),
514
    myModesMenuCommands(this),
515
    myEditMenuCommands(this),
516
    myLockMenuCommands(this),
517
    myProcessingMenuCommands(this),
518
    myLocateMenuCommands(this),
519
    myToolsMenuCommands(this),
520
    myWindowsMenuCommands(this),
521
    myHelpMenuCommands(this),
522
    mySupermodeCommands(this),
523
    myFileBucketHandler(new GNEApplicationWindowHelper::FileBucketHandler(this, OptionsCont::getOptions(), mySumoOptions)),
524
    myTitlePrefix("netedit " VERSION_STRING),
525
    myAllowUndoRedo(getApp()->reg().readBoolEntry("NETEDIT", "AllowUndoRedo", true) == TRUE),
526
    myAllowUndoRedoLoading(getApp()->reg().readBoolEntry("NETEDIT", "AllowUndoRedoLoading", true) == TRUE) {
527
    // init icons
528
    GUIIconSubSys::initIcons(app);
529
    // init Textures
530
    GUITextureSubSys::initTextures(app);
531
    // init cursors
532
    GUICursorSubSys::initCursors(app);
533
    // set tooltip options
534
    app->setTooltipTime(1000000000);
535
    app->setTooltipPause(1000000000);
536
    // set SUMO Options descriptions
537
    mySumoOptions.setApplicationDescription(TL("A microscopic, multi-modal traffic simulation."));
538
    mySumoOptions.setApplicationName("sumo", "Eclipse SUMO sumo " VERSION_STRING);
539
    // set default netedit options
540
    GNELoadThread::fillOptions(myOriginalNeteditOptions);
541
    GNELoadThread::setDefaultOptions(myOriginalNeteditOptions);
542
    // parse options
543
    TemplateHandler::parseTemplate(mySumoOptions, sumoTemplate);
544
    TemplateHandler::parseTemplate(myNetconvertOptions, netconvertTemplate);
545
    TemplateHandler::parseTemplate(myOriginalSumoOptions, sumoTemplate);
546
    TemplateHandler::parseTemplate(myNetgenerateOptions, netgenerateTemplate);
547
    TemplateHandler::parseTemplate(myOriginalNetgenerateOptions, netgenerateTemplate);
548
    // add extra option for automatic closing
549
    myNetgenerateOptions.doRegister("close-dialog-automatic", new Option_Bool(true));
550
    myNetgenerateOptions.addDescription("close-dialog-automatic", "report", TL("Close dialog automatically"));
551
}
552
#ifdef _MSC_VER
553
#pragma warning(pop)
554
#endif
555

556

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

620

621
void
622
GNEApplicationWindow::create() {
623
    // set windows size and position
624
    setWindowSizeAndPos();
625
    // set current folder
626
    gCurrentFolder = getApp()->reg().readStringEntry("SETTINGS", "basedir", "");
627
    // Create main window
628
    FXMainWindow::create();
629
    // get text width
630
    const auto textWidth = getApp()->getNormalFont()->getTextWidth("8", 1) * 22;
631
    // adjust cartesian and geo frame
632
    myCartesianFrame->setWidth(textWidth);
633
    myGeoFrame->setWidth(textWidth);
634
    // fill online maps
635
    if (myOnlineMaps.empty()) {
636
        myOnlineMaps["GeoHack"] = "https://geohack.toolforge.org/geohack.php?params=%lat;%lon_scale:1000";
637
        myOnlineMaps["Google Maps"] = "https://www.google.com/maps?ll=%lat,%lon&t=h&z=18";
638
        myOnlineMaps["OSM"] = "https://www.openstreetmap.org/?mlat=%lat&mlon=%lon&zoom=18&layers=M";
639
    }
640
    // show application windows
641
    show(PLACEMENT_DEFAULT);
642
    // check if maximice
643
    if (!OptionsCont::getOptions().isSet("window-size")) {
644
        if (getApp()->reg().readIntEntry("SETTINGS", "maximized", 0) == 1) {
645
            maximize();
646
        }
647
    }
648
}
649

650

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

715

716
long
717
GNEApplicationWindow::onCmdQuit(FXObject* sender, FXSelector sel, void* ptr) {
718
    if (askSaveElements(sender, sel, ptr)) {
719
        storeWindowSizeAndPos();
720
        getApp()->reg().writeStringEntry("SETTINGS", "basedir", gCurrentFolder.text());
721
        if (isMaximized()) {
722
            getApp()->reg().writeIntEntry("SETTINGS", "maximized", 1);
723
        } else {
724
            getApp()->reg().writeIntEntry("SETTINGS", "maximized", 0);
725
        }
726
        getApp()->exit(0);
727
    }
728
    return 1;
729
}
730

731

732
long
733
GNEApplicationWindow::onCmdEditChosen(FXObject*, FXSelector, void*) {
734
    GUIDialog_GLChosenEditor* chooser =
735
        new GUIDialog_GLChosenEditor(this, &gSelected);
736
    chooser->create();
737
    chooser->show();
738
    return 1;
739
}
740

741

742
long
743
GNEApplicationWindow::onCmdNewNetwork(FXObject*, FXSelector, void*) {
744
    // check if close current simulation
745
    if (onCmdClose(0, 0, 0) == 1) {
746
        // create new network
747
        createNewNetwork();
748
    }
749
    return 1;
750
}
751

752

753
long
754
GNEApplicationWindow::onCmdOpenNetconvertConfig(FXObject*, FXSelector, void*) {
755
    auto& neteditOptions = OptionsCont::getOptions();
756
    // get netconvert file dialog
757
    const GNEFileDialog netConvertFileDialog(this, TL("netconvert config file"),
758
            SUMOXMLDefinitions::NetconvertConfigFileExtensions.getStrings(),
759
            GNEFileDialog::OpenMode::LOAD_SINGLE,
760
            GNEFileDialog::ConfigType::NETEDIT,
761
            myFileBucketHandler->getConfigDirectory());
762
    // continue depending of dialog
763
    if ((netConvertFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
764
        // stop test before calling load thread
765
        if (myInternalTest) {
766
            myInternalTest->stopTests();
767
        }
768
        // reset netedit options
769
        myLoadThread->fillOptions(neteditOptions);
770
        myLoadThread->setDefaultOptions(neteditOptions);
771
        // set netconvert configuration file to load
772
        neteditOptions.resetWritable();
773
        neteditOptions.set("netccfg-file", netConvertFileDialog.getFilename());
774
        // run load thread
775
        myLoadThread->loadNetworkOrConfig();
776
        // update view
777
        update();
778
    }
779
    return 1;
780
}
781

782

783
long
784
GNEApplicationWindow::onCmdOpenNetwork(FXObject*, FXSelector, void*) {
785
    // get netconvert filename
786
    const GNEFileDialog networkFileDialog(this, TL("network file"),
787
                                          SUMOXMLDefinitions::NetFileExtensions.getStrings(),
788
                                          GNEFileDialog::OpenMode::LOAD_SINGLE,
789
                                          GNEFileDialog::ConfigType::NETEDIT,
790
                                          myFileBucketHandler->getConfigDirectory());
791
    // continue depending of dialog
792
    if ((networkFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
793
        // load network
794
        loadNetwork(networkFileDialog.getFilename());
795
    }
796
    return 0;
797
}
798

799

800
long
801
GNEApplicationWindow::onCmdOpenForeign(FXObject*, FXSelector, void*) {
802
    // get OSM file dilaog
803
    const GNEFileDialog OSMFileDialog(this, TL("OpenStreetMap file"),
804
                                      SUMOXMLDefinitions::OSMFileExtensions.getStrings(),
805
                                      GNEFileDialog::OpenMode::LOAD_SINGLE,
806
                                      GNEFileDialog::ConfigType::NETEDIT,
807
                                      myFileBucketHandler->getConfigDirectory());
808
    // continue depending of dialog
809
    if ((OSMFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
810
        loadOSM(OSMFileDialog.getFilename());
811
    }
812
    return 1;
813
}
814

815

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

845

846
long
847
GNEApplicationWindow::onCmdOpenSumoConfig(FXObject*, FXSelector, void*) {
848
    auto& neteditOptions = OptionsCont::getOptions();
849
    // get netconvert filename
850
    const GNEFileDialog sumoConfigFileDialog(this, TL("sumo config file"),
851
            SUMOXMLDefinitions::SumoConfigFileExtensions.getStrings(),
852
            GNEFileDialog::OpenMode::LOAD_SINGLE,
853
            GNEFileDialog::ConfigType::NETEDIT,
854
            myFileBucketHandler->getConfigDirectory());
855
    // continue depending of dialog
856
    if ((sumoConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) && (onCmdClose(0, 0, 0) == 1)) {
857
        // stop test before calling load thread
858
        if (myInternalTest) {
859
            myInternalTest->stopTests();
860
        }
861
        // reset options
862
        myLoadThread->fillOptions(neteditOptions);
863
        myLoadThread->setDefaultOptions(neteditOptions);
864
        // set sumo configuration file to load
865
        neteditOptions.resetWritable();
866
        neteditOptions.set("sumocfg-file", sumoConfigFileDialog.getFilename());
867
        // run load thread
868
        myLoadThread->loadNetworkOrConfig();
869
        // update view
870
        update();
871
    }
872
    return 1;
873
}
874

875

876
long
877
GNEApplicationWindow::onCmdReloadNeteditConfig(FXObject*, FXSelector, void*) {
878
    // get existent configuration file
879
    const auto neteditConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETEDIT_CONFIG);
880
    // check if close current simulation
881
    if (onCmdClose(0, 0, 0) == 1) {
882
        // stop test before calling load thread
883
        if (myInternalTest) {
884
            myInternalTest->stopTests();
885
        }
886
        auto& neteditOptions = OptionsCont::getOptions();
887
        // reset options
888
        myLoadThread->fillOptions(neteditOptions);
889
        myLoadThread->setDefaultOptions(neteditOptions);
890
        // set netedit configuration file to load
891
        neteditOptions.resetWritable();
892
        neteditOptions.set("netecfg-file", neteditConfigFile);
893
        // run load thread
894
        myLoadThread->loadNetworkOrConfig();
895
        // update view
896
        update();
897
    }
898
    return 1;
899
}
900

901

902
long
903
GNEApplicationWindow::onCmdReloadSumoConfig(FXObject*, FXSelector, void*) {
904
    // get existent sumo config file
905
    const auto sumoConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG);
906
    // check if close current simulation
907
    if (onCmdClose(0, 0, 0) == 1) {
908
        // stop test before calling load thread
909
        if (myInternalTest) {
910
            myInternalTest->stopTests();
911
        }
912
        auto& neteditOptions = OptionsCont::getOptions();
913
        // reset options
914
        myLoadThread->fillOptions(neteditOptions);
915
        myLoadThread->setDefaultOptions(neteditOptions);
916
        // set configuration file to load
917
        neteditOptions.resetWritable();
918
        neteditOptions.set("sumocfg-file", sumoConfigFile);
919
        // run load thread
920
        myLoadThread->loadNetworkOrConfig();
921
        // update view
922
        update();
923
    }
924
    return 1;
925
}
926

927

928
long
929
GNEApplicationWindow::onUpdReloadNeteditConfig(FXObject* sender, FXSelector, void*) {
930
    // check if file exist
931
    if (myViewNet && myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
932
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
933
    } else {
934
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
935
    }
936
}
937

938

939
long
940
GNEApplicationWindow::onUpdReloadSumoConfig(FXObject* sender, FXSelector, void*) {
941
    // check if file exist
942
    if (myViewNet && myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG)) {
943
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
944
    } else {
945
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
946
    }
947
}
948

949

950
long
951
GNEApplicationWindow::onCmdOpenTLSPrograms(FXObject*, FXSelector, void*) {
952
    // get netconvert filename
953
    const GNEFileDialog TLSfileDialog(this, TL("Traffic Light definitions file"),
954
                                      SUMOXMLDefinitions::TLSFileExtensions.getStrings(),
955
                                      GNEFileDialog::OpenMode::LOAD_SINGLE,
956
                                      GNEFileDialog::ConfigType::NETEDIT,
957
                                      myFileBucketHandler->getConfigDirectory());
958
    // continue depending of dialog
959
    if (TLSfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
960
        // set tls type in bucket
961
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::TLS, TLSfileDialog.getFilename());
962
        // load traffic lights
963
        loadTrafficLights("Loading");
964
    }
965
    return 1;
966
}
967

968

969
long
970
GNEApplicationWindow::onCmdReloadTLSPrograms(FXObject*, FXSelector, void*) {
971
    // load traffic lights
972
    loadTrafficLights("Reloading");
973
    return 1;
974
}
975

976

977
long
978
GNEApplicationWindow::onUpdReloadTLSPrograms(FXObject* sender, FXSelector, void*) {
979
    // check if file exist
980
    if (myViewNet && !myFileBucketHandler->isFilenameDefined(FileBucket::Type::TLS)) {
981
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
982
    } else {
983
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
984
    }
985
}
986

987

988
long
989
GNEApplicationWindow::onCmdOpenEdgeTypes(FXObject*, FXSelector, void*) {
990
    // get netconvert filename
991
    const GNEFileDialog edgeTypesFileDialog(this, TL("EdgeTypes file"),
992
                                            SUMOXMLDefinitions::EdgeTypeFileExtensions.getStrings(),
993
                                            GNEFileDialog::OpenMode::LOAD_SINGLE,
994
                                            GNEFileDialog::ConfigType::NETEDIT,
995
                                            myFileBucketHandler->getConfigDirectory());
996
    // continue depending of dialog
997
    if (edgeTypesFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
998
        // set tls type in bucket
999
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::EDGETYPE, edgeTypesFileDialog.getFilename());
1000
        // load edge types
1001
        loadEdgeTypes("Loading");
1002
    }
1003
    return 1;
1004
}
1005

1006

1007
long
1008
GNEApplicationWindow::onCmdReloadEdgeTypes(FXObject*, FXSelector, void*) {
1009
    // load edge types
1010
    loadEdgeTypes("Reloading");
1011
    return 0;
1012
}
1013

1014

1015
long
1016
GNEApplicationWindow::onUpdReloadEdgeTypes(FXObject* sender, FXSelector, void*) {
1017
    // check if file exist
1018
    if (myViewNet && !myFileBucketHandler->isFilenameDefined(FileBucket::Type::EDGETYPE)) {
1019
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1020
    } else {
1021
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1022
    }
1023
}
1024

1025

1026
long
1027
GNEApplicationWindow::onCmdSmartReload(FXObject*, FXSelector sel, void*) {
1028
    auto& neteditOptions = OptionsCont::getOptions();
1029
    // check if close current file
1030
    if (onCmdClose(0, sel, 0) == 1) {
1031
        // stop test before calling load thread
1032
        if (myInternalTest) {
1033
            myInternalTest->stopTests();
1034
        }
1035
        // store size, position and viewport
1036
        storeWindowSizeAndPos();
1037
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1038
        // set flag
1039
        myAmLoading = true;
1040
        // get files
1041
        const auto neteditConfig = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETEDIT_CONFIG);
1042
        const auto sumoConfig = myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG);
1043
        const auto networkFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK);
1044
        // fill (reset) all options
1045
        myLoadThread->fillOptions(neteditOptions);
1046
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1047
        myLoadThread->setDefaultOptions(neteditOptions);
1048
        // set file to load
1049
        neteditOptions.resetWritable();
1050
        if (neteditConfig.size() > 0) {
1051
            // set netedit config
1052
            myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETEDIT_CONFIG, neteditConfig);
1053
            // set status bar
1054
            setStatusBarText(TLF("Reloading netedit config file '%'", neteditConfig));
1055
        } else if (sumoConfig.size() > 0) {
1056
            // set sumo config
1057
            myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::SUMO_CONFIG, sumoConfig);
1058
            // set status bar
1059
            setStatusBarText(TLF("Reloading sumo config file '%'", sumoConfig));
1060
        } else if (networkFile.size() > 0) {
1061
            // set network config
1062
            myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, networkFile);
1063
            // set status bar
1064
            setStatusBarText(TLF("Reloading network file '%'", networkFile));
1065
        } else {
1066
            // nothing to load
1067
            return 0;
1068
        }
1069
        // load network
1070
        myLoadThread->loadNetworkOrConfig();
1071
    }
1072
    return 1;
1073
}
1074

1075

1076
long
1077
GNEApplicationWindow::onUpdSmartReload(FXObject* sender, FXSelector, void*) {
1078
    // declare strings
1079
    FXString neteditConfig = TL("&Reload Netedit config");
1080
    FXString sumoConfig = TL("&Reload Sumo config");
1081
    FXString netFile = TL("&Reload Network");
1082
    FXString reload = TL("&Reload");
1083
    // check options
1084
    if (myNet == nullptr) {
1085
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1086
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &reload);
1087
    } else if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
1088
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1089
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &neteditConfig);
1090
    } else if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG)) {
1091
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1092
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &sumoConfig);
1093
    } else if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETWORK)) {
1094
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1095
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &netFile);
1096
    } else {
1097
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1098
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SETSTRINGVALUE), &reload);
1099
    }
1100
    return 1;
1101
}
1102

1103

1104
long
1105
GNEApplicationWindow::onCmdReloadNetwork(FXObject*, FXSelector sel, void*) {
1106
    auto& neteditOptions = OptionsCont::getOptions();
1107
    // check if close current file
1108
    if (onCmdClose(0, sel, 0) == 1) {
1109
        // stop test before calling load thread
1110
        if (myInternalTest) {
1111
            myInternalTest->stopTests();
1112
        }
1113
        // store size, position and viewport
1114
        storeWindowSizeAndPos();
1115
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1116
        // set flag
1117
        myAmLoading = true;
1118
        // get network
1119
        const std::string networkFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK);
1120
        // fill (reset) all options
1121
        myLoadThread->fillOptions(neteditOptions);
1122
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1123
        myLoadThread->setDefaultOptions(neteditOptions);
1124
        // set file to load
1125
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, networkFile);
1126
        // set status bar
1127
        setStatusBarText(TLF("Reloading network file '%'", networkFile));
1128
        // loaad network
1129
        myLoadThread->loadNetworkOrConfig();
1130
    }
1131
    return 1;
1132
}
1133

1134

1135
long
1136
GNEApplicationWindow::onUpdReloadNetwork(FXObject* sender, FXSelector, void*) {
1137
    if (myNet == nullptr) {
1138
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1139
        sender->handle(this, FXSEL(SEL_COMMAND, ID_HIDE), nullptr);
1140
    } else if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETWORK) &&
1141
               (myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG) || myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG))) {
1142
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1143
        sender->handle(this, FXSEL(SEL_COMMAND, ID_SHOW), nullptr);
1144
    } else {
1145
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
1146
        sender->handle(this, FXSEL(SEL_COMMAND, ID_HIDE), nullptr);
1147
    }
1148
    return 1;
1149
}
1150

1151

1152
long
1153
GNEApplicationWindow::onCmdOpenRecent(FXObject*, FXSelector, void* fileData) {
1154
    // first check that current edited Net can be closed (und therefore the undo-list cleared, see #5753)
1155
    if (myAmLoading) {
1156
        myStatusbar->getStatusLine()->setText(TL("Already loading!"));
1157
    } else if (onCmdClose(0, 0, 0) == 1) {
1158
        // get filedata
1159
        const std::string recentFile = ((const char*)fileData);
1160
        // check if we're loading a network o a config
1161
        if ((recentFile.find(".netecfg") != std::string::npos) ||
1162
                (recentFile.find(".sumocfg") != std::string::npos) ||
1163
                (recentFile.find(".netccfg") != std::string::npos)) {
1164
            // load config
1165
            loadConfiguration(recentFile);
1166
        } else {
1167
            // load network
1168
            loadNetwork(recentFile);
1169
        }
1170
    }
1171
    return 1;
1172
}
1173

1174

1175
long
1176
GNEApplicationWindow::onCmdClose(FXObject* sender, FXSelector sel, void* ptr) {
1177
    if (myViewNet == nullptr) {
1178
        return 1;
1179
    } else if (askSaveElements(sender, sel, ptr)) {
1180
        // check if is reloading
1181
        const bool reloading = (FXSELID(sel) == MID_GNE_TOOLBARFILE_RELOADNETWORK) || (FXSELID(sel) == MID_HOTKEY_CTRL_R_RELOAD);
1182
        // close all windows
1183
        closeAllWindows(!reloading);
1184
        // add a separator to the log
1185
        myMessageWindow->addSeparator();
1186
        // hide all menu commands
1187
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
1188
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
1189
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
1190
        // hide view options
1191
        myEditMenuCommands.networkViewOptions.hideNetworkViewOptionsMenuChecks();
1192
        myEditMenuCommands.demandViewOptions.hideDemandViewOptionsMenuChecks();
1193
        myEditMenuCommands.dataViewOptions.hideDataViewOptionsMenuChecks();
1194
        return 1;
1195
    } else {
1196
        return 0;
1197
    }
1198
}
1199

1200

1201
long
1202
GNEApplicationWindow::onCmdLocate(FXObject*, FXSelector sel, void*) {
1203
    if (myMDIClient->numChildren() > 0) {
1204
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
1205
        if (w != nullptr) {
1206
            w->onCmdLocate(nullptr, sel, nullptr);
1207
        }
1208
    }
1209
    return 1;
1210
}
1211

1212

1213
long
1214
GNEApplicationWindow::onCmdOpenPythonToolDialog(FXObject* obj, FXSelector, void*) {
1215
    return myToolsMenuCommands.showTool(obj);
1216
}
1217

1218

1219
long
1220
GNEApplicationWindow::onCmdRunPythonTool(FXObject* obj, FXSelector, void*) {
1221
    return myToolsMenuCommands.runToolDialog(obj);
1222
}
1223

1224

1225
long
1226
GNEApplicationWindow::onCmdPostProcessingPythonTool(FXObject* obj, FXSelector, void*) {
1227
    return myToolsMenuCommands.postProcessing(obj);
1228
}
1229

1230

1231
long
1232
GNEApplicationWindow::onUpdPythonTool(FXObject*, FXSelector, void*) {
1233
    // currently always enabled
1234
    return 1;
1235
}
1236

1237

1238
long
1239
GNEApplicationWindow::onUpdOpen(FXObject* sender, FXSelector, void*) {
1240
    sender->handle(this, myAmLoading ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
1241
    return 1;
1242
}
1243

1244

1245
long
1246
GNEApplicationWindow::onCmdClearMsgWindow(FXObject*, FXSelector, void*) {
1247
    myMessageWindow->clear();
1248
    return 1;
1249
}
1250

1251

1252
long
1253
GNEApplicationWindow::onCmdLoadAdditionalsInSUMOGUI(FXObject*, FXSelector, void*) {
1254
    return 1;
1255
}
1256

1257

1258
long
1259
GNEApplicationWindow::onCmdLoadDemandInSUMOGUI(FXObject*, FXSelector, void*) {
1260
    return 1;
1261
}
1262

1263

1264
long
1265
GNEApplicationWindow::onCmdAbout(FXObject*, FXSelector, void*) {
1266
    // create and open about dialog
1267
    GNEAboutDialog(this);
1268
    return 1;
1269
}
1270

1271

1272
long GNEApplicationWindow::onClipboardRequest(FXObject*, FXSelector, void* ptr) {
1273
    FXEvent* event = (FXEvent*)ptr;
1274
    FXString string = GUIUserIO::clipped.c_str();
1275
    setDNDData(FROM_CLIPBOARD, event->target, string);
1276
    return 1;
1277
}
1278

1279

1280
long
1281
GNEApplicationWindow::onLoadThreadEvent(FXObject*, FXSelector, void*) {
1282
    eventOccurred();
1283
    return 1;
1284
}
1285

1286

1287
void
1288
GNEApplicationWindow::eventOccurred() {
1289
    // load events
1290
    while (!myThreadEvents.empty()) {
1291
        // get the next event
1292
        GUIEvent* e = myThreadEvents.top();
1293
        myThreadEvents.pop();
1294
        // process
1295
        switch (e->getOwnType()) {
1296
            case GUIEventType::SIMULATION_LOADED:
1297
                handleEvent_FileLoaded(e);
1298
                break;
1299
            case GUIEventType::MESSAGE_OCCURRED:
1300
            case GUIEventType::WARNING_OCCURRED:
1301
            case GUIEventType::ERROR_OCCURRED:
1302
            case GUIEventType::DEBUG_OCCURRED:
1303
            case GUIEventType::GLDEBUG_OCCURRED:
1304
                handleEvent_Message(e);
1305
                break;
1306
            default:
1307
                break;
1308
        }
1309
        delete e;
1310
    }
1311
}
1312

1313

1314
void
1315
GNEApplicationWindow::handleEvent_FileLoaded(GUIEvent* e) {
1316
    myAmLoading = false;
1317
    GNEEvent_FileLoaded* fileLoadedEvent = static_cast<GNEEvent_FileLoaded*>(e);
1318
    // check whether the loading was successful
1319
    if (fileLoadedEvent->getNet() == nullptr) {
1320
        // report failure
1321
        std::string failureMessage;
1322
        switch (fileLoadedEvent->getType()) {
1323
            case GNEEvent_FileLoaded::Type::NETECFG:
1324
                failureMessage = TLF("Loading of netedit config '%' failed", fileLoadedEvent->getFile());
1325
                break;
1326
            case GNEEvent_FileLoaded::Type::SUMOCFG:
1327
                failureMessage = TLF("Loading of sumo config '%' failed", fileLoadedEvent->getFile());
1328
                break;
1329
            case GNEEvent_FileLoaded::Type::NETCCFG:
1330
                failureMessage = TLF("Loading of netconvert config '%' failed", fileLoadedEvent->getFile());
1331
                break;
1332
            case GNEEvent_FileLoaded::Type::NETWORK:
1333
                failureMessage = TLF("Loading of network '%' failed", fileLoadedEvent->getFile());
1334
                break;
1335
            case GNEEvent_FileLoaded::Type::OSM:
1336
                failureMessage = TLF("Loading of OSM Network '%' failed", fileLoadedEvent->getFile());
1337
                break;
1338
            case GNEEvent_FileLoaded::Type::INVALID_OPTIONS:
1339
                failureMessage = TL("Invalid Options. Nothing loaded");
1340
                break;
1341
            case GNEEvent_FileLoaded::Type::INVALID_PROJECTION:
1342
                failureMessage = TL("Could not build projection. Nothing loaded");
1343
                break;
1344
            case GNEEvent_FileLoaded::Type::INVALID_CONFIG:
1345
                failureMessage = TL("Invalid extension for config file. Only .netecfg, .sumocfg or .netccfg are allowed");
1346
                break;
1347
            default:
1348
                failureMessage = TL("Invalid input network option. Load with either sumo/netedit/netconvert config or with --new option");
1349
                break;
1350
        }
1351
        // write info
1352
        WRITE_ERROR(failureMessage);
1353
        setStatusBarText(failureMessage);
1354
    } else {
1355
        // report success
1356
        std::string successMessage;
1357
        switch (fileLoadedEvent->getType()) {
1358
            case GNEEvent_FileLoaded::Type::NETECFG:
1359
                successMessage = TLF("Netedit config '%' loaded", fileLoadedEvent->getFile());
1360
                break;
1361
            case GNEEvent_FileLoaded::Type::SUMOCFG:
1362
                successMessage = TLF("Sumo config '%' loaded", fileLoadedEvent->getFile());
1363
                break;
1364
            case GNEEvent_FileLoaded::Type::NETCCFG:
1365
                successMessage = TLF("Netconvert config '%' loaded", fileLoadedEvent->getFile());
1366
                break;
1367
            case GNEEvent_FileLoaded::Type::NETWORK:
1368
                successMessage = TLF("Network '%' loaded", fileLoadedEvent->getFile());
1369
                break;
1370
            case GNEEvent_FileLoaded::Type::OSM:
1371
                successMessage = TLF("OSM Network '%' loaded", fileLoadedEvent->getFile());
1372
                break;
1373
            case GNEEvent_FileLoaded::Type::CONSOLE:
1374
                successMessage = TLF("Network '%' loaded through console", fileLoadedEvent->getFile());
1375
                break;
1376
            case GNEEvent_FileLoaded::Type::NEW:
1377
                successMessage = TL("New network successfully created");
1378
                break;
1379
            default:
1380
                throw ProcessError("Invalid sucess mesage. Check if all cases were covered");
1381
        }
1382
        // write info
1383
        WRITE_MESSAGE(successMessage);
1384
        setStatusBarText(successMessage);
1385
        // set new Net
1386
        myNet = fileLoadedEvent->getNet();
1387
        // set size and pos
1388
        setWindowSizeAndPos();
1389
        // build viewparent toolbar grips before creating view parent
1390
        getToolbarsGrip().buildViewParentToolbarsGrips();
1391
        // initialise netedit View
1392
        GNEViewParent* viewParent = new GNEViewParent(myMDIClient, myMDIMenu, "netedit VIEW", this, nullptr, myNet, myUndoList, nullptr, MDI_TRACKING, 10, 10, 300, 200);
1393
        // create it maximized
1394
        viewParent->maximize();
1395
        // mark it as Active child
1396
        myMDIClient->setActiveChild(viewParent);
1397
        // cast pointer myViewNet
1398
        myViewNet = dynamic_cast<GNEViewNet*>(viewParent->getView());
1399
        // set settings in view
1400
        if (viewParent->getView() && (fileLoadedEvent->getSettingsFile().size() > 0)) {
1401
            GUISettingsHandler settings(fileLoadedEvent->getSettingsFile(), true, true);
1402
            settings.addSettings(viewParent->getView());
1403
            viewParent->getView()->addDecals(settings.getDecals());
1404
            settings.applyViewport(viewParent->getView());
1405
            settings.setSnapshots(viewParent->getView());
1406
        }
1407
        // set network name on the caption
1408
        setTitle(MFXUtils::getTitleText(myTitlePrefix, fileLoadedEvent->getFile().c_str()));
1409
        // force supermode network
1410
        myViewNet->forceSupemodeNetwork();
1411
        // update view port
1412
        if (fileLoadedEvent->getViewportFromRegistry()) {
1413
            Position off;
1414
            off.set(getApp()->reg().readRealEntry("viewport", "x"), getApp()->reg().readRealEntry("viewport", "y"), getApp()->reg().readRealEntry("viewport", "z"));
1415
            Position p(off.x(), off.y(), 0);
1416
            myViewNet->setViewportFromToRot(off, p, 0);
1417
        }
1418
        // load elements
1419
        loadAdditionalElements("Loading");
1420
        loadDemandElements("Loading");
1421
        loadDataElements("Loading");
1422
        loadMeanDataElements("Loading");
1423
        // load selection
1424
        if (!OptionsCont::getOptions().isDefault("selection-file")) {
1425
            myViewNet->getViewParent()->getSelectorFrame()->getSelectionOperationModul()->loadFromFile(OptionsCont::getOptions().getString("selection-file"));
1426
        }
1427
        myNet->getSavingStatus()->networkSaved();
1428
    }
1429
    myMessageWindow->registerMsgHandlers();
1430
    // update app
1431
    update();
1432
    // restore focus
1433
    setFocus();
1434
}
1435

1436

1437
void
1438
GNEApplicationWindow::handleEvent_Message(GUIEvent* e) {
1439
    GUIEvent_Message* ec = static_cast<GUIEvent_Message*>(e);
1440
    myMessageWindow->appendMsg(ec->getOwnType(), ec->getMsg());
1441
}
1442

1443
// ---------------------------------------------------------------------------
1444
// private methods
1445
// ---------------------------------------------------------------------------
1446

1447
void
1448
GNEApplicationWindow::fillMenuBar() {
1449
    // build file menu
1450
    myFileMenu = new FXMenuPane(this, LAYOUT_FIX_HEIGHT);
1451
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&File"), nullptr, myFileMenu);
1452
    myFileMenuNeteditConfig = new FXMenuPane(this);
1453
    myFileMenuSumoConfig = new FXMenuPane(this);
1454
    myFileMenuTLS = new FXMenuPane(this);
1455
    myFileMenuEdgeTypes = new FXMenuPane(this);
1456
    myFileMenuAdditionals = new FXMenuPane(this);
1457
    myFileMenuDemandElements = new FXMenuPane(this);
1458
    myFileMenuDataElements = new FXMenuPane(this);
1459
    myFileMenuMeanDataElements = new FXMenuPane(this);
1460
    myFileMenuRecentNetworks = new FXMenuPane(this);
1461
    myFileMenuRecentConfigs = new FXMenuPane(this);
1462
    myFileMenuCommands.buildFileMenuCommands(myFileMenu, myFileMenuNeteditConfig, myFileMenuSumoConfig,
1463
            myFileMenuTLS, myFileMenuEdgeTypes, myFileMenuAdditionals, myFileMenuDemandElements,
1464
            myFileMenuDataElements, myFileMenuMeanDataElements);
1465
    // add separator for recent files
1466
    new FXMenuSeparator(myFileMenu);
1467
    // build recent files
1468
    myMenuBarFile.buildRecentNetworkFiles(myFileMenu, myFileMenuRecentNetworks);
1469
    myMenuBarFile.buildRecentConfigFiles(myFileMenu, myFileMenuRecentConfigs);
1470
    new FXMenuSeparator(myFileMenu);
1471
    GUIDesigns::buildFXMenuCommandShortcut(myFileMenu, TL("&Quit"), "Ctrl+Q", TL("Quit the Application."),
1472
                                           nullptr, this, MID_HOTKEY_CTRL_Q_CLOSE);
1473
    // build modes menu
1474
    myModesMenu = new FXMenuPane(this);
1475
    myModesMenuTitle = GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Modes"), nullptr, myModesMenu);
1476
    myModesMenuTitle->setTarget(this);
1477
    myModesMenuTitle->setSelector(MID_GNE_MODESMENUTITLE);
1478
    // build Supermode commands and hide it
1479
    mySupermodeCommands.buildSupermodeCommands(myModesMenu);
1480
    // add separator
1481
    new FXSeparator(myModesMenu);
1482
    // build modes menu commands
1483
    myModesMenuCommands.buildModesMenuCommands(myModesMenu);
1484
    // build edit menu
1485
    myEditMenu = new FXMenuPane(this);
1486
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Edit"), nullptr, myEditMenu);
1487
    // build edit menu commands
1488
    myEditMenuCommands.buildUndoRedoMenuCommands(myEditMenu);
1489
    // build separator
1490
    new FXMenuSeparator(myEditMenu);
1491
    // build view options
1492
    myEditMenuCommands.networkViewOptions.buildNetworkViewOptionsMenuChecks(myEditMenu);
1493
    myEditMenuCommands.demandViewOptions.buildDemandViewOptionsMenuChecks(myEditMenu);
1494
    myEditMenuCommands.dataViewOptions.buildDataViewOptionsMenuChecks(myEditMenu);
1495
    // hide view options
1496
    myEditMenuCommands.networkViewOptions.hideNetworkViewOptionsMenuChecks();
1497
    myEditMenuCommands.demandViewOptions.hideDemandViewOptionsMenuChecks();
1498
    myEditMenuCommands.dataViewOptions.hideDataViewOptionsMenuChecks();
1499
    // build view menu commands
1500
    myEditMenuCommands.buildViewMenuCommands(myEditMenu);
1501
    // build separator
1502
    new FXMenuSeparator(myEditMenu);
1503
    // build front element menu commands
1504
    myEditMenuCommands.buildFrontElementMenuCommand(myEditMenu);
1505
    // build separator
1506
    new FXMenuSeparator(myEditMenu);
1507
    // build open in sumo menu commands
1508
    myEditMenuCommands.buildOpenSUMOMenuCommands(myEditMenu);
1509
    // build lock menu
1510
    myLockMenu = new FXMenuPane(this);
1511
    myLockMenuTitle = GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("L&ock"), nullptr, myLockMenu);
1512
    myLockMenuTitle->setTarget(this);
1513
    myLockMenuTitle->setSelector(MID_GNE_LOCK_MENUTITLE);
1514
    // build lock menu commands
1515
    myLockMenuCommands.buildLockMenuCommands(myLockMenu);
1516
    // build processing menu (trigger netbuild computations)
1517
    myProcessingMenu = new FXMenuPane(this);
1518
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Processing"), nullptr, myProcessingMenu);
1519
    myProcessingMenuCommands.buildProcessingMenuCommands(myProcessingMenu);
1520
    // build locate menu
1521
    myLocatorMenu = new FXMenuPane(this);
1522
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Locate"), nullptr, myLocatorMenu);
1523
    myLocateMenuCommands.buildLocateMenuCommands(myLocatorMenu);
1524
    // build tools menu
1525
    myToolsMenu = new FXMenuPane(this);
1526
    myToolsAssignMenu = new FXMenuPane(this);
1527
    myToolsDetectorMenu = new FXMenuPane(this);
1528
    myToolsDistrictMenu = new FXMenuPane(this);
1529
    myToolsDRTMenu = new FXMenuPane(this);
1530
    myToolsEmissionsMenu = new FXMenuPane(this);
1531
    myToolsImportMenu = new FXMenuPane(this);
1532
    myToolsImportCityBrainMenu = new FXMenuPane(this);
1533
    myToolsImportGTFSMenu = new FXMenuPane(this);
1534
    myToolsImportVissim = new FXMenuPane(this);
1535
    myToolsImportVisum = new FXMenuPane(this);
1536
    myToolsNetMenu = new FXMenuPane(this);
1537
    myToolsRouteMenu = new FXMenuPane(this);
1538
    myToolsOutputMenu = new FXMenuPane(this);
1539
    myToolsShapes = new FXMenuPane(this);
1540
    myToolsTLS = new FXMenuPane(this);
1541
    myToolsTriggerMenu = new FXMenuPane(this);
1542
    myToolsTurnDefs = new FXMenuPane(this);
1543
    myToolsVisualizationMenu = new FXMenuPane(this);
1544
    myToolsXML = new FXMenuPane(this);
1545
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Tools"), nullptr, myToolsMenu);
1546
    // build tools menu cascasde
1547
    new FXMenuCascade(myToolsMenu, TL("Assign"), nullptr, myToolsAssignMenu);
1548
    new FXMenuCascade(myToolsMenu, TL("Detectors"), GUIIconSubSys::getIcon(GUIIcon::E1), myToolsDetectorMenu);
1549
    new FXMenuCascade(myToolsMenu, TL("Districts"), GUIIconSubSys::getIcon(GUIIcon::TAZ), myToolsDistrictMenu);
1550
    new FXMenuCascade(myToolsMenu, TL("DRT"), GUIIconSubSys::getIcon(GUIIcon::VCLASS_SMALL_TAXI), myToolsDRTMenu);
1551
    //new FXMenuCascade(myToolsMenu, TL("Emissions"), GUIIconSubSys::getIcon(GUIIcon::TOOL_EMISSIONS), myToolsEmissionsMenu);
1552
    new FXMenuCascade(myToolsImportMenu, TL("CityBrain"), GUIIconSubSys::getIcon(GUIIcon::TOOL_CITYBRAIN), myToolsImportCityBrainMenu);
1553
    new FXMenuCascade(myToolsImportMenu, TL("GTFS"), GUIIconSubSys::getIcon(GUIIcon::TOOL_GTFS), myToolsImportGTFSMenu);
1554
    new FXMenuCascade(myToolsImportMenu, TL("Vissim"), GUIIconSubSys::getIcon(GUIIcon::TOOL_VISSIM), myToolsImportVissim);
1555
    new FXMenuCascade(myToolsImportMenu, TL("Visum"), GUIIconSubSys::getIcon(GUIIcon::TOOL_VISUM), myToolsImportVisum);
1556
    new FXMenuCascade(myToolsMenu, TL("Import"), GUIIconSubSys::getIcon(GUIIcon::TOOL_IMPORT), myToolsImportMenu);
1557
    new FXMenuCascade(myToolsMenu, TL("Net"), GUIIconSubSys::getIcon(GUIIcon::MODECREATEEDGE), myToolsNetMenu);
1558
    new FXMenuCascade(myToolsMenu, TL("Output"), GUIIconSubSys::getIcon(GUIIcon::TOOL_OUTPUT), myToolsOutputMenu);
1559
    new FXMenuCascade(myToolsMenu, TL("Route"), GUIIconSubSys::getIcon(GUIIcon::MODEADDITIONAL), myToolsRouteMenu);
1560
    //new FXMenuCascade(myToolsMenu, TL("Shapes"), GUIIconSubSys::getIcon(GUIIcon::MODESHAPE), myToolsShapes);
1561
    new FXMenuCascade(myToolsMenu, TL("TLS"), GUIIconSubSys::getIcon(GUIIcon::MODETLS), myToolsTLS);
1562
    new FXMenuCascade(myToolsMenu, TL("Trigger"), nullptr, myToolsTriggerMenu);
1563
    new FXMenuCascade(myToolsMenu, TL("Turn-defs"), GUIIconSubSys::getIcon(GUIIcon::TOOL_TURNDEFS), myToolsTurnDefs);
1564
    new FXMenuCascade(myToolsMenu, TL("Visualization"), GUIIconSubSys::getIcon(GUIIcon::COLORWHEEL), myToolsVisualizationMenu);
1565
    new FXMenuCascade(myToolsMenu, TL("XML"), GUIIconSubSys::getIcon(GUIIcon::TOOL_XML), myToolsXML);
1566
    // add separators between folders
1567
    new FXMenuSeparator(myToolsMenu);
1568
    new FXMenuSeparator(myToolsImportMenu);
1569
    // create map with tool Menu panes and their associated folder
1570
    myMenuPaneToolMaps["assign"] = myToolsAssignMenu;
1571
    myMenuPaneToolMaps["detector"] = myToolsDetectorMenu;
1572
    myMenuPaneToolMaps["district"] = myToolsDistrictMenu;
1573
    myMenuPaneToolMaps["drt"] = myToolsDRTMenu;
1574
    myMenuPaneToolMaps["emissions"] = myToolsEmissionsMenu;
1575
    myMenuPaneToolMaps["import"] = myToolsImportMenu;
1576
    myMenuPaneToolMaps["import/citybrain"] = myToolsImportCityBrainMenu;
1577
    myMenuPaneToolMaps["import/gtfs"] = myToolsImportGTFSMenu;
1578
    myMenuPaneToolMaps["import/vissim"] = myToolsImportVissim;
1579
    myMenuPaneToolMaps["import/visum"] = myToolsImportVisum;
1580
    myMenuPaneToolMaps["net"] = myToolsNetMenu;
1581
    myMenuPaneToolMaps["route"] = myToolsRouteMenu;
1582
    myMenuPaneToolMaps["output"] = myToolsOutputMenu;
1583
    myMenuPaneToolMaps["shapes"] = myToolsShapes;
1584
    myMenuPaneToolMaps["tls"] = myToolsTLS;
1585
    myMenuPaneToolMaps["trigger"] = myToolsTriggerMenu;
1586
    myMenuPaneToolMaps["turn-defs"] = myToolsTurnDefs;
1587
    myMenuPaneToolMaps["visualization"] = myToolsVisualizationMenu;
1588
    myMenuPaneToolMaps["xml"] = myToolsXML;
1589
    // build tools
1590
    myToolsMenuCommands.buildTools(myToolsMenu, myMenuPaneToolMaps);
1591
    // build windows menu
1592
    myWindowMenu = new FXMenuPane(this);
1593
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Window"), nullptr, myWindowMenu);
1594
    myWindowsMenuCommands.buildWindowsMenuCommands(myWindowMenu, myStatusbar, myMessageWindow);
1595
    // build language menu
1596
    buildLanguageMenu(myToolbarsGrip.menu);
1597
    // build help menu
1598
    myHelpMenu = new FXMenuPane(this);
1599
    GUIDesigns::buildFXMenuTitle(myToolbarsGrip.menu, TL("&Help"), nullptr, myHelpMenu);
1600
    myHelpMenuCommands.buildHelpMenuCommands(myHelpMenu);
1601
}
1602

1603

1604
FXGLCanvas*
1605
GNEApplicationWindow::getBuildGLCanvas() const {
1606
    // netedit uses only a single View, then return nullptr
1607
    return nullptr;
1608
}
1609

1610

1611
SUMOTime
1612
GNEApplicationWindow::getCurrentSimTime() const {
1613
    return 0;
1614
}
1615

1616

1617
double
1618
GNEApplicationWindow::getTrackerInterval() const {
1619
    return 1;
1620
}
1621

1622

1623
const GNETagPropertiesDatabase*
1624
GNEApplicationWindow::getTagPropertiesDatabase() const {
1625
    return myTagPropertiesDatabase;
1626
}
1627

1628

1629
GNEUndoList*
1630
GNEApplicationWindow::getUndoList() {
1631
    return myUndoList;
1632
}
1633

1634

1635
GNEViewNet*
1636
GNEApplicationWindow::getViewNet() {
1637
    return myViewNet;
1638
}
1639

1640

1641
GNEApplicationWindowHelper::ToolbarsGrip&
1642
GNEApplicationWindow::getToolbarsGrip() {
1643
    return myToolbarsGrip;
1644
}
1645

1646

1647
void
1648
GNEApplicationWindow::updateRecomputingLabel() {
1649
    if (myViewNet && myViewNet->getNet()) {
1650
        // show
1651
        myRequireRecomputingButton->show();
1652
        // set label depending of recomputing
1653
        if (myNet->getAttributeCarriers()->getJunctions().empty() || myNet->isNetRecomputed()) {
1654
            myRequireRecomputingButton->setText("");
1655
            myRequireRecomputingButton->setTipText(TL("Network computed"));
1656
            myRequireRecomputingButton->setIcon(GUIIconSubSys::getIcon(GUIIcon::OK));
1657
            myRequireRecomputingButton->setBackColor(FXRGBA(240, 255, 205, 255));
1658
        } else {
1659
            myRequireRecomputingButton->setText(TL("Press F5"));
1660
            myRequireRecomputingButton->setTipText(TL("Network requires recomputing"));
1661
            myRequireRecomputingButton->setIcon(GUIIconSubSys::getIcon(GUIIcon::WARNING));
1662
            myRequireRecomputingButton->setBackColor(FXRGBA(253, 255, 206, 255));
1663
        }
1664
    } else {
1665
        // hide
1666
        myRequireRecomputingButton->hide();
1667
    }
1668
}
1669

1670

1671
void
1672
GNEApplicationWindow::closeAllWindows(const bool resetFilenames) {
1673
    // first check if net must be deleted
1674
    if (myNet != nullptr) {
1675
        delete myNet;
1676
        myNet = nullptr;
1677
        GeoConvHelper::resetLoaded();
1678
    }
1679
    // reset default filenames
1680
    if (resetFilenames) {
1681
        myFileBucketHandler->resetDefaultFilenames();
1682
    }
1683
    // check if view has to be saved
1684
    if (myViewNet) {
1685
        myViewNet->saveVisualizationSettings();
1686
        // clear decals
1687
        myViewNet->getDecals().clear();
1688
    }
1689
    // lock tracker
1690
    myTrackerLock.lock();
1691
    // remove trackers and other external windows
1692
    while (!myGLWindows.empty()) {
1693
        delete myGLWindows.front();
1694
    }
1695
    myViewNet = nullptr;
1696
    for (FXMainWindow* const window : myTrackerWindows) {
1697
        window->destroy();
1698
        delete window;
1699
    }
1700
    myTrackerWindows.clear();
1701
    // reset the caption
1702
    setTitle(myTitlePrefix);
1703
    // unlock tracker
1704
    myTrackerLock.unlock();
1705
    // remove coordinate information
1706
    myGeoCoordinate->setText(TL("N/A"));
1707
    myCartesianCoordinate->setText(TL("N/A"));
1708
    myTestCoordinate->setText(TL("N/A"));
1709
    myTestFrame->hide();
1710
    myMessageWindow->unregisterMsgHandlers();
1711
    // Reset textures
1712
    GUITextureSubSys::resetTextures();
1713
    // reset fonts
1714
    GLHelper::resetFont();
1715
}
1716

1717

1718
FXCursor*
1719
GNEApplicationWindow::getDefaultCursor() {
1720
    return getApp()->getDefaultCursor(DEF_ARROW_CURSOR);
1721
}
1722

1723

1724
void
1725
GNEApplicationWindow::loadOptionOnStartup() {
1726
    auto& neteditOptions = OptionsCont::getOptions();
1727
    if (neteditOptions.getBool("new")) {
1728
        // save output file
1729
        const auto outputFile = neteditOptions.getString("output-file");
1730
        // create new network reset all options
1731
        createNewNetwork();
1732
        // check if define network file using this ouput file
1733
        if (!outputFile.empty()) {
1734
            myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, outputFile);
1735
        }
1736
    } else {
1737
        // set flag
1738
        myAmLoading = true;
1739
        // set status bar
1740
        setStatusBarText(TL("Loading console arguments."));
1741
        // load console arguments
1742
        myLoadThread->loadNetworkOrConfig();
1743
        // add it into recent networks and configs
1744
        if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETWORK)) {
1745
            myMenuBarFile.myRecentNetworks.appendFile(FXPath::absolute(myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK).c_str()));
1746
        }
1747
        if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG)) {
1748
            myMenuBarFile.myRecentConfigs.appendFile(FXPath::absolute(myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG).c_str()));
1749
        }
1750
    }
1751
}
1752

1753

1754
void
1755
GNEApplicationWindow::createNewNetwork() {
1756
    auto& neteditOptions = OptionsCont::getOptions();
1757
    // save windows size and position
1758
    storeWindowSizeAndPos();
1759
    // enable loading flag and disable reloading flag
1760
    myAmLoading = true;
1761
    // recenter view
1762
    gSchemeStorage.saveViewport(0, 0, -1, 0);
1763
    // fill (reset) all options
1764
    GNELoadThread::fillOptions(neteditOptions);
1765
    // set default options defined in GNELoadThread::setDefaultOptions(...)
1766
    GNELoadThread::setDefaultOptions(neteditOptions);
1767
    // update status bar
1768
    setStatusBarText(TL("Creating new network."));
1769
    // create new network
1770
    myLoadThread->newNetwork();
1771
    // update window
1772
    update();
1773
}
1774

1775

1776
void
1777
GNEApplicationWindow::loadNetwork(const std::string& networkFile) {
1778
    if (networkFile.empty()) {
1779
        WRITE_ERROR(TL("Trying to load an empty network."));
1780
    } else {
1781
        auto& neteditOptions = OptionsCont::getOptions();
1782
        // stop test before calling load thread
1783
        if (myInternalTest) {
1784
            myInternalTest->stopTests();
1785
        }
1786
        // store size, position and viewport
1787
        storeWindowSizeAndPos();
1788
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1789
        // set flag
1790
        myAmLoading = true;
1791
        // fill (reset) all options
1792
        myLoadThread->fillOptions(neteditOptions);
1793
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1794
        myLoadThread->setDefaultOptions(neteditOptions);
1795
        // update default net file
1796
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, networkFile);
1797
        // set status bar
1798
        setStatusBarText(TLF("Loading network file '%'.", networkFile));
1799
        // load network
1800
        myLoadThread->loadNetworkOrConfig();
1801
        // add it into recent nets
1802
        myMenuBarFile.myRecentNetworks.appendFile(networkFile.c_str());
1803
    }
1804
}
1805

1806

1807
void
1808
GNEApplicationWindow::loadConfiguration(const std::string& configurationFile) {
1809
    if (configurationFile.empty()) {
1810
        WRITE_ERROR(TL("Trying to load an empty configuration."));
1811
    } else {
1812
        auto& neteditOptions = OptionsCont::getOptions();
1813
        // store size, position and viewport
1814
        storeWindowSizeAndPos();
1815
        gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1816
        // set flag
1817
        myAmLoading = true;
1818
        // fill (reset) all options
1819
        myLoadThread->fillOptions(neteditOptions);
1820
        // set default options defined in GNELoadThread::setDefaultOptions(...)
1821
        myLoadThread->setDefaultOptions(neteditOptions);
1822
        // set file to load
1823
        neteditOptions.resetWritable();
1824
        neteditOptions.set("configuration-file", configurationFile);
1825
        // set status bar
1826
        setStatusBarText(TLF("Loading configuration file '%'.", configurationFile));
1827
        // load config
1828
        myLoadThread->loadNetworkOrConfig();
1829
        // add it into recent configs
1830
        myMenuBarFile.myRecentConfigs.appendFile(configurationFile.c_str());
1831
    }
1832
}
1833

1834

1835
void
1836
GNEApplicationWindow::loadOSM(const std::string& OSMFile) {
1837
    auto& neteditOptions = OptionsCont::getOptions();
1838
    // store size, position and viewport
1839
    storeWindowSizeAndPos();
1840
    gSchemeStorage.saveViewport(0, 0, -1, 0); // recenter view
1841
    // set flag
1842
    myAmLoading = true;
1843
    // fill (reset) all options
1844
    myLoadThread->fillOptions(neteditOptions);
1845
    // set default options defined in GNELoadThread::setDefaultOptions(...)
1846
    myLoadThread->setDefaultOptions(neteditOptions);
1847
    // recommended osm options
1848
    // https://sumo.dlr.de/wiki/Networks/Import/OpenStreetMap#Recommended_NETCONVERT_Options
1849
    neteditOptions.set("osm-files", OSMFile);
1850
    neteditOptions.set("geometry.remove", "true");
1851
    neteditOptions.set("ramps.guess", "true");
1852
    neteditOptions.set("junctions.join", "true");
1853
    neteditOptions.set("tls.guess-signals", "true");
1854
    neteditOptions.set("tls.discard-simple", "true");
1855
    // open netedit options dialog
1856
    const GNENeteditOptionsDialog neteditOptionsDialog(this, neteditOptions, myOriginalNeteditOptions);
1857
    // open wizard dialog
1858
    if (neteditOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) {
1859
        // needed to set projection parameters
1860
        NIFrame::checkOptions(neteditOptions);
1861
        // set file to load
1862
        neteditOptions.resetWritable();
1863
        neteditOptions.set("configuration-file", OSMFile);
1864
        // set status bar
1865
        setStatusBarText(TLF("Loading OSM file '%'.", OSMFile));
1866
        // load config
1867
        myLoadThread->loadNetworkOrConfig();
1868
    }
1869
}
1870

1871
void
1872
GNEApplicationWindow::setStatusBarText(const std::string& statusBarText) {
1873
    myStatusbar->getStatusLine()->setText(statusBarText.c_str());
1874
    myStatusbar->getStatusLine()->setNormalText(statusBarText.c_str());
1875
}
1876

1877

1878
long
1879
GNEApplicationWindow::computeJunctionWithVolatileOptions(FXObject* sender, FXSelector sel, void* ptr) {
1880
    // open question dialog box
1881
    const GNEQuestionBasicDialog questionDialog(this, GNEDialog::Buttons::YES_NO,
1882
            TL("Recompute with volatile options"),
1883
            TL("Changes produced in the net due a recomputing with"),
1884
            TL("volatile options cannot be undone. Continue?"));
1885
    // check result
1886
    if (questionDialog.getResult() == GNEDialog::Result::ACCEPT) {
1887
        // save all elements
1888
        onCmdSaveAdditionalElements(sender, sel, ptr);
1889
        onCmdSaveDemandElements(sender, sel, ptr);
1890
        onCmdSaveDataElements(sender, sel, ptr);
1891
        onCmdSaveMeanDataElements(sender, sel, ptr);
1892
        // compute with volatile options
1893
        myNet->computeNetwork(this, true, true);
1894
        updateControls();
1895
    }
1896
    return 1;
1897
}
1898

1899

1900
bool
1901
GNEApplicationWindow::consoleOptionsLoaded() {
1902
    if (myConsoleOptionsLoaded) {
1903
        myConsoleOptionsLoaded = false;
1904
        return true;
1905
    } else {
1906
        return false;
1907
    }
1908
}
1909

1910

1911
GNEApplicationWindowHelper::FileBucketHandler*
1912
GNEApplicationWindow::getFileBucketHandler() const {
1913
    return myFileBucketHandler;
1914
}
1915

1916

1917
GNEExternalRunner*
1918
GNEApplicationWindow::getExternalRunner() const {
1919
    return myExternalRunner;
1920
}
1921

1922

1923
void
1924
GNEApplicationWindow::setExternalRunner(GNEExternalRunner* externalRunner) {
1925
    myExternalRunner = externalRunner;
1926
}
1927

1928

1929
long
1930
GNEApplicationWindow::onCmdSetSuperMode(FXObject* sender, FXSelector sel, void* ptr) {
1931
    // check that currently there is a View
1932
    if (myViewNet) {
1933
        myViewNet->onCmdSetSupermode(sender, sel, ptr);
1934
    }
1935
    return 1;
1936
}
1937

1938

1939
long
1940
GNEApplicationWindow::onCmdSetMode(FXObject* sender, FXSelector sel, void* ptr) {
1941
    // check that currently there is a View
1942
    if (myViewNet) {
1943
        myViewNet->onCmdSetMode(sender, sel, ptr);
1944
    }
1945
    return 1;
1946
}
1947

1948

1949
long
1950
GNEApplicationWindow::onCmdLockElements(FXObject*, FXSelector sel, void*) {
1951
    if (myViewNet) {
1952
        // check if we're calling the functions using internal test
1953
        switch (FXSELID(sel)) {
1954
            case MID_GNE_LOCK_JUNCTION:
1955
                myLockMenuCommands.menuCheckLockJunctions->toggleCheck();
1956
                break;
1957
            case MID_GNE_LOCK_EDGE:
1958
                myLockMenuCommands.menuCheckLockEdges->toggleCheck();
1959
                break;
1960
            case MID_GNE_LOCK_LANE:
1961
                myLockMenuCommands.menuCheckLockLanes->toggleCheck();
1962
                break;
1963
            case MID_GNE_LOCK_CONNECTION:
1964
                myLockMenuCommands.menuCheckLockConnections->toggleCheck();
1965
                break;
1966
            case MID_GNE_LOCK_CROSSING:
1967
                myLockMenuCommands.menuCheckLockCrossings->toggleCheck();
1968
                break;
1969
            case MID_GNE_LOCK_WALKINGAREA:
1970
                myLockMenuCommands.menuCheckLockWalkingAreas->toggleCheck();
1971
                break;
1972
            case MID_GNE_LOCK_ADDITIONALELEMENT:
1973
                myLockMenuCommands.menuCheckLockAdditionals->toggleCheck();
1974
                break;
1975
            case MID_GNE_LOCK_WIRE:
1976
                myLockMenuCommands.menuCheckLockWires->toggleCheck();
1977
                break;
1978
            case MID_GNE_LOCK_TAZ:
1979
                myLockMenuCommands.menuCheckLockTAZs->toggleCheck();
1980
                break;
1981
            case MID_GNE_LOCK_POLYGON:
1982
                myLockMenuCommands.menuCheckLockPolygons->toggleCheck();
1983
                break;
1984
            case MID_GNE_LOCK_POI:
1985
                myLockMenuCommands.menuCheckLockPOIs->toggleCheck();
1986
                break;
1987
            case MID_GNE_LOCK_JPS_WALKABLEAREA:
1988
                myLockMenuCommands.menuCheckLockJpsWalkableAreas->toggleCheck();
1989
                break;
1990
            case MID_GNE_LOCK_JPS_OBSTACLE:
1991
                myLockMenuCommands.menuCheckLockJpsObstacles->toggleCheck();
1992
                break;
1993
            case MID_GNE_LOCK_ROUTE:
1994
                myLockMenuCommands.menuCheckLockRoutes->toggleCheck();
1995
                break;
1996
            case MID_GNE_LOCK_VEHICLE:
1997
                myLockMenuCommands.menuCheckLockVehicles->toggleCheck();
1998
                break;
1999
            case MID_GNE_LOCK_PERSON:
2000
                myLockMenuCommands.menuCheckLockPersons->toggleCheck();
2001
                break;
2002
            case MID_GNE_LOCK_PERSONTRIP:
2003
                myLockMenuCommands.menuCheckLockPersonTrips->toggleCheck();
2004
                break;
2005
            case MID_GNE_LOCK_WALK:
2006
                myLockMenuCommands.menuCheckLockWalks->toggleCheck();
2007
                break;
2008
            case MID_GNE_LOCK_RIDE:
2009
                myLockMenuCommands.menuCheckLockRides->toggleCheck();
2010
                break;
2011
            case MID_GNE_LOCK_CONTAINER:
2012
                myLockMenuCommands.menuCheckLockContainers->toggleCheck();
2013
                break;
2014
            case MID_GNE_LOCK_TRANSPORT:
2015
                myLockMenuCommands.menuCheckLockTransports->toggleCheck();
2016
                break;
2017
            case MID_GNE_LOCK_TRANSHIP:
2018
                myLockMenuCommands.menuCheckLockTranships->toggleCheck();
2019
                break;
2020
            case MID_GNE_LOCK_STOP:
2021
                myLockMenuCommands.menuCheckLockStops->toggleCheck();
2022
                break;
2023
            case MID_GNE_LOCK_EDGEDATA:
2024
                myLockMenuCommands.menuCheckLockEdgeDatas->toggleCheck();
2025
                break;
2026
            case MID_GNE_LOCK_EDGERELDATA:
2027
                myLockMenuCommands.menuCheckLockEdgeRelDatas->toggleCheck();
2028
                break;
2029
            case MID_GNE_LOCK_TAZRELDATA:
2030
                myLockMenuCommands.menuCheckLockEdgeTAZRels->toggleCheck();
2031
                break;
2032
            default:
2033
                break;
2034
        }
2035
        myViewNet->getLockManager().updateFlags();
2036
    }
2037
    return 1;
2038
}
2039

2040

2041
long
2042
GNEApplicationWindow::onCmdLockAllElements(FXObject*, FXSelector, void*) {
2043
    // lock all
2044
    myLockMenuCommands.lockAll();
2045
    myViewNet->getLockManager().updateFlags();
2046
    return 1;
2047
}
2048

2049

2050
long
2051
GNEApplicationWindow::onCmdUnlockAllElements(FXObject*, FXSelector, void*) {
2052
    // unlock all
2053
    myLockMenuCommands.unlockAll();
2054
    myViewNet->getLockManager().updateFlags();
2055
    return 1;
2056
}
2057

2058

2059
long
2060
GNEApplicationWindow::onCmdLockSelectElements(FXObject*, FXSelector, void*) {
2061
    if (myViewNet) {
2062
        myViewNet->update();
2063
    }
2064
    return 1;
2065
}
2066

2067

2068
long
2069
GNEApplicationWindow::onUpdLockMenuTitle(FXObject*, FXSelector, void*) {
2070
    if (myViewNet) {
2071
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
2072
            // supermode network
2073
            if ((myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_INSPECT) ||
2074
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_SELECT) ||
2075
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_DELETE) ||
2076
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_CONNECT) ||
2077
                    (myViewNet->getEditModes().networkEditMode == NetworkEditMode::NETWORK_MOVE)) {
2078
                myLockMenuTitle->enable();
2079
            } else {
2080
                myLockMenuTitle->disable();
2081
            }
2082
        } else if (myViewNet->getEditModes().isCurrentSupermodeDemand()) {
2083
            // supermode demand
2084
            if ((myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_INSPECT) ||
2085
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_SELECT) ||
2086
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_DELETE) ||
2087
                    (myViewNet->getEditModes().demandEditMode == DemandEditMode::DEMAND_MOVE)) {
2088
                myLockMenuTitle->enable();
2089
            } else {
2090
                myLockMenuTitle->disable();
2091
            }
2092
        } else if (myViewNet->getEditModes().isCurrentSupermodeData()) {
2093
            // supermode data
2094
            if ((myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_INSPECT) ||
2095
                    (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_SELECT) ||
2096
                    (myViewNet->getEditModes().dataEditMode == DataEditMode::DATA_DELETE)) {
2097
                myLockMenuTitle->enable();
2098
            } else {
2099
                myLockMenuTitle->disable();
2100
            }
2101
        } else {
2102
            myLockMenuTitle->disable();
2103
        }
2104
    } else {
2105
        myLockMenuTitle->disable();
2106
    }
2107
    return 1;
2108
}
2109

2110

2111
long
2112
GNEApplicationWindow::onCmdProcessButton(FXObject* sender, FXSelector sel, void* ptr) {
2113
    // first check if there is a view
2114
    if (myViewNet) {
2115
        // process depending of supermode
2116
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
2117
            // check what FXMenuCommand was called
2118
            switch (FXSELID(sel)) {
2119
                case MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND:
2120
                    myNet->computeNetwork(this, true, false);
2121
                    updateControls();
2122
                    break;
2123
                case MID_HOTKEY_SHIFT_F5_COMPUTEJUNCTIONS_VOLATILE:
2124
                    computeJunctionWithVolatileOptions(sender, sel, ptr);
2125
                    break;
2126
                case MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES:
2127
                    myNet->removeSolitaryJunctions(myUndoList);
2128
                    break;
2129
                case MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES:
2130
                    myNet->joinSelectedJunctions(myUndoList);
2131
                    break;
2132
                case MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS:
2133
                    myNet->cleanInvalidCrossings(myUndoList);
2134
                    break;
2135
                default:
2136
                    break;
2137
            }
2138
        } else if (myViewNet->getEditModes().isCurrentSupermodeDemand()) {
2139
            // check what FXMenuCommand was called
2140
            switch (FXSELID(sel)) {
2141
                case MID_HOTKEY_F5_COMPUTE_NETWORK_DEMAND:
2142
                    myNet->computeDemandElements(this);
2143
                    updateControls();
2144
                    break;
2145
                case MID_HOTKEY_F6_CLEAN_SOLITARYJUNCTIONS_UNUSEDROUTES:
2146
                    myNet->cleanUnusedRoutes(myUndoList);
2147
                    break;
2148
                case MID_HOTKEY_F7_JOIN_SELECTEDJUNCTIONS_ROUTES:
2149
                    myNet->joinRoutes(myUndoList);
2150
                    break;
2151
                case MID_HOTKEY_SHIFT_F7_ADJUST_PERSON_PLANS:
2152
                    myNet->adjustPersonPlans(myUndoList);
2153
                    break;
2154
                case MID_HOTKEY_F8_CLEANINVALID_CROSSINGS_DEMANDELEMENTS:
2155
                    myNet->cleanInvalidDemandElements(myUndoList);
2156
                    break;
2157
                default:
2158
                    break;
2159
            }
2160
        }
2161
        // refresh to update undo-redo button
2162
        myViewNet->getViewParent()->getGNEAppWindows()->forceRefresh();
2163
    }
2164
    return 1;
2165
}
2166

2167

2168
long
2169
GNEApplicationWindow::onCmdNewWindow(FXObject*, FXSelector sel, void* /*ptr*/) {
2170
    // get extra arguments
2171
    std::string extraArg;
2172
    if (sel == MID_GNE_POSTPROCESSINGNETGENERATE) {
2173
        extraArg = " -s \"" + StringUtils::escapeShell(myNetgenerateOptions.getValueString("output-file")) + "\" ";
2174
    }
2175
    FXRegistry reg("SUMO netedit", "netedit");
2176
    std::string netedit = "netedit";
2177
    const char* sumoPath = getenv("SUMO_HOME");
2178
    if (sumoPath != nullptr) {
2179
#ifdef DEBUG
2180
        std::string newPath = std::string(sumoPath) + "/bin/neteditD";
2181
#else
2182
        std::string newPath = std::string(sumoPath) + "/bin/netedit";
2183
#endif
2184
        if (FileHelpers::isReadable(newPath) || FileHelpers::isReadable(newPath + ".exe")) {
2185
            netedit = "\"" + newPath + "\"";
2186
        }
2187
    }
2188
    std::string cmd = netedit + extraArg;
2189
    // start in background
2190
#ifndef WIN32
2191
    cmd = cmd + " &";
2192
#else
2193
    // see "help start" for the parameters
2194
    cmd = "start /B \"\" " + cmd;
2195
#endif
2196
    WRITE_MESSAGE(TLF("Running '%'.", cmd));
2197
    // yay! fun with dangerous commands... Never use this over the internet
2198
    SysUtils::runHiddenCommand(cmd);
2199
    return 1;
2200
}
2201

2202

2203
long
2204
GNEApplicationWindow::onCmdOpenSUMOGUI(FXObject* obj, FXSelector sel, void* ptr) {
2205
    // input parameters
2206
    std::string inputParameters;
2207
    // if we have only a network, then load directly without creating a SumoConfig
2208
    if ((myNet->getAttributeCarriers()->getNumberOfAdditionals() == 0 && myNet->getAttributeCarriers()->getNumberOfDemandElements() == 0) ||
2209
            ((myEditMenuCommands.loadAdditionalsInSUMOGUI->getCheck() == FALSE) && (myEditMenuCommands.loadDemandInSUMOGUI->getCheck() == FALSE))) {
2210
        // force save network
2211
        if (onCmdSaveNetwork(obj, sel, ptr) == 0) {
2212
            // network wasn't saved, then stop
2213
            return 0;
2214
        }
2215
        inputParameters = " --registry-viewport -n \"" + myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK) + "\"";
2216
        // write info
2217
        WRITE_MESSAGE(TLF("Loading network '%' in SUMO-GUI.", myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK)));
2218
    } else {
2219
        // force save SumoConfig
2220
        if (onCmdSaveSumoConfig(obj, sel, ptr) == 0) {
2221
            // SumoConfig wasn't saved, then stop
2222
            return 0;
2223
        }
2224
        inputParameters = " --registry-viewport -c \"" + myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG) + "\"";
2225
        // write info
2226
        WRITE_MESSAGE(TLF("Loading sumo config '%' in SUMO-GUI.", myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG)));
2227
    }
2228
    // save current viewport in registry
2229
    FXRegistry reg("SUMO GUI", "sumo-gui");
2230
    reg.read();
2231
    reg.writeRealEntry("viewport", "x", myViewNet->getChanger().getXPos());
2232
    reg.writeRealEntry("viewport", "y", myViewNet->getChanger().getYPos());
2233
    reg.writeRealEntry("viewport", "z", myViewNet->getChanger().getZPos());
2234
    reg.write();
2235
    // declare executable
2236
    std::string sumoGuiExecutable = "sumo-gui";
2237
    // if SUMO_HOME is defined, update executable
2238
    const char* sumoHome = getenv("SUMO_HOME");
2239
    if (sumoHome != nullptr) {
2240
        std::string newPath = std::string(sumoHome) + "/bin/sumo-gui";
2241
        if (FileHelpers::isReadable(newPath) || FileHelpers::isReadable(newPath + ".exe")) {
2242
            sumoGuiExecutable = "\"" + newPath + "\"";
2243
        }
2244
    }
2245
    // declare command
2246
    std::string cmd = sumoGuiExecutable + inputParameters;
2247
    // start in background
2248
#ifndef WIN32
2249
    cmd = cmd + " &";
2250
#else
2251
    // see "help start" for the parameters
2252
    cmd = "start /B \"\" " + cmd;
2253
#endif
2254
    WRITE_MESSAGE(TLF("Running '%'.", cmd));
2255
    // yay! fun with dangerous commands... Never use this over the internet
2256
    SysUtils::runHiddenCommand(cmd);
2257
    return 1;
2258
}
2259

2260

2261
long
2262
GNEApplicationWindow::onCmdAbort(FXObject*, FXSelector, void*) {
2263
    // check that view exists
2264
    if (myViewNet) {
2265
        // first check if we're selecting a subset of edges in TAZ Frame
2266
        if (myViewNet->getViewParent()->getTAZFrame()->getTAZSelectionStatisticsModule()->getEdgeAndTAZChildrenSelected().size() > 0) {
2267
            // clear current selection
2268
            myViewNet->getViewParent()->getTAZFrame()->getTAZSelectionStatisticsModule()->clearSelectedEdges();
2269
        } else if (myViewNet->getViewParent()->getInspectorFrame()->shown()) {
2270
            // check if stop select parent
2271
            if (myViewNet->getViewParent()->getInspectorFrame()->getAttributesEditor()->isReparenting()) {
2272
                // and stop select paretn
2273
                myViewNet->getViewParent()->getInspectorFrame()->getAttributesEditor()->abortReparenting();
2274
            } else {
2275
                // clear inspected elements
2276
                myViewNet->getViewParent()->getInspectorFrame()->clearInspection();
2277
            }
2278
        } else {
2279
            // abort current operation
2280
            myViewNet->abortOperation();
2281
        }
2282
    }
2283
    return 1;
2284
}
2285

2286

2287
long
2288
GNEApplicationWindow::onCmdDel(FXObject*, FXSelector, void*) {
2289
    // check that view exists
2290
    if (myViewNet) {
2291
        myViewNet->hotkeyDel();
2292
    }
2293
    return 1;
2294
}
2295

2296

2297
long
2298
GNEApplicationWindow::onCmdEnter(FXObject*, FXSelector, void*) {
2299
    // check that view exists
2300
    if (myViewNet) {
2301
        myViewNet->hotkeyEnter();
2302
    }
2303
    return 1;
2304
}
2305

2306

2307
long
2308
GNEApplicationWindow::onCmdBackspace(FXObject*, FXSelector, void*) {
2309
    // check that view exists
2310
    if (myViewNet) {
2311
        myViewNet->hotkeyBackSpace();
2312
    }
2313
    return 1;
2314
}
2315

2316

2317
long
2318
GNEApplicationWindow::onCmdFocusFrame(FXObject*, FXSelector, void*) {
2319
    // check that view exists
2320
    if (myViewNet) {
2321
        myViewNet->hotkeyFocusFrame();
2322
    }
2323
    return 1;
2324
}
2325

2326

2327
long
2328
GNEApplicationWindow::onCmdClearSelectionShortcut(FXObject*, FXSelector, void*) {
2329
    // check that view exists
2330
    if (myViewNet) {
2331
        myViewNet->getViewParent()->getSelectorFrame()->clearCurrentSelection();
2332
    }
2333
    return 1;
2334
}
2335

2336

2337
long
2338
GNEApplicationWindow::onCmdToggleTimeFormat(FXObject*, FXSelector, void*) {
2339
    // check that view exists
2340
    if (myViewNet) {
2341
        myViewNet->getTimeFormat().switchTimeFormat();
2342
        // refresh flow frames
2343
        if (myViewNet->getViewParent()->getVehicleFrame()->shown()) {
2344
            myViewNet->getViewParent()->getVehicleFrame()->getVehicleAttributesEditor()->refreshAttributesEditor();
2345
        }
2346
        if (myViewNet->getViewParent()->getPersonFrame()->shown()) {
2347
            myViewNet->getViewParent()->getPersonFrame()->getPersonAttributesEditor()->refreshAttributesEditor();
2348
        }
2349
        if (myViewNet->getViewParent()->getContainerFrame()->shown()) {
2350
            myViewNet->getViewParent()->getContainerFrame()->getContainerAttributesEditor()->refreshAttributesEditor();
2351
        }
2352
        // refresh inspector frame
2353
        if (myViewNet->getViewParent()->getInspectorFrame()->shown()) {
2354
            myViewNet->getViewParent()->getInspectorFrame()->refreshInspection();
2355
        }
2356
    }
2357
    return 1;
2358
}
2359

2360

2361
long
2362
GNEApplicationWindow::onUpdToggleTimeFormat(FXObject*, FXSelector, void*) {
2363
    // check that view exists
2364
    if (myViewNet) {
2365
        myViewNet->getTimeFormat().updateButtonLabel();
2366
    }
2367
    return 1;
2368
}
2369

2370

2371
long
2372
GNEApplicationWindow::onCmdRunTests(FXObject*, FXSelector, void*) {
2373
    if (myInternalTest && !myInternalTest->isRunning()) {
2374
        myInternalTest->runNeteditInternalTests(this);
2375
    }
2376
    return 1;
2377
}
2378

2379

2380
long
2381
GNEApplicationWindow::onUpdRequireViewNet(FXObject* sender, FXSelector, void*) {
2382
    // enable or disable sender element depending of viewNet
2383
    return sender->handle(this, myViewNet ? FXSEL(SEL_COMMAND, ID_ENABLE) : FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2384
}
2385

2386

2387
long
2388
GNEApplicationWindow::onUpdRequireRecomputing(FXObject*, FXSelector, void*) {
2389
    updateRecomputingLabel();
2390
    return 1;
2391
}
2392

2393

2394
long
2395
GNEApplicationWindow::onCmdRunNetgenerate(FXObject*, FXSelector, void*) {
2396
    GNERunNetgenerateDialog netgenerateDialog(this, &myNetgenerateOptions);
2397
    return 1;
2398
}
2399

2400

2401
long
2402
GNEApplicationWindow::onCmdPostprocessingNetgenerate(FXObject* obj, FXSelector, void* ptr) {
2403
    return onCmdNewWindow(obj, MID_GNE_POSTPROCESSINGNETGENERATE, ptr);
2404
}
2405

2406

2407
long
2408
GNEApplicationWindow::onCmdEditViewport(FXObject*, FXSelector, void*) {
2409
    // check that view exists
2410
    if (myViewNet) {
2411
        myViewNet->showViewportEditor();
2412
    }
2413
    return 1;
2414
}
2415

2416

2417
long
2418
GNEApplicationWindow::onCmdEditViewScheme(FXObject*, FXSelector, void*) {
2419
    // check that view exists
2420
    if (myViewNet) {
2421
        myViewNet->showViewschemeEditor();
2422
    }
2423
    return 1;
2424
}
2425

2426

2427
long
2428
GNEApplicationWindow::onCmdToggleGrid(FXObject* sender, FXSelector sel, void* ptr) {
2429
    // check that view exists
2430
    if (myViewNet) {
2431
        // Call manually toggle grid function
2432
        myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
2433
    }
2434
    return 1;
2435
}
2436

2437

2438
long
2439
GNEApplicationWindow::onCmdToggleDrawJunctionShape(FXObject* sender, FXSelector sel, void* ptr) {
2440
    // check that view exists
2441
    if (myViewNet) {
2442
        // Call manually toggle junction shape function
2443
        myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
2444
    }
2445
    return 1;
2446
}
2447

2448

2449
long
2450
GNEApplicationWindow::onCmdToggleFrontElement(FXObject*, FXSelector, void*) {
2451
    if (myViewNet) {
2452
        // check if all element are front
2453
        bool allFront = true;
2454
        for (auto& AC : myViewNet->getInspectedElements().getACs()) {
2455
            if (!AC->isMarkedForDrawingFront()) {
2456
                allFront = false;
2457
                break;
2458
            }
2459
        }
2460
        // first unfront all elements
2461
        myViewNet->getMarkFrontElements().unmarkAll();
2462
        // only mark front elements if we have at least one non-front element
2463
        if (!allFront) {
2464
            for (auto& AC : myViewNet->getInspectedElements().getACs()) {
2465
                AC->markForDrawingFront();
2466
            }
2467
        }
2468
        myViewNet->update();
2469
        myViewNet->getViewParent()->getInspectorFrame()->getAttributesEditor()->getNeteditAttributesEditor()->refreshAttributesEditor();
2470
    }
2471
    return 1;
2472
}
2473

2474

2475
long
2476
GNEApplicationWindow::onCmdToggleEditOptions(FXObject* sender, FXSelector sel, void* /* ptr */) {
2477
    // first check that we have a ViewNet
2478
    if (myViewNet) {
2479
        // first check what selector was called
2480
        int numericalKeyPressed = sel - FXSEL(SEL_COMMAND, MID_HOTKEY_ALT_0_TOGGLEEDITOPTION) - 1;
2481
        // check that numericalKeyPressed is valid
2482
        if ((numericalKeyPressed < 0) || (numericalKeyPressed > 10)) {
2483
            return 0;
2484
        }
2485
        // declare a vector in which save visible menu commands
2486
        std::vector<MFXCheckableButton*> visibleMenuCommands;
2487
        // get common, network and demand visible menu commands
2488
        myViewNet->getNetworkViewOptions().getVisibleNetworkMenuCommands(visibleMenuCommands);
2489
        myViewNet->getDemandViewOptions().getVisibleDemandMenuCommands(visibleMenuCommands);
2490
        myViewNet->getDataViewOptions().getVisibleDataMenuCommands(visibleMenuCommands);
2491
        // now check that numericalKeyPressed isn't greater than visible view options
2492
        if (numericalKeyPressed >= (int)visibleMenuCommands.size()) {
2493
            return 0;
2494
        }
2495
        // toggle edit options
2496
        if (GNEApplicationWindowHelper::toggleEditOptionsNetwork(myViewNet,
2497
                visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2498
            return 1;
2499
        } else if (GNEApplicationWindowHelper::toggleEditOptionsDemand(myViewNet,
2500
                   visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2501
            return 1;
2502
        } else if (GNEApplicationWindowHelper::toggleEditOptionsData(myViewNet,
2503
                   visibleMenuCommands.at(numericalKeyPressed), sender, sel)) {
2504
            return 1;
2505
        }
2506
    }
2507
    return 0;
2508
}
2509

2510

2511
long
2512
GNEApplicationWindow::onCmdHelp(FXObject*, FXSelector, void*) {
2513
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/netedit.html");
2514
    return 1;
2515
}
2516

2517

2518
long
2519
GNEApplicationWindow::onCmdChangelog(FXObject*, FXSelector, void*) {
2520
    // update in every version
2521
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/ChangeLog.html");
2522
    return 1;
2523
}
2524

2525

2526
long
2527
GNEApplicationWindow::onCmdHotkeys(FXObject*, FXSelector, void*) {
2528
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/Netedit/shortcuts.html");
2529
    return 1;
2530
}
2531

2532

2533
long
2534
GNEApplicationWindow::onCmdToggleComputeNetworkData(FXObject*, FXSelector, void*) {
2535
    if (myProcessingMenuCommands.menuCheckRecomputeDataMode->getCheck() == TRUE) {
2536
        return getApp()->reg().writeBoolEntry("NETEDIT", "RecomputeData", true);
2537
    } else {
2538
        return getApp()->reg().writeBoolEntry("NETEDIT", "RecomputeData", false);
2539
    }
2540
}
2541

2542

2543
long
2544
GNEApplicationWindow::onCmdToggleUndoRedo(FXObject*, FXSelector, void*) {
2545
    if (myEditMenuCommands.menuCheckAllowUndoRedo->getCheck() == TRUE) {
2546
        myAllowUndoRedo = true;
2547
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedo", true);
2548
    } else {
2549
        myAllowUndoRedo = false;
2550
        // drop undo-redo list after changing flag
2551
        myUndoList->clear();
2552
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedo", false);
2553
    }
2554
}
2555

2556

2557
long
2558
GNEApplicationWindow::onCmdToggleUndoRedoLoading(FXObject*, FXSelector, void*) {
2559
    if (myFileMenuCommands.menuCheckAllowUndoRedoLoading->getCheck() == TRUE) {
2560
        myAllowUndoRedoLoading = true;
2561
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedoLoading", true);
2562
    } else {
2563
        myAllowUndoRedoLoading = false;
2564
        return getApp()->reg().writeBoolEntry("NETEDIT", "AllowUndoRedoLoading", false);
2565
    }
2566
}
2567

2568

2569
long
2570
GNEApplicationWindow::onCmdTutorial(FXObject*, FXSelector, void*) {
2571
    MFXLinkLabel::fxexecute("https://sumo.dlr.de/docs/Tutorials/index.html");
2572
    return 1;
2573
}
2574

2575

2576
long
2577
GNEApplicationWindow::onCmdFeedback(FXObject*, FXSelector, void*) {
2578
    // create and open feedback dialog
2579
    GUIDialog_Feedback* feedback = new GUIDialog_Feedback(this);
2580
    feedback->create();
2581
    feedback->show(PLACEMENT_OWNER);
2582
    return 1;
2583
}
2584

2585

2586
long
2587
GNEApplicationWindow::onCmdOpenOptionsDialog(FXObject*, FXSelector, void*) {
2588
    auto& neteditOptions = OptionsCont::getOptions();
2589
    // open netedit option dialog
2590
    const GNENeteditOptionsDialog neteditOptionsDialog(this, neteditOptions, myOriginalNeteditOptions);
2591
    // continue depending of result
2592
    if (neteditOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) {
2593
        NIFrame::checkOptions(neteditOptions); // needed to set projection parameters
2594
        NBFrame::checkOptions(neteditOptions);
2595
        NWFrame::checkOptions(neteditOptions);
2596
        SystemFrame::checkOptions(neteditOptions); // needed to set precision
2597
        // check if mark netedit config as unsaved
2598
        if (neteditOptionsDialog.isOptionModified() && myNet) {
2599
            myNet->getSavingStatus()->requireSaveNeteditConfig();
2600
        }
2601
    }
2602
    return 1;
2603
}
2604

2605

2606
long
2607
GNEApplicationWindow::onCmdOpenSumoOptionsDialog(FXObject*, FXSelector, void*) {
2608
    // open sumo option dialog
2609
    const GNESumoOptionsDialog sumoOptionsDialog(this, mySumoOptions, myOriginalSumoOptions);
2610
    // continue depending of result
2611
    if ((sumoOptionsDialog.getResult() == GNEDialog::Result::ACCEPT) && sumoOptionsDialog.isOptionModified() && myNet) {
2612
        myNet->getSavingStatus()->requireSaveSumoConfig();
2613
    }
2614
    return 1;
2615
}
2616

2617

2618
long
2619
GNEApplicationWindow::onCmdOpenNetgenerateDialog(FXObject*, FXSelector, void*) {
2620
    GNENetgenerateDialog(this);
2621
    return 1;
2622
}
2623

2624

2625
long
2626
GNEApplicationWindow::onCmdOpenNetgenerateOptionsDialog(FXObject*, FXSelector, void*) {
2627
    // open netgenerate options dialog
2628
    GNENetgenerateOptionsDialog(this, myNetgenerateOptions, myOriginalNetgenerateOptions);
2629
    return 1;
2630
}
2631

2632

2633
long
2634
GNEApplicationWindow::onCmdUndo(FXObject* sender, FXSelector, void*) {
2635
    // Check conditions
2636
    if (myViewNet == nullptr) {
2637
        return 0;
2638
    } else if ((myInternalTest != sender) && !myEditMenuCommands.undoLastChange->isEnabled()) {
2639
        return 0;
2640
    } else {
2641
        // check supermode (currently ignore supermode data)
2642
        if ((myViewNet->getUndoList()->getUndoSupermode() != Supermode::DATA) &&
2643
                (myViewNet->getUndoList()->getUndoSupermode() != myViewNet->getEditModes().currentSupermode)) {
2644
            // abort if user doesn't press "yes"
2645
            if (!myViewNet->aksChangeSupermode(TL("Undo"), myViewNet->getUndoList()->getUndoSupermode())) {
2646
                return 0;
2647
            }
2648
        }
2649
        myViewNet->getUndoList()->undo();
2650
        // update current show frame after undo
2651
        if (myViewNet->getViewParent()->getCurrentShownFrame()) {
2652
            myViewNet->getViewParent()->getCurrentShownFrame()->updateFrameAfterUndoRedo();
2653
        }
2654
        // update file bucket options (needed to maintain integrity)
2655
        myFileBucketHandler->updateOptions();
2656
        // update manually undo/redo menu commands (see #6005)
2657
        onUpdUndo(myEditMenuCommands.undoLastChange, 0, 0);
2658
        onUpdRedo(myEditMenuCommands.redoLastChange, 0, 0);
2659
        // update toolbar undo-redo buttons
2660
        myViewNet->getViewParent()->updateUndoRedoButtons();
2661
        return 1;
2662
    }
2663
}
2664

2665

2666
long
2667
GNEApplicationWindow::onCmdRedo(FXObject* sender, FXSelector, void*) {
2668
    // Check conditions
2669
    if (myViewNet == nullptr) {
2670
        return 0;
2671
    } else if ((myInternalTest != sender) && !myEditMenuCommands.redoLastChange->isEnabled()) {
2672
        return 0;
2673
    } else {
2674
        // check supermode (currently ignore supermode data)
2675
        if ((myViewNet->getUndoList()->getRedoSupermode() != Supermode::DATA) &&
2676
                (myViewNet->getUndoList()->getRedoSupermode() != myViewNet->getEditModes().currentSupermode)) {
2677
            // abort if user doesn't press "yes"
2678
            if (!myViewNet->aksChangeSupermode(TL("Redo"), myViewNet->getUndoList()->getRedoSupermode())) {
2679
                return 0;
2680
            }
2681
        }
2682
        myViewNet->getUndoList()->redo();
2683
        // update current show frame after redo
2684
        if (myViewNet->getViewParent()->getCurrentShownFrame()) {
2685
            myViewNet->getViewParent()->getCurrentShownFrame()->updateFrameAfterUndoRedo();
2686
        }
2687
        // update file bucket options (needed to maintain integrity)
2688
        myFileBucketHandler->updateOptions();
2689
        // update manually undo/redo menu commands (see #6005)
2690
        onUpdUndo(myEditMenuCommands.undoLastChange, 0, 0);
2691
        onUpdRedo(myEditMenuCommands.redoLastChange, 0, 0);
2692
        // update toolbar undo-redo buttons
2693
        myViewNet->getViewParent()->updateUndoRedoButtons();
2694
        return 1;
2695
    }
2696
}
2697

2698

2699
long
2700
GNEApplicationWindow::onCmdOpenUndoListDialog(FXObject*, FXSelector, void*) {
2701
    // open UndoList Dialog
2702
    GNEUndoListDialog(this);
2703
    return 1;
2704
}
2705

2706

2707
long
2708
GNEApplicationWindow::onUpdOpenUndoListDialog(FXObject* sender, FXSelector, void*) {
2709
    // check if net exist and there is something to undo/redo
2710
    if (myNet && (myEditMenuCommands.undoLastChange->isEnabled() || myEditMenuCommands.redoLastChange->isEnabled())) {
2711
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2712
    } else {
2713
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2714
    }
2715
    return 1;
2716
}
2717

2718

2719
long
2720
GNEApplicationWindow::onCmdComputePathManager(FXObject*, FXSelector, void*) {
2721
    // first check viewNet
2722
    if (myViewNet && !myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2723
        // update demand path calculator
2724
        myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->updatePathCalculator();
2725
    }
2726
    return 1;
2727
}
2728

2729

2730
long
2731
GNEApplicationWindow::onCmdCut(FXObject*, FXSelector, void*) {
2732
    // Prepared for #6042
2733
    return 1;
2734
}
2735

2736

2737
long
2738
GNEApplicationWindow::onCmdCopy(FXObject*, FXSelector, void*) {
2739
    // Prepared for #6042
2740
    return 1;
2741
}
2742

2743

2744
long
2745
GNEApplicationWindow::onCmdPaste(FXObject*, FXSelector, void*) {
2746
    // Prepared for #6042
2747
    return 1;
2748
}
2749

2750

2751
long
2752
GNEApplicationWindow::onCmdSetTemplate(FXObject*, FXSelector, void*) {
2753
    // first check if myViewNet exist
2754
    if (myViewNet) {
2755
        // call set template in inspector frame
2756
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->setTemplate();
2757
    }
2758
    return 1;
2759
}
2760

2761

2762
long
2763
GNEApplicationWindow::onCmdCopyTemplate(FXObject*, FXSelector, void*) {
2764
    // first check if myViewNet exist
2765
    if (myViewNet) {
2766
        // call copy template in inspector frame
2767
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->copyTemplate();
2768
    }
2769
    return 1;
2770
}
2771

2772

2773
long
2774
GNEApplicationWindow::onCmdClearTemplate(FXObject*, FXSelector, void*) {
2775
    // first check if myViewNet exist
2776
    if (myViewNet) {
2777
        // call clear template in inspector frame
2778
        myViewNet->getViewParent()->getInspectorFrame()->getTemplateEditor()->clearTemplate();
2779
    }
2780
    return 1;
2781
}
2782

2783

2784
long
2785
GNEApplicationWindow::onUpdNeedsNetwork(FXObject* sender, FXSelector, void*) {
2786
    // check if net exist
2787
    if (myNet) {
2788
        myFileMenuCommands.enableMenuCascades();
2789
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2790
    } else {
2791
        myFileMenuCommands.disableMenuCascades();
2792
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2793
    }
2794
}
2795

2796

2797
long
2798
GNEApplicationWindow::onUpdNeedsNetworkElement(FXObject* sender, FXSelector, void*) {
2799
    // check if at least there is one edge in the network
2800
    if (myNet && (myNet->getAttributeCarriers()->getEdges().size() > 0)) {
2801
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2802
    } else {
2803
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2804
    }
2805
}
2806

2807

2808
long
2809
GNEApplicationWindow::onUpdNeedsFrontElement(FXObject* sender, FXSelector, void*) {
2810
    // check if net, viewnet and front attribute exist
2811
    if (myViewNet && (myViewNet->getInspectedElements().getACs().size() > 0)) {
2812
        // check if all element are front
2813
        bool allFront = true;
2814
        for (auto& AC : myViewNet->getInspectedElements().getACs()) {
2815
            if (!AC->isMarkedForDrawingFront()) {
2816
                allFront = false;
2817
                break;
2818
            }
2819
        }
2820
        // set button text depending of all selected
2821
        if (allFront) {
2822
            myEditMenuCommands.toggleFrontElement->setText(TL("Unfront element"));
2823
            myEditMenuCommands.toggleFrontElement->setTipText(TL("Unfront inspected elements"));
2824
        } else {
2825
            myEditMenuCommands.toggleFrontElement->setText(TL("Front element"));
2826
            myEditMenuCommands.toggleFrontElement->setTipText(TL("Mark element to be drawn above everything else"));
2827
        }
2828
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2829
    } else if (myViewNet && (myViewNet->getMarkFrontElements().getACs().size() > 0)) {
2830
        myEditMenuCommands.toggleFrontElement->setText(TL("Unfront all element"));
2831
        myEditMenuCommands.toggleFrontElement->setTipText(TL("Unfront all elements"));
2832
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2833
    } else {
2834
        myEditMenuCommands.toggleFrontElement->setText(TL("Front element (only inspected elements)"));
2835
        myEditMenuCommands.toggleFrontElement->setTipText(TL("Mark element to be drawn above everything else"));
2836
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2837
    }
2838
}
2839

2840

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

2852

2853
long
2854
GNEApplicationWindow::onUpdSaveAdditionalElements(FXObject* sender, FXSelector, void*) {
2855
    if (myNet == nullptr) {
2856
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2857
    } else if (myNet->getViewParent()->getTAZFrame()->getTAZSaveChangesModule()->isChangesPending()) {
2858
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2859
    } else {
2860
        return sender->handle(this, myNet->getSavingStatus()->isAdditionalsSaved() ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2861
    }
2862
}
2863

2864

2865
long
2866
GNEApplicationWindow::onUpdSaveAdditionalElementsUnified(FXObject* sender, FXSelector, void*) {
2867
    if (myNet == nullptr) {
2868
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2869
    } else if (myNet->getAttributeCarriers()->getNumberOfAdditionals() == 0) {
2870
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2871
    } else {
2872
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2873
    }
2874
}
2875

2876

2877
long
2878
GNEApplicationWindow::onUpdSaveJuPedSimElementsAs(FXObject* sender, FXSelector, void*) {
2879
    if (myNet == nullptr) {
2880
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2881
    } else if (myNet->getAttributeCarriers()->getAdditionals().at(GNE_TAG_JPS_WALKABLEAREA).size() > 0) {
2882
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2883
    } else if (myNet->getAttributeCarriers()->getAdditionals().at(GNE_TAG_JPS_OBSTACLE).size() > 0) {
2884
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2885
    } else {
2886
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2887
    }
2888
}
2889

2890

2891
long
2892
GNEApplicationWindow::onUpdSaveDemandElements(FXObject* sender, FXSelector, void*) {
2893
    if (myNet == nullptr) {
2894
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2895
    } else if (myNet->getSavingStatus()->isDemandElementsSaved()) {
2896
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2897
    } else {
2898
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2899
    }
2900

2901
}
2902

2903

2904
long
2905
GNEApplicationWindow::onUpdSaveDemandElementsUnified(FXObject* sender, FXSelector, void*) {
2906
    if (myNet == nullptr) {
2907
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2908
    } else if (myNet->getAttributeCarriers()->getNumberOfDemandElements() == 0) {
2909
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2910
    } else {
2911
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2912
    }
2913
}
2914

2915

2916
long
2917
GNEApplicationWindow::onUpdSaveDataElements(FXObject* sender, FXSelector, void*) {
2918
    if (myNet == nullptr) {
2919
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2920
    } else if (myNet->getSavingStatus()->isDataElementsSaved()) {
2921
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2922
    } else {
2923
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2924
    }
2925

2926
}
2927

2928

2929
long
2930
GNEApplicationWindow::onUpdSaveDataElementsUnified(FXObject* sender, FXSelector, void*) {
2931
    if (myNet == nullptr) {
2932
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2933
    } else if (myNet->getAttributeCarriers()->getDataSets().size() == 0) {
2934
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2935
    } else {
2936
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2937
    }
2938

2939
}
2940

2941

2942
long
2943
GNEApplicationWindow::onUpdSaveMeanDataElements(FXObject* sender, FXSelector, void*) {
2944
    if (myNet == nullptr) {
2945
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2946
    } else if (myNet->getSavingStatus()->isMeanDatasSaved()) {
2947
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2948
    } else {
2949
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2950
    }
2951
}
2952

2953

2954
long
2955
GNEApplicationWindow::onUpdSaveMeanDataElementsUnified(FXObject* sender, FXSelector, void*) {
2956
    if (myNet == nullptr) {
2957
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2958
    } else if (myNet->getAttributeCarriers()->getNumberOfMeanDatas() == 0) {
2959
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2960
    } else {
2961
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2962
    }
2963

2964
}
2965

2966

2967
long
2968
GNEApplicationWindow::onUpdUndo(FXObject* sender, FXSelector sel, void* ptr) {
2969
    return myUndoList->onUpdUndo(sender, sel, ptr);
2970
}
2971

2972

2973
long
2974
GNEApplicationWindow::onUpdRedo(FXObject* sender, FXSelector sel, void* ptr) {
2975
    return myUndoList->onUpdRedo(sender, sel, ptr);
2976
}
2977

2978

2979
long
2980
GNEApplicationWindow::onUpdComputePathManager(FXObject* sender, FXSelector /*sel*/, void* /*ptr*/) {
2981
    // first check viewNet
2982
    if (myViewNet) {
2983
        // check supermode network
2984
        if (myViewNet->getEditModes().isCurrentSupermodeNetwork()) {
2985
            // disable
2986
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2987
        } else if (myViewNet->getNet()->getDemandPathManager()->getPathCalculator()->isPathCalculatorUpdated()) {
2988
            // disable
2989
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2990
        } else {
2991
            // enable
2992
            return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
2993
        }
2994
    } else {
2995
        // disable
2996
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
2997
    }
2998
}
2999

3000

3001
long
3002
GNEApplicationWindow::onCmdToggleViewOption(FXObject* sender, FXSelector sel, void* ptr) {
3003
    // check viewNet
3004
    if (myViewNet) {
3005
        // continue depending of selector
3006
        switch (FXSELID(sel)) {
3007
            // Network
3008
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID:
3009
                return myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
3010
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3011
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
3012
            case MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES:
3013
                return myViewNet->onCmdToggleDrawSpreadVehicles(sender, sel, ptr);
3014
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS:
3015
                return myViewNet->onCmdToggleShowDemandElementsNetwork(sender, sel, ptr);
3016
            case MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES:
3017
                return myViewNet->onCmdToggleSelectEdges(sender, sel, ptr);
3018
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS:
3019
                return myViewNet->onCmdToggleShowConnections(sender, sel, ptr);
3020
            case MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS:
3021
                return myViewNet->onCmdToggleHideConnections(sender, sel, ptr);
3022
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS:
3023
                return myViewNet->onCmdToggleShowAdditionalSubElements(sender, sel, ptr);
3024
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS:
3025
                return myViewNet->onCmdToggleShowTAZElements(sender, sel, ptr);
3026
            case MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION:
3027
                return myViewNet->onCmdToggleExtendSelection(sender, sel, ptr);
3028
            case MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES:
3029
                return myViewNet->onCmdToggleChangeAllPhases(sender, sel, ptr);
3030
            case MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY:
3031
                return myViewNet->onCmdToggleMergeAutomatically(sender, sel, ptr);
3032
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES:
3033
                return myViewNet->onCmdToggleShowJunctionBubbles(sender, sel, ptr);
3034
            case MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION:
3035
                return myViewNet->onCmdToggleMoveElevation(sender, sel, ptr);
3036
            case MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES:
3037
                return myViewNet->onCmdToggleChainEdges(sender, sel, ptr);
3038
            case MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES:
3039
                return myViewNet->onCmdToggleAutoOppositeEdge(sender, sel, ptr);
3040
            // Demand
3041
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID:
3042
                return myViewNet->onCmdToggleShowGrid(sender, sel, ptr);
3043
            case MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3044
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
3045
            case MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES:
3046
                return myViewNet->onCmdToggleDrawSpreadVehicles(sender, sel, ptr);
3047
            case MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED:
3048
                return myViewNet->onCmdToggleHideNonInspecteDemandElements(sender, sel, ptr);
3049
            case MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES:
3050
                return myViewNet->onCmdToggleHideShapes(sender, sel, ptr);
3051
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS:
3052
                return myViewNet->onCmdToggleShowTrips(sender, sel, ptr);
3053
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS:
3054
                return myViewNet->onCmdToggleShowAllPersonPlans(sender, sel, ptr);
3055
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON:
3056
                return myViewNet->onCmdToggleLockPerson(sender, sel, ptr);
3057
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS:
3058
                return myViewNet->onCmdToggleShowAllContainerPlans(sender, sel, ptr);
3059
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER:
3060
                return myViewNet->onCmdToggleLockContainer(sender, sel, ptr);
3061
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES:
3062
                return myViewNet->onCmdToggleShowOverlappedRoutes(sender, sel, ptr);
3063
            // Data
3064
            case MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3065
                return myViewNet->onCmdToggleDrawJunctionShape(sender, sel, ptr);
3066
            case MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS:
3067
                return myViewNet->onCmdToggleShowAdditionals(sender, sel, ptr);
3068
            case MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES:
3069
                return myViewNet->onCmdToggleShowShapes(sender, sel, ptr);
3070
            case MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS:
3071
                return myViewNet->onCmdToggleShowDemandElementsData(sender, sel, ptr);
3072
            case MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING:
3073
                return myViewNet->onCmdToggleTAZRelDrawing(sender, sel, ptr);
3074
            case MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL:
3075
                return myViewNet->onCmdToggleTAZRelDrawing(sender, sel, ptr);
3076
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM:
3077
                return myViewNet->onCmdToggleTAZRelOnlyFrom(sender, sel, ptr);
3078
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO:
3079
                return myViewNet->onCmdToggleTAZRelOnlyTo(sender, sel, ptr);
3080
            default:
3081
                return 0;
3082
        }
3083
    } else {
3084
        return 0;
3085
    }
3086
}
3087

3088

3089
long
3090
GNEApplicationWindow::onUpdToggleViewOption(FXObject* sender, FXSelector sel, void* /*ptr*/) {
3091
    // get menuCheck
3092
    MFXMenuCheckIcon* menuCheck = dynamic_cast<MFXMenuCheckIcon*>(sender);
3093
    // check viewNet
3094
    if (myViewNet && menuCheck) {
3095
        // continue depending of selector
3096
        switch (FXSELID(sel)) {
3097
            // Network
3098
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEGRID:
3099
                if (myViewNet->getNetworkViewOptions().menuCheckToggleGrid->amChecked()) {
3100
                    menuCheck->setCheck(TRUE);
3101
                } else {
3102
                    menuCheck->setCheck(FALSE);
3103
                }
3104
                break;
3105
            case MID_GNE_NETWORKVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3106
                if (myViewNet->getNetworkViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3107
                    menuCheck->setCheck(TRUE);
3108
                } else {
3109
                    menuCheck->setCheck(FALSE);
3110
                }
3111
                break;
3112
            case MID_GNE_NETWORKVIEWOPTIONS_DRAWSPREADVEHICLES:
3113
                if (myViewNet->getNetworkViewOptions().menuCheckDrawSpreadVehicles->amChecked()) {
3114
                    menuCheck->setCheck(TRUE);
3115
                } else {
3116
                    menuCheck->setCheck(FALSE);
3117
                }
3118
                break;
3119
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWDEMANDELEMENTS:
3120
                if (myViewNet->getNetworkViewOptions().menuCheckShowDemandElements->amChecked()) {
3121
                    menuCheck->setCheck(TRUE);
3122
                } else {
3123
                    menuCheck->setCheck(FALSE);
3124
                }
3125
                break;
3126
            case MID_GNE_NETWORKVIEWOPTIONS_SELECTEDGES:
3127
                if (myViewNet->getNetworkViewOptions().menuCheckSelectEdges->amChecked()) {
3128
                    menuCheck->setCheck(TRUE);
3129
                } else {
3130
                    menuCheck->setCheck(FALSE);
3131
                }
3132
                break;
3133
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWCONNECTIONS:
3134
                if (myViewNet->getNetworkViewOptions().menuCheckShowConnections->amChecked()) {
3135
                    menuCheck->setCheck(TRUE);
3136
                } else {
3137
                    menuCheck->setCheck(FALSE);
3138
                }
3139
                break;
3140
            case MID_GNE_NETWORKVIEWOPTIONS_HIDECONNECTIONS:
3141
                if (myViewNet->getNetworkViewOptions().menuCheckHideConnections->amChecked()) {
3142
                    menuCheck->setCheck(TRUE);
3143
                } else {
3144
                    menuCheck->setCheck(FALSE);
3145
                }
3146
                break;
3147
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWSUBADDITIONALS:
3148
                if (myViewNet->getNetworkViewOptions().menuCheckShowAdditionalSubElements->amChecked()) {
3149
                    menuCheck->setCheck(TRUE);
3150
                } else {
3151
                    menuCheck->setCheck(FALSE);
3152
                }
3153
                break;
3154
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWTAZELEMENTS:
3155
                if (myViewNet->getNetworkViewOptions().menuCheckShowTAZElements->amChecked()) {
3156
                    menuCheck->setCheck(TRUE);
3157
                } else {
3158
                    menuCheck->setCheck(FALSE);
3159
                }
3160
                break;
3161
            case MID_GNE_NETWORKVIEWOPTIONS_EXTENDSELECTION:
3162
                if (myViewNet->getNetworkViewOptions().menuCheckExtendSelection->amChecked()) {
3163
                    menuCheck->setCheck(TRUE);
3164
                } else {
3165
                    menuCheck->setCheck(FALSE);
3166
                }
3167
                break;
3168
            case MID_GNE_NETWORKVIEWOPTIONS_CHANGEALLPHASES:
3169
                if (myViewNet->getNetworkViewOptions().menuCheckChangeAllPhases->amChecked()) {
3170
                    menuCheck->setCheck(TRUE);
3171
                } else {
3172
                    menuCheck->setCheck(FALSE);
3173
                }
3174
                break;
3175
            case MID_GNE_NETWORKVIEWOPTIONS_MERGEAUTOMATICALLY:
3176
                if (myViewNet->getNetworkViewOptions().menuCheckMergeAutomatically->amChecked()) {
3177
                    menuCheck->setCheck(TRUE);
3178
                } else {
3179
                    menuCheck->setCheck(FALSE);
3180
                }
3181
                break;
3182
            case MID_GNE_NETWORKVIEWOPTIONS_SHOWBUBBLES:
3183
                if (myViewNet->getNetworkViewOptions().menuCheckShowJunctionBubble->amChecked()) {
3184
                    menuCheck->setCheck(TRUE);
3185
                } else {
3186
                    menuCheck->setCheck(FALSE);
3187
                }
3188
                break;
3189
            case MID_GNE_NETWORKVIEWOPTIONS_MOVEELEVATION:
3190
                if (myViewNet->getNetworkViewOptions().menuCheckMoveElevation->amChecked()) {
3191
                    menuCheck->setCheck(TRUE);
3192
                } else {
3193
                    menuCheck->setCheck(FALSE);
3194
                }
3195
                break;
3196
            case MID_GNE_NETWORKVIEWOPTIONS_CHAINEDGES:
3197
                if (myViewNet->getNetworkViewOptions().menuCheckChainEdges->amChecked()) {
3198
                    menuCheck->setCheck(TRUE);
3199
                } else {
3200
                    menuCheck->setCheck(FALSE);
3201
                }
3202
                break;
3203
            case MID_GNE_NETWORKVIEWOPTIONS_AUTOOPPOSITEEDGES:
3204
                if (myViewNet->getNetworkViewOptions().menuCheckAutoOppositeEdge->amChecked()) {
3205
                    menuCheck->setCheck(TRUE);
3206
                } else {
3207
                    menuCheck->setCheck(FALSE);
3208
                }
3209
                break;
3210
            // Demand
3211
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWGRID:
3212
                if (myViewNet->getDemandViewOptions().menuCheckToggleGrid->amChecked()) {
3213
                    menuCheck->setCheck(TRUE);
3214
                } else {
3215
                    menuCheck->setCheck(FALSE);
3216
                }
3217
                break;
3218
            case MID_GNE_DEMANDVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3219
                if (myViewNet->getDemandViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3220
                    menuCheck->setCheck(TRUE);
3221
                } else {
3222
                    menuCheck->setCheck(FALSE);
3223
                }
3224
                break;
3225
            case MID_GNE_DEMANDVIEWOPTIONS_DRAWSPREADVEHICLES:
3226
                if (myViewNet->getDemandViewOptions().menuCheckDrawSpreadVehicles->amChecked()) {
3227
                    menuCheck->setCheck(TRUE);
3228
                } else {
3229
                    menuCheck->setCheck(FALSE);
3230
                }
3231
                break;
3232
            case MID_GNE_DEMANDVIEWOPTIONS_HIDESHAPES:
3233
                if (myViewNet->getDemandViewOptions().menuCheckHideShapes->amChecked()) {
3234
                    menuCheck->setCheck(TRUE);
3235
                } else {
3236
                    menuCheck->setCheck(FALSE);
3237
                }
3238
                break;
3239
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWTRIPS:
3240
                if (myViewNet->getDemandViewOptions().menuCheckShowAllTrips->amChecked()) {
3241
                    menuCheck->setCheck(TRUE);
3242
                } else {
3243
                    menuCheck->setCheck(FALSE);
3244
                }
3245
                break;
3246
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLPERSONPLANS:
3247
                if (myViewNet->getDemandViewOptions().menuCheckShowAllPersonPlans->amChecked()) {
3248
                    menuCheck->setCheck(TRUE);
3249
                } else {
3250
                    menuCheck->setCheck(FALSE);
3251
                }
3252
                break;
3253
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKPERSON:
3254
                if (myViewNet->getDemandViewOptions().menuCheckLockPerson->amChecked()) {
3255
                    menuCheck->setCheck(TRUE);
3256
                } else {
3257
                    menuCheck->setCheck(FALSE);
3258
                }
3259
                // special case for lock persons
3260
                if (myViewNet->getDemandViewOptions().menuCheckLockPerson->isEnabled()) {
3261
                    menuCheck->enable();
3262
                } else {
3263
                    menuCheck->disable();
3264
                }
3265
                break;
3266
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWALLCONTAINERPLANS:
3267
                if (myViewNet->getDemandViewOptions().menuCheckShowAllContainerPlans->amChecked()) {
3268
                    menuCheck->setCheck(TRUE);
3269
                } else {
3270
                    menuCheck->setCheck(FALSE);
3271
                }
3272
                break;
3273
            case MID_GNE_DEMANDVIEWOPTIONS_LOCKCONTAINER:
3274
                if (myViewNet->getDemandViewOptions().menuCheckLockContainer->amChecked()) {
3275
                    menuCheck->setCheck(TRUE);
3276
                } else {
3277
                    menuCheck->setCheck(FALSE);
3278
                }
3279
                // special case for lock containers
3280
                if (myViewNet->getDemandViewOptions().menuCheckLockContainer->isEnabled()) {
3281
                    menuCheck->enable();
3282
                } else {
3283
                    menuCheck->disable();
3284
                }
3285
                break;
3286
            case MID_GNE_DEMANDVIEWOPTIONS_HIDENONINSPECTED:
3287
                if (myViewNet->getDemandViewOptions().menuCheckHideNonInspectedDemandElements->amChecked()) {
3288
                    menuCheck->setCheck(TRUE);
3289
                } else {
3290
                    menuCheck->setCheck(FALSE);
3291
                }
3292
                break;
3293
            case MID_GNE_DEMANDVIEWOPTIONS_SHOWOVERLAPPEDROUTES:
3294
                if (myViewNet->getDemandViewOptions().menuCheckShowOverlappedRoutes->amChecked()) {
3295
                    menuCheck->setCheck(TRUE);
3296
                } else {
3297
                    menuCheck->setCheck(FALSE);
3298
                }
3299
                break;
3300
            // Data
3301
            case MID_GNE_DATAVIEWOPTIONS_TOGGLEDRAWJUNCTIONSHAPE:
3302
                if (myViewNet->getDataViewOptions().menuCheckToggleDrawJunctionShape->amChecked()) {
3303
                    menuCheck->setCheck(TRUE);
3304
                } else {
3305
                    menuCheck->setCheck(FALSE);
3306
                }
3307
                break;
3308
            case MID_GNE_DATAVIEWOPTIONS_SHOWADDITIONALS:
3309
                if (myViewNet->getDataViewOptions().menuCheckShowAdditionals->amChecked()) {
3310
                    menuCheck->setCheck(TRUE);
3311
                } else {
3312
                    menuCheck->setCheck(FALSE);
3313
                }
3314
                break;
3315
            case MID_GNE_DATAVIEWOPTIONS_SHOWSHAPES:
3316
                if (myViewNet->getDataViewOptions().menuCheckShowShapes->amChecked()) {
3317
                    menuCheck->setCheck(TRUE);
3318
                } else {
3319
                    menuCheck->setCheck(FALSE);
3320
                }
3321
                break;
3322
            case MID_GNE_DATAVIEWOPTIONS_SHOWDEMANDELEMENTS:
3323
                if (myViewNet->getDataViewOptions().menuCheckShowDemandElements->amChecked()) {
3324
                    menuCheck->setCheck(TRUE);
3325
                } else {
3326
                    menuCheck->setCheck(FALSE);
3327
                }
3328
                break;
3329
            case MID_GNE_DATAVIEWOPTIONS_TAZRELDRAWING:
3330
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelDrawing->amChecked()) {
3331
                    menuCheck->setCheck(TRUE);
3332
                } else {
3333
                    menuCheck->setCheck(FALSE);
3334
                }
3335
                break;
3336
            case MID_GNE_DATAVIEWOPTIONS_TAZDRAWFILL:
3337
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZDrawFill->amChecked()) {
3338
                    menuCheck->setCheck(TRUE);
3339
                } else {
3340
                    menuCheck->setCheck(FALSE);
3341
                }
3342
                break;
3343

3344
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYFROM:
3345
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelOnlyFrom->amChecked()) {
3346
                    menuCheck->setCheck(TRUE);
3347
                } else {
3348
                    menuCheck->setCheck(FALSE);
3349
                }
3350
                break;
3351
            case MID_GNE_DATAVIEWOPTIONS_TAZRELONLYTO:
3352
                if (myViewNet->getDataViewOptions().menuCheckToggleTAZRelOnlyTo->amChecked()) {
3353
                    menuCheck->setCheck(TRUE);
3354
                } else {
3355
                    menuCheck->setCheck(FALSE);
3356
                }
3357
                break;
3358
            default:
3359
                break;
3360
        }
3361
    }
3362
    return 0;
3363
}
3364

3365

3366
long
3367
GNEApplicationWindow::onCmdSaveNetwork(FXObject* sender, FXSelector sel, void* ptr) {
3368
    auto& neteditOptions = OptionsCont::getOptions();
3369
    // check if we're forcing to saving additionals
3370
    if (myNet->getSavingStatus()->isNetworkSaved() &&
3371
            neteditOptions.getBool("force-saving")) {
3372
        WRITE_MESSAGE(TL("Force save network"));
3373
    } else if (myNet->getSavingStatus()->isNetworkSaved()) {
3374
        // nothing to save
3375
        return 1;
3376
    }
3377
    // first check if we have to set the output filename
3378
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETWORK)) {
3379
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, myFileBucketHandler->getConfigFilePrefix(".net.xml"));
3380
    }
3381
    // function onCmdSaveNetworkAs must be executed if this is the first save
3382
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETWORK)) {
3383
        return onCmdSaveNetworkAs(sender, sel, ptr);
3384
    } else {
3385
        // always recompute before saving
3386
        myNet->computeNetwork(this);
3387
        bool saved = false;
3388
        try {
3389
            // obtain invalid networkElements (currently only edges or crossings
3390
            std::vector<GNENetworkElement*> invalidNetworkElements;
3391
            // iterate over crossings and edges
3392
            for (const auto& edge : myViewNet->getNet()->getAttributeCarriers()->getEdges()) {
3393
                if (!edge.second->isNetworkElementValid()) {
3394
                    invalidNetworkElements.push_back(edge.second);
3395
                }
3396
            }
3397
            for (const auto& crossing : myViewNet->getNet()->getAttributeCarriers()->getCrossings()) {
3398
                if (!crossing.second->isNetworkElementValid()) {
3399
                    invalidNetworkElements.push_back(crossing.second);
3400
                }
3401
            }
3402
            // if there are invalid network elements, open GNEFixNetworkElements
3403
            if (invalidNetworkElements.size() > 0) {
3404
                // create fix network elements dialog
3405
                const GNEFixNetworkElements fixNetworkElementsDialog(this, invalidNetworkElements);
3406
                // continue depending of result
3407
                if (fixNetworkElementsDialog.getResult() == GNEDialog::Result::ACCEPT) {
3408
                    // Save network
3409
                    myNet->saveNetwork();
3410
                    saved = true;
3411
                } else {
3412
                    // stop
3413
                    return 0;
3414
                }
3415
            } else {
3416
                // Save network
3417
                myNet->saveNetwork();
3418
                saved = true;
3419
            }
3420
        } catch (IOError& e) {
3421
            // open error message box
3422
            GNEErrorBasicDialog(this, TL("Saving network failed"), e.what());
3423
        }
3424
        if (saved) {
3425
            // write info
3426
            WRITE_MESSAGE(TLF("Network saved in '%'.", myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK)));
3427
            // After saving a net successfully, add it into Recent Nets list.
3428
            myMenuBarFile.myRecentNetworks.appendFile(myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK).c_str());
3429
            myMessageWindow->addSeparator();
3430
        } else {
3431
            PROGRESS_FAILED_MESSAGE();
3432
            WRITE_ERROR(TLF("Could not save network in '%'.", myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETWORK)));
3433
            return 0;
3434
        }
3435
        return 1;
3436
    }
3437
}
3438

3439

3440
long
3441
GNEApplicationWindow::onCmdSaveNetworkAs(FXObject* sender, FXSelector sel, void* ptr) {
3442
    // get network file file
3443
    const GNEFileDialog networkFileDialog(this, TL("network file"),
3444
                                          SUMOXMLDefinitions::NetFileExtensions.getStrings(),
3445
                                          GNEFileDialog::OpenMode::SAVE,
3446
                                          GNEFileDialog::ConfigType::NETEDIT,
3447
                                          myFileBucketHandler->getConfigDirectory());
3448
    // continue depending of dialog
3449
    if (networkFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3450
        // update default network file
3451
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETWORK, networkFileDialog.getFilename());
3452
        // update netedit title with the network name
3453
        setTitle(MFXUtils::getTitleText(myTitlePrefix, networkFileDialog.getFilename().c_str()));
3454
        // enable save network
3455
        myNet->getSavingStatus()->requireSaveNetwork();
3456
        // save network
3457
        return onCmdSaveNetwork(sender, sel, ptr);
3458
    } else {
3459
        return 0;
3460
    }
3461
}
3462

3463

3464
long
3465
GNEApplicationWindow::onCmdSavePlainXML(FXObject* sender, FXSelector sel, void* ptr) {
3466
    // first check if we have to set the output filename
3467
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETCONVERT_CONFIG)) {
3468
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETCONVERT_CONFIG, myFileBucketHandler->getConfigFilePrefix(".netccfg"));
3469
    }
3470
    // function onCmdSaveNetworkAs must be executed if this is the first save
3471
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETCONVERT_CONFIG)) {
3472
        return onCmdSavePlainXMLAs(sender, sel, ptr);
3473
    } else {
3474
        // start saving plain XML
3475
        getApp()->beginWaitCursor();
3476
        try {
3477
            // we use the prefix instead the netconvert config
3478
            const auto& plainXMLPrefix = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETCONVERT_PREFIX);
3479
            // save plain xml
3480
            myNet->savePlain(plainXMLPrefix, myNetconvertOptions);
3481
            // write info
3482
            WRITE_MESSAGE(TLF("Plain XML saved with prefix '%'.", plainXMLPrefix));
3483
        } catch (IOError& e) {
3484
            // open message box
3485
            GNEErrorBasicDialog(this, TL("Saving plain xml failed"), e.what());
3486
        }
3487
        // end saving plain XML
3488
        getApp()->endWaitCursor();
3489
        // set focus again in viewNet
3490
        myViewNet->setFocus();
3491
    }
3492
    return 1;
3493
}
3494

3495

3496
long
3497
GNEApplicationWindow::onCmdSavePlainXMLAs(FXObject* sender, FXSelector sel, void* ptr) {
3498
    // get neteditConfig filename
3499
    const GNEFileDialog plainXMLFileDialog(this, TL("plain XML file"),
3500
                                           SUMOXMLDefinitions::NetconvertConfigFileExtensions.getStrings(),
3501
                                           GNEFileDialog::OpenMode::SAVE,
3502
                                           GNEFileDialog::ConfigType::NETEDIT,
3503
                                           myFileBucketHandler->getConfigDirectory());
3504
    // continue depending of dialog
3505
    if (plainXMLFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3506
        // update default netconvert file
3507
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETCONVERT_CONFIG, plainXMLFileDialog.getFilename());
3508
        // save plain xml
3509
        return onCmdSavePlainXML(sender, sel, ptr);
3510
    }
3511
    return 1;
3512
}
3513

3514

3515
long
3516
GNEApplicationWindow::onCmdSaveJoinedJunctionsAs(FXObject*, FXSelector, void*) {
3517
    // get neteditConfig filename
3518
    const GNEFileDialog joinedJunctionsFileDialog(this, TL("joined junctions file"),
3519
            SUMOXMLDefinitions::JunctionFileExtensions.getStrings(),
3520
            GNEFileDialog::OpenMode::SAVE,
3521
            GNEFileDialog::ConfigType::NETEDIT,
3522
            myFileBucketHandler->getConfigDirectory());
3523
    // continue depending of dialog
3524
    if (joinedJunctionsFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3525
        getApp()->beginWaitCursor();
3526
        try {
3527
            myNet->saveJoined(joinedJunctionsFileDialog.getFilename());
3528
            // write info
3529
            WRITE_MESSAGE(TLF("Joined junctions saved to '%'.", joinedJunctionsFileDialog.getFilename()));
3530
        } catch (IOError& e) {
3531
            // opening error message
3532
            GNEErrorBasicDialog(this, TL("Saving joined junctions failed"), e.what());
3533
        }
3534
        getApp()->endWaitCursor();
3535
        // set focus again in viewNet
3536
        myViewNet->setFocus();
3537
    }
3538
    return 1;
3539
}
3540

3541

3542
long
3543
GNEApplicationWindow::onCmdSaveNeteditConfig(FXObject* sender, FXSelector sel, void* ptr) {
3544
    // first check if netedit config is already saved
3545
    if (myNet->getSavingStatus()->isNeteditConfigSaved()) {
3546
        return 1;
3547
    }
3548
    // Check if configuration file was already set at start of netedit or with a previous save
3549
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
3550
        return onCmdSaveNeteditConfigAs(sender, sel, ptr);
3551
    } else {
3552
        // save all elements giving automatic names based on patter if their file isn't defined
3553
        if (onCmdSaveNetwork(sender, sel, ptr) != 1) {
3554
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted (due network)."));
3555
            return 0;
3556
        }
3557
        if (onCmdSaveAdditionalElements(sender, sel, ptr) != 1) {
3558
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted (due additional file)."));
3559
            return 0;
3560
        }
3561
        if (onCmdSaveDemandElements(sender, sel, ptr) != 1) {
3562
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted (due demand file)."));
3563
            return 0;
3564
        }
3565
        if (onCmdSaveDataElements(sender, sel, ptr) != 1) {
3566
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted (due data file)."));
3567
            return 0;
3568
        }
3569
        if (onCmdSaveMeanDataElements(sender, sel, ptr) != 1) {
3570
            WRITE_MESSAGE(TL("Saving of netedit configuration aborted (due meanData file)."));
3571
            return 0;
3572
        }
3573
        // get netedit config file
3574
        auto neteditConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETEDIT_CONFIG);
3575
        // configuration
3576
        std::ofstream out(StringUtils::transcodeToLocal(neteditConfigFile));
3577
        if (out.good()) {
3578
            const auto& neteditOptions = OptionsCont::getOptions();
3579
            // write netedit config
3580
            neteditOptions.writeConfiguration(out, true, false, false, neteditConfigFile, true);
3581
            // write info
3582
            WRITE_MESSAGE(TLF("Netedit configuration saved in '%'.", neteditConfigFile));
3583
            // config saved
3584
            myNet->getSavingStatus()->neteditConfigSaved();
3585
            // After saving a config successfully, add it into recent configs
3586
            myMenuBarFile.myRecentConfigs.appendFile(neteditConfigFile.c_str());
3587
            // if we have a sumo config defined, save it also
3588
            if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG)) {
3589
                // get SumoConfig file
3590
                const auto sumoConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG);
3591
                std::ofstream sumoCfg(StringUtils::transcodeToLocal(sumoConfigFile));
3592
                if (sumoCfg.good()) {
3593
                    // before saving sumo config, check if force enable option junction-taz
3594
                    if (myNet->getAttributeCarriers()->requireJunctionTazOption()) {
3595
                        mySumoOptions.set("junction-taz", "true");
3596
                    }
3597
                    // write SUMO config
3598
                    mySumoOptions.writeConfiguration(sumoCfg, true, false, false, sumoConfigFile, true);
3599
                    // write info
3600
                    WRITE_MESSAGE(TLF("SUMO configuration saved in '%'.", sumoConfigFile));
3601
                    // After saving a config successfully, add it into recent configs
3602
                    myMenuBarFile.myRecentConfigs.appendFile(sumoConfigFile.c_str());
3603
                }
3604
            }
3605
            // save in plain XML (netconvert) if the option is enabled (usually used in netedit tests)
3606
            if (neteditOptions.getBool("autosave-netconvert-file")) {
3607
                onCmdSavePlainXML(sender, sel, ptr);
3608
            }
3609
        } else {
3610
            WRITE_ERROR(TLF("Could not save netedit configuration in '%'.", neteditConfigFile));
3611
        }
3612
        out.close();
3613
        return 1;
3614
    }
3615
}
3616

3617

3618
long
3619
GNEApplicationWindow::onCmdSaveNeteditConfigAs(FXObject* sender, FXSelector sel, void* ptr) {
3620
    // get neteditConfig filename
3621
    const GNEFileDialog neteditConfigFileDialog(this, TL("netedit config file"),
3622
            SUMOXMLDefinitions::NeteditConfigFileExtensions.getStrings(),
3623
            GNEFileDialog::OpenMode::SAVE,
3624
            GNEFileDialog::ConfigType::NETEDIT,
3625
            myFileBucketHandler->getConfigDirectory());
3626
    // continue depending of dialog
3627
    if (neteditConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3628
        // set file in file bucket handler
3629
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::NETEDIT_CONFIG, neteditConfigFileDialog.getFilename());
3630
        // mark netedit config as unsaved
3631
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3632
        // continue saving netedit config
3633
        return onCmdSaveNeteditConfig(sender, sel, ptr);
3634
    } else {
3635
        return 0;
3636
    }
3637
}
3638

3639

3640
long
3641
GNEApplicationWindow::onUpdSaveNeteditConfig(FXObject* sender, FXSelector, void*) {
3642
    // check if enable or disable save netedit config button
3643
    if (myNet == nullptr) {
3644
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3645
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
3646
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3647
    } else if (!myNet->getSavingStatus()->isNeteditConfigSaved()) {
3648
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3649
    } else {
3650
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3651
    }
3652
    // check if enable/disable save individual files
3653
    if (myNet) {
3654
        if (myNet->getSavingStatus()->isAdditionalsSaved() && myNet->getSavingStatus()->isDemandElementsSaved() &&
3655
                myNet->getSavingStatus()->isDataElementsSaved() && myNet->getSavingStatus()->isMeanDatasSaved()) {
3656
            myViewNet->getSaveElements().setSaveIndividualFiles(false);
3657
        } else {
3658
            myViewNet->getSaveElements().setSaveIndividualFiles(true);
3659
        }
3660
    }
3661
    return 1;
3662
}
3663

3664

3665
long
3666
GNEApplicationWindow::onCmdSaveSumoConfig(FXObject* sender, FXSelector sel, void* ptr) {
3667
    // first check if netedit config is already saved
3668
    if (myNet->getSavingStatus()->isSumoConfigSaved()) {
3669
        return 1;
3670
    }
3671
    // obtain netedit option container
3672
    auto& neteditOptions = OptionsCont::getOptions();
3673
    // reset containers
3674
    neteditOptions.resetWritable();
3675
    mySumoOptions.resetWritable();
3676
    // Check if configuration file was already set at start of netedit or with a previous save
3677
    if (myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG).empty()) {
3678
        return onCmdSaveSumoConfigAs(sender, sel, ptr);
3679
    } else {
3680
        // save all elements giving automatic names based on patter in their file isn't defined
3681
        if (onCmdSaveNetwork(sender, sel, ptr) != 1) {
3682
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3683
            return 0;
3684
        }
3685
        if (onCmdSaveAdditionalElements(sender, sel, ptr) != 1) {
3686
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3687
            return 0;
3688
        }
3689
        if (onCmdSaveDemandElements(sender, sel, ptr) != 1) {
3690
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3691
            return 0;
3692
        }
3693
        if (onCmdSaveDataElements(sender, sel, ptr) != 1) {
3694
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3695
            return 0;
3696
        }
3697
        if (onCmdSaveMeanDataElements(sender, sel, ptr) != 1) {
3698
            WRITE_MESSAGE(TL("Saving of SUMO configuration aborted"));
3699
            return 0;
3700
        }
3701
        // get SumoConfig file
3702
        const auto sumoConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::SUMO_CONFIG);
3703
        // confinguration
3704
        std::ofstream out(StringUtils::transcodeToLocal(sumoConfigFile));
3705
        if (out.good()) {
3706
            // before saving sumo config, check if force enable option junction-taz
3707
            if (myNet->getAttributeCarriers()->requireJunctionTazOption()) {
3708
                mySumoOptions.set("junction-taz", "true");
3709
            }
3710
            // write SUMO config
3711
            mySumoOptions.writeConfiguration(out, true, false, false, sumoConfigFile, true);
3712
            // write info
3713
            WRITE_MESSAGE(TLF("SUMO configuration saved in '%'.", sumoConfigFile));
3714
            // After saving a config successfully, add it into recent configs
3715
            myMenuBarFile.myRecentConfigs.appendFile(sumoConfigFile.c_str());
3716
            // if we have a netedit cong defined, save it also
3717
            if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
3718
                // get netedit config file
3719
                auto neteditConfigFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::NETEDIT_CONFIG);
3720
                // configuration
3721
                std::ofstream neteditCfg(StringUtils::transcodeToLocal(neteditConfigFile));
3722
                if (neteditCfg.good()) {
3723
                    // write netedit config
3724
                    neteditOptions.writeConfiguration(neteditCfg, true, false, false, myFileBucketHandler->getDefaultFolder(FileBucket::Type::NETEDIT_CONFIG), true);
3725
                    // write info
3726
                    WRITE_MESSAGE(TLF("Netedit configuration saved in '%'.", neteditConfigFile));
3727
                    // config saved
3728
                    myNet->getSavingStatus()->neteditConfigSaved();
3729
                    // After saving a config successfully, add it into recent configs
3730
                    myMenuBarFile.myRecentConfigs.appendFile(neteditConfigFile.c_str());
3731
                }
3732
            }
3733
            // save in plain XML (netconvert) if the option is enabled (usually used in netedit tests)
3734
            if (neteditOptions.getBool("autosave-netconvert-file")) {
3735
                onCmdSavePlainXML(sender, sel, ptr);
3736
            }
3737
        } else {
3738
            WRITE_MESSAGE(TLF("Could not save SUMO configuration in '%'.", sumoConfigFile));
3739
        }
3740
        out.close();
3741
        return 1;
3742
    }
3743
}
3744

3745

3746
long
3747
GNEApplicationWindow::onCmdSaveSumoConfigAs(FXObject* sender, FXSelector sel, void* ptr) {
3748
    // get sumoConfig filename
3749
    const GNEFileDialog sumoConfigFileDialog(this, TL("sumo config file"),
3750
            SUMOXMLDefinitions::SumoConfigFileExtensions.getStrings(),
3751
            GNEFileDialog::OpenMode::SAVE,
3752
            GNEFileDialog::ConfigType::NETEDIT,
3753
            myFileBucketHandler->getConfigDirectory());
3754
    // continue depending of dialog
3755
    if (sumoConfigFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3756
        // set sumo config
3757
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::SUMO_CONFIG, sumoConfigFileDialog.getFilename());
3758
        // mark netedit config as unsaved
3759
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3760
        // check instead saving sumo config, save netedit config (this will save also the sumoConfig)
3761
        if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
3762
            return onCmdSaveNeteditConfig(sender, sel, ptr);
3763
        } else {
3764
            return onCmdSaveSumoConfig(sender, sel, ptr);
3765
        }
3766
    } else {
3767
        return 0;
3768
    }
3769
}
3770

3771

3772
long
3773
GNEApplicationWindow::onUpdSaveSumoConfig(FXObject* sender, FXSelector, void*) {
3774
    if (myNet == nullptr) {
3775
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3776
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::SUMO_CONFIG)) {
3777
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3778
    } else if (!myNet->getSavingStatus()->isSumoConfigSaved()) {
3779
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3780
    } else {
3781
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3782
    }
3783
}
3784

3785

3786
long
3787
GNEApplicationWindow::onCmdSaveTLSPrograms(FXObject* obj, FXSelector sel, void* ptr) {
3788
    // Check if TLS Programs file was already set at start of netedit or with a previous save
3789
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::TLS)) {
3790
        return onCmdSaveTLSProgramsAs(obj, sel, ptr);
3791
    } else {
3792
        // Start saving TLS Programs
3793
        getApp()->beginWaitCursor();
3794
        try {
3795
            // compute before saving
3796
            myNet->computeNetwork(this, true); // GNEChange_TLS does not triggere GNENet:requireRecompute
3797
            myNet->saveTLSPrograms(myFileBucketHandler->getDefaultFilename(FileBucket::Type::TLS));
3798
            // write info
3799
            WRITE_MESSAGE(TLF("TLS Programs saved in '%'.", myFileBucketHandler->getDefaultFilename(FileBucket::Type::TLS)));
3800
        } catch (IOError& e) {
3801
            // open error message box
3802
            GNEErrorBasicDialog(this, TL("Saving TLS Programs failed"), e.what());
3803
        }
3804
        myMessageWindow->addSeparator();
3805
        getApp()->endWaitCursor();
3806
        // set focus again in viewNet
3807
        myViewNet->setFocus();
3808
    }
3809
    return 1;
3810
}
3811

3812

3813
long
3814
GNEApplicationWindow::onUpdSaveTLSPrograms(FXObject* sender, FXSelector, void*) {
3815
    if (myNet == nullptr) {
3816
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3817
    } else {
3818
        // check if there is at least one TLS
3819
        for (const auto& junction : myNet->getAttributeCarriers()->getJunctions()) {
3820
            if (junction.second->getNBNode()->getControllingTLS().size() > 0) {
3821
                return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3822
            }
3823
        }
3824
        // no TLS, then disable
3825
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3826
    }
3827
}
3828

3829

3830
long
3831
GNEApplicationWindow::onCmdSaveEdgeTypes(FXObject* obj, FXSelector sel, void* ptr) {
3832
    // Check if edgeType file was already set at start of netedit or with a previous save
3833
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::EDGETYPE)) {
3834
        return onCmdSaveEdgeTypesAs(obj, sel, ptr);
3835
    } else {
3836
        // Start saving edgeTypes
3837
        getApp()->beginWaitCursor();
3838
        try {
3839
            const auto edgeTypeFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::EDGETYPE);
3840
            // save edge types
3841
            myNet->saveEdgeTypes(edgeTypeFile);
3842
            // write info
3843
            WRITE_MESSAGE(TLF("EdgeType saved in '%'.", edgeTypeFile));
3844
        } catch (IOError& e) {
3845
            // open error message box
3846
            GNEErrorBasicDialog(this, TL("Saving edgeTypes failed"), e.what());
3847
        }
3848
        myMessageWindow->addSeparator();
3849
        getApp()->endWaitCursor();
3850
    }
3851
    return 1;
3852
}
3853

3854

3855
long
3856
GNEApplicationWindow::onUpdSaveEdgeTypes(FXObject* sender, FXSelector, void*) {
3857
    // check if net exist and there are edge types
3858
    if (myNet && (myNet->getAttributeCarriers()->getEdgeTypes().size() > 0)) {
3859
        sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3860
    } else {
3861
        sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3862
    }
3863
    return 1;
3864
}
3865

3866

3867
long
3868
GNEApplicationWindow::onCmdSaveTLSProgramsAs(FXObject* sender, FXSelector sel, void* ptr) {
3869
    // get TLS file
3870
    const GNEFileDialog TLSfileDialog(this, TL("Traffic Light definitions file"),
3871
                                      SUMOXMLDefinitions::TLSFileExtensions.getStrings(),
3872
                                      GNEFileDialog::OpenMode::SAVE,
3873
                                      GNEFileDialog::ConfigType::NETEDIT,
3874
                                      myFileBucketHandler->getConfigDirectory());
3875
    // continue depending of dialog
3876
    if (TLSfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3877
        // set tls type in bucket
3878
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::TLS, TLSfileDialog.getFilename());
3879
        // enable save netedit config
3880
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3881
        // set focus again in viewNet
3882
        myViewNet->setFocus();
3883
        // save TLS Programs
3884
        return onCmdSaveTLSPrograms(sender, sel, ptr);
3885
    } else {
3886
        return 1;
3887
    }
3888
}
3889

3890

3891
long
3892
GNEApplicationWindow::onCmdSaveEdgeTypesAs(FXObject* sender, FXSelector sel, void* ptr) {
3893
    // get network file file
3894
    const GNEFileDialog edgeTypeFileDialog(this, TL("EdgeTypes file"),
3895
                                           SUMOXMLDefinitions::EdgeTypeFileExtensions.getStrings(),
3896
                                           GNEFileDialog::OpenMode::SAVE,
3897
                                           GNEFileDialog::ConfigType::NETEDIT,
3898
                                           myFileBucketHandler->getConfigDirectory());
3899
    // continue depending of dialog
3900
    if (edgeTypeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3901
        // set tls type in bucket
3902
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::EDGETYPE, edgeTypeFileDialog.getFilename());
3903
        // enable save netedit config
3904
        myNet->getSavingStatus()->requireSaveNeteditConfig();
3905
        // set focus again in viewNet
3906
        myViewNet->setFocus();
3907
        // save edgeTypes
3908
        return onCmdSaveEdgeTypes(sender, sel, ptr);
3909
    } else {
3910
        return 1;
3911
    }
3912
}
3913

3914

3915
long
3916
GNEApplicationWindow::onCmdOpenAdditionalElements(FXObject*, FXSelector, void*) {
3917
    // get file
3918
    const GNEFileDialog additionalFileDialog(this, TL("Additional elements file"),
3919
            SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
3920
            GNEFileDialog::OpenMode::LOAD_SINGLE,
3921
            GNEFileDialog::ConfigType::NETEDIT,
3922
            myFileBucketHandler->getConfigDirectory());
3923
    // continue depending of dialog
3924
    if (additionalFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
3925
        // flag for save current saving status
3926
        const auto previouslySaved = myNet->getSavingStatus()->isAdditionalsSaved();
3927
        // get (or create) bucket for this new file
3928
        auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::ADDITIONAL, additionalFileDialog.getFilename(), true);
3929
        // disable validation for additionals
3930
        XMLSubSys::setValidation("never", "auto", "auto");
3931
        // Create additional handler
3932
        GNEGeneralHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
3933
        // begin undoList operation
3934
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TLF("load additionals from '%'", bucket->getFilename()));
3935
        // Run parser
3936
        if (!generalHandler.parse()) {
3937
            // write error
3938
            WRITE_ERROR(TLF("Loading of additional file '%' failed.", bucket->getFilename()));
3939
        } else {
3940
            // write info
3941
            WRITE_MESSAGE(TLF("Loading of additional file '%' successfully.", bucket->getFilename()));
3942
            // enable save if there is errors loading additionals
3943
            if (previouslySaved && !generalHandler.isErrorCreatingElement()) {
3944
                myNet->getSavingStatus()->additionalsSaved();
3945
            }
3946
        }
3947
        // end undoList operation
3948
        myUndoList->end();
3949
        // restore validation for additionals
3950
        XMLSubSys::setValidation("auto", "auto", "auto");
3951
        // check if clear undoList
3952
        if (!myAllowUndoRedoLoading) {
3953
            myUndoList->clear();
3954
        }
3955
        update();
3956
    }
3957
    return 1;
3958
}
3959

3960

3961
long
3962
GNEApplicationWindow::onCmdReloadAdditionalElements(FXObject*, FXSelector, void*) {
3963
    // disable validation for additionals
3964
    XMLSubSys::setValidation("never", "auto", "auto");
3965
    // begin undoList operation
3966
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODENETWORK, TL("reloading additionals"));
3967
    // clear additionals
3968
    myNet->clearAdditionalElements(myUndoList);
3969
    // reload additional elements stored in options
3970
    loadAdditionalElements("Reloading");
3971
    // end undoList operation
3972
    myUndoList->end();
3973
    // restore validation for additionals
3974
    XMLSubSys::setValidation("auto", "auto", "auto");
3975
    // check if clear undoList
3976
    if (!myAllowUndoRedoLoading) {
3977
        myUndoList->clear();
3978
    }
3979
    update();
3980
    return 1;
3981
}
3982

3983

3984
long
3985
GNEApplicationWindow::onUpdReloadAdditionalElements(FXObject* sender, FXSelector, void*) {
3986
    if (myViewNet == nullptr) {
3987
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3988
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::ADDITIONAL)) {
3989
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
3990
    } else {
3991
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
3992
    }
3993
}
3994

3995

3996
long
3997
GNEApplicationWindow::onCmdSaveAdditionalElements(FXObject* sender, FXSelector sel, void* ptr) {
3998
    const auto savingFileHandler = myFileBucketHandler;
3999
    // get option container
4000
    auto& neteditOptions = OptionsCont::getOptions();
4001
    // check if we're forcing to saving additionals
4002
    if (myNet->getSavingStatus()->isAdditionalsSaved() &&
4003
            neteditOptions.getBool("force-saving") &&
4004
            myFileBucketHandler->isFilenameDefined(FileBucket::Type::ADDITIONAL)) {
4005
        WRITE_MESSAGE(TL("Force save additional elements"));
4006
    } else if (myNet->getSavingStatus()->isAdditionalsSaved()) {
4007
        // nothing to save
4008
        return 1;
4009
    }
4010
    // check if we have to define a default filename
4011
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::ADDITIONAL)) {
4012
        savingFileHandler->setDefaultFilenameFile(FileBucket::Type::ADDITIONAL, myFileBucketHandler->getConfigFilePrefix(".add.xml"));
4013
    }
4014
    // check if we have to open save as dialog
4015
    if (!savingFileHandler->isFilenameDefined(FileBucket::Type::ADDITIONAL)) {
4016
        // choose file to save
4017
        return onCmdSaveAdditionalElementsAs(sender, sel, ptr);
4018
    } else {
4019
        // always recompute before saving
4020
        myNet->computeNetwork(this);
4021
        try {
4022
            // compute before saving (for detectors positions)
4023
            myNet->computeNetwork(this);
4024
            // save additionals
4025
            const bool savingResult = myNet->saveAdditionals();
4026
            // show info
4027
            if (savingResult) {
4028
                WRITE_MESSAGE(TL("Additionals saved."));
4029
                return 1;
4030
            } else {
4031
                WRITE_MESSAGE(TL("Saving additional aborted."));
4032
                return 0;
4033
            }
4034
        } catch (IOError& e) {
4035
            // open error message box
4036
            GNEErrorBasicDialog(this, TL("Saving additional elements failed"), e.what());
4037
        }
4038
        return 0;
4039
    }
4040
}
4041

4042

4043
long
4044
GNEApplicationWindow::onCmdSaveAdditionalElementsAs(FXObject* sender, FXSelector sel, void* ptr) {
4045
    // get additional file
4046
    const GNEFileDialog additionalFileDialog(this, TL("Additional elements as"),
4047
            SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
4048
            GNEFileDialog::OpenMode::SAVE,
4049
            GNEFileDialog::ConfigType::NETEDIT,
4050
            myFileBucketHandler->getConfigDirectory());
4051
    // continue depending of dialog
4052
    if (additionalFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4053
        // update default name
4054
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::ADDITIONAL, additionalFileDialog.getFilename());
4055
        // save additional
4056
        return onCmdSaveAdditionalElements(sender, sel, ptr);
4057
    } else {
4058
        return 0;
4059
    }
4060
}
4061

4062

4063
long
4064
GNEApplicationWindow::onCmdSaveAdditionalElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4065
    // get additional file
4066
    const GNEFileDialog additionalFileDialog(this, TL("Additional elements in unified file"),
4067
            SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
4068
            GNEFileDialog::OpenMode::SAVE,
4069
            GNEFileDialog::ConfigType::NETEDIT,
4070
            myFileBucketHandler->getConfigDirectory());
4071
    // continue depending of dialog
4072
    if (additionalFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4073
        // use the file as default file
4074
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::ADDITIONAL, additionalFileDialog.getFilename());
4075
        // begin undoList operation
4076
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TLF("saving of unified additional elements in '%'", additionalFileDialog.getFilename()));
4077
        // iterate over all demand elementes and change file
4078
        for (const auto& additionalElementTag : myNet->getAttributeCarriers()->getAdditionals()) {
4079
            for (const auto& additionalElement : additionalElementTag.second) {
4080
                additionalElement.second->setAttribute(GNE_ATTR_SAVEFILE, additionalFileDialog.getFilename(), myUndoList);
4081
            }
4082
        }
4083
        // end undoList operation
4084
        myUndoList->end();
4085
        // save additionals
4086
        return onCmdSaveAdditionalElements(sender, sel, ptr);
4087
    } else {
4088
        return 0;
4089
    }
4090
}
4091

4092

4093
long
4094
GNEApplicationWindow::onCmdSaveJuPedSimElementsAs(FXObject*, FXSelector, void*) {
4095
    // get juPedSim file
4096
    const GNEFileDialog juPedSimfileDialog(this, TL("JuPedSim elements file"),
4097
                                           SUMOXMLDefinitions::AdditionalFileExtensions.getStrings(),
4098
                                           GNEFileDialog::OpenMode::SAVE,
4099
                                           GNEFileDialog::ConfigType::NETEDIT,
4100
                                           myFileBucketHandler->getConfigDirectory());
4101
    // continue depending of dialog
4102
    if (juPedSimfileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4103
        try {
4104
            // save additionals
4105
            const bool savingResult = myNet->saveJuPedSimElements(juPedSimfileDialog.getFilename());
4106
            // set focus again in viewNet
4107
            myViewNet->setFocus();
4108
            // show info
4109
            if (savingResult) {
4110
                WRITE_MESSAGE(TL("JuPedSim elements saved."));
4111
                return 1;
4112
            } else {
4113
                WRITE_MESSAGE(TL("Saving JuPedSim elements aborted."));
4114
                return 0;
4115
            }
4116
        } catch (IOError& e) {
4117
            // open error message box
4118
            GNEErrorBasicDialog(this, TL("Saving JuPedSim elements failed"), e.what());
4119
        }
4120
    }
4121
    return 0;
4122
}
4123

4124

4125
long
4126
GNEApplicationWindow::onCmdOpenDemandElements(FXObject*, FXSelector, void*) {
4127
    // get file
4128
    const GNEFileDialog routeFileDialog(this, TL("Route elements file"),
4129
                                        SUMOXMLDefinitions::RouteFileExtensions.getStrings(),
4130
                                        GNEFileDialog::OpenMode::LOAD_SINGLE,
4131
                                        GNEFileDialog::ConfigType::NETEDIT,
4132
                                        myFileBucketHandler->getConfigDirectory());
4133
    // continue depending of dialog
4134
    if (routeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4135
        // save previous demand element status saving
4136
        const auto previouslySaved = myNet->getSavingStatus()->isDemandElementsSaved();
4137
        // disable validation for additionals
4138
        XMLSubSys::setValidation("never", "auto", "auto");
4139
        // get (or create) bucket for this new file
4140
        auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::DEMAND, routeFileDialog.getFilename(), true);
4141
        // Create generic handler
4142
        GNEGeneralHandler handler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4143
        // begin undoList operation
4144
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("loading demand elements from '%'", bucket->getFilename()));
4145
        // Run parser for additionals
4146
        if (!handler.parse()) {
4147
            // write error
4148
            WRITE_ERROR(TLF("Loading of route file '%' failed.", bucket->getFilename()));
4149
        } else {
4150
            // show info
4151
            WRITE_MESSAGE(TLF("Loading of route file '%' successfully.", bucket->getFilename()));
4152
            // enable demand elements if there is an error creating element
4153
            if (previouslySaved && !handler.isErrorCreatingElement()) {
4154
                myNet->getSavingStatus()->demandElementsSaved();
4155
            }
4156
        }
4157
        // end undoList operation
4158
        myUndoList->end();
4159
        // restore validation
4160
        XMLSubSys::setValidation("auto", "auto", "auto");
4161
        // check if clear undoList
4162
        if (!myAllowUndoRedoLoading) {
4163
            myUndoList->clear();
4164
        }
4165
        update();
4166
    }
4167
    return 1;
4168
}
4169

4170

4171
long
4172
GNEApplicationWindow::onCmdReloadDemandElements(FXObject*, FXSelector, void*) {
4173
    // disable validation for additionals
4174
    XMLSubSys::setValidation("never", "auto", "auto");
4175
    // begin undoList operation
4176
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TL("reloading demand elements"));
4177
    // clear demand elements
4178
    myNet->clearDemandElements(myUndoList);
4179
    // reload demand elements stored in options
4180
    loadDemandElements("Reloading");
4181
    // end undoList operation and update view
4182
    myUndoList->end();
4183
    // restore validation for demand
4184
    XMLSubSys::setValidation("auto", "auto", "auto");
4185
    // check if clear undoList
4186
    if (!myAllowUndoRedoLoading) {
4187
        myUndoList->clear();
4188
    }
4189
    update();
4190
    return 1;
4191
}
4192

4193

4194
long
4195
GNEApplicationWindow::onUpdReloadDemandElements(FXObject* sender, FXSelector, void*) {
4196
    if (myViewNet == nullptr) {
4197
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4198
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::DEMAND)) {
4199
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4200
    } else {
4201
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4202
    }
4203
}
4204

4205

4206
long
4207
GNEApplicationWindow::onCmdSaveDemandElements(FXObject* sender, FXSelector sel, void* ptr) {
4208
    const auto savingFileHandler = myFileBucketHandler;
4209
    // get option container
4210
    auto& neteditOptions = OptionsCont::getOptions();
4211
    // check if we're forcing to saving demand elements
4212
    if (myNet->getSavingStatus()->isDemandElementsSaved() &&
4213
            neteditOptions.getBool("force-saving") &&
4214
            myFileBucketHandler->isFilenameDefined(FileBucket::Type::DEMAND)) {
4215
        WRITE_MESSAGE(TL("Force save demand elements"));
4216
    } else if (myNet->getSavingStatus()->isDemandElementsSaved()) {
4217
        // nothing to save
4218
        return 1;
4219
    }
4220
    // check if we have to define a default filename
4221
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::DEMAND)) {
4222
        savingFileHandler->setDefaultFilenameFile(FileBucket::Type::DEMAND, myFileBucketHandler->getConfigFilePrefix(".rou.xml"));
4223
    }
4224
    // check if we have to open save as dialog
4225
    if (!savingFileHandler->isFilenameDefined(FileBucket::Type::DEMAND)) {
4226
        // choose file to save
4227
        return onCmdSaveDemandElementsAs(sender, sel, ptr);
4228
    } else {
4229
        // always recompute before saving
4230
        myNet->computeNetwork(this);
4231
        try {
4232
            // save demand elements
4233
            const bool savingResult = myNet->saveDemandElements();
4234
            // show info
4235
            if (savingResult) {
4236
                WRITE_MESSAGE(TL("Demand elements saved."));
4237
                return 1;
4238
            } else {
4239
                WRITE_MESSAGE(TL("Saving demand elements aborted."));
4240
                return 0;
4241
            }
4242
        } catch (IOError& e) {
4243
            // open error message box
4244
            GNEErrorBasicDialog(this, TL("Saving demand elements failed"), e.what());
4245
        }
4246
    }
4247
    return 0;
4248
}
4249

4250

4251
long
4252
GNEApplicationWindow::onCmdSaveDemandElementsAs(FXObject* sender, FXSelector sel, void* ptr) {
4253
    // get route file
4254
    const GNEFileDialog routeFileDialog(this, TL("Route elements"),
4255
                                        SUMOXMLDefinitions::RouteFileExtensions.getStrings(),
4256
                                        GNEFileDialog::OpenMode::SAVE,
4257
                                        GNEFileDialog::ConfigType::NETEDIT,
4258
                                        myFileBucketHandler->getConfigDirectory());
4259
    // continue depending of dialog
4260
    if (routeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4261
        // update default name
4262
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::DEMAND, routeFileDialog.getFilename());
4263
        // save demand elements
4264
        return onCmdSaveDemandElements(sender, sel, ptr);
4265
    } else {
4266
        return 0;
4267
    }
4268
}
4269

4270

4271
long
4272
GNEApplicationWindow::onCmdSaveDemandElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4273
    // get route file
4274
    const GNEFileDialog routeFileDialog(this, TL("Route elements file in unified file"),
4275
                                        SUMOXMLDefinitions::RouteFileExtensions.getStrings(),
4276
                                        GNEFileDialog::OpenMode::SAVE,
4277
                                        GNEFileDialog::ConfigType::NETEDIT,
4278
                                        myFileBucketHandler->getConfigDirectory());
4279
    // continue depending of dialog
4280
    if (routeFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4281
        // use the file as default file
4282
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::DEMAND, routeFileDialog.getFilename());
4283
        // begin undoList operation
4284
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("saving of unified demand elements in '%'.", routeFileDialog.getFilename()));
4285
        // iterate over all demand elementes and change file
4286
        for (const auto& demandElementTag : myNet->getAttributeCarriers()->getDemandElements()) {
4287
            for (const auto& demandElement : demandElementTag.second) {
4288
                demandElement.second->setAttribute(GNE_ATTR_SAVEFILE, routeFileDialog.getFilename(), myUndoList);
4289
            }
4290
        }
4291
        // end undoList operation
4292
        myUndoList->end();
4293
        // save demand elements
4294
        return onCmdSaveDemandElements(sender, sel, ptr);
4295
    } else {
4296
        return 0;
4297
    }
4298
}
4299

4300

4301
long
4302
GNEApplicationWindow::onCmdOpenDataElements(FXObject*, FXSelector, void*) {
4303
    // get file
4304
    const GNEFileDialog dataFileDialog(this, TL("Data elements file"),
4305
                                       SUMOXMLDefinitions::EdgeDataFileExtensions.getStrings(),
4306
                                       GNEFileDialog::OpenMode::LOAD_SINGLE,
4307
                                       GNEFileDialog::ConfigType::NETEDIT,
4308
                                       myFileBucketHandler->getConfigDirectory());
4309
    // continue depending of dialog
4310
    if (dataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4311
        // save previous demand element status saving
4312
        const auto previouslySaved = myNet->getSavingStatus()->isDataElementsSaved();
4313
        // get (or create) bucket for this new file
4314
        auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::DATA, dataFileDialog.getFilename(), true);
4315
        // disable update data
4316
        myViewNet->getNet()->disableUpdateData();
4317
        // disable validation for data elements
4318
        XMLSubSys::setValidation("never", "auto", "auto");
4319
        // Create data handler
4320
        GNEDataHandler dataHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4321
        // begin undoList operation
4322
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("loading data elements from '%'.", bucket->getFilename()));
4323
        // Run data parser
4324
        if (!dataHandler.parse()) {
4325
            // write error
4326
            WRITE_ERROR(TLF("Loading of data file '%' failed.", bucket->getFilename()));
4327
        } else {
4328
            // show info
4329
            WRITE_MESSAGE(TLF("Loading of data file '%' successfully.", bucket->getFilename()));
4330
            // enable demand elements if there is an error creating element
4331
            if (previouslySaved && !dataHandler.isErrorCreatingElement()) {
4332
                myNet->getSavingStatus()->dataElementsSaved();
4333
            }
4334
        }
4335
        // end undoList operation
4336
        myUndoList->end();
4337
        // enable update data
4338
        myViewNet->getNet()->enableUpdateData();
4339
        // restore validation for data
4340
        XMLSubSys::setValidation("auto", "auto", "auto");
4341
        // check if clear undoList
4342
        if (!myAllowUndoRedoLoading) {
4343
            myUndoList->clear();
4344
        }
4345
        update();
4346
    }
4347
    return 1;
4348
}
4349

4350

4351
long
4352
GNEApplicationWindow::onCmdReloadDataElements(FXObject*, FXSelector, void*) {
4353
    // disable update data
4354
    myViewNet->getNet()->disableUpdateData();
4355
    // disable validation for additionals
4356
    XMLSubSys::setValidation("never", "auto", "auto");
4357
    // begin undoList operation
4358
    myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TL("reloading data elements"));
4359
    // clear data elements
4360
    myNet->clearDataElements(myUndoList);
4361
    // reload data elements stored in options
4362
    loadDataElements("Reloading");
4363
    // restore validation for data
4364
    XMLSubSys::setValidation("auto", "auto", "auto");
4365
    // end undoList operation and update view
4366
    myUndoList->end();
4367
    // enable update data
4368
    myViewNet->getNet()->enableUpdateData();
4369
    // check if clear undoList
4370
    if (!myAllowUndoRedoLoading) {
4371
        myUndoList->clear();
4372
    }
4373
    update();
4374
    return 1;
4375
}
4376

4377

4378
long
4379
GNEApplicationWindow::onUpdReloadDataElements(FXObject* sender, FXSelector, void*) {
4380
    if (myViewNet == nullptr) {
4381
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4382
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::DATA)) {
4383
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4384
    } else {
4385
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4386
    }
4387
}
4388

4389

4390
long
4391
GNEApplicationWindow::onCmdSaveDataElements(FXObject* sender, FXSelector sel, void* ptr) {
4392
    const auto savingFileHandler = myFileBucketHandler;
4393
    // get option container
4394
    auto& neteditOptions = OptionsCont::getOptions();
4395
    // check if we're forcing to saving data elements
4396
    if (myNet->getSavingStatus()->isDataElementsSaved() &&
4397
            neteditOptions.getBool("force-saving") &&
4398
            myFileBucketHandler->isFilenameDefined(FileBucket::Type::DATA)) {
4399
        WRITE_MESSAGE(TL("Force save data elements"));
4400
    } else if (myNet->getSavingStatus()->isDataElementsSaved()) {
4401
        // nothing to save
4402
        return 1;
4403
    }
4404
    // check if we have to define a default filename
4405
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::DATA)) {
4406
        savingFileHandler->setDefaultFilenameFile(FileBucket::Type::DATA, myFileBucketHandler->getConfigFilePrefix(".dat.xml"));
4407
    }
4408
    // check if we have to open save as dialog
4409
    if (!savingFileHandler->isFilenameDefined(FileBucket::Type::DATA)) {
4410
        return onCmdSaveDataElementsAs(sender, sel, ptr);
4411
    } else {
4412
        try {
4413
            // save data elements
4414
            const bool savingResult = myNet->saveDataElements();
4415
            // show info
4416
            if (savingResult) {
4417
                WRITE_MESSAGE(TL("Data elements saved."));
4418
                return 1;
4419
            } else {
4420
                WRITE_MESSAGE(TL("Saving demand elements aborted."));
4421
                return 0;
4422
            }
4423
        } catch (IOError& e) {
4424
            // open error message box
4425
            GNEErrorBasicDialog(this, TL("Saving data elements failed"), e.what());
4426
        }
4427
    }
4428
    return 0;
4429
}
4430

4431

4432
long
4433
GNEApplicationWindow::onCmdSaveDataElementsAs(FXObject* sender, FXSelector sel, void* ptr) {
4434
    // get data file
4435
    const GNEFileDialog dataFileDialog(this, TL("Data elements file"),
4436
                                       SUMOXMLDefinitions::EdgeDataFileExtensions.getStrings(),
4437
                                       GNEFileDialog::OpenMode::SAVE,
4438
                                       GNEFileDialog::ConfigType::NETEDIT,
4439
                                       myFileBucketHandler->getConfigDirectory());
4440
    // continue depending of dialog
4441
    if (dataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4442
        // update default name
4443
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::DATA, dataFileDialog.getFilename());
4444
        // save data elements
4445
        return onCmdSaveDataElements(sender, sel, ptr);
4446
    } else {
4447
        return 0;
4448
    }
4449
}
4450

4451

4452
long
4453
GNEApplicationWindow::onCmdSaveDataElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4454
    // get data file
4455
    const GNEFileDialog dataFileDialog(this, TL("Data elements file in unified file"),
4456
                                       SUMOXMLDefinitions::EdgeDataFileExtensions.getStrings(),
4457
                                       GNEFileDialog::OpenMode::SAVE,
4458
                                       GNEFileDialog::ConfigType::NETEDIT,
4459
                                       myFileBucketHandler->getConfigDirectory());
4460
    // continue depending of dialog
4461
    if (dataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4462
        // use the file as default file
4463
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::DATA, dataFileDialog.getFilename());
4464
        // begin undoList operation
4465
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("saving of unified data elements in '%'", dataFileDialog.getFilename()));
4466
        // iterate over all demand elementes and change file
4467
        for (const auto& dataSet : myNet->getAttributeCarriers()->getDataSets()) {
4468
            dataSet.second->setAttribute(GNE_ATTR_SAVEFILE, dataFileDialog.getFilename(), myUndoList);
4469
        }
4470
        // end undoList operation
4471
        myUndoList->end();
4472
        // save data elements
4473
        return onCmdSaveDataElements(sender, sel, ptr);
4474
    } else {
4475
        return 0;
4476
    }
4477
}
4478

4479

4480
long
4481
GNEApplicationWindow::onCmdOpenMeanDataElements(FXObject*, FXSelector, void*) {
4482
    // get file
4483
    const GNEFileDialog meanDataFileDialog(this, TL("MeanData elements file"),
4484
                                           SUMOXMLDefinitions::MeanDataFileExtensions.getStrings(),
4485
                                           GNEFileDialog::OpenMode::LOAD_SINGLE,
4486
                                           GNEFileDialog::ConfigType::NETEDIT,
4487
                                           myFileBucketHandler->getConfigDirectory());
4488
    // continue depending of dialog
4489
    if (meanDataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4490
        // save previous demand element status saving
4491
        const auto previouslySaved = myNet->getSavingStatus()->isMeanDatasSaved();
4492
        // get (or create) bucket for this new file
4493
        auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::MEANDATA, meanDataFileDialog.getFilename(), true);
4494
        // disable validation for meanDatas
4495
        XMLSubSys::setValidation("never", "auto", "auto");
4496
        // Create meanData handler
4497
        GNEGeneralHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4498
        // begin undoList operation
4499
        myUndoList->begin(Supermode::DATA, GUIIcon::SUPERMODEDATA, TLF("load meanDatas from '%'", bucket->getFilename()));
4500
        // Run parser
4501
        if (!generalHandler.parse()) {
4502
            // write error
4503
            WRITE_ERROR(TLF("Loading of meandata file '%' failed.", bucket->getFilename()));
4504
        } else {
4505
            // show info
4506
            WRITE_MESSAGE(TLF("Loading of meandata file '%' successfully.", bucket->getFilename()));
4507
            // enable demand elements if there is an error creating element
4508
            if (previouslySaved && !generalHandler.isErrorCreatingElement()) {
4509
                myNet->getSavingStatus()->meanDatasSaved();
4510
            }
4511
        }
4512
        // end undoList operation
4513
        myUndoList->end();
4514
        // restore validation for meanDatas
4515
        XMLSubSys::setValidation("auto", "auto", "auto");
4516
        // check if clear undoList
4517
        if (!myAllowUndoRedoLoading) {
4518
            myUndoList->clear();
4519
        }
4520
        update();
4521
    }
4522
    return 1;
4523
}
4524

4525

4526
long
4527
GNEApplicationWindow::onCmdReloadMeanDataElements(FXObject*, FXSelector, void*) {
4528
    // disable validation for meanDatas
4529
    XMLSubSys::setValidation("never", "auto", "auto");
4530
    // begin undoList operation
4531
    myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODENETWORK, TL("reloading meanDatas"));
4532
    // clear meanDatas
4533
    myNet->clearMeanDataElements(myUndoList);
4534
    // reload meanData elements stored in options
4535
    loadMeanDataElements("Reloading");
4536
    // end undoList operation and update view
4537
    myUndoList->end();
4538
    // restore validation for meanDatas
4539
    XMLSubSys::setValidation("auto", "auto", "auto");
4540
    // check if clear undoList
4541
    if (!myAllowUndoRedoLoading) {
4542
        myUndoList->clear();
4543
    }
4544
    update();
4545
    return 1;
4546
}
4547

4548

4549
long
4550
GNEApplicationWindow::onUpdReloadMeanDataElements(FXObject* sender, FXSelector, void*) {
4551
    if (myViewNet == nullptr) {
4552
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4553
    } else if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::MEANDATA)) {
4554
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_DISABLE), nullptr);
4555
    } else {
4556
        return sender->handle(this, FXSEL(SEL_COMMAND, ID_ENABLE), nullptr);
4557
    }
4558
}
4559

4560

4561
long
4562
GNEApplicationWindow::onCmdSaveMeanDataElements(FXObject* sender, FXSelector sel, void* ptr) {
4563
    const auto savingFileHandler = myFileBucketHandler;
4564
    // get option container
4565
    auto& neteditOptions = OptionsCont::getOptions();
4566
    // check if we're forcing to saving meandata elements
4567
    if (myNet->getSavingStatus()->isMeanDatasSaved() &&
4568
            neteditOptions.getBool("force-saving") &&
4569
            myFileBucketHandler->isFilenameDefined(FileBucket::Type::MEANDATA)) {
4570
        WRITE_MESSAGE(TL("Force save meandata elements"));
4571
    } else if (myNet->getSavingStatus()->isMeanDatasSaved()) {
4572
        // nothing to save
4573
        return 1;
4574
    }
4575
    // check if we have to define a default filename
4576
    if (!myFileBucketHandler->isFilenameDefined(FileBucket::Type::MEANDATA)) {
4577
        savingFileHandler->setDefaultFilenameFile(FileBucket::Type::MEANDATA, myFileBucketHandler->getConfigFilePrefix(".dat.add.xml"));
4578
    }
4579
    // check if we have to open save as dialog
4580
    if (!savingFileHandler->isFilenameDefined(FileBucket::Type::MEANDATA)) {
4581
        return onCmdSaveMeanDataElementsAs(sender, sel, ptr);
4582
    } else {
4583
        try {
4584
            // compute before saving
4585
            myNet->computeNetwork(this);
4586
            // save demand elements
4587
            const bool savingResult = myNet->saveMeanDatas();
4588
            // show info
4589
            if (savingResult) {
4590
                WRITE_MESSAGE(TL("MeanDatas elements saved"));
4591
                return 1;
4592
            } else {
4593
                WRITE_MESSAGE(TL("Saving MeanData elements aborted"));
4594
                return 0;
4595
            }
4596
        } catch (IOError& e) {
4597
            // open error message box
4598
            GNEErrorBasicDialog(this, TL("Saving demand elements failed!"), e.what());
4599
        }
4600
    }
4601
    return 0;
4602
}
4603

4604

4605
long
4606
GNEApplicationWindow::onCmdSaveMeanDataElementsAs(FXObject* sender, FXSelector sel, void* ptr) {
4607
    // get meanData file
4608
    const GNEFileDialog meanDataFileDialog(this, TL("MeanData elements"),
4609
                                           SUMOXMLDefinitions::MeanDataFileExtensions.getStrings(),
4610
                                           GNEFileDialog::OpenMode::SAVE,
4611
                                           GNEFileDialog::ConfigType::NETEDIT,
4612
                                           myFileBucketHandler->getConfigDirectory());
4613
    // continue depending of dialog
4614
    if (meanDataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4615
        // update default name
4616
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::MEANDATA, meanDataFileDialog.getFilename());
4617
        // save meanDatas
4618
        return onCmdSaveMeanDataElements(sender, sel, ptr);
4619
    } else {
4620
        return 0;
4621
    }
4622
}
4623

4624

4625
long
4626
GNEApplicationWindow::onCmdSaveMeanDataElementsUnified(FXObject* sender, FXSelector sel, void* ptr) {
4627
    // get meanData file
4628
    const GNEFileDialog meanDataFileDialog(this, TL("MeanData elements file in unified file"),
4629
                                           SUMOXMLDefinitions::MeanDataFileExtensions.getStrings(),
4630
                                           GNEFileDialog::OpenMode::SAVE,
4631
                                           GNEFileDialog::ConfigType::NETEDIT,
4632
                                           myFileBucketHandler->getConfigDirectory());
4633
    // continue depending of dialog
4634
    if (meanDataFileDialog.getResult() == GNEDialog::Result::ACCEPT) {
4635
        // use the file as default file
4636
        myFileBucketHandler->setDefaultFilenameFile(FileBucket::Type::MEANDATA, meanDataFileDialog.getFilename());
4637
        // begin undoList operation
4638
        myUndoList->begin(Supermode::DATA, GUIIcon::MODEMEANDATA, TLF("saving of unified mean data elements in '%'", meanDataFileDialog.getFilename()));
4639
        // iterate over all demand elementes and change file
4640
        for (const auto& meanDataTag : myNet->getAttributeCarriers()->getMeanDatas()) {
4641
            for (const auto& meanData : meanDataTag.second) {
4642
                meanData.second->setAttribute(GNE_ATTR_SAVEFILE, meanDataFileDialog.getFilename(), myUndoList);
4643
            }
4644
        }
4645
        // end undoList operation
4646
        myUndoList->end();
4647
        // save meanDatas
4648
        return onCmdSaveMeanDataElements(sender, sel, ptr);
4649
    } else {
4650
        return 0;
4651
    }
4652
}
4653

4654

4655
bool
4656
GNEApplicationWindow::askSaveElements(FXObject* sender, FXSelector sel, void* ptr) {
4657
    if (myNet) {
4658
        GNEDialog::Result commonResult = GNEDialog::Result::ACCEPT;
4659
        const auto saveNetwork = myNet->getSavingStatus()->askSaveNetwork(commonResult);
4660
        const auto saveAdditionalElements = myNet->getSavingStatus()->askSaveAdditionalElements(commonResult);
4661
        const auto saveDemandElements = myNet->getSavingStatus()->askSaveDemandElements(commonResult);
4662
        const auto saveDataElements = myNet->getSavingStatus()->askSaveDataElements(commonResult);
4663
        const auto saveMeanDataElements = myNet->getSavingStatus()->askSaveMeanDataElements(commonResult);
4664
        // first check if abort saving
4665
        if (commonResult == GNEDialog::Result::ABORT) {
4666
            return false;
4667
        }
4668
        // save every type of file
4669
        if ((saveNetwork == GNEDialog::Result::ACCEPT) &&
4670
                (onCmdSaveNetwork(sender, sel, ptr) != 1)) {
4671
            return false;
4672
        }
4673
        if ((saveAdditionalElements == GNEDialog::Result::ACCEPT) &&
4674
                (onCmdSaveAdditionalElements(sender, sel, ptr) != 1)) {
4675
            return false;
4676
        }
4677
        if ((saveDemandElements == GNEDialog::Result::ACCEPT) &&
4678
                (onCmdSaveDemandElements(sender, sel, ptr) != 1)) {
4679
            return false;
4680
        }
4681
        if ((saveDataElements == GNEDialog::Result::ACCEPT) &&
4682
                (onCmdSaveDataElements(sender, sel, ptr) != 1)) {
4683
            return false;
4684
        }
4685
        if ((saveMeanDataElements == GNEDialog::Result::ACCEPT) &&
4686
                (onCmdSaveMeanDataElements(sender, sel, ptr) != 1)) {
4687
            return false;
4688
        }
4689
        // restore focus in viewNet
4690
        myViewNet->setFocus();
4691
        // clear undo list
4692
        clearUndoList();
4693
        // all saved, then continue
4694
        return true;
4695
    } else {
4696
        // nothing to do, then continue
4697
        return true;
4698
    }
4699
}
4700

4701

4702
void
4703
GNEApplicationWindow::updateControls() {
4704
    // check that view exists
4705
    if (myViewNet) {
4706
        myViewNet->updateControls();
4707
    }
4708
    // update require recomputing
4709
    updateRecomputingLabel();
4710
}
4711

4712

4713
void
4714
GNEApplicationWindow::updateSuperModeMenuCommands(const Supermode supermode) {
4715
    // remove lock hotkeys
4716
    myLockMenuCommands.removeHotkeys();
4717
    // check supermode
4718
    if (supermode == Supermode::NETWORK) {
4719
        // menu commands
4720
        myModesMenuCommands.networkMenuCommands.showNetworkMenuCommands();
4721
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4722
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4723
        // lock
4724
        myLockMenuCommands.showNetworkLockMenuCommands();
4725
        myLockMenuCommands.hideDemandLockMenuCommands();
4726
        myLockMenuCommands.hideDataLockMenuCommands();
4727
        // processing
4728
        myProcessingMenuCommands.showNetworkProcessingMenuCommands();
4729
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4730
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4731
        myProcessingMenuCommands.showSeparator();
4732
    } else if (supermode == Supermode::DEMAND) {
4733
        // menu commands
4734
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4735
        myModesMenuCommands.demandMenuCommands.showDemandMenuCommands();
4736
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4737
        // lock
4738
        myLockMenuCommands.hideNetworkLockMenuCommands();
4739
        myLockMenuCommands.showDemandLockMenuCommands();
4740
        myLockMenuCommands.hideDataLockMenuCommands();
4741
        // processing
4742
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4743
        myProcessingMenuCommands.showDemandProcessingMenuCommands();
4744
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4745
        myProcessingMenuCommands.showSeparator();
4746
    } else if (supermode == Supermode::DATA) {
4747
        // menu commands
4748
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4749
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4750
        myModesMenuCommands.dataMenuCommands.showDataMenuCommands();
4751
        // lock
4752
        myLockMenuCommands.hideNetworkLockMenuCommands();
4753
        myLockMenuCommands.hideDemandLockMenuCommands();
4754
        myLockMenuCommands.showDataLockMenuCommands();
4755
        // processing
4756
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4757
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4758
        myProcessingMenuCommands.showDataProcessingMenuCommands();
4759
        myProcessingMenuCommands.hideSeparator();
4760
    } else {
4761
        // menu commands
4762
        myModesMenuCommands.networkMenuCommands.hideNetworkMenuCommands();
4763
        myModesMenuCommands.demandMenuCommands.hideDemandMenuCommands();
4764
        myModesMenuCommands.dataMenuCommands.hideDataMenuCommands();
4765
        myProcessingMenuCommands.hideSeparator();
4766
        // lock
4767
        myLockMenuCommands.hideNetworkLockMenuCommands();
4768
        myLockMenuCommands.hideDemandLockMenuCommands();
4769
        myLockMenuCommands.hideDataLockMenuCommands();
4770
        // processing
4771
        myProcessingMenuCommands.hideNetworkProcessingMenuCommands();
4772
        myProcessingMenuCommands.hideDemandProcessingMenuCommands();
4773
        myProcessingMenuCommands.hideDataProcessingMenuCommands();
4774
    }
4775
    // continue depending of view
4776
    if (myViewNet) {
4777
        if (myViewNet->getEditModes().isDefaultView()) {
4778
            mySupermodeCommands.setDefaultView();
4779
            myModesMenuCommands.setDefaultView(supermode);
4780
        } else if (myViewNet->getEditModes().isJuPedSimView()) {
4781
            mySupermodeCommands.setJuPedSimView();
4782
            myModesMenuCommands.setJuPedSimView(supermode);
4783
        }
4784
    }
4785
}
4786

4787

4788
bool
4789
GNEApplicationWindow::isUndoRedoAllowed() const {
4790
    return myAllowUndoRedo;
4791
}
4792

4793

4794
void
4795
GNEApplicationWindow::enableUndoRedoTemporally() {
4796
    myUndoRedoListEnabled.clear();
4797
}
4798

4799

4800
void
4801
GNEApplicationWindow::disableUndoRedoTemporally(const std::string& reason) {
4802
    myUndoRedoListEnabled = reason;
4803
}
4804

4805

4806
const std::string&
4807
GNEApplicationWindow::isUndoRedoEnabledTemporally() const {
4808
    return myUndoRedoListEnabled;
4809
}
4810

4811

4812
void
4813
GNEApplicationWindow::clearUndoList() {
4814
    if (myViewNet) {
4815
        // destroy Popup (to avoid crashes)
4816
        myViewNet->destroyPopup();
4817
    }
4818
    // clear undo list and return true to continue with closing/reload
4819
    myUndoList->clear();
4820
}
4821

4822

4823
GNEApplicationWindowHelper::FileMenuCommands&
4824
GNEApplicationWindow::getFileMenuCommands() {
4825
    return myFileMenuCommands;
4826
}
4827

4828

4829
GNEApplicationWindowHelper::ModesMenuCommands&
4830
GNEApplicationWindow::getModesMenuCommands() {
4831
    return myModesMenuCommands;
4832
}
4833

4834

4835
GNEApplicationWindowHelper::EditMenuCommands&
4836
GNEApplicationWindow::getEditMenuCommands() {
4837
    return myEditMenuCommands;
4838
}
4839

4840

4841
GNEApplicationWindowHelper::LockMenuCommands&
4842
GNEApplicationWindow::getLockMenuCommands() {
4843
    return myLockMenuCommands;
4844
}
4845

4846

4847
const GNEApplicationWindowHelper::ProcessingMenuCommands&
4848
GNEApplicationWindow::getProcessingMenuCommands() const {
4849
    return myProcessingMenuCommands;
4850
}
4851

4852

4853
OptionsCont&
4854
GNEApplicationWindow::getSumoOptions() {
4855
    return mySumoOptions;
4856
}
4857

4858

4859
OptionsCont&
4860
GNEApplicationWindow::getNetgenerateOptions() {
4861
    return myNetgenerateOptions;
4862
}
4863

4864

4865
void
4866
GNEApplicationWindow::loadAdditionalElements(const std::string operation) {
4867
    // get netedit option container
4868
    auto& neteditOptions = OptionsCont::getOptions();
4869
    // get additional files (don't use reference because it's modified during loading)
4870
    const StringVector additionalFiles = neteditOptions.getStringVector("additional-files");
4871
    // check if we have additionals to load
4872
    if (myNet && (additionalFiles.size() > 0)) {
4873
        // disable validation for additionals
4874
        XMLSubSys::setValidation("never", "auto", "auto");
4875
        // begin undolist
4876
        myUndoList->begin(Supermode::NETWORK, GUIIcon::SUPERMODENETWORK, TLF("% additional elements from '%'", operation, toString(additionalFiles)));
4877
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4878
        bool setSaved = additionalFiles.size() == 1;
4879
        // iterate over every additional file
4880
        for (const auto& file : additionalFiles) {
4881
            // check if ignore missing inputs
4882
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4883
                WRITE_MESSAGE(TLF("% additionals from '%'.", operation, file));
4884
                // get (or create) bucket for this new file
4885
                auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::ADDITIONAL, file, true);
4886
                // declare general handler
4887
                GNEGeneralHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4888
                // check if force overwritte
4889
                if (operation == "reloading") {
4890
                    generalHandler.forceOverwriteElements();
4891
                }
4892
                // Run parser
4893
                if (!generalHandler.parse()) {
4894
                    WRITE_ERROR(TLF("% of '%' failed.", operation, file));
4895
                }
4896
                setSaved &= !generalHandler.isErrorCreatingElement();
4897
            }
4898
        }
4899
        // end undo list
4900
        myUndoList->end();
4901
        // disable validation for additionals
4902
        XMLSubSys::setValidation("auto", "auto", "auto");
4903
        if (setSaved) {
4904
            myNet->getSavingStatus()->additionalsSaved();
4905
        }
4906
        // check if clear undoList
4907
        if (!myAllowUndoRedoLoading) {
4908
            myUndoList->clear();
4909
        }
4910
    }
4911
}
4912

4913

4914
void
4915
GNEApplicationWindow::loadDemandElements(const std::string operation) {
4916
    // get netedit option container
4917
    auto& neteditOptions = OptionsCont::getOptions();
4918
    // get demand files (don't use reference because it's modified during loading)
4919
    const StringVector demandFiles = neteditOptions.getStringVector("route-files");
4920
    // check if we have demand files to load
4921
    if (myNet && (demandFiles.size() > 0)) {
4922
        // disable validation for additionals
4923
        XMLSubSys::setValidation("never", "auto", "auto");
4924
        // begin undolist
4925
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("% demand elements from '%'", operation, toString(demandFiles)));
4926
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4927
        bool setSaved = demandFiles.size() == 1;
4928
        // iterate over every demand file
4929
        for (const auto& file : demandFiles) {
4930
            // check if ignore missing inputs
4931
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4932
                WRITE_MESSAGE(TLF("% demand elements from '%'.", operation, file));
4933
                // get (or create) bucket for this new file
4934
                auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::DEMAND, file, true);
4935
                // declare general handler
4936
                GNEGeneralHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4937
                // check if force overwritte
4938
                if (operation == "reloading") {
4939
                    generalHandler.forceOverwriteElements();
4940
                }
4941
                // Run parser
4942
                if (!generalHandler.parse()) {
4943
                    WRITE_ERROR(TLF("% of '%' failed.", operation, file));
4944
                }
4945
                setSaved &= !generalHandler.isErrorCreatingElement();
4946
            }
4947
        }
4948
        // end undo list
4949
        myUndoList->end();
4950
        // disable validation for additionals
4951
        XMLSubSys::setValidation("auto", "auto", "auto");
4952
        if (setSaved) {
4953
            myNet->getSavingStatus()->demandElementsSaved();
4954
        }
4955
        // check if clear undoList
4956
        if (!myAllowUndoRedoLoading) {
4957
            myUndoList->clear();
4958
        }
4959
    }
4960
}
4961

4962

4963
void
4964
GNEApplicationWindow::loadDataElements(const std::string operation) {
4965
    // get option container
4966
    auto& neteditOptions = OptionsCont::getOptions();
4967
    // get data files (don't use reference because it's modified during loading)
4968
    const StringVector dataFiles = neteditOptions.getStringVector("data-files");
4969
    if (myNet && (dataFiles.size() > 0)) {
4970
        // disable validation for additionals
4971
        XMLSubSys::setValidation("never", "auto", "auto");
4972
        // begin undolist
4973
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("% data elements from '%'", operation, toString(dataFiles)));
4974
        // use this flag for mark all elements as saved after loading, if it was sucessfully
4975
        bool setSaved = dataFiles.size() == 1;
4976
        // iterate over every data file
4977
        for (const auto& file : dataFiles) {
4978
            // check if ignore missing inputs
4979
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
4980
                WRITE_MESSAGE(TLF("% data elements from '%'.", operation, file));
4981
                // get (or create) bucket for this new file
4982
                auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::DATA, file, true);
4983
                // declare general handler
4984
                GNEDataHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
4985
                // check if force overwritte
4986
                if (operation == "reloading") {
4987
                    generalHandler.forceOverwriteElements();
4988
                }
4989
                // Run parser
4990
                if (!generalHandler.parse()) {
4991
                    WRITE_ERROR(TLF("% of % failed.", operation, file));
4992
                }
4993
                setSaved &= !generalHandler.isErrorCreatingElement();
4994
            }
4995
        }
4996
        // end undo list
4997
        myUndoList->end();
4998
        // disable validation for additionals
4999
        XMLSubSys::setValidation("auto", "auto", "auto");
5000
        if (setSaved) {
5001
            myNet->getSavingStatus()->dataElementsSaved();
5002
        }
5003
        // check if clear undoList
5004
        if (!myAllowUndoRedoLoading) {
5005
            myUndoList->clear();
5006
        }
5007
    }
5008
}
5009

5010

5011
void
5012
GNEApplicationWindow::loadMeanDataElements(const std::string operation) {
5013
    // get option container
5014
    auto& neteditOptions = OptionsCont::getOptions();
5015
    // get meanData files (don't use reference because it's modified during loading)
5016
    const StringVector meanDataFiles = neteditOptions.getStringVector("meandata-files");
5017
    if (myNet && (meanDataFiles.size() > 0)) {
5018
        // disable validation for additionals
5019
        XMLSubSys::setValidation("never", "auto", "auto");
5020
        // begin undolist
5021
        myUndoList->begin(Supermode::DEMAND, GUIIcon::SUPERMODEDEMAND, TLF("% meanData elements from '%'", operation, toString(meanDataFiles)));
5022
        // use this flag for mark all elements as saved after loading, if it was sucessfully
5023
        bool setSaved = meanDataFiles.size() == 1;
5024
        // iterate over every meanData file
5025
        for (const auto& file : meanDataFiles) {
5026
            // check if ignore missing inputs
5027
            if (FileHelpers::isReadable(file) || !neteditOptions.getBool("ignore-missing-inputs")) {
5028
                WRITE_MESSAGE(TLF("% meanData elements from '%'.", operation, file));
5029
                // get (or create) bucket for this new file
5030
                auto bucket = myFileBucketHandler->getBucket(FileBucket::Type::MEANDATA, file, true);
5031
                // declare general handler
5032
                GNEGeneralHandler generalHandler(myNet, bucket, myAllowUndoRedoLoading ? myAllowUndoRedo : false);
5033
                // check if force overwritte
5034
                if (operation == "reloading") {
5035
                    generalHandler.forceOverwriteElements();
5036
                }
5037
                // Run parser
5038
                if (!generalHandler.parse()) {
5039
                    WRITE_ERROR(TLF("% of % failed.", operation, file));
5040
                }
5041
                setSaved &= !generalHandler.isErrorCreatingElement();
5042
            }
5043
        }
5044
        // end undo list
5045
        myUndoList->end();
5046
        // disable validation for additionals
5047
        XMLSubSys::setValidation("auto", "auto", "auto");
5048
        if (setSaved) {
5049
            myNet->getSavingStatus()->meanDatasSaved();
5050
        }
5051
        // check if clear undoList
5052
        if (!myAllowUndoRedoLoading) {
5053
            myUndoList->clear();
5054
        }
5055
    }
5056
}
5057

5058

5059
void
5060
GNEApplicationWindow::loadTrafficLights(const std::string operation) {
5061
    // get TLS file
5062
    const auto tlsFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::TLS);
5063
    if (tlsFile.size() > 0) {
5064
        // show info
5065
        WRITE_MESSAGE(TLF("% TLS programs from '%'.", operation, tlsFile));
5066
        myUndoList->begin(Supermode::NETWORK, GUIIcon::MODETLS, TLF("% TLS programs from '%'.", operation, tlsFile));
5067
        myNet->computeNetwork(this);
5068
        // parse TLS programs
5069
        if (myNet->getViewParent()->getTLSEditorFrame()->parseTLSPrograms(tlsFile) == false) {
5070
            // Abort undo/redo
5071
            myUndoList->abortAllChangeGroups();
5072
        } else {
5073
            // commit undo/redo operation
5074
            myUndoList->end();
5075
            update();
5076
        }
5077
        // requiere save network
5078
        myNet->getSavingStatus()->requireSaveNetwork();
5079
        // if defined, require save netedit config
5080
        if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
5081
            myNet->getSavingStatus()->requireSaveNeteditConfig();
5082
        }
5083
    }
5084
}
5085

5086

5087
void
5088
GNEApplicationWindow::loadEdgeTypes(const std::string operation) {
5089
    // get edgeType file
5090
    const auto edgeTypeFile = myFileBucketHandler->getDefaultFilename(FileBucket::Type::EDGETYPE);
5091
    if (edgeTypeFile.size() > 0) {
5092
        // declare type container
5093
        NBTypeCont typeContainerAux;
5094
        // declare type handler
5095
        NIXMLTypesHandler handler(typeContainerAux);
5096
        // load edge types
5097
        NITypeLoader::load(handler, {edgeTypeFile}, toString(SUMO_TAG_TYPES));
5098
        // now create GNETypes based on typeContainerAux
5099
        WRITE_MESSAGE(TLF("% edge types from '%'.", operation, edgeTypeFile));
5100
        myUndoList->begin(Supermode::NETWORK, GUIIcon::MODETLS, TLF("% edge types from '%'.", operation, edgeTypeFile));
5101
        // iterate over typeContainerAux
5102
        for (const auto& auxEdgeType : typeContainerAux) {
5103
            // create new edge type
5104
            GNEEdgeType* edgeType = new GNEEdgeType(myNet, auxEdgeType.first, auxEdgeType.second);
5105
            // add lane types
5106
            for (const auto& laneType : auxEdgeType.second->laneTypeDefinitions) {
5107
                edgeType->addLaneType(new GNELaneType(edgeType, laneType));
5108
            }
5109
            // add it using undoList
5110
            myViewNet->getUndoList()->add(new GNEChange_EdgeType(edgeType, true), true);
5111

5112
        }
5113
        // end undo list
5114
        myViewNet->getUndoList()->end();
5115
        // refresh edge type selector
5116
        myViewNet->getViewParent()->getCreateEdgeFrame()->getEdgeTypeSelector()->refreshEdgeTypeSelector();
5117
        // requiere save network
5118
        myNet->getSavingStatus()->requireSaveNetwork();
5119
        // if defined, require save netedit config
5120
        if (myFileBucketHandler->isFilenameDefined(FileBucket::Type::NETEDIT_CONFIG)) {
5121
            myNet->getSavingStatus()->requireSaveNeteditConfig();
5122
        }
5123
    }
5124
}
5125

5126

5127
GNEInternalTest*
5128
GNEApplicationWindow::getInternalTest() const {
5129
    return myInternalTest;
5130
}
5131

5132

5133
bool
5134
GNEApplicationWindow::allowInputSignals(FXObject* obj) const {
5135
    if (myInternalTest == nullptr) {
5136
        return true;
5137
    } else if (obj == myInternalTest) {
5138
        return true;
5139
    } else {
5140
        return false;
5141
    }
5142
}
5143

5144
// ---------------------------------------------------------------------------
5145
// GNEApplicationWindow - protected methods
5146
// ---------------------------------------------------------------------------
5147
#ifdef _MSC_VER
5148
#pragma warning(push)
5149
#pragma warning(disable: 4355) // mask warning about "this" in initializers
5150
#endif
5151
GNEApplicationWindow::GNEApplicationWindow() :
5152
    myToolbarsGrip(this),
5153
    myMenuBarFile(this),
5154
    myFileMenuCommands(this),
5155
    myModesMenuCommands(this),
5156
    myEditMenuCommands(this),
5157
    myLockMenuCommands(this),
5158
    myProcessingMenuCommands(this),
5159
    myLocateMenuCommands(this),
5160
    myToolsMenuCommands(this),
5161
    myWindowsMenuCommands(this),
5162
    myHelpMenuCommands(this),
5163
    mySupermodeCommands(this) {
5164
}
5165
#ifdef _MSC_VER
5166
#pragma warning(pop)
5167
#endif
5168

5169

5170
long
5171
GNEApplicationWindow::onKeyPress(FXObject* o, FXSelector sel, void* eventData) {
5172
    const long handled = FXMainWindow::onKeyPress(o, sel, eventData);
5173
    if (handled == 0 && myMDIClient->numChildren() > 0) {
5174
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
5175
        if (w != nullptr) {
5176
            w->onKeyPress(nullptr, sel, eventData);
5177
        }
5178
    }
5179
    return 0;
5180
}
5181

5182

5183
long
5184
GNEApplicationWindow::onKeyRelease(FXObject* o, FXSelector sel, void* eventData) {
5185
    const long handled = FXMainWindow::onKeyRelease(o, sel, eventData);
5186
    if (handled == 0 && myMDIClient->numChildren() > 0) {
5187
        GNEViewParent* w = dynamic_cast<GNEViewParent*>(myMDIClient->getActiveChild());
5188
        if (w != nullptr) {
5189
            w->onKeyRelease(nullptr, sel, eventData);
5190
        }
5191
    }
5192
    return 0;
5193
}
5194

5195

5196
/****************************************************************************/
5197

5198
Product

Resources

Company
