SUMO - Simulation of Urban MObility
GNEViewNet.cpp
Go to the documentation of this file.
1 /****************************************************************************/
8 // A view on the network being edited (adapted from GUIViewTraffic)
9 /****************************************************************************/
10 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
11 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
12 /****************************************************************************/
13 //
14 // This file is part of SUMO.
15 // SUMO is free software: you can redistribute it and/or modify
16 // it under the terms of the GNU General Public License as published by
17 // the Free Software Foundation, either version 3 of the License, or
18 // (at your option) any later version.
19 //
20 /****************************************************************************/
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #ifdef _MSC_VER
27 #include <windows_config.h>
28 #else
29 #include <config.h>
30 #endif
31 
32 #include <iostream>
33 #include <utility>
34 #include <cmath>
35 #include <limits>
36 #include <foreign/polyfonts/polyfonts.h>
37 #include <utils/gui/globjects/GLIncludes.h>
38 #include <utils/foxtools/MFXImageHelper.h>
39 #include <utils/foxtools/MFXCheckableButton.h>
40 #include <utils/common/RGBColor.h>
41 #include <utils/options/OptionsCont.h>
42 #include <utils/geom/PositionVector.h>
43 #include <utils/gui/windows/GUISUMOAbstractView.h>
44 #include <utils/gui/windows/GUIDanielPerspectiveChanger.h>
45 #include <utils/gui/windows/GUIAppEnum.h>
46 #include <utils/gui/images/GUIIconSubSys.h>
47 #include <utils/gui/images/GUITextureSubSys.h>
48 #include <utils/gui/windows/GUIDialog_ViewSettings.h>
49 #include <utils/gui/settings/GUICompleteSchemeStorage.h>
50 #include <utils/gui/images/GUITexturesHelper.h>
51 #include <utils/gui/globjects/GUIGlObjectStorage.h>
52 #include <utils/gui/div/GLHelper.h>
53 #include <utils/gui/div/GUIGlobalSelection.h>
54 #include <utils/gui/div/GUIDesigns.h>
55 #include <utils/xml/XMLSubSys.h>
56 
57 #include "GNEViewNet.h"
58 #include "GNEEdge.h"
59 #include "GNELane.h"
60 #include "GNEJunction.h"
61 #include "GNEPOI.h"
62 #include "GNEApplicationWindow.h"
63 #include "GNEViewParent.h"
64 #include "GNENet.h"
65 #include "GNEUndoList.h"
66 #include "GNEInspectorFrame.h"
67 #include "GNESelectorFrame.h"
68 #include "GNEConnectorFrame.h"
69 #include "GNETLSEditorFrame.h"
70 #include "GNEAdditionalFrame.h"
71 #include "GNECrossingFrame.h"
72 #include "GNEDeleteFrame.h"
73 #include "GNEAdditionalHandler.h"
74 #include "GNEPoly.h"
75 #include "GNECrossing.h"
76 #include "GNEAdditional.h"
77 #include "GNEAdditionalDialog.h"
78 #include "GNERerouter.h"
79 #include "GNEConnection.h"
80 
81 
82 #ifdef CHECK_MEMORY_LEAKS
83 #include <foreign/nvwa/debug_new.h>
84 #endif // CHECK_MEMORY_LEAKS
85 
86 // ===========================================================================
87 // FOX callback mapping
88 // ===========================================================================
89 FXDEFMAP(GNEViewNet) GNEViewNetMap[] = {
90  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_CREATE_EDGE, GNEViewNet::onCmdSetModeCreateEdge),
91  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_MOVE, GNEViewNet::onCmdSetModeMove),
92  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_DELETE, GNEViewNet::onCmdSetModeDelete),
93  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_INSPECT, GNEViewNet::onCmdSetModeInspect),
94  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_SELECT, GNEViewNet::onCmdSetModeSelect),
95  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_CONNECT, GNEViewNet::onCmdSetModeConnect),
96  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_TLS, GNEViewNet::onCmdSetModeTLS),
97  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_ADDITIONAL, GNEViewNet::onCmdSetModeAdditional),
98  FXMAPFUNC(SEL_COMMAND, MID_GNE_MODE_CROSSING, GNEViewNet::onCmdSetModeCrossing),
99  FXMAPFUNC(SEL_COMMAND, MID_GNE_SPLIT_EDGE, GNEViewNet::onCmdSplitEdge),
100  FXMAPFUNC(SEL_COMMAND, MID_GNE_SPLIT_EDGE_BIDI, GNEViewNet::onCmdSplitEdgeBidi),
101  FXMAPFUNC(SEL_COMMAND, MID_GNE_REVERSE_EDGE, GNEViewNet::onCmdReverseEdge),
102  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADD_REVERSE_EDGE, GNEViewNet::onCmdAddReversedEdge),
103  FXMAPFUNC(SEL_COMMAND, MID_GNE_SET_EDGE_ENDPOINT, GNEViewNet::onCmdSetEdgeEndpoint),
104  FXMAPFUNC(SEL_COMMAND, MID_GNE_RESET_EDGE_ENDPOINT, GNEViewNet::onCmdResetEdgeEndpoint),
105  FXMAPFUNC(SEL_COMMAND, MID_GNE_STRAIGHTEN, GNEViewNet::onCmdStraightenEdges),
106  FXMAPFUNC(SEL_COMMAND, MID_GNE_SIMPLIFY_SHAPE, GNEViewNet::onCmdSimplifyShape),
107  FXMAPFUNC(SEL_COMMAND, MID_GNE_DELETE_GEOMETRY, GNEViewNet::onCmdDeleteGeometry),
108  FXMAPFUNC(SEL_COMMAND, MID_GNE_DUPLICATE_LANE, GNEViewNet::onCmdDuplicateLane),
109  FXMAPFUNC(SEL_COMMAND, MID_GNE_TRANSFORM_LANE_SIDEWALK, GNEViewNet::onCmdRestrictLaneSidewalk),
110  FXMAPFUNC(SEL_COMMAND, MID_GNE_TRANSFORM_LANE_BIKE, GNEViewNet::onCmdRestrictLaneBikelane),
111  FXMAPFUNC(SEL_COMMAND, MID_GNE_TRANSFORM_LANE_BUS, GNEViewNet::onCmdRestrictLaneBuslane),
112  FXMAPFUNC(SEL_COMMAND, MID_GNE_REVERT_TRANSFORMATION, GNEViewNet::onCmdRevertRestriction),
113  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADD_LANE_SIDEWALK, GNEViewNet::onCmdAddRestrictedLaneSidewalk),
114  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADD_LANE_BIKE, GNEViewNet::onCmdAddRestrictedLaneBikelane),
115  FXMAPFUNC(SEL_COMMAND, MID_GNE_ADD_LANE_BUS, GNEViewNet::onCmdAddRestrictedLaneBuslane),
116  FXMAPFUNC(SEL_COMMAND, MID_GNE_REMOVE_LANE_SIDEWALK, GNEViewNet::onCmdRemoveRestrictedLaneSidewalk),
117  FXMAPFUNC(SEL_COMMAND, MID_GNE_REMOVE_LANE_BIKE, GNEViewNet::onCmdRemoveRestrictedLaneBikelane),
118  FXMAPFUNC(SEL_COMMAND, MID_GNE_REMOVE_LANE_BUS, GNEViewNet::onCmdRemoveRestrictedLaneBuslane),
119  FXMAPFUNC(SEL_COMMAND, MID_GNE_NODE_SHAPE, GNEViewNet::onCmdNodeShape),
120  FXMAPFUNC(SEL_COMMAND, MID_GNE_NODE_REPLACE, GNEViewNet::onCmdNodeReplace),
121  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHOW_CONNECTIONS, GNEViewNet::onCmdToogleShowConnection),
122  FXMAPFUNC(SEL_COMMAND, MID_GNE_SHOW_BUBBLES, GNEViewNet::onCmdToogleShowBubbles)
123 };
124 
125 // Object implementation
126 FXIMPLEMENT(GNEViewNet, GUISUMOAbstractView, GNEViewNetMap, ARRAYNUMBER(GNEViewNetMap))
127 
128 // ===========================================================================
129 // member method definitions
130 // ===========================================================================
131 GNEViewNet::GNEViewNet(FXComposite* tmpParent, FXComposite* actualParent, GUIMainWindow& app,
132  GNEViewParent* viewParent, GNENet* net, GNEUndoList* undoList,
133  FXGLVisual* glVis, FXGLCanvas* share, FXToolBar* toolBar) :
134  GUISUMOAbstractView(tmpParent, app, viewParent, net->getVisualisationSpeedUp(), glVis, share),
135  myViewParent(viewParent),
136  myNet(net),
137  myEditMode(GNE_MODE_MOVE),
138  myPreviousEditMode(GNE_MODE_MOVE),
139  myShowConnectionActivated(false),
140  myCreateEdgeSource(0),
141  myJunctionToMove(0),
142  myEdgeToMove(0),
143  myPolyToMove(0),
144  myPoiToMove(0),
145  myAdditionalToMove(0),
146  myMoveSelection(false),
147  myAmInRectSelect(false),
148  myToolbar(toolBar),
149  myEditModeCreateEdge(0),
150  myEditModeMove(0),
151  myEditModeDelete(0),
152  myEditModeInspect(0),
153  myEditModeSelect(0),
154  myEditModeConnection(0),
155  myEditModeTrafficLight(0),
156  myEditModeAdditional(0),
157  myEditModeCrossing(0),
158  myEditModeNames(),
159  myUndoList(undoList),
160  myCurrentPoly(0),
161  myTestingMode(OptionsCont::getOptions().getBool("gui-testing")) {
162  // view must be the final member of actualParent
163  reparent(actualParent);
164 
165  buildEditModeControls();
166  myUndoList->mark();
167  myNet->setViewNet(this);
168 
169  ((GUIDanielPerspectiveChanger*)myChanger)->setDragDelay(100000000); // 100 milliseconds
170 
171  // init color schemes
172  GUIColorer laneColorer;
173  GUIColorScheme scheme = GUIColorScheme("uniform", RGBColor::BLACK, "road", true);
174  scheme.addColor(RGBColor::GREY, 1, "Sidewalk");
175  scheme.addColor(RGBColor(192, 66, 44), 2, "bike lane");
176  scheme.addColor(RGBColor(200, 255, 200), 3, "green verge");
177  scheme.addColor(RGBColor(150, 200, 200), 4, "waterway");
178  scheme.addColor(RGBColor(92, 92, 92), 5, "no passenger"); // paths, service roads etc
179  laneColorer.addScheme(scheme);
180  scheme = GUIColorScheme("by selection (lane-/streetwise)", RGBColor(128, 128, 128, 255), "unselected", true);
181  scheme.addColor(RGBColor(0, 80, 180, 255), 1, "selected");
182  laneColorer.addScheme(scheme);
183  scheme = GUIColorScheme("by permission code", RGBColor(240, 240, 240), "nobody");
184  scheme.addColor(RGBColor(10, 10, 10), (SUMOReal)SVC_PASSENGER, "passenger");
185  scheme.addColor(RGBColor(128, 128, 128), (SUMOReal)SVC_PEDESTRIAN, "pedestrian");
186  scheme.addColor(RGBColor(80, 80, 80), (SUMOReal)(SVC_PEDESTRIAN | SVC_DELIVERY), "pedestrian_delivery");
187  scheme.addColor(RGBColor(192, 66, 44), (SUMOReal)SVC_BICYCLE, "bicycle");
188  scheme.addColor(RGBColor(40, 100, 40), (SUMOReal)SVC_BUS, "bus");
189  scheme.addColor(RGBColor(166, 147, 26), (SUMOReal)SVC_TAXI, "taxi");
190  scheme.addColor(RGBColor::BLACK, (SUMOReal)(SVCAll & ~SVC_NON_ROAD), "normal_road");
191  scheme.addColor(RGBColor::BLACK, (SUMOReal)(SVCAll & ~(SVC_PEDESTRIAN | SVC_NON_ROAD)), "disallow_pedestrian");
192  scheme.addColor(RGBColor(255, 206, 0), (SUMOReal)(SVCAll & ~(SVC_PEDESTRIAN | SVC_BICYCLE | SVC_MOPED | SVC_NON_ROAD)), "motorway");
193  scheme.addColor(RGBColor(150, 200, 200), (SUMOReal)SVC_SHIP, "waterway");
194  scheme.addColor(RGBColor::GREEN, (SUMOReal)SVCAll, "all");
195  laneColorer.addScheme(scheme);
196 
197  scheme = GUIColorScheme("by allowed speed (lanewise)", RGBColor::RED);
198  scheme.addColor(RGBColor::YELLOW, (SUMOReal)(30 / 3.6));
199  scheme.addColor(RGBColor::GREEN, (SUMOReal)(55 / 3.6));
200  scheme.addColor(RGBColor::CYAN, (SUMOReal)(80 / 3.6));
201  scheme.addColor(RGBColor::BLUE, (SUMOReal)(120 / 3.6));
202  scheme.addColor(RGBColor::MAGENTA, (SUMOReal)(150 / 3.6));
203  laneColorer.addScheme(scheme);
204 
205  scheme = GUIColorScheme("by lane number (streetwise)", RGBColor::RED);
206  scheme.addColor(RGBColor::BLUE, (SUMOReal)5);
207  laneColorer.addScheme(scheme);
208 
209  scheme = GUIColorScheme("by given length/geometrical length", RGBColor::BLACK);
210  scheme.addColor(RGBColor::RED, (SUMOReal)0.25);
211  scheme.addColor(RGBColor::YELLOW, (SUMOReal)0.5);
212  scheme.addColor(RGBColor(179, 179, 179, 255), (SUMOReal)1.0);
213  scheme.addColor(RGBColor::GREEN, (SUMOReal)2.0);
214  scheme.addColor(RGBColor::BLUE, (SUMOReal)4.0);
215  laneColorer.addScheme(scheme);
216  laneColorer.addScheme(GUIColorScheme("by angle", RGBColor::YELLOW, "", true));
217 
218  scheme = GUIColorScheme("by priority", RGBColor::YELLOW);
219  scheme.addColor(RGBColor::RED, (SUMOReal) - 20);
220  scheme.addColor(RGBColor::GREEN, (SUMOReal)20);
221  scheme.setAllowsNegativeValues(true);
222  laneColorer.addScheme(scheme);
223  scheme = GUIColorScheme("by height at start", RGBColor::RED);
224  scheme.addColor(RGBColor::BLUE, (SUMOReal) - 10);
225  scheme.addColor(RGBColor::YELLOW, (SUMOReal)50);
226  scheme.addColor(RGBColor::GREEN, (SUMOReal)100);
227  scheme.addColor(RGBColor::MAGENTA, (SUMOReal)200);
228  scheme.setAllowsNegativeValues(true);
229  laneColorer.addScheme(scheme);
230  scheme = GUIColorScheme("by height at segment start", RGBColor::RED);
231  scheme.addColor(RGBColor::BLUE, (SUMOReal) - 10);
232  scheme.addColor(RGBColor::YELLOW, (SUMOReal)50);
233  scheme.addColor(RGBColor::GREEN, (SUMOReal)100);
234  scheme.addColor(RGBColor::MAGENTA, (SUMOReal)200);
235  scheme.setAllowsNegativeValues(true);
236  laneColorer.addScheme(scheme);
237  scheme = GUIColorScheme("by inclination", RGBColor::GREY);
238  scheme.addColor(RGBColor::YELLOW, (SUMOReal) .1);
239  scheme.addColor(RGBColor::RED, (SUMOReal) .3);
240  scheme.addColor(RGBColor::GREEN, (SUMOReal) - .1);
241  scheme.addColor(RGBColor::BLUE, (SUMOReal) - .3);
242  scheme.setAllowsNegativeValues(true);
243  laneColorer.addScheme(scheme);
244  scheme = GUIColorScheme("by segment inclination", RGBColor::GREY);
245  scheme.addColor(RGBColor::YELLOW, (SUMOReal) .1);
246  scheme.addColor(RGBColor::RED, (SUMOReal) .3);
247  scheme.addColor(RGBColor::GREEN, (SUMOReal) - .1);
248  scheme.addColor(RGBColor::BLUE, (SUMOReal) - .3);
249  scheme.setAllowsNegativeValues(true);
250  laneColorer.addScheme(scheme);
251 
252  myVisualizationSettings->laneColorer = laneColorer;
253 
254  GUIColorer junctionColorer;
255  scheme = GUIColorScheme("uniform", RGBColor(102, 0, 0), "", true);
256  scheme.addColor(RGBColor(204, 0, 0), 1, "shape not computed");
257  scheme.addColor(RGBColor(153, 0, 0), 2, "geometry points");
258  junctionColorer.addScheme(scheme);
259  scheme = GUIColorScheme("by selection", RGBColor(128, 128, 128, 255), "unselected", true);
260  scheme.addColor(RGBColor(0, 80, 180, 255), 1, "selected");
261  junctionColorer.addScheme(scheme);
262  scheme = GUIColorScheme("by type", RGBColor::GREEN, "traffic_light", true);
263  scheme.addColor(RGBColor(0, 128, 0), 1, "traffic_light_unregulated");
264  scheme.addColor(RGBColor::YELLOW, 2, "priority");
265  scheme.addColor(RGBColor::RED, 3, "priority_stop");
266  scheme.addColor(RGBColor::BLUE, 4, "right_before_left");
267  scheme.addColor(RGBColor::CYAN, 5, "allway_stop");
268  scheme.addColor(RGBColor::GREY, 6, "district");
269  scheme.addColor(RGBColor::MAGENTA, 7, "unregulated");
270  scheme.addColor(RGBColor::BLACK, 8, "dead_end");
271  scheme.addColor(RGBColor::ORANGE, 9, "rail_signal");
272  scheme.addColor(RGBColor(192, 128, 64), 10, "zipper");
273  scheme.addColor(RGBColor(192, 255, 192), 11, "traffic_light_right_on_red");
274  scheme.addColor(RGBColor(128, 0, 128), 12, "rail_crossing"); // dark purple
275  junctionColorer.addScheme(scheme);
276  myVisualizationSettings->junctionColorer = junctionColorer;
277 
278  if (myTestingMode && OptionsCont::getOptions().isSet("window-size")) {
279  std::vector<std::string> windowSize = OptionsCont::getOptions().getStringVector("window-size");
280  assert(windowSize.size() == 2);
281  myTestingWidth = TplConvert::_str2int(windowSize[0]);
282  myTestingHeight = TplConvert::_str2int(windowSize[1]);
283  }
284 }
285 
286 
287 GNEViewNet::~GNEViewNet() { }
288 
289 
290 void
291 GNEViewNet::doInit() {}
292 
293 
294 void
295 GNEViewNet::buildViewToolBars(GUIGlChildWindow& cw) {
296  /*
297  // build coloring tools
298  {
299  const std::vector<std::string> &names = gSchemeStorage.getNames();
300  for (std::vector<std::string>::const_iterator i=names.begin(); i!=names.end(); ++i) {
301  v.getColoringSchemesCombo().appendItem((*i).c_str());
302  if ((*i) == myVisualizationSettings->name) {
303  v.getColoringSchemesCombo().setCurrentItem(v.getColoringSchemesCombo().getNumItems()-1);
304  }
305  }
306  v.getColoringSchemesCombo().setNumVisible(5);
307  }
308  */
309 
310  // locator button for junctions
311  new FXButton(cw.getLocatorPopup(),
312  "\tLocate Junction\tLocate a junction within the network.",
313  GUIIconSubSys::getIcon(ICON_LOCATEJUNCTION), &cw, MID_LOCATEJUNCTION,
314  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
315  // locator button for edges
316  new FXButton(cw.getLocatorPopup(),
317  "\tLocate Street\tLocate a street within the network.",
318  GUIIconSubSys::getIcon(ICON_LOCATEEDGE), &cw, MID_LOCATEEDGE,
319  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
320  // locator button for tls
321  new FXButton(cw.getLocatorPopup(),
322  "\tLocate TLS\tLocate a traffic light within the network.",
323  GUIIconSubSys::getIcon(ICON_LOCATETLS), &cw, MID_LOCATETLS,
324  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
325 }
326 
327 
328 bool
329 GNEViewNet::setColorScheme(const std::string& name) {
330  if (!gSchemeStorage.contains(name)) {
331  return false;
332  }
333  if (myVisualizationChanger != 0) {
334  if (myVisualizationChanger->getCurrentScheme() != name) {
335  myVisualizationChanger->setCurrentScheme(name);
336  }
337  }
338  myVisualizationSettings = &gSchemeStorage.get(name.c_str());
339  update();
340  return true;
341 }
342 
343 
344 void
345 GNEViewNet::setStatusBarText(const std::string& text) {
346  myApp->setStatusBarText(text);
347 }
348 
349 
350 bool
351 GNEViewNet::selectEdges() {
352  return mySelectEdges->getCheck() != 0;
353 }
354 
355 
356 bool
357 GNEViewNet::showConnections() {
358  if (myEditMode == GNE_MODE_CONNECT) {
359  return true;
360  } else if (myShowConnections->shown() == false) {
361  return false;
362  } else {
363  return (myShowConnections->getCheck() == 1);
364  }
365 }
366 
367 
368 bool
369 GNEViewNet::autoSelectNodes() {
370  return myExtendToEdgeNodes->getCheck() != 0;
371 }
372 
373 
374 void
375 GNEViewNet::setSelectionScaling(SUMOReal selectionScale) {
376  myVisualizationSettings->selectionScale = selectionScale;
377 }
378 
379 
380 bool
381 GNEViewNet::changeAllPhases() const {
382  return myChangeAllPhases->getCheck() != FALSE;
383 }
384 
385 
386 bool
387 GNEViewNet::showJunctionAsBubbles() const {
388  return (myEditMode == GNE_MODE_MOVE) && (myShowBubbleOverJunction->getCheck());
389 }
390 
391 
392 int
393 GNEViewNet::doPaintGL(int mode, const Boundary& bound) {
394  // init view settings
395  glRenderMode(mode);
396  glMatrixMode(GL_MODELVIEW);
397  glPushMatrix();
398  glDisable(GL_TEXTURE_2D);
399  glDisable(GL_ALPHA_TEST);
400  glDisable(GL_BLEND);
401  glEnable(GL_DEPTH_TEST);
402 
403  // visualize rectangular selection
404  if (myAmInRectSelect) {
405  glPushMatrix();
406  glTranslated(0, 0, GLO_MAX - 1);
407  GLHelper::setColor(GNENet::selectionColor);
408  glLineWidth(2);
409  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
410  glBegin(GL_QUADS);
411  glVertex2d(mySelCorner1.x(), mySelCorner1.y());
412  glVertex2d(mySelCorner1.x(), mySelCorner2.y());
413  glVertex2d(mySelCorner2.x(), mySelCorner2.y());
414  glVertex2d(mySelCorner2.x(), mySelCorner1.y());
415  glEnd();
416  glPopMatrix();
417  }
418 
419  // compute lane width
420  SUMOReal lw = m2p(SUMO_const_laneWidth);
421  // draw decals (if not in grabbing mode)
422  if (!myUseToolTips) {
423  drawDecals();
424  if (myVisualizationSettings->showGrid) {
425  paintGLGrid();
426  }
427  if (myTestingMode) {
428  if (myTestingWidth > 0 && (getWidth() != myTestingWidth || getHeight() != myTestingHeight)) {
429  // only resize once to avoid flickering
430  //std::cout << " before resize: view=" << getWidth() << ", " << getHeight() << " app=" << myApp->getWidth() << ", " << myApp->getHeight() << "\n";
431  myApp->resize(myTestingWidth + myTestingWidth - getWidth(), myTestingHeight + myTestingHeight - getHeight());
432  //std::cout << " directly after resize: view=" << getWidth() << ", " << getHeight() << " app=" << myApp->getWidth() << ", " << myApp->getHeight() << "\n";
433  myTestingWidth = 0;
434  }
435  //std::cout << " fixed: view=" << getWidth() << ", " << getHeight() << " app=" << myApp->getWidth() << ", " << myApp->getHeight() << "\n";
436  // draw pink square in the upper left corner on top of everything
437  glPushMatrix();
438  const SUMOReal size = p2m(32);
439  Position center = screenPos2NetPos(8, 8);
440  GLHelper::setColor(RGBColor::MAGENTA);
441  glTranslated(center.x(), center.y(), GLO_MAX - 1);
442  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
443  glBegin(GL_QUADS);
444  glVertex2d(0, 0);
445  glVertex2d(0, -size);
446  glVertex2d(size, -size);
447  glVertex2d(size, 0);
448  glEnd();
449  glPopMatrix();
450 
451  // Reset textures due bug #2780. This solution is only provisional, and must be updated in the future
452  GUITextureSubSys::resetTextures();
453  }
454  }
455  glLineWidth(1);
456  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
457  const float minB[2] = { (float)bound.xmin(), (float)bound.ymin() };
458  const float maxB[2] = { (float)bound.xmax(), (float)bound.ymax() };
459  myVisualizationSettings->scale = lw;
460  glEnable(GL_POLYGON_OFFSET_FILL);
461  glEnable(GL_POLYGON_OFFSET_LINE);
462  myVisualizationSettings->editMode = myEditMode;
463  int hits2 = myGrid->Search(minB, maxB, *myVisualizationSettings);
464 
465  glTranslated(0, 0, GLO_ADDITIONAL);
466  for (std::map<const GUIGlObject*, int>::iterator i = myAdditionallyDrawn.begin(); i != myAdditionallyDrawn.end(); ++i) {
467  (i->first)->drawGLAdditional(this, *myVisualizationSettings);
468  }
469  glPopMatrix();
470  return hits2;
471 }
472 
473 
474 long
475 GNEViewNet::onLeftBtnPress(FXObject* obj, FXSelector sel, void* data) {
476  FXEvent* e = (FXEvent*) data;
477  setFocus();
478  // interpret object under curser
479  if (makeCurrent()) {
480  int id = getObjectUnderCursor();
481  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
482  GUIGlObjectStorage::gIDStorage.unblockObject(id);
483  GNEJunction* pointed_junction = 0;
484  GNELane* pointed_lane = 0;
485  GNEEdge* pointed_edge = 0;
486  GNEPOI* pointed_poi = 0;
487  GNEPoly* pointed_poly = 0;
488  GNECrossing* pointed_crossing = 0;
489  GNEAdditional* pointed_additional = 0;
490  GNEConnection* pointed_connection = 0;
491  if (pointed) {
492  switch (pointed->getType()) {
493  case GLO_JUNCTION:
494  pointed_junction = (GNEJunction*)pointed;
495  break;
496  case GLO_EDGE:
497  pointed_edge = (GNEEdge*)pointed;
498  break;
499  case GLO_LANE:
500  pointed_lane = (GNELane*)pointed;
501  pointed_edge = &(pointed_lane->getParentEdge());
502  break;
503  case GLO_POI:
504  pointed_poi = (GNEPOI*)pointed;
505  break;
506  case GLO_POLYGON:
507  pointed_poly = (GNEPoly*)pointed;
508  break;
509  case GLO_CROSSING:
510  pointed_crossing = (GNECrossing*)pointed;
511  break;
512  case GLO_ADDITIONAL:
513  pointed_additional = (GNEAdditional*)pointed;
514  break;
515  case GLO_CONNECTION:
516  pointed_connection = (GNEConnection*)pointed;
517  break;
518  default:
519  pointed = 0;
520  break;
521  }
522  }
523 
524  // decide what to do based on mode
525  switch (myEditMode) {
526  case GNE_MODE_CREATE_EDGE: {
527  if ((e->state & CONTROLMASK) == 0) {
528  // allow moving when control is held down
529  if (!myUndoList->hasCommandGroup()) {
530  myUndoList->p_begin("create new " + toString(SUMO_TAG_EDGE));
531  }
532  if (!pointed_junction) {
533  pointed_junction = myNet->createJunction(getPositionInformation(), myUndoList);
534  }
535  if (myCreateEdgeSource == 0) {
536  myCreateEdgeSource = pointed_junction;
537  myCreateEdgeSource->markAsCreateEdgeSource();
538  update();
539  } else {
540  if (myCreateEdgeSource != pointed_junction) {
541  // may fail to prevent double edges
542  GNEEdge* newEdge = myNet->createEdge(
543  myCreateEdgeSource, pointed_junction, myViewParent->getInspectorFrame()->getEdgeTemplate(), myUndoList);
544  if (newEdge) {
545  if (myAutoCreateOppositeEdge->getCheck()) {
546  myNet->createEdge(
547  pointed_junction, myCreateEdgeSource, myViewParent->getInspectorFrame()->getEdgeTemplate(), myUndoList, "-" + newEdge->getNBEdge()->getID());
548  }
549  myCreateEdgeSource->unMarkAsCreateEdgeSource();
550  if (myUndoList->hasCommandGroup()) {
551  myUndoList->p_end();
552  } else {
553  std::cout << "edge created without an open CommandGroup )-:\n";
554  }
555  if (myChainCreateEdge->getCheck()) {
556  myCreateEdgeSource = pointed_junction;
557  myCreateEdgeSource->markAsCreateEdgeSource();
558  myUndoList->p_begin("create new " + toString(SUMO_TAG_EDGE));
559  } else {
560  myCreateEdgeSource = 0;
561  }
562  } else {
563  setStatusBarText("An edge with the same geometry already exists!");
564  }
565  } else {
566  setStatusBarText("Start- and endpoint for an edge must be distinct!");
567  }
568  update();
569  }
570  }
571  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
572  break;
573  }
574  case GNE_MODE_MOVE: {
575  if (pointed_poly) {
576  myPolyToMove = pointed_poly;
577  myMoveSrc = getPositionInformation();
578  } else if (pointed_poi) {
579  myPoiToMove = pointed_poi;
580  myMoveSrc = getPositionInformation();
581  } else if (pointed_junction) {
582  if (gSelected.isSelected(GLO_JUNCTION, pointed_junction->getGlID())) {
583  myMoveSelection = true;
584  } else {
585  myJunctionToMove = pointed_junction;
586  }
587  myMoveSrc = getPositionInformation();
588  } else if (pointed_edge) {
589  if (gSelected.isSelected(GLO_EDGE, pointed_edge->getGlID())) {
590  myMoveSelection = true;
591  } else {
592  myEdgeToMove = pointed_edge;
593  }
594  myMoveSrc = getPositionInformation();
595  } else if (pointed_additional) {
596  if (gSelected.isSelected(GLO_ADDITIONAL, pointed_additional->getGlID())) {
597  myMoveSelection = true;
598  } else {
599  // Only move additional if can be moved
600  if (pointed_additional->isAdditionalBlocked() == false) {
601  myAdditionalToMove = pointed_additional;
602  if (myAdditionalToMove->getLane()) {
603  if (GNEAttributeCarrier::hasAttribute(myAdditionalToMove->getTag(), SUMO_ATTR_STARTPOS)) {
604  // Obtain start position
605  SUMOReal startPos = GNEAttributeCarrier::parse<SUMOReal>(myAdditionalToMove->getAttribute(SUMO_ATTR_STARTPOS));
606  if (GNEAttributeCarrier::hasAttribute(myAdditionalToMove->getTag(), SUMO_ATTR_ENDPOS)) {
607  // Obtain end position
608  SUMOReal endPos = GNEAttributeCarrier::parse<SUMOReal>(myAdditionalToMove->getAttribute(SUMO_ATTR_ENDPOS));
609  // Save both values in myOldAdditionalPosition
610  myOldAdditionalPosition.set(startPos, endPos);
611  } else if (GNEAttributeCarrier::hasAttribute(myAdditionalToMove->getTag(), SUMO_ATTR_LENGTH)) {
612  // Obtain length attribute
613  SUMOReal length = GNEAttributeCarrier::parse<SUMOReal>(myAdditionalToMove->getAttribute(SUMO_ATTR_LENGTH));
614  // Save both values in myOldAdditionalPosition
615  myOldAdditionalPosition.set(startPos, length);
616  } else {
617  // Save only startpos in myOldAdditionalPosition
618  myOldAdditionalPosition.set(startPos, 0);
619  }
620  }
621  // Set myAdditionalMovingReference
622  myAdditionalMovingReference.set(pointed_additional->getLane()->getShape().nearest_offset_to_point2D(getPositionInformation(), false), 0, 0);
623  } else {
624  // Set myOldAdditionalPosition and myAdditionalMovingReference
625  myOldAdditionalPosition = getPositionInformation();
626  myAdditionalMovingReference = pointed_additional->getPositionInView() - getPositionInformation();
627  }
628  }
629  }
630  } else {
631  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
632  }
633  update();
634  break;
635  }
636  case GNE_MODE_DELETE: {
637  // Check if Control key is pressed
638  bool markElementMode = (((FXEvent*)data)->state & CONTROLMASK) != 0;
639  GNEAttributeCarrier* ac = dynamic_cast<GNEAttributeCarrier*>(pointed);
640  if (ac) {
641  // if pointed element is an attribute carrier, remove it or mark it
642  if (markElementMode) {
643  if (myViewParent->getDeleteFrame()->getMarkedAttributeCarrier() != ac) {
644  myViewParent->getDeleteFrame()->markAttributeCarrier(ac);
645  myViewParent->getDeleteFrame()->showAttributeCarrierChilds(ac);
646  }
647  } else if (myViewParent->getDeleteFrame()->getMarkedAttributeCarrier() != NULL) {
648  myViewParent->getDeleteFrame()->markAttributeCarrier(NULL);
649  myViewParent->getDeleteFrame()->showAttributeCarrierChilds(ac);
650  } else {
651  myViewParent->getDeleteFrame()->removeAttributeCarrier(ac);
652  }
653  } else {
654  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
655  }
656  break;
657  }
658  case GNE_MODE_INSPECT: {
659  GNEAttributeCarrier* pointedAC = 0;
660  GUIGlObject* pointedO = 0;
661  if (pointed_junction) {
662  pointedAC = pointed_junction;
663  pointedO = pointed_junction;
664  } else if (pointed_lane) { // implies pointed_edge
665  if (selectEdges()) {
666  pointedAC = pointed_edge;
667  pointedO = pointed_edge;
668  } else {
669  pointedAC = pointed_lane;
670  pointedO = pointed_lane;
671  }
672  } else if (pointed_edge) {
673  pointedAC = pointed_edge;
674  pointedO = pointed_edge;
675  } else if (pointed_crossing) {
676  pointedAC = pointed_crossing;
677  pointedO = pointed_crossing;
678  } else if (pointed_additional) {
679  pointedAC = pointed_additional;
680  pointedO = pointed_additional;
681  } else if (pointed_connection) {
682  pointedAC = pointed_connection;
683  pointedO = pointed_connection;
684  }
685  // obtain selected ACs
686  std::vector<GNEAttributeCarrier*> selected;
687  if (pointedO && gSelected.isSelected(pointedO->getType(), pointedO->getGlID())) {
688  std::set<GUIGlID> selectedIDs = gSelected.getSelected(pointedO->getType());
689  selected = myNet->retrieveAttributeCarriers(selectedIDs, pointedO->getType());
690  } else if (pointedAC != 0) {
691  selected.push_back(pointedAC);
692  }
693  // Inspect seleted ACs, or single clicked AC
694  myViewParent->getInspectorFrame()->inspectMultisection(selected);
695  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
696  update();
697  break;
698  }
699  case GNE_MODE_SELECT:
700  if (pointed_lane && selectEdges()) {
701  gSelected.toggleSelection(pointed_edge->getGlID());
702  } else if (pointed) {
703  gSelected.toggleSelection(pointed->getGlID());
704  }
705 
706  myAmInRectSelect = (((FXEvent*)data)->state & SHIFTMASK) != 0;
707  if (myAmInRectSelect) {
708  mySelCorner1 = getPositionInformation();
709  mySelCorner2 = getPositionInformation();
710  } else {
711  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
712  }
713  update();
714  break;
715 
716  case GNE_MODE_CONNECT: {
717  if (pointed_lane) {
718  const bool mayPass = (((FXEvent*)data)->state & SHIFTMASK) != 0;
719  const bool allowConflict = (((FXEvent*)data)->state & CONTROLMASK) != 0;
720  myViewParent->getConnectorFrame()->handleLaneClick(pointed_lane, mayPass, allowConflict, true);
721  update();
722  }
723  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
724  break;
725  }
726  case GNE_MODE_TLS: {
727  if (pointed_junction) {
728  myViewParent->getTLSEditorFrame()->editJunction(pointed_junction);
729  update();
730  }
731  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
732  break;
733  }
734  case GNE_MODE_ADDITIONAL: {
735  if (pointed_additional == NULL) {
736  GNENetElement* netElement = dynamic_cast<GNENetElement*>(pointed);
737  if (myViewParent->getAdditionalFrame()->addAdditional(netElement, this)) {
738  update();
739  }
740  }
741  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
742  break;
743  }
744  case GNE_MODE_CROSSING: {
745  if (pointed_crossing == NULL) {
746  GNENetElement* netElement = dynamic_cast<GNENetElement*>(pointed);
747  if (myViewParent->getCrossingFrame()->addCrossing(netElement)) {
748  update();
749  }
750  }
751  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
752  break;
753  }
754  default: {
755  GUISUMOAbstractView::onLeftBtnPress(obj, sel, data);
756  }
757  }
758  makeNonCurrent();
759  }
760  return 1;
761 }
762 
763 
764 long
765 GNEViewNet::onLeftBtnRelease(FXObject* obj, FXSelector sel, void* data) {
766  GUISUMOAbstractView::onLeftBtnRelease(obj, sel, data);
767  if (myPolyToMove) {
768  myPolyToMove = 0;
769  } else if (myPoiToMove) {
770  myPoiToMove = 0;
771  } else if (myJunctionToMove) {
772  // position is already up to date but we must register with myUndoList
773  if (!mergeJunctions(myJunctionToMove)) {
774  myJunctionToMove->registerMove(myUndoList);
775  }
776  myJunctionToMove = 0;
777  } else if (myEdgeToMove) {
778  // shape is already up to date but we must register with myUndoList
779  const std::string& newShape = myEdgeToMove->getAttribute(SUMO_ATTR_SHAPE);
780  myEdgeToMove->setAttribute(SUMO_ATTR_SHAPE, newShape, myUndoList);
781  myEdgeToMove = 0;
782  } else if (myAdditionalToMove) {
783  if (myAdditionalToMove->getLane()) {
784  myAdditionalToMove->commmitAdditionalGeometryMoved(myOldAdditionalPosition, myUndoList);
785  myAdditionalToMove = 0;
786  } else {
787  myAdditionalToMove->commmitAdditionalGeometryMoved(myOldAdditionalPosition + myAdditionalMovingReference, myUndoList);
788  myAdditionalToMove = 0;
789  }
790  } else if (myMoveSelection) {
791  // positions and shapes are already up to date but we must register with myUndoList
792  myNet->finishMoveSelection(myUndoList);
793  myMoveSelection = false;
794  } else if (myAmInRectSelect) {
795  myAmInRectSelect = false;
796  // shift held down on mouse-down and mouse-up
797  if (((FXEvent*)data)->state & SHIFTMASK) {
798  if (makeCurrent()) {
799  Boundary b;
800  b.add(mySelCorner1);
801  b.add(mySelCorner2);
802  myViewParent->getSelectorFrame()->handleIDs(getObjectsInBoundary(b), selectEdges());
803  makeNonCurrent();
804  }
805  }
806  update();
807  }
808  return 1;
809 }
810 
811 
812 long
813 GNEViewNet::onDoubleClicked(FXObject*, FXSelector, void*) {
814  // If current edit mode is INSPECT or ADDITIONAL
815  if (myEditMode == GNE_MODE_INSPECT || myEditMode == GNE_MODE_ADDITIONAL) {
816  setFocus();
817  // interpret object under curser
818  if (makeCurrent()) {
819  int id = getObjectUnderCursor();
820  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
821  GUIGlObjectStorage::gIDStorage.unblockObject(id);
822  GNEAdditional* pointed_additional = dynamic_cast<GNEAdditional*>(pointed);
823  // If pointed element is an additional
824  if (pointed_additional != NULL) {
825  // If additional has a additional dialog, open it.
826  pointed_additional->openAdditionalDialog();
827  }
828  makeNonCurrent();
829  }
830  }
831  return 1;
832 }
833 
834 
835 long
836 GNEViewNet::onMouseMove(FXObject* obj, FXSelector sel, void* data) {
837  GUISUMOAbstractView::onMouseMove(obj, sel, data);
838  // in delete mode object under cursor must be checked in every mouse movement
839  if (myEditMode == GNE_MODE_DELETE) {
840  setFocus();
841  // show object information in delete frame
842  if (makeCurrent()) {
843  // obtain ac of globjectID
844  int glid = getObjectUnderCursor();
845  GNEAttributeCarrier* ac = dynamic_cast<GNEAttributeCarrier*>(GUIGlObjectStorage::gIDStorage.getObjectBlocking(glid));
846  GUIGlObjectStorage::gIDStorage.unblockObject(glid);
847  // Update current label of delete frame
848  myViewParent->getDeleteFrame()->updateCurrentLabel(ac);
849  // show childs of object in GNEDeleteFrame if current there isn't a marked element
850  if (myViewParent->getDeleteFrame()->getMarkedAttributeCarrier() == NULL) {
851  myViewParent->getDeleteFrame()->showAttributeCarrierChilds(ac);
852  }
853  }
854  } else {
855  if (myPolyToMove) {
856  myMoveSrc = myPolyToMove->moveGeometry(myMoveSrc, getPositionInformation());
857  } else if (myPoiToMove) {
858  myPoiToMove->move(getPositionInformation());
859  } else if (myJunctionToMove) {
860  myJunctionToMove->move(getPositionInformation());
861  } else if (myEdgeToMove) {
862  myMoveSrc = myEdgeToMove->moveGeometry(myMoveSrc, getPositionInformation());
863  } else if (myAdditionalToMove) {
864  // If additional is placed over lane, move it across it
865  if (myAdditionalToMove->getLane()) {
866  SUMOReal posOfMouseOverLane = myAdditionalToMove->getLane()->getShape().nearest_offset_to_point2D(getPositionInformation(), false);
867  myAdditionalToMove->moveAdditionalGeometry(posOfMouseOverLane - myAdditionalMovingReference.x(), 0);
868  myAdditionalMovingReference.set(posOfMouseOverLane, 0, 0);
869  } else {
870  // Calculate offset movement
871  Position offsetPosition = getPositionInformation() - myOldAdditionalPosition;
872  myAdditionalToMove->moveAdditionalGeometry(myOldAdditionalPosition + offsetPosition + myAdditionalMovingReference);
873  }
874  update();
875  } else if (myMoveSelection) {
876  Position moveTarget = getPositionInformation();
877  myNet->moveSelection(myMoveSrc, moveTarget);
878  myMoveSrc = moveTarget;
879  } else if (myAmInRectSelect) {
880  mySelCorner2 = getPositionInformation();
881  update();
882  }
883  }
884  return 1;
885 }
886 
887 
888 void
889 GNEViewNet::abortOperation(bool clearSelection) {
890  setFocus(); // steal focus from any text fields
891  if (myCreateEdgeSource) {
892  myCreateEdgeSource->unMarkAsCreateEdgeSource();
893  myCreateEdgeSource = 0;
894  } else if (myEditMode == GNE_MODE_SELECT) {
895  myAmInRectSelect = false;
896  if (clearSelection) {
897  gSelected.clear();
898  }
899  } else if (myEditMode == GNE_MODE_CONNECT) {
900  myViewParent->getConnectorFrame()->onCmdCancel(0, 0, 0);
901  } else if (myEditMode == GNE_MODE_TLS) {
902  myViewParent->getTLSEditorFrame()->onCmdCancel(0, 0, 0);
903  } else if (myEditMode == GNE_MODE_MOVE) {
904  removeCurrentPoly();
905  }
906  myUndoList->p_abort();
907 }
908 
909 
910 void
911 GNEViewNet::hotkeyDel() {
912  if (myEditMode == GNE_MODE_CONNECT || myEditMode == GNE_MODE_TLS) {
913  setStatusBarText("Cannot delete in this mode");
914  } else {
915  myUndoList->p_begin("delete selection");
916  deleteSelectedJunctions();
917  deleteSelectedEdges();
918  myUndoList->p_end();
919  }
920 }
921 
922 
923 void
924 GNEViewNet::hotkeyEnter() {
925  if (myEditMode == GNE_MODE_CONNECT) {
926  myViewParent->getConnectorFrame()->onCmdOK(0, 0, 0);
927  } else if (myEditMode == GNE_MODE_TLS) {
928  myViewParent->getTLSEditorFrame()->onCmdOK(0, 0, 0);
929  } else if (myEditMode == GNE_MODE_MOVE && myCurrentPoly != 0) {
930  if (myCurrentPoly->getEditedJunction() != 0) {
931  myCurrentPoly->getEditedJunction()->setAttribute(SUMO_ATTR_SHAPE, toString(myCurrentPoly->getShape()), myUndoList);
932  removeCurrentPoly();
933  update();
934  }
935  }
936 }
937 
938 
939 void
940 GNEViewNet::setEditModeFromHotkey(FXushort selid) {
941  switch (selid) {
942  case MID_GNE_MODE_CREATE_EDGE:
943  setEditMode(GNE_MODE_CREATE_EDGE);
944  break;
945  case MID_GNE_MODE_MOVE:
946  setEditMode(GNE_MODE_MOVE);
947  break;
948  case MID_GNE_MODE_DELETE:
949  setEditMode(GNE_MODE_DELETE);
950  break;
951  case MID_GNE_MODE_INSPECT:
952  setEditMode(GNE_MODE_INSPECT);
953  break;
954  case MID_GNE_MODE_SELECT:
955  setEditMode(GNE_MODE_SELECT);
956  break;
957  case MID_GNE_MODE_CONNECT:
958  setEditMode(GNE_MODE_CONNECT);
959  break;
960  case MID_GNE_MODE_TLS:
961  setEditMode(GNE_MODE_TLS);
962  break;
963  case MID_GNE_MODE_ADDITIONAL:
964  setEditMode(GNE_MODE_ADDITIONAL);
965  break;
966  case MID_GNE_MODE_CROSSING:
967  setEditMode(GNE_MODE_CROSSING);
968  break;
969  default:
970  FXMessageBox::error(this, MBOX_OK, "invalid edit mode", "%s", "...");
971  break;
972  }
973 }
974 
975 
976 void
977 GNEViewNet::markPopupPosition() {
978  myPopupSpot = getPositionInformation();
979 }
980 
981 
982 GNEViewParent*
983 GNEViewNet::getViewParent() const {
984  return myViewParent;
985 }
986 
987 
988 GNENet*
989 GNEViewNet::getNet() const {
990  return myNet;
991 }
992 
993 
994 GNEUndoList*
995 GNEViewNet::getUndoList() const {
996  return myUndoList;
997 }
998 
999 
1000 EditMode
1001 GNEViewNet::getCurrentEditMode() const {
1002  return myEditMode;
1003 }
1004 
1005 
1006 bool
1007 GNEViewNet::showLockIcon() const {
1008  return (myEditMode == GNE_MODE_MOVE || myEditMode == GNE_MODE_INSPECT || myEditMode == GNE_MODE_ADDITIONAL);
1009 }
1010 
1011 
1012 GNEJunction*
1013 GNEViewNet::getJunctionAtCursorPosition(Position& /* pos */) {
1014  GNEJunction* junction = 0;
1015  if (makeCurrent()) {
1016  int id = getObjectAtPosition(myPopupSpot);
1017  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
1018  GUIGlObjectStorage::gIDStorage.unblockObject(id);
1019  if (pointed) {
1020  switch (pointed->getType()) {
1021  case GLO_JUNCTION:
1022  junction = (GNEJunction*)pointed;
1023  break;
1024  default:
1025  break;
1026  }
1027  }
1028  }
1029  return junction;
1030 }
1031 
1032 
1033 
1034 
1035 GNEEdge*
1036 GNEViewNet::getEdgeAtCursorPosition(Position& /* pos */) {
1037  GNEEdge* edge = 0;
1038  if (makeCurrent()) {
1039  int id = getObjectAtPosition(myPopupSpot);
1040  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
1041  GUIGlObjectStorage::gIDStorage.unblockObject(id);
1042  if (pointed) {
1043  switch (pointed->getType()) {
1044  case GLO_EDGE:
1045  edge = (GNEEdge*)pointed;
1046  break;
1047  case GLO_LANE:
1048  edge = &(((GNELane*)pointed)->getParentEdge());
1049  break;
1050  default:
1051  break;
1052  }
1053  }
1054  }
1055  return edge;
1056 }
1057 
1058 
1059 GNELane*
1060 GNEViewNet::getLaneAtCurserPosition(Position& /* pos */) {
1061  GNELane* lane = 0;
1062  if (makeCurrent()) {
1063  int id = getObjectAtPosition(myPopupSpot);
1064  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
1065  GUIGlObjectStorage::gIDStorage.unblockObject(id);
1066  if (pointed) {
1067  if (pointed->getType() == GLO_LANE) {
1068  lane = (GNELane*)pointed;
1069  }
1070  }
1071  }
1072  return lane;
1073 }
1074 
1075 
1076 std::set<GNEEdge*>
1077 GNEViewNet::getEdgesAtCursorPosition(Position& /* pos */) {
1078  std::set<GNEEdge*> result;
1079  if (makeCurrent()) {
1080  const std::vector<GUIGlID> ids = getObjectsAtPosition(myPopupSpot, 1.0);
1081  for (std::vector<GUIGlID>::const_iterator it = ids.begin(); it != ids.end(); ++it) {
1082  GUIGlObject* pointed = GUIGlObjectStorage::gIDStorage.getObjectBlocking(*it);
1083  GUIGlObjectStorage::gIDStorage.unblockObject(*it);
1084  if (pointed) {
1085  switch (pointed->getType()) {
1086  case GLO_EDGE:
1087  result.insert((GNEEdge*)pointed);
1088  break;
1089  case GLO_LANE:
1090  result.insert(&(((GNELane*)pointed)->getParentEdge()));
1091  break;
1092  default:
1093  break;
1094  }
1095  }
1096  }
1097  }
1098  return result;
1099 }
1100 
1101 
1102 long
1103 GNEViewNet::onCmdSetModeCreateEdge(FXObject*, FXSelector, void*) {
1104  setEditMode(GNE_MODE_CREATE_EDGE);
1105  return 1;
1106 }
1107 
1108 
1109 long
1110 GNEViewNet::onCmdSetModeMove(FXObject*, FXSelector, void*) {
1111  setEditMode(GNE_MODE_MOVE);
1112  return 1;
1113 }
1114 
1115 
1116 long
1117 GNEViewNet::onCmdSetModeDelete(FXObject*, FXSelector, void*) {
1118  setEditMode(GNE_MODE_DELETE);
1119  return 1;
1120 }
1121 
1122 
1123 long
1124 GNEViewNet::onCmdSetModeInspect(FXObject*, FXSelector, void*) {
1125  setEditMode(GNE_MODE_INSPECT);
1126  return 1;
1127 }
1128 
1129 
1130 long
1131 GNEViewNet::onCmdSetModeSelect(FXObject*, FXSelector, void*) {
1132  setEditMode(GNE_MODE_SELECT);
1133  return 1;
1134 }
1135 
1136 
1137 long
1138 GNEViewNet::onCmdSetModeConnect(FXObject*, FXSelector, void*) {
1139  setEditMode(GNE_MODE_CONNECT);
1140  return 1;
1141 }
1142 
1143 
1144 long
1145 GNEViewNet::onCmdSetModeTLS(FXObject*, FXSelector, void*) {
1146  setEditMode(GNE_MODE_TLS);
1147  return 1;
1148 }
1149 
1150 
1151 long
1152 GNEViewNet::onCmdSetModeAdditional(FXObject*, FXSelector, void*) {
1153  setEditMode(GNE_MODE_ADDITIONAL);
1154  return 1;
1155 }
1156 
1157 
1158 long
1159 GNEViewNet::onCmdSetModeCrossing(FXObject*, FXSelector, void*) {
1160  setEditMode(GNE_MODE_CROSSING);
1161  return 1;
1162 }
1163 
1164 
1165 long
1166 GNEViewNet::onCmdSplitEdge(FXObject*, FXSelector, void*) {
1167  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1168  if (edge != 0) {
1169  myNet->splitEdge(edge, edge->getSplitPos(myPopupSpot), myUndoList);
1170  }
1171  return 1;
1172 }
1173 
1174 
1175 long
1176 GNEViewNet::onCmdSplitEdgeBidi(FXObject*, FXSelector, void*) {
1177  std::set<GNEEdge*> edges = getEdgesAtCursorPosition(myPopupSpot);
1178  if (edges.size() != 0) {
1179  myNet->splitEdgesBidi(edges, (*edges.begin())->getSplitPos(myPopupSpot), myUndoList);
1180  }
1181  return 1;
1182 }
1183 
1184 
1185 long
1186 GNEViewNet::onCmdReverseEdge(FXObject*, FXSelector, void*) {
1187  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1188  if (edge != 0) {
1189  myNet->reverseEdge(edge, myUndoList);
1190  }
1191  return 1;
1192 }
1193 
1194 
1195 long
1196 GNEViewNet::onCmdAddReversedEdge(FXObject*, FXSelector, void*) {
1197  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1198  if (edge != 0) {
1199  myNet->addReversedEdge(edge, myUndoList);
1200  }
1201  return 1;
1202 }
1203 
1204 
1205 long
1206 GNEViewNet::onCmdSetEdgeEndpoint(FXObject*, FXSelector, void*) {
1207  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1208  if (edge != 0) {
1209  edge->setEndpoint(myPopupSpot, myUndoList);
1210  }
1211  return 1;
1212 }
1213 
1214 
1215 long
1216 GNEViewNet::onCmdResetEdgeEndpoint(FXObject*, FXSelector, void*) {
1217  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1218  if (edge != 0) {
1219  edge->resetEndpoint(myPopupSpot, myUndoList);
1220  }
1221  return 1;
1222 }
1223 
1224 
1225 long
1226 GNEViewNet::onCmdStraightenEdges(FXObject*, FXSelector, void*) {
1227  GNEEdge* edge = getEdgeAtCursorPosition(myPopupSpot);
1228  if (edge != 0) {
1229  if (gSelected.isSelected(GLO_EDGE, edge->getGlID())) {
1230  myUndoList->p_begin("straighten selected " + toString(SUMO_TAG_EDGE) + "s");
1231  std::vector<GNEEdge*> edges = myNet->retrieveEdges(true);
1232  for (std::vector<GNEEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
1233  (*it)->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
1234  }
1235  myUndoList->p_end();
1236  } else {
1237  myUndoList->p_begin("straighten " + toString(SUMO_TAG_EDGE));
1238  edge->setAttribute(SUMO_ATTR_SHAPE, "", myUndoList);
1239  myUndoList->p_end();
1240  }
1241  }
1242  return 1;
1243 }
1244 
1245 
1246 long
1247 GNEViewNet::onCmdSimplifyShape(FXObject*, FXSelector, void*) {
1248  if (myCurrentPoly != 0) {
1249  myCurrentPoly->simplifyShape();
1250  update();
1251  }
1252  return 1;
1253 }
1254 
1255 
1256 long
1257 GNEViewNet::onCmdDeleteGeometry(FXObject*, FXSelector, void*) {
1258  if (myCurrentPoly != 0) {
1259  myCurrentPoly->deleteGeometryNear(myPopupSpot);
1260  update();
1261  }
1262  return 1;
1263 }
1264 
1265 
1266 long
1267 GNEViewNet::onCmdDuplicateLane(FXObject*, FXSelector, void*) {
1268  GNELane* lane = getLaneAtCurserPosition(myPopupSpot);
1269  if (lane != 0) {
1270  if (gSelected.isSelected(GLO_LANE, lane->getGlID())) {
1271  myUndoList->p_begin("duplicate selected " + toString(SUMO_TAG_LANE) + "s");
1272  std::vector<GNELane*> lanes = myNet->retrieveLanes(true);
1273  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1274  myNet->duplicateLane(*it, myUndoList);
1275  }
1276  myUndoList->p_end();
1277  } else {
1278  myUndoList->p_begin("duplicate " + toString(SUMO_TAG_LANE));
1279  myNet->duplicateLane(lane, myUndoList);
1280  myUndoList->p_end();
1281  }
1282  }
1283  return 1;
1284 }
1285 
1286 
1287 long
1288 GNEViewNet::onCmdRestrictLaneSidewalk(FXObject*, FXSelector, void*) {
1289  return restrictLane(SVC_PEDESTRIAN);
1290 }
1291 
1292 
1293 long
1294 GNEViewNet::onCmdRestrictLaneBikelane(FXObject*, FXSelector, void*) {
1295  return restrictLane(SVC_BICYCLE);
1296 }
1297 
1298 
1299 long
1300 GNEViewNet::onCmdRestrictLaneBuslane(FXObject*, FXSelector, void*) {
1301  return restrictLane(SVC_BUS);
1302 }
1303 
1304 
1305 long
1306 GNEViewNet::onCmdAddRestrictedLaneSidewalk(FXObject*, FXSelector, void*) {
1307  return addRestrictedLane(SVC_PEDESTRIAN);
1308 }
1309 
1310 
1311 long
1312 GNEViewNet::onCmdAddRestrictedLaneBikelane(FXObject*, FXSelector, void*) {
1313  return addRestrictedLane(SVC_BICYCLE);
1314 }
1315 
1316 
1317 long
1318 GNEViewNet::onCmdAddRestrictedLaneBuslane(FXObject*, FXSelector, void*) {
1319  return addRestrictedLane(SVC_BUS);
1320 }
1321 
1322 
1323 long
1324 GNEViewNet::onCmdRemoveRestrictedLaneSidewalk(FXObject*, FXSelector, void*) {
1325  return removeRestrictedLane(SVC_PEDESTRIAN);
1326 }
1327 
1328 
1329 long
1330 GNEViewNet::onCmdRemoveRestrictedLaneBikelane(FXObject*, FXSelector, void*) {
1331  return removeRestrictedLane(SVC_BICYCLE);
1332 }
1333 
1334 
1335 long
1336 GNEViewNet::onCmdRemoveRestrictedLaneBuslane(FXObject*, FXSelector, void*) {
1337  return removeRestrictedLane(SVC_BUS);
1338 }
1339 
1340 
1341 bool
1342 GNEViewNet::restrictLane(SUMOVehicleClass vclass) {
1343  GNELane* lane = getLaneAtCurserPosition(myPopupSpot);
1344  if (lane != 0) {
1345  // Get selected lanes
1346  std::vector<GNELane*> lanes = myNet->retrieveLanes(true); ;
1347  // Declare map of edges and lanes
1348  std::map<GNEEdge*, GNELane*> mapOfEdgesAndLanes;
1349  // Iterate over selected lanes
1350  for (std::vector<GNELane*>::iterator i = lanes.begin(); i != lanes.end(); i++) {
1351  mapOfEdgesAndLanes[myNet->retrieveEdge((*i)->getParentEdge().getID())] = (*i);
1352  }
1353  // Throw warning dialog if there hare multiple lanes selected in the same edge
1354  if (mapOfEdgesAndLanes.size() != lanes.size()) {
1355  FXMessageBox::information(getApp(), MBOX_OK,
1356  "Multiple lane in the same edge selected", "%s",
1357  ("There are selected lanes that belong to the same edge.\n Only one lane per edge will be restricted for " + toString(vclass) + ".").c_str());
1358  }
1359  // If we handeln a set of lanes
1360  if (mapOfEdgesAndLanes.size() > 0) {
1361  // declare counter for number of Sidewalks
1362  int counter = 0;
1363  // iterate over selected lanes
1364  for (std::map<GNEEdge*, GNELane*>::iterator i = mapOfEdgesAndLanes.begin(); i != mapOfEdgesAndLanes.end(); i++) {
1365  if (i->first->hasRestrictedLane(vclass)) {
1366  counter++;
1367  }
1368  }
1369  // if all edges parent own a Sidewalk, stop function
1370  if (counter == (int)mapOfEdgesAndLanes.size()) {
1371  FXMessageBox::information(getApp(), MBOX_OK,
1372  ("Set vclass for " + toString(vclass) + " to selected lanes").c_str(), "%s",
1373  ("All lanes own already another lane in the same edge with a restriction for " + toString(vclass)).c_str());
1374  return 0;
1375  } else {
1376  // Ask confirmation to user
1377  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO,
1378  ("Set vclass for " + toString(vclass) + " to selected lanes").c_str(), "%s",
1379  (toString(mapOfEdgesAndLanes.size() - counter) + " lanes will be restricted for " + toString(vclass) + ". continue?").c_str());
1380  if (answer != 1) { //1:yes, 2:no, 4:esc
1381  return 0;
1382  }
1383  }
1384  // begin undo operation
1385  myUndoList->p_begin("restrict lanes to " + toString(vclass));
1386  // iterate over selected lanes
1387  for (std::map<GNEEdge*, GNELane*>::iterator i = mapOfEdgesAndLanes.begin(); i != mapOfEdgesAndLanes.end(); i++) {
1388  // Transform lane to Sidewalk
1389  myNet->restrictLane(vclass, i->second, myUndoList);
1390  }
1391  // end undo operation
1392  myUndoList->p_end();
1393  } else {
1394  // If only have a single lane, start undo/redo operation
1395  myUndoList->p_begin("restrict lane to " + toString(vclass));
1396  // Transform lane to Sidewalk
1397  myNet->restrictLane(vclass, lane, myUndoList);
1398  // end undo operation
1399  myUndoList->p_end();
1400  }
1401  }
1402  return 1;
1403 }
1404 
1405 
1406 bool
1407 GNEViewNet::addRestrictedLane(SUMOVehicleClass vclass) {
1408  GNELane* lane = getLaneAtCurserPosition(myPopupSpot);
1409  if (lane != 0) {
1410  // Get selected edges
1411  std::vector<GNEEdge*> edges = myNet->retrieveEdges(true);
1412  // get selected lanes
1413  std::vector<GNELane*> lanes = myNet->retrieveLanes(true);
1414  // Declare set of edges
1415  std::set<GNEEdge*> setOfEdges;
1416  // Fill set of edges with vector of edges
1417  for (std::vector<GNEEdge*>::iterator i = edges.begin(); i != edges.end(); i++) {
1418  setOfEdges.insert(*i);
1419  }
1420  // iterate over selected lanes
1421  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1422  // Insert pointer to edge into set of edges (To avoid duplicates)
1423  setOfEdges.insert(myNet->retrieveEdge((*it)->getParentEdge().getID()));
1424  }
1425  // If we handeln a set of edges
1426  if (setOfEdges.size() > 0) {
1427  // declare counter for number of restrictions
1428  int counter = 0;
1429  // iterate over set of edges
1430  for (std::set<GNEEdge*>::iterator it = setOfEdges.begin(); it != setOfEdges.end(); it++) {
1431  // update counter if edge has already a restricted lane of type "vclass"
1432  if ((*it)->hasRestrictedLane(vclass) == true) {
1433  counter++;
1434  }
1435  }
1436  // if all lanes own a Sidewalk, stop function
1437  if (counter == (int)setOfEdges.size()) {
1438  FXMessageBox::information(getApp(), MBOX_OK,
1439  ("Add vclass for" + toString(vclass) + " to selected lanes").c_str(), "%s",
1440  ("All lanes own already another lane in the same edge with a restriction for " + toString(vclass)).c_str());
1441  return 0;
1442  } else {
1443  // Ask confirmation to user
1444  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO,
1445  ("Add vclass for " + toString(vclass) + " to selected lanes").c_str(), "%s",
1446  (toString(setOfEdges.size() - counter) + " restrictions for " + toString(vclass) + " will be added. continue?").c_str());
1447  if (answer != 1) { //1:yes, 2:no, 4:esc
1448  return 0;
1449  }
1450  }
1451  // begin undo operation
1452  myUndoList->p_begin("Add restrictions for " + toString(vclass));
1453  // iterate over set of edges
1454  for (std::set<GNEEdge*>::iterator it = setOfEdges.begin(); it != setOfEdges.end(); it++) {
1455  // add Sidewalk
1456  myNet->addSRestrictedLane(vclass, *(*it), myUndoList);
1457  }
1458  // end undo operation
1459  myUndoList->p_end();
1460  } else {
1461  // If only have a single lane, start undo/redo operation
1462  myUndoList->p_begin("Add vclass for " + toString(vclass));
1463  // Add Sidewalk
1464  myNet->addSRestrictedLane(vclass, lane->getParentEdge(), myUndoList);
1465  // end undo/redo operation
1466  myUndoList->p_end();
1467  }
1468  }
1469  return 1;
1470 }
1471 
1472 
1473 bool
1474 GNEViewNet::removeRestrictedLane(SUMOVehicleClass vclass) {
1475  GNELane* lane = getLaneAtCurserPosition(myPopupSpot);
1476  if (lane != 0) {
1477  // Get selected edges
1478  std::vector<GNEEdge*> edges = myNet->retrieveEdges(true);
1479  // get selected lanes
1480  std::vector<GNELane*> lanes = myNet->retrieveLanes(true);
1481  // Declare set of edges
1482  std::set<GNEEdge*> setOfEdges;
1483  // Fill set of edges with vector of edges
1484  for (std::vector<GNEEdge*>::iterator i = edges.begin(); i != edges.end(); i++) {
1485  setOfEdges.insert(*i);
1486  }
1487  // iterate over selected lanes
1488  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1489  // Insert pointer to edge into set of edges (To avoid duplicates)
1490  setOfEdges.insert(myNet->retrieveEdge((*it)->getParentEdge().getID()));
1491  }
1492  // If we handeln a set of edges
1493  if (setOfEdges.size() > 0) {
1494  // declare counter for number of restrictions
1495  int counter = 0;
1496  // iterate over set of edges
1497  for (std::set<GNEEdge*>::iterator it = setOfEdges.begin(); it != setOfEdges.end(); it++) {
1498  // update counter if edge has already a restricted lane of type "vclass"
1499  if ((*it)->hasRestrictedLane(vclass) == true) {
1500  counter++;
1501  }
1502  }
1503  // if all lanes don't own a Sidewalk, stop function
1504  if (counter == 0) {
1505  FXMessageBox::information(getApp(), MBOX_OK,
1506  ("Remove vclass for " + toString(vclass) + " to selected lanes").c_str(), "%s",
1507  ("Selected lanes and edges haven't a restriction for " + toString(vclass)).c_str());
1508  return 0;
1509  } else {
1510  // Ask confirmation to user
1511  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO,
1512  ("Remove vclass for " + toString(vclass) + " to selected lanes").c_str(), "%s",
1513  (toString(counter) + " restrictions for " + toString(vclass) + " will be removed. continue?").c_str());
1514  if (answer != 1) { //1:yes, 2:no, 4:esc
1515  return 0;
1516  }
1517  }
1518  // begin undo operation
1519  myUndoList->p_begin("Remove restrictions for " + toString(vclass));
1520  // iterate over set of edges
1521  for (std::set<GNEEdge*>::iterator it = setOfEdges.begin(); it != setOfEdges.end(); it++) {
1522  // add Sidewalk
1523  myNet->removeRestrictedLane(vclass, *(*it), myUndoList);
1524  }
1525  // end undo operation
1526  myUndoList->p_end();
1527  } else {
1528  // If only have a single lane, start undo/redo operation
1529  myUndoList->p_begin("Remove vclass for " + toString(vclass));
1530  // Remove Sidewalk
1531  myNet->removeRestrictedLane(vclass, lane->getParentEdge(), myUndoList);
1532  // end undo/redo operation
1533  myUndoList->p_end();
1534  }
1535  }
1536  return 1;
1537 }
1538 
1539 
1540 long
1541 GNEViewNet::onCmdRevertRestriction(FXObject*, FXSelector, void*) {
1542  GNELane* lane = getLaneAtCurserPosition(myPopupSpot);
1543  if (lane != 0) {
1544  // Declare vector of lanes
1545  std::vector<GNELane*> lanes;
1546  // Check if we have a set of selected edges or lanes
1547  if (gSelected.isSelected(GLO_EDGE, lane->getParentEdge().getGlID())) {
1548  // Get selected edgeds
1549  std::vector<GNEEdge*> edges = myNet->retrieveEdges(true);
1550  // fill vector of lanes with the lanes of selected edges
1551  for (std::vector<GNEEdge*>::iterator i = edges.begin(); i != edges.end(); i++) {
1552  for (std::vector<GNELane*>::const_iterator j = (*i)->getLanes().begin(); j != (*i)->getLanes().end(); j++) {
1553  lanes.push_back(*j);
1554  }
1555  }
1556  } else if (gSelected.isSelected(GLO_LANE, lane->getGlID())) {
1557  // get selected lanes
1558  lanes = myNet->retrieveLanes(true);
1559  }
1560  // If we handeln a set of lanes
1561  if (lanes.size() > 0) {
1562  // declare counter for number of Sidewalks
1563  int counter = 0;
1564  // iterate over selected lanes
1565  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1566  if (((*it)->isRestricted(SVC_PEDESTRIAN)) || ((*it)->isRestricted(SVC_BICYCLE)) || ((*it)->isRestricted(SVC_BUS))) {
1567  counter++;
1568  }
1569  }
1570  // if none of selected lanes has a transformation, stop
1571  if (counter == 0) {
1572  FXMessageBox::information(getApp(), MBOX_OK,
1573  "Revert restriction", "%s",
1574  "None of selected lanes has a previous restriction");
1575  return 0;
1576  } else {
1577  // Ask confirmation to user
1578  FXuint answer = FXMessageBox::question(getApp(), MBOX_YES_NO,
1579  "Revert restriction", "%s",
1580  (toString(counter) + " restrictions of lanes lanes will be reverted. continue?").c_str());
1581  if (answer != 1) { //1:yes, 2:no, 4:esc
1582  return 0;
1583  }
1584  }
1585  // begin undo operation
1586  myUndoList->p_begin("revert restrictions");
1587  // iterate over selected lanes
1588  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1589  // revert transformation
1590  myNet->revertLaneRestriction(*it, myUndoList);
1591  }
1592  // end undo operation
1593  myUndoList->p_end();
1594  } else {
1595  // If only have a single lane, start undo/redo operation
1596  myUndoList->p_begin("revert restriction");
1597  // revert transformation
1598  myNet->revertLaneRestriction(lane, myUndoList);
1599  // end undo operation
1600  myUndoList->p_end();
1601  }
1602  }
1603  return 1;
1604 }
1605 
1606 
1607 long
1608 GNEViewNet::onCmdNodeShape(FXObject*, FXSelector, void*) {
1609  GNEJunction* junction = getJunctionAtCursorPosition(myPopupSpot);
1610  if (junction != 0) {
1611  if (myCurrentPoly == 0) {
1612  if (junction->getNBNode()->getShape().size() > 1) {
1613  setEditModeFromHotkey(MID_GNE_MODE_MOVE);
1614  //std::cout << junction->getNBNode()->getShape() << "\n";
1615  junction->getNBNode()->computeNodeShape(-1);
1616  if (myCurrentPoly != 0) {
1617  myNet->getVisualisationSpeedUp().removeAdditionalGLObject(myCurrentPoly);
1618  delete myCurrentPoly;
1619  myCurrentPoly = 0;
1620  }
1621  PositionVector shape = junction->getNBNode()->getShape();
1622  shape.closePolygon();
1623  myCurrentPoly = new GNEPoly(myNet, junction, "junction_shape:" + junction->getMicrosimID(), "junction shape",
1624  shape, false, RGBColor::GREEN, GLO_POLYGON);
1625  myCurrentPoly->setLineWidth(0.3);
1626  myNet->getVisualisationSpeedUp().addAdditionalGLObject(myCurrentPoly);
1627 
1628  update();
1629  }
1630  } else {
1631  junction->setAttribute(SUMO_ATTR_SHAPE, toString(myCurrentPoly->getShape()), myUndoList);
1632  removeCurrentPoly();
1633  update();
1634  }
1635  }
1636  return 1;
1637 }
1638 
1639 
1640 void
1641 GNEViewNet::removeCurrentPoly() {
1642  if (myCurrentPoly != 0) {
1643  myNet->getVisualisationSpeedUp().removeAdditionalGLObject(myCurrentPoly);
1644  delete myCurrentPoly;
1645  myCurrentPoly = 0;
1646  }
1647 }
1648 
1649 
1650 long
1651 GNEViewNet::onCmdNodeReplace(FXObject*, FXSelector, void*) {
1652  GNEJunction* junction = getJunctionAtCursorPosition(myPopupSpot);
1653  if (junction != 0) {
1654  myNet->replaceJunctionByGeometry(junction, myUndoList);
1655  update();
1656  }
1657  return 1;
1658 }
1659 
1660 
1661 long
1662 GNEViewNet::onCmdToogleShowConnection(FXObject*, FXSelector, void*) {
1663  if (!myShowConnectionActivated) {
1664  getNet()->initGNEConnections();
1665  myShowConnectionActivated = true;
1666  }
1667  // Update viewnNet to show/hide conections
1668  update();
1669  // Hide/show connections requiere recompute
1670  getNet()->requireRecompute();
1671  return 1;
1672 }
1673 
1674 
1675 long
1676 GNEViewNet::onCmdToogleShowBubbles(FXObject*, FXSelector, void*) {
1677  // Update view net Shapes
1678  update();
1679  return 1;
1680 }
1681 
1682 
1683 // ===========================================================================
1684 // private
1685 // ===========================================================================
1686 
1687 void
1688 GNEViewNet::setEditMode(EditMode mode) {
1689  setStatusBarText("");
1690  abortOperation(false);
1691  if (mode == myEditMode) {
1692  setStatusBarText("Mode already selected");
1693  } else {
1694  myPreviousEditMode = myEditMode;
1695  myEditMode = mode;
1696  switch (mode) {
1697  case GNE_MODE_CONNECT:
1698  case GNE_MODE_TLS:
1699  // modes which depend on computed data
1700  myNet->computeEverything((GNEApplicationWindow*)myApp);
1701  break;
1702  default:
1703  break;
1704  }
1705  }
1706  updateModeSpecificControls();
1707 }
1708 
1709 
1710 void
1711 GNEViewNet::buildEditModeControls() {
1712  // initialize mappings
1713  myEditModeNames.insert("(e) Create Edge", GNE_MODE_CREATE_EDGE);
1714  myEditModeNames.insert("(m) Move", GNE_MODE_MOVE);
1715  myEditModeNames.insert("(d) Delete", GNE_MODE_DELETE);
1716  myEditModeNames.insert("(i) Inspect", GNE_MODE_INSPECT);
1717  myEditModeNames.insert("(s) Select", GNE_MODE_SELECT);
1718  myEditModeNames.insert("(c) Connect", GNE_MODE_CONNECT);
1719  myEditModeNames.insert("(t) Traffic Lights", GNE_MODE_TLS);
1720  myEditModeNames.insert("(a) Additionals", GNE_MODE_ADDITIONAL);
1721  myEditModeNames.insert("(r) Crossings", GNE_MODE_CROSSING);
1722 
1723  // initialize buttons for modes
1724  myEditModeCreateEdge = new MFXCheckableButton(false, myToolbar, "\tset create edge mode\tMode for creating junction and edges.",
1725  GUIIconSubSys::getIcon(ICON_MODECREATEEDGE), this, MID_GNE_MODE_CREATE_EDGE, GUIDesignButtonToolbarCheckable);
1726  myEditModeMove = new MFXCheckableButton(false, myToolbar, "\tset move mode\tMode for move elements.",
1727  GUIIconSubSys::getIcon(ICON_MODEMOVE), this, MID_GNE_MODE_MOVE, GUIDesignButtonToolbarCheckable);
1728  myEditModeDelete = new MFXCheckableButton(false, myToolbar, "\tset delete mode\tMode for delete elements.",
1729  GUIIconSubSys::getIcon(ICON_MODEDELETE), this, MID_GNE_MODE_DELETE, GUIDesignButtonToolbarCheckable);
1730  myEditModeInspect = new MFXCheckableButton(false, myToolbar, "\tset inspect mode\tMode for inspect elements and change their attributes.",
1731  GUIIconSubSys::getIcon(ICON_MODEINSPECT), this, MID_GNE_MODE_INSPECT, GUIDesignButtonToolbarCheckable);
1732  myEditModeSelect = new MFXCheckableButton(false, myToolbar, "\tset select mode\tMode for select elements.",
1733  GUIIconSubSys::getIcon(ICON_MODESELECT), this, MID_GNE_MODE_SELECT, GUIDesignButtonToolbarCheckable);
1734  myEditModeConnection = new MFXCheckableButton(false, myToolbar, "\tset connection mode\tMode for edit connections between lanes.",
1735  GUIIconSubSys::getIcon(ICON_MODECONNECTION), this, MID_GNE_MODE_CONNECT, GUIDesignButtonToolbarCheckable);
1736  myEditModeTrafficLight = new MFXCheckableButton(false, myToolbar, "\tset traffic light mode\tMode for edit traffic lights over junctions.",
1737  GUIIconSubSys::getIcon(ICON_MODETLS), this, MID_GNE_MODE_TLS, GUIDesignButtonToolbarCheckable);
1738  myEditModeAdditional = new MFXCheckableButton(false, myToolbar, "\tset additional mode\tMode for adding additional elements.",
1739  GUIIconSubSys::getIcon(ICON_MODEADDITIONAL), this, MID_GNE_MODE_ADDITIONAL, GUIDesignButtonToolbarCheckable);
1740  myEditModeCrossing = new MFXCheckableButton(false, myToolbar, "\tset crossing mode\tMode for creating crossings between edges.",
1741  GUIIconSubSys::getIcon(ICON_MODECROSSING), this, MID_GNE_MODE_CROSSING, GUIDesignButtonToolbarCheckable);
1742 
1743  // @ToDo add here new FXToolBarGrip(myNavigationToolBar, NULL, 0, GUIDesignToolbarGrip);
1744 
1745  // initialize mode specific controls
1746  myChainCreateEdge = new FXMenuCheck(myToolbar, "chain\t\tCreate consecutive edges with a single click (hit ESC to cancel chain).", this, 0);
1747  myAutoCreateOppositeEdge = new FXMenuCheck(myToolbar, "two-way\t\tAutomatically create an edge in the opposite direction", this, 0);
1748  mySelectEdges = new FXMenuCheck(myToolbar, "select edges\t\tToggle whether clicking should select edges or lanes", this, 0);
1749  mySelectEdges->setCheck();
1750 
1751  myShowConnections = new FXMenuCheck(myToolbar, "show connections\t\tToggle show connections over junctions", this, MID_GNE_SHOW_CONNECTIONS);
1752  myShowConnections->setCheck(false);
1753 
1754  myExtendToEdgeNodes = new FXMenuCheck(myToolbar, "auto-select junctions\t\tToggle whether selecting multiple edges should automatically select their junctions", this, 0);
1755 
1756  myWarnAboutMerge = new FXMenuCheck(myToolbar, "ask for merge\t\tAsk for confirmation before merging junctions.", this, 0);
1757  myWarnAboutMerge->setCheck(true);
1758 
1759  myShowBubbleOverJunction = new FXMenuCheck(myToolbar, "Show bubbles over junction \t\tShow bubbles over juntion's shapes.", this, MID_GNE_SHOW_BUBBLES);
1760  myShowBubbleOverJunction->setCheck(false);
1761 
1762  myChangeAllPhases = new FXMenuCheck(myToolbar, "apply change to all phases\t\tToggle whether clicking should apply state changes to all phases of the current traffic light plan", this, 0);
1763  myChangeAllPhases->setCheck(false);
1764 }
1765 
1766 
1767 void
1768 GNEViewNet::updateModeSpecificControls() {
1769  // hide all controls (checkboxs)
1770  myChainCreateEdge->hide();
1771  myAutoCreateOppositeEdge->hide();
1772  mySelectEdges->hide();
1773  myShowConnections->hide();
1774  myExtendToEdgeNodes->hide();
1775  myChangeAllPhases->hide();
1776  myWarnAboutMerge->hide();
1777  myShowBubbleOverJunction->hide();
1778  // unckeck all edit modes
1779  myEditModeCreateEdge->setChecked(false);
1780  myEditModeMove->setChecked(false);
1781  myEditModeDelete->setChecked(false);
1782  myEditModeInspect->setChecked(false);
1783  myEditModeSelect->setChecked(false);
1784  myEditModeConnection->setChecked(false);
1785  myEditModeTrafficLight->setChecked(false);
1786  myEditModeAdditional->setChecked(false);
1787  myEditModeCrossing->setChecked(false);
1788  // hide all Frames
1789  myViewParent->hideAllFrames();
1790  // enable selected controls
1791  switch (myEditMode) {
1792  case GNE_MODE_CREATE_EDGE:
1793  // show additionals checkboxs
1794  myChainCreateEdge->show();
1795  myAutoCreateOppositeEdge->show();
1796  // check create edge mode button
1797  myEditModeCreateEdge->setChecked(true);
1798  break;
1799  case GNE_MODE_MOVE:
1800  // show additionals checkboxs
1801  myWarnAboutMerge->show();
1802  myShowBubbleOverJunction->show();
1803  // check move mode button
1804  myEditModeMove->setChecked(true);
1805  break;
1806  case GNE_MODE_DELETE:
1807  // Show delete frame
1808  myViewParent->getDeleteFrame()->show();
1809  // show additionals checkboxs
1810  mySelectEdges->show();
1811  myShowConnections->show();
1812  // check delete mode button
1813  myEditModeDelete->setChecked(true);
1814  break;
1815  case GNE_MODE_INSPECT:
1816  // show inspector frame
1817  myViewParent->getInspectorFrame()->show();
1818  // show additionals checkboxs
1819  mySelectEdges->show();
1820  myShowConnections->show();
1821  // check inspect mode button
1822  myEditModeInspect->setChecked(true);
1823  break;
1824  case GNE_MODE_SELECT:
1825  // show selector frame
1826  myViewParent->getSelectorFrame()->show();
1827  // show additionals checkboxs
1828  mySelectEdges->show();
1829  myShowConnections->show();
1830  myExtendToEdgeNodes->show();
1831  // check select mode button
1832  myEditModeSelect->setChecked(true);
1833  break;
1834  case GNE_MODE_CONNECT:
1835  // show connector frame
1836  myViewParent->getConnectorFrame()->show();
1837  // check connection mode button
1838  myEditModeConnection->setChecked(true);
1839  break;
1840  case GNE_MODE_TLS:
1841  // show TLS Frame
1842  myViewParent->getTLSEditorFrame()->show();
1843  // show additionals checkboxs
1844  myChangeAllPhases->show();
1845  // check TLS mode button
1846  myEditModeTrafficLight->setChecked(true);
1847  break;
1848  case GNE_MODE_ADDITIONAL:
1849  // show additional frame
1850  myViewParent->getAdditionalFrame()->show();
1851  // check additional mode button
1852  myEditModeAdditional->setChecked(true);
1853  break;
1854  case GNE_MODE_CROSSING:
1855  // show crossing frame
1856  myViewParent->getCrossingFrame()->show();
1857  // check crossing mode button
1858  myEditModeCrossing->setChecked(true);
1859  break;
1860  default:
1861  break;
1862  }
1863  // Update buttons
1864  myEditModeCreateEdge->update();
1865  myEditModeMove->update();
1866  myEditModeDelete->update();
1867  myEditModeInspect->update();
1868  myEditModeSelect->update();
1869  myEditModeConnection->update();
1870  myEditModeTrafficLight->update();
1871  myEditModeAdditional->update();
1872  myEditModeCrossing->update();
1873  // force repaint because different modes draw different things
1874  myToolbar->recalc();
1875  onPaint(0, 0, 0);
1876  update();
1877 }
1878 
1879 
1880 void
1881 GNEViewNet::deleteSelectedJunctions() {
1882  myUndoList->p_begin("delete selected " + toString(SUMO_TAG_JUNCTION) + "s");
1883  std::vector<GNEJunction*> junctions = myNet->retrieveJunctions(true);
1884  for (std::vector<GNEJunction*>::iterator it = junctions.begin(); it != junctions.end(); it++) {
1885  myNet->deleteJunction(*it, myUndoList);
1886  }
1887  myUndoList->p_end();
1888 }
1889 
1890 
1891 void
1892 GNEViewNet::deleteSelectedEdges() {
1893  if (mySelectEdges->getCheck()) {
1894  myUndoList->p_begin("delete selected " + toString(SUMO_TAG_EDGE) + "s");
1895  std::vector<GNEEdge*> edges = myNet->retrieveEdges(true);
1896  for (std::vector<GNEEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
1897  myNet->deleteEdge(*it, myUndoList);
1898  }
1899  } else {
1900  myUndoList->p_begin("delete selected " + toString(SUMO_TAG_LANE) + "s");
1901  std::vector<GNELane*> lanes = myNet->retrieveLanes(true);
1902  for (std::vector<GNELane*>::iterator it = lanes.begin(); it != lanes.end(); it++) {
1903  myNet->deleteLane(*it, myUndoList);
1904  }
1905  }
1906  myUndoList->p_end();
1907 }
1908 
1909 
1910 bool
1911 GNEViewNet::mergeJunctions(GNEJunction* moved) {
1912  const Position& newPos = moved->getNBNode()->getPosition();
1913  GNEJunction* mergeTarget = 0;
1914  // try to find another junction to merge with
1915  if (makeCurrent()) {
1916  Boundary selection;
1917  selection.add(newPos);
1918  selection.grow(0.1);
1919  const std::vector<GUIGlID> ids = getObjectsInBoundary(selection);
1920  GUIGlObject* object = 0;
1921  for (std::vector<GUIGlID>::const_iterator it = ids.begin(); it != ids.end(); it++) {
1922  GUIGlID id = *it;
1923  if (id == 0) {
1924  continue;
1925  }
1926  object = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
1927  if (!object) {
1928  throw ProcessError("Unkown object in selection (id=" + toString(id) + ").");
1929  }
1930  if (object->getType() == GLO_JUNCTION && id != moved->getGlID()) {
1931  mergeTarget = dynamic_cast<GNEJunction*>(object);
1932  }
1933  GUIGlObjectStorage::gIDStorage.unblockObject(id);
1934  }
1935  }
1936  if (mergeTarget) {
1937  // optionally ask for confirmation
1938  if (myWarnAboutMerge->getCheck()) {
1939  FXuint answer = FXMessageBox::question(this, MBOX_YES_NO,
1940  "Confirm Junction Merger", "%s",
1941  ("Do you wish to merge junctions '" + moved->getMicrosimID() +
1942  "' and '" + mergeTarget->getMicrosimID() + "'?\n" +
1943  "('" + moved->getMicrosimID() +
1944  "' will be eliminated and its roads added to '" +
1945  mergeTarget->getMicrosimID() + "')").c_str());
1946  if (answer != 1) { //1:yes, 2:no, 4:esc
1947  return false;
1948  }
1949  }
1950  myNet->mergeJunctions(moved, mergeTarget, myUndoList);
1951  return true;
1952  } else {
1953  return false;
1954  }
1955 }
1956 
1957 
1958 void
1959 GNEViewNet::updateControls() {
1960  switch (myEditMode) {
1961  case GNE_MODE_INSPECT:
1962  myViewParent->getInspectorFrame()->update();
1963  break;
1964  default:
1965  break;
1966  }
1967 }
1968 /****************************************************************************/
GNEViewNet::onCmdAddRestrictedLaneSidewalk
long onCmdAddRestrictedLaneSidewalk(FXObject *, FXSelector typeOfTransformation, void *)
Add restricted lane for pedestrians.
Definition: GNEViewNet.cpp:1306
GNENet::splitEdge
GNEJunction * splitEdge(GNEEdge *edge, const Position &pos, GNEUndoList *undoList, GNEJunction *newJunction=0)
split edge at position by inserting a new junction
Definition: GNENet.cpp:532
GNEViewNet::onCmdResetEdgeEndpoint
long onCmdResetEdgeEndpoint(FXObject *, FXSelector, void *)
restore geometry endpoint to node position
Definition: GNEViewNet.cpp:1216
GUITexturesHelper.h
GNEViewNet::onCmdDeleteGeometry
long onCmdDeleteGeometry(FXObject *, FXSelector, void *)
delete the closes geometry point
Definition: GNEViewNet.cpp:1257
GNEViewNet::myViewParent
GNEViewParent * myViewParent
view parent
Definition: GNEViewNet.h:303
GNEAdditional::openAdditionalDialog
virtual void openAdditionalDialog()
open Additional Dialog
Definition: GNEAdditional.cpp:105
GUISUMOAbstractView::paintGLGrid
void paintGLGrid()
paints a grid
Definition: GUISUMOAbstractView.cpp:420
GNEViewNet::getCurrentEditMode
EditMode getCurrentEditMode() const
get the current edit mode
Definition: GNEViewNet.cpp:1001
GNENet::retrieveJunctions
std::vector< GNEJunction * > retrieveJunctions(bool onlySelected=false)
return all junctions
Definition: GNENet.cpp:794
GNEViewNet::onCmdRestrictLaneBikelane
long onCmdRestrictLaneBikelane(FXObject *, FXSelector typeOfTransformation, void *)
restrict lane to bikes
Definition: GNEViewNet.cpp:1294
GLO_CROSSING
a tl-logic
Definition: GUIGlObjectTypes.h:57
GUIGlObjectStorage.h
RGBColor::BLUE
static const RGBColor BLUE
Definition: RGBColor.h:191
GNEViewNet::showLockIcon
bool showLockIcon() const
check if lock icon should be visible
Definition: GNEViewNet.cpp:1007
GNEPoly::moveGeometry
Position moveGeometry(const Position &oldPos, const Position &newPos, bool relative=false)
draw the polygon and also little movement handles
Definition: GNEPoly.cpp:126
FXDEFMAP
FXDEFMAP(GNEViewNet) GNEViewNetMap[]
OptionsCont::getStringVector
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
Definition: OptionsCont.cpp:888
GNENet::retrieveLanes
std::vector< GNELane * > retrieveLanes(bool onlySelected=false)
return all lanes
Definition: GNENet.cpp:759
GNEViewNet::mySelectEdges
FXMenuCheck * mySelectEdges
menu check to select only edges
Definition: GNEViewNet.h:315
GNEViewNet::selectEdges
bool selectEdges()
whether inspection, selection and inversion should apply to edges or to lanes
Definition: GNEViewNet.cpp:351
GNEViewNet::getJunctionAtCursorPosition
GNEJunction * getJunctionAtCursorPosition(Position &pos)
try to retrieve a junction at the given position
Definition: GNEViewNet.cpp:1013
GNEJunction::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNEJunction.cpp:588
GNEViewNet::myPopupSpot
Position myPopupSpot
Poput spot.
Definition: GNEViewNet.h:435
gSchemeStorage
GUICompleteSchemeStorage gSchemeStorage
Definition: GUICompleteSchemeStorage.cpp:50
MID_GNE_ADD_LANE_BUS
add busLane
Definition: GUIAppEnum.h:635
GNENet::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:732
SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:589
GNEViewNet::abortOperation
void abortOperation(bool clearSelection=true)
abort current edition operation
Definition: GNEViewNet.cpp:889
ICON_MODECREATEEDGE
Definition: GUIIcons.h:201
GNEViewNet::deleteSelectedJunctions
void deleteSelectedJunctions()
delete all currently selected junctions
Definition: GNEViewNet.cpp:1881
GNEApplicationWindow.h
SUMO_const_laneWidth
const SUMOReal SUMO_const_laneWidth
Definition: StdDefs.h:48
GNEViewNet::setColorScheme
bool setColorScheme(const std::string &name)
set color schieme
Definition: GNEViewNet.cpp:329
ICON_MODECONNECTION
Definition: GUIIcons.h:200
SVC_PEDESTRIAN
is a pedestrian
Definition: SUMOVehicleClass.h:187
GLO_POLYGON
a polygon
Definition: GUIGlObjectTypes.h:71
GNEViewNet::onCmdSetModeAdditional
long onCmdSetModeAdditional(FXObject *, FXSelector, void *)
called when user press the button for additional mode
Definition: GNEViewNet.cpp:1152
GNE_MODE_MOVE
mode for moving things
Definition: GNEViewNet.h:53
GNEViewNet::changeAllPhases
bool changeAllPhases() const
change all phases
Definition: GNEViewNet.cpp:381
GNEViewNet::restrictLane
bool restrictLane(SUMOVehicleClass vclass)
restrict lane
Definition: GNEViewNet.cpp:1342
PositionVector::nearest_offset_to_point2D
SUMOReal nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
Definition: PositionVector.cpp:723
GNEPOI::move
void move(Position pos)
reposition the POI at pos and informs the edges
Definition: GNEPOI.cpp:86
MID_GNE_SHOW_CONNECTIONS
show connections
Definition: GUIAppEnum.h:549
GNEViewNet::markPopupPosition
void markPopupPosition()
store the position where a popup-menu was requested
Definition: GNEViewNet.cpp:977
GNEViewNet::onCmdDuplicateLane
long onCmdDuplicateLane(FXObject *, FXSelector, void *)
duplicate selected lane
Definition: GNEViewNet.cpp:1267
SUMO_TAG_JUNCTION
begin/end of the description of a junction
Definition: SUMOXMLDefinitions.h:65
SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:57
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
Definition: SUMOVehicleClass.h:132
GNEViewNet::myEditModeNames
StringBijection< EditMode > myEditModeNames
since we cannot switch on strings we map the mode names to an enum
Definition: GNEViewNet.h:425
GNEViewNet::onMouseMove
long onMouseMove(FXObject *, FXSelector, void *)
called when user moves mouse
Definition: GNEViewNet.cpp:836
SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:588
GLHelper.h
GNEJunction::markAsCreateEdgeSource
void markAsCreateEdgeSource()
marks as first junction in createEdge-mode
Definition: GNEJunction.cpp:343
GNEViewParent::getDeleteFrame
GNEDeleteFrame * getDeleteFrame() const
get frame for GNE_MODE_DELETE
Definition: GNEViewParent.cpp:209
GNEApplicationWindow
The main window of the Netedit.
Definition: GNEApplicationWindow.h:70
RGBColor.h
GUISUMOAbstractView::myGrid
SUMORTree * myGrid
The visualization speed-up.
Definition: GUISUMOAbstractView.h:383
GNEViewNet::onCmdSetModeSelect
long onCmdSetModeSelect(FXObject *, FXSelector, void *)
called when user press the button for select mode
Definition: GNEViewNet.cpp:1131
ICON_LOCATEJUNCTION
Definition: GUIIcons.h:80
GNEViewNet::myTestingHeight
int myTestingHeight
Definition: GNEViewNet.h:443
GNEInspectorFrame::getEdgeTemplate
GNEEdge * getEdgeTemplate() const
get the template edge (to copy attributes from)
Definition: GNEInspectorFrame.cpp:332
windows_config.h
GUIPropertyScheme::setAllowsNegativeValues
void setAllowsNegativeValues(bool value)
Definition: GUIPropertyScheme.h:168
debug_new.h
GNENet::revertLaneRestriction
bool revertLaneRestriction(GNELane *lane, GNEUndoList *undoList)
revert prevously restricted lane
Definition: GNENet.cpp:477
GNEDeleteFrame::removeAttributeCarrier
void removeAttributeCarrier(GNEAttributeCarrier *ac)
remove attribute carrier (element)
Definition: GNEDeleteFrame.cpp:336
GUISelectedStorage::toggleSelection
void toggleSelection(GUIGlID id)
Toggles selection of an object.
Definition: GUISelectedStorage.cpp:153
GUISUMOAbstractView::onMouseMove
virtual long onMouseMove(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:713
GNEViewNet::myChainCreateEdge
FXMenuCheck * myChainCreateEdge
whether the endpoint for a created edge should be set as the new source
Definition: GNEViewNet.h:335
GNEViewNet::myShowConnections
FXMenuCheck * myShowConnections
menu check to show connections
Definition: GNEViewNet.h:318
GLIncludes.h
Boundary::ymin
SUMOReal ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:142
GNE_MODE_DELETE
mode for deleting things
Definition: GNEViewNet.h:55
GNEPOI
Definition: GNEPOI.h:51
GNEViewNet::onCmdSplitEdge
long onCmdSplitEdge(FXObject *, FXSelector, void *)
split edge at cursor position
Definition: GNEViewNet.cpp:1166
GNEDeleteFrame::updateCurrentLabel
void updateCurrentLabel(GNEAttributeCarrier *ac)
update current label
Definition: GNEDeleteFrame.cpp:433
SUMO::Polygon::getShape
const PositionVector & getShape() const
Returns whether the shape of the polygon.
Definition: Polygon.h:87
GLO_CONNECTION
a connection
Definition: GUIGlObjectTypes.h:59
MFXCheckableButton::setChecked
void setChecked(bool val)
check or uncheck this MFXCheckableButton
Definition: MFXCheckableButton.cpp:69
SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:185
GNESelectorFrame::show
void show()
show Frame
Definition: GNESelectorFrame.cpp:366
GUISUMOAbstractView::myApp
GUIMainWindow * myApp
The application.
Definition: GUISUMOAbstractView.h:377
MFXCheckableButton.h
GNEViewNet::myChangeAllPhases
FXMenuCheck * myChangeAllPhases
menu check to set change all phases
Definition: GNEViewNet.h:327
SVC_DELIVERY
vehicle is a small delivery vehicle
Definition: SUMOVehicleClass.h:166
GNEViewNet::setEditMode
void setEditMode(EditMode mode)
set edit mode
Definition: GNEViewNet.cpp:1688
GUITextureSubSys::resetTextures
static void resetTextures()
Reset textures.
Definition: GUITextureSubSys.cpp:208
GNEEdge::moveGeometry
Position moveGeometry(const Position &oldPos, const Position &newPos, bool relative=false)
change the edge geometry It is up to the Edge to decide whether an new geometry node should be genera...
Definition: GNEEdge.cpp:278
GNENet::computeEverything
void computeEverything(GNEApplicationWindow *window, bool force=false)
Definition: GNENet.cpp:937
GNEViewNet::myEditModeSelect
MFXCheckableButton * myEditModeSelect
chekable button for edit mode select
Definition: GNEViewNet.h:407
Boundary::xmin
SUMOReal xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:130
GNEViewNet::mySelCorner2
Position mySelCorner2
second corner of the rectangle-selection
Definition: GNEViewNet.h:384
GNEViewParent::getAdditionalFrame
GNEAdditionalFrame * getAdditionalFrame() const
get frame for GNE_MODE_ADDITIONAL
Definition: GNEViewParent.cpp:197
SVC_NON_ROAD
classes which (normally) do not drive on normal roads
Definition: SUMOVehicleClass.h:199
SUMORTree::removeAdditionalGLObject
void removeAdditionalGLObject(GUIGlObject *o)
Removes an additional object (detector/shape/trigger) from being visualised.
Definition: SUMORTree.h:141
GNE_MODE_TLS
mode for editing tls
Definition: GNEViewNet.h:63
MID_GNE_DUPLICATE_LANE
duplicate a lane
Definition: GUIAppEnum.h:621
MID_LOCATETLS
Locate TLS - button.
Definition: GUIAppEnum.h:181
GUICompleteSchemeStorage.h
MID_GNE_MODE_CROSSING
mode for editing crossing
Definition: GUIAppEnum.h:450
GNEAdditional.h
GNEJunction::getNBNode
NBNode * getNBNode() const
Return net build node.
Definition: GNEJunction.cpp:258
MID_GNE_SHOW_BUBBLES
show junctions as bubbles
Definition: GUIAppEnum.h:551
GNENet::reverseEdge
void reverseEdge(GNEEdge *edge, GNEUndoList *undoList)
reverse edge
Definition: GNENet.cpp:596
GNEAdditional::getPositionInView
virtual Position getPositionInView() const =0
Returns position of additional in view.
GNEViewNet::setSelectionScaling
void setSelectionScaling(SUMOReal selectionScale)
set selection scaling
Definition: GNEViewNet.cpp:375
GUISUMOAbstractView::p2m
SUMOReal p2m(SUMOReal pixel) const
pixels-to-meters conversion method
Definition: GUISUMOAbstractView.cpp:526
GUIPolygon::setLineWidth
void setLineWidth(SUMOReal lineWidth)
set a new shape and update the tesselation
Definition: GUIPolygon.h:116
GNEViewNet::onCmdNodeShape
long onCmdNodeShape(FXObject *, FXSelector, void *)
input custom node shape
Definition: GNEViewNet.cpp:1608
RGBColor::ORANGE
static const RGBColor ORANGE
Definition: RGBColor.h:195
GNEEdge::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEEdge.cpp:497
GNEViewNet::myEditModeMove
MFXCheckableButton * myEditModeMove
chekable button for edit mode move
Definition: GNEViewNet.h:398
GUISUMOAbstractView::onLeftBtnPress
virtual long onLeftBtnPress(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:621
GNENet::splitEdgesBidi
void splitEdgesBidi(const std::set< GNEEdge * > &edges, const Position &pos, GNEUndoList *undoList)
split all edges at position by inserting one new junction
Definition: GNENet.cpp:585
MID_GNE_REMOVE_LANE_SIDEWALK
remove sidewalk
Definition: GUIAppEnum.h:637
GNEViewNet::myEditModeDelete
MFXCheckableButton * myEditModeDelete
chekable button for edit mode delete
Definition: GNEViewNet.h:401
GUISelectedStorage::isSelected
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
Definition: GUISelectedStorage.cpp:106
GNENet
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:87
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:54
GNETLSEditorFrame::editJunction
void editJunction(GNEJunction *junction)
edits the traffic light for the given junction
Definition: GNETLSEditorFrame.cpp:189
MID_GNE_REMOVE_LANE_BIKE
remove bikelane
Definition: GUIAppEnum.h:639
GNENet::createEdge
GNEEdge * createEdge(GNEJunction *src, GNEJunction *dest, GNEEdge *tpl, GNEUndoList *undoList, const std::string &suggestedName="", bool wasSplit=false, bool allowDuplicateGeom=false)
creates a new edge (unless an edge with the same geometry already exists)
Definition: GNENet.cpp:252
GUIVisualizationSettings::editMode
int editMode
the current NETEDIT mode (temporary)
Definition: GUIVisualizationSettings.h:289
GNEAdditional::commmitAdditionalGeometryMoved
void commmitAdditionalGeometryMoved(const Position &oldPos, GNEUndoList *undoList)
updated geometry changes in the attributes of additional
Definition: GNEAdditional.cpp:97
GNEUndoList::p_begin
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:86
MID_GNE_TRANSFORM_LANE_BUS
transform lane to busLane
Definition: GUIAppEnum.h:627
GNEViewNet::myPoiToMove
GNEPOI * myPoiToMove
the poi which is being moved
Definition: GNEViewNet.h:351
GNEViewNet::setEditModeFromHotkey
void setEditModeFromHotkey(FXushort selid)
sets edit mode (from hotkey)
Definition: GNEViewNet.cpp:940
MID_GNE_MODE_TLS
mode for editing tls
Definition: GUIAppEnum.h:446
GNEAdditionalFrame::addAdditional
bool addAdditional(GNENetElement *netElement, GUISUMOAbstractView *parent)
add additional element
Definition: GNEAdditionalFrame.cpp:179
GNEViewNet::onCmdSetEdgeEndpoint
long onCmdSetEdgeEndpoint(FXObject *, FXSelector, void *)
set non-default geometry endpoint
Definition: GNEViewNet.cpp:1206
MID_GNE_ADD_REVERSE_EDGE
add reverse edge
Definition: GUIAppEnum.h:605
MID_GNE_SPLIT_EDGE_BIDI
split an edge
Definition: GUIAppEnum.h:601
RGBColor::BLACK
static const RGBColor BLACK
Definition: RGBColor.h:197
GUIDanielPerspectiveChanger.h
SVCAll
const SVCPermissions SVCAll
Definition: SUMOVehicleClass.cpp:143
GUISUMOAbstractView::myVisualizationChanger
GUIDialog_ViewSettings * myVisualizationChanger
Visualization changer.
Definition: GUISUMOAbstractView.h:413
GNEViewNet::getViewParent
GNEViewParent * getViewParent() const
get the net object
Definition: GNEViewNet.cpp:983
GNENet::deleteEdge
void deleteEdge(GNEEdge *edge, GNEUndoList *undoList)
removes edge
Definition: GNENet.cpp:337
GNEViewNet::updateControls
void updateControls()
update control contents after undo/redo or recompute
Definition: GNEViewNet.cpp:1959
GNEViewNet::myPreviousEditMode
EditMode myPreviousEditMode
the previous edit mode used for toggling
Definition: GNEViewNet.h:312
GNEJunction::registerMove
void registerMove(GNEUndoList *undoList)
registers completed movement with the undoList
Definition: GNEJunction.cpp:375
MID_GNE_ADD_LANE_SIDEWALK
add sidewalk
Definition: GUIAppEnum.h:631
MID_LOCATEJUNCTION
Locate junction - button.
Definition: GUIAppEnum.h:173
Position::x
SUMOReal x() const
Returns the x-position.
Definition: Position.h:63
ICON_MODEADDITIONAL
Definition: GUIIcons.h:199
GNEViewNet::myShowBubbleOverJunction
FXMenuCheck * myShowBubbleOverJunction
show connection as buuble in "Move" mode.
Definition: GNEViewNet.h:372
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:125
Boundary::xmax
SUMOReal xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:136
GNEInspectorFrame.h
GNEViewNet::myEdgeToMove
GNEEdge * myEdgeToMove
the edge of which geometry is being moved
Definition: GNEViewNet.h:345
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:48
GUIGlobalSelection.h
GNEViewNet::myShowConnectionActivated
bool myShowConnectionActivated
whether show connections has been activated once
Definition: GNEViewNet.h:321
GNEViewParent
A single child window which contains a view of the simulation area.
Definition: GNEViewParent.h:72
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
GUIVisualizationSettings::scale
SUMOReal scale
information about a lane&#39;s width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:283
GNEViewNet.h
ICON_LOCATEEDGE
Definition: GUIIcons.h:81
GUISUMOAbstractView::screenPos2NetPos
Position screenPos2NetPos(int x, int y) const
Translate screen position to network position.
Definition: GUISUMOAbstractView.cpp:181
MID_GNE_TRANSFORM_LANE_BIKE
transform lane to bikelane
Definition: GUIAppEnum.h:625
GNEViewNet::getUndoList
GNEUndoList * getUndoList() const
get the undoList object
Definition: GNEViewNet.cpp:995
GUISUMOAbstractView::myAdditionallyDrawn
std::map< const GUIGlObject *, int > myAdditionallyDrawn
List of objects for which GUIGlObject::drawGLAdditional is called.
Definition: GUISUMOAbstractView.h:431
GNEEdge.h
GNENet::restrictLane
bool restrictLane(SUMOVehicleClass vclass, GNELane *lane, GNEUndoList *undoList)
transform lane to restricted lane
Definition: GNENet.cpp:451
GNEViewNet::myMoveSelection
bool myMoveSelection
whether a selection is being moved
Definition: GNEViewNet.h:366
MID_GNE_MODE_CREATE_EDGE
mode for adding edges
Definition: GUIAppEnum.h:434
GNEViewNet::onCmdSetModeCrossing
long onCmdSetModeCrossing(FXObject *, FXSelector, void *)
called when user press the button for crossing mode
Definition: GNEViewNet.cpp:1159
GUIGlObject::getMicrosimID
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition: GUIGlObject.cpp:139
GNEConnectorFrame::handleLaneClick
void handleLaneClick(GNELane *lane, bool mayDefinitelyPass, bool allowConflict, bool toggle)
either sets the current lane or toggles the connection of the current lane to this lane (if they shar...
Definition: GNEConnectorFrame.cpp:179
GNEPOI.h
Named::getID
const std::string & getID() const
Returns the id.
Definition: Named.h:66
GUISUMOAbstractView::getObjectsAtPosition
std::vector< GUIGlID > getObjectsAtPosition(Position pos, SUMOReal radius)
returns the ids of the object at position within the given (rectangular) radius using GL_SELECT ...
Definition: GUISUMOAbstractView.cpp:339
ICON_LOCATETLS
Definition: GUIIcons.h:84
StringBijection::insert
void insert(const std::string str, const T key, bool checkDuplicates=true)
Definition: StringBijection.h:80
GUIGlObject::getType
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.cpp:152
GNEViewNet::myOldAdditionalPosition
Position myOldAdditionalPosition
variable for saving additional position before moving
Definition: GNEViewNet.h:360
GNEViewNet::buildEditModeControls
void buildEditModeControls()
adds controls for setting the edit mode
Definition: GNEViewNet.cpp:1711
GUISUMOAbstractView::getObjectAtPosition
GUIGlID getObjectAtPosition(Position pos)
returns the id of the object at position using GL_SELECT
Definition: GUISUMOAbstractView.cpp:294
GNEViewNet::getEdgesAtCursorPosition
std::set< GNEEdge * > getEdgesAtCursorPosition(Position &pos)
try to retrieve multiple edges at the given position
Definition: GNEViewNet.cpp:1077
MID_GNE_REVERSE_EDGE
reverse an edge
Definition: GUIAppEnum.h:603
GNEViewNet::onLeftBtnPress
long onLeftBtnPress(FXObject *, FXSelector, void *)
Definition: GNEViewNet.cpp:475
NBNode::getPosition
const Position & getPosition() const
Definition: NBNode.h:232
GNEViewNet::onCmdSimplifyShape
long onCmdSimplifyShape(FXObject *, FXSelector, void *)
simply shape of current polygon
Definition: GNEViewNet.cpp:1247
GUIPropertyScheme::addColor
int addColor(const T &color, const SUMOReal threshold, const std::string &name="")
Definition: GUIPropertyScheme.h:83
RGBColor::GREEN
static const RGBColor GREEN
Definition: RGBColor.h:190
RGBColor::GREY
static const RGBColor GREY
Definition: RGBColor.h:198
GUISUMOAbstractView::onPaint
virtual long onPaint(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:601
MID_GNE_SIMPLIFY_SHAPE
simplify polygon geometry
Definition: GUIAppEnum.h:617
GUISelectedStorage::getSelected
const std::set< GUIGlID > & getSelected() const
Returns the set of ids of all selected objects.
Definition: GUISelectedStorage.cpp:170
GNEViewNet::myCurrentPoly
GNEPoly * myCurrentPoly
current polygon
Definition: GNEViewNet.h:438
GUIVisualizationSettings::selectionScale
SUMOReal selectionScale
the current selection scaling in NETEDIT (temporary)
Definition: GUIVisualizationSettings.h:295
GNEViewNet::onCmdRemoveRestrictedLaneBuslane
long onCmdRemoveRestrictedLaneBuslane(FXObject *, FXSelector typeOfTransformation, void *)
remove restricted lane for bus
Definition: GNEViewNet.cpp:1336
MID_GNE_SET_EDGE_ENDPOINT
set non-default geometry endpoint
Definition: GUIAppEnum.h:611
GNENet::removeRestrictedLane
bool removeRestrictedLane(SUMOVehicleClass vclass, GNEEdge &edge, GNEUndoList *undoList)
remove restricted lane
Definition: GNENet.cpp:510
GNEViewNet::myWarnAboutMerge
FXMenuCheck * myWarnAboutMerge
whether we should warn about merging junctions
Definition: GNEViewNet.h:369
MID_GNE_RESET_EDGE_ENDPOINT
restore geometry endpoint to node position
Definition: GUIAppEnum.h:613
GNELane.h
GNE_MODE_INSPECT
mode for inspecting object attributes
Definition: GNEViewNet.h:57
GUIDialog_ViewSettings::setCurrentScheme
void setCurrentScheme(const std::string &)
Sets the named scheme as the current.
Definition: GUIDialog_ViewSettings.cpp:1501
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:55
GNEAttributeCarrier::hasAttribute
static bool hasAttribute(SumoXMLTag tag, SumoXMLAttr attr)
check if an element with certain tag has a certain attribute
Definition: GNEAttributeCarrier.cpp:672
GUIMainWindow::setStatusBarText
virtual void setStatusBarText(const std::string &)
Definition: GUIMainWindow.h:79
GNEViewNet::myAdditionalToMove
GNEAdditional * myAdditionalToMove
the stoppingPlace element which shape is being moved
Definition: GNEViewNet.h:354
GNEAdditional::getLane
GNELane * getLane() const
get lane of additional, or NULL if additional isn&#39;t placed over a Lane
Definition: GNEAdditional.cpp:179
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:443
GNETLSEditorFrame::onCmdCancel
long onCmdCancel(FXObject *, FXSelector, void *)
Called when the user presses the Cancel-button.
Definition: GNETLSEditorFrame.cpp:203
GNECrossing
This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routete...
Definition: GNECrossing.h:51
GNELane::getParentEdge
GNEEdge & getParentEdge()
Returns underlying parent edge.
Definition: GNELane.cpp:1027
GNEViewNet::~GNEViewNet
virtual ~GNEViewNet()
destructor
Definition: GNEViewNet.cpp:287
GNEViewNet::onCmdSetModeMove
long onCmdSetModeMove(FXObject *, FXSelector, void *)
called when user press the button for move mode
Definition: GNEViewNet.cpp:1110
MID_GNE_MODE_INSPECT
mode for inspecting object attributes
Definition: GUIAppEnum.h:440
GNEUndoList::p_end
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise, the sub-group will be added as a new command into parent group. A matching begin() must have been called previously.
Definition: GNEUndoList.cpp:93
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
PositionVector.h
GNEDeleteFrame.h
PositionVector
A list of positions.
Definition: PositionVector.h:53
GNEViewNet::myToolbar
FXToolBar * myToolbar
Definition: GNEViewNet.h:390
GUITextureSubSys.h
MID_GNE_REVERT_TRANSFORMATION
revert transformation
Definition: GUIAppEnum.h:629
GNENet::deleteLane
void deleteLane(GNELane *lane, GNEUndoList *undoList)
removes lane
Definition: GNENet.cpp:374
GNEViewNet::onCmdToogleShowConnection
long onCmdToogleShowConnection(FXObject *, FXSelector, void *)
toogle show connections
Definition: GNEViewNet.cpp:1662
GUICompleteSchemeStorage::contains
bool contains(const std::string &name) const
Returns the information whether a setting with the given name is stored.
Definition: GUICompleteSchemeStorage.cpp:86
GNEConnectorFrame.h
GNERerouter.h
GNEViewNet::myEditModeCreateEdge
MFXCheckableButton * myEditModeCreateEdge
Definition: GNEViewNet.h:395
GUIGlObjectStorage::gIDStorage
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
Definition: GUIGlObjectStorage.h:149
GUIIconSubSys.h
TplConvert::_str2int
static int _str2int(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter...
Definition: TplConvert.h:160
GUICompleteSchemeStorage::get
GUIVisualizationSettings & get(const std::string &name)
Returns the named scheme.
Definition: GUICompleteSchemeStorage.cpp:74
MID_GNE_NODE_REPLACE
turn junction into geometry node
Definition: GUIAppEnum.h:609
GNEViewNet::onCmdRevertRestriction
long onCmdRevertRestriction(FXObject *, FXSelector, void *)
revert transformation
Definition: GNEViewNet.cpp:1541
GNEViewNet::removeRestrictedLane
bool removeRestrictedLane(SUMOVehicleClass vclass)
remove restricted lane
Definition: GNEViewNet.cpp:1474
GNEViewNet::onCmdSplitEdgeBidi
long onCmdSplitEdgeBidi(FXObject *, FXSelector, void *)
split edge at cursor position
Definition: GNEViewNet.cpp:1176
GNEViewNet::autoSelectNodes
bool autoSelectNodes()
whether to autoselect nodes or to lanes
Definition: GNEViewNet.cpp:369
RGBColor::MAGENTA
static const RGBColor MAGENTA
Definition: RGBColor.h:194
GNESelectorFrame.h
ICON_MODECROSSING
Definition: GUIIcons.h:202
GNEViewNet::myEditModeTrafficLight
MFXCheckableButton * myEditModeTrafficLight
chekable button for edit mode traffic light
Definition: GNEViewNet.h:413
GNEViewParent::getCrossingFrame
GNECrossingFrame * getCrossingFrame() const
get frame for GNE_MODE_CROSSING
Definition: GNEViewParent.cpp:203
GNENet::initGNEConnections
void initGNEConnections()
initialize GNEConnections
Definition: GNENet.cpp:1420
GNEViewNet::onCmdRemoveRestrictedLaneBikelane
long onCmdRemoveRestrictedLaneBikelane(FXObject *, FXSelector typeOfTransformation, void *)
remove restricted lane for bikes
Definition: GNEViewNet.cpp:1330
GNE_MODE_SELECT
mode for selecting objects
Definition: GNEViewNet.h:59
GNEViewNet::removeCurrentPoly
void removeCurrentPoly()
remove the currently edited polygon
Definition: GNEViewNet.cpp:1641
GNEViewNet::myJunctionToMove
GNEJunction * myJunctionToMove
the Junction to be moved.
Definition: GNEViewNet.h:342
GNECrossingFrame::addCrossing
bool addCrossing(GNENetElement *netElement)
add Crossing element
Definition: GNECrossingFrame.cpp:595
GNEViewNet::myEditModeAdditional
MFXCheckableButton * myEditModeAdditional
chekable button for edit mode additional
Definition: GNEViewNet.h:416
GNEDeleteFrame::markAttributeCarrier
void markAttributeCarrier(GNEAttributeCarrier *ac)
mark attribute carrier (element)
Definition: GNEDeleteFrame.cpp:418
GNEViewNet::getLaneAtCurserPosition
GNELane * getLaneAtCurserPosition(Position &pos)
try to retrieve a lane at the given position
Definition: GNEViewNet.cpp:1060
SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:497
GNENet::retrieveAttributeCarriers
std::vector< GNEAttributeCarrier * > retrieveAttributeCarriers(const std::set< GUIGlID > &ids, GUIGlObjectType type)
get the attribute carriers based on GlIDs
Definition: GNENet.cpp:826
GUIDialog_ViewSettings::getCurrentScheme
std::string getCurrentScheme() const
Returns the name of the currently chosen scheme.
Definition: GUIDialog_ViewSettings.cpp:1495
GNEViewParent::getInspectorFrame
GNEInspectorFrame * getInspectorFrame() const
get frame for GNE_MODE_INSPECT
Definition: GNEViewParent.cpp:173
GNEViewParent::getConnectorFrame
GNEConnectorFrame * getConnectorFrame() const
get frame for GNE_MODE_CONNECT
Definition: GNEViewParent.cpp:185
GNEJunction::unMarkAsCreateEdgeSource
void unMarkAsCreateEdgeSource()
removes mark as first junction in createEdge-mode
Definition: GNEJunction.cpp:349
MID_GNE_MODE_MOVE
mode for moving things
Definition: GUIAppEnum.h:436
GNENet::moveSelection
void moveSelection(const Position &moveSrc, const Position &moveDest)
move all selected junctions and edges
Definition: GNENet.cpp:1147
GNEViewNet::myTestingWidth
int myTestingWidth
Definition: GNEViewNet.h:442
GNENet::createJunction
GNEJunction * createJunction(const Position &pos, GNEUndoList *undoList)
creates a new junction
Definition: GNENet.cpp:241
GNENet.h
GNEAdditional::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEViewNet::mySelCorner1
Position mySelCorner1
firstcorner of the rectangle-selection
Definition: GNEViewNet.h:381
GNEViewNet::myAdditionalMovingReference
Position myAdditionalMovingReference
variable for calculating moving offset of additionals
Definition: GNEViewNet.h:357
GNEUndoList::p_abort
void p_abort()
reverts and discards ALL active command groups
Definition: GNEUndoList.cpp:107
NBNode::getShape
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:1720
ICON_MODETLS
Definition: GUIIcons.h:207
GNEViewNet::onCmdRestrictLaneBuslane
long onCmdRestrictLaneBuslane(FXObject *, FXSelector typeOfTransformation, void *)
restrict lane to buslanes
Definition: GNEViewNet.cpp:1300
GUISUMOAbstractView::myUseToolTips
bool myUseToolTips
use tool tips
Definition: GUISUMOAbstractView.h:401
ICON_MODEMOVE
Definition: GUIIcons.h:205
EditMode
EditMode
Definition: GNEViewNet.h:47
GNENet::getVisualisationSpeedUp
SUMORTree & getVisualisationSpeedUp()
Returns the RTree used for visualisation speed-up.
Definition: GNENet.cpp:229
SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:156
MID_GNE_MODE_CONNECT
mode for connecting lanes
Definition: GUIAppEnum.h:444
MID_GNE_TRANSFORM_LANE_SIDEWALK
transform lane to sidewalk
Definition: GUIAppEnum.h:623
GNEViewNet::doInit
void doInit()
called after some features are already initialized
Definition: GNEViewNet.cpp:291
SVC_SHIP
is an arbitrary ship
Definition: SUMOVehicleClass.h:191
SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:55
GNECrossing.h
GNEViewNet::myAutoCreateOppositeEdge
FXMenuCheck * myAutoCreateOppositeEdge
Definition: GNEViewNet.h:336
GNEViewNet::mergeJunctions
bool mergeJunctions(GNEJunction *moved)
try to merge moved junction with another junction in that spot return true if merging did take place ...
Definition: GNEViewNet.cpp:1911
GNEViewNet::myEditModeInspect
MFXCheckableButton * myEditModeInspect
chekable button for edit mode inspect
Definition: GNEViewNet.h:404
SVC_MOPED
vehicle is a moped
Definition: SUMOVehicleClass.h:183
XMLSubSys.h
GNENet::replaceJunctionByGeometry
void replaceJunctionByGeometry(GNEJunction *junction, GNEUndoList *undoList)
replace the selected junction by geometry node(s) and merge the edges
Definition: GNENet.cpp:1074
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:54
GUIGlID
unsigned int GUIGlID
Definition: GUIGlObject.h:50
GUISUMOAbstractView::makeCurrent
FXbool makeCurrent()
A reimplementation due to some internal reasons.
Definition: GUISUMOAbstractView.cpp:576
GNEConnectorFrame::onCmdOK
long onCmdOK(FXObject *, FXSelector, void *)
Definition: GNEConnectorFrame.cpp:244
SVC_TAXI
vehicle is a taxi
Definition: SUMOVehicleClass.h:160
GLO_ADDITIONAL
compound additional
Definition: GUIGlObjectTypes.h:69
GUISUMOAbstractView::onLeftBtnRelease
virtual long onLeftBtnRelease(FXObject *, FXSelector, void *)
Definition: GUISUMOAbstractView.cpp:652
SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:342
SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:162
RGBColor::YELLOW
static const RGBColor YELLOW
Definition: RGBColor.h:192
Boundary::grow
Boundary & grow(SUMOReal by)
extends the boundary by the given amount
Definition: Boundary.cpp:238
GLO_POI
a poi
Definition: GUIGlObjectTypes.h:73
GNEAdditionalFrame.h
MID_GNE_MODE_ADDITIONAL
mode for editing additional
Definition: GUIAppEnum.h:448
MID_GNE_SPLIT_EDGE
split an edge
Definition: GUIAppEnum.h:599
RGBColor::RED
static const RGBColor RED
Definition: RGBColor.h:189
GLO_LANE
a lane
Definition: GUIGlObjectTypes.h:53
GNELane::getShape
const PositionVector & getShape() const
returns the shape of the lane
Definition: GNELane.cpp:583
GNEViewNet::myExtendToEdgeNodes
FXMenuCheck * myExtendToEdgeNodes
menu check to extend to edge nodes
Definition: GNEViewNet.h:324
GNEUndoList.h
GUIDesignButtonToolbarCheckable
#define GUIDesignButtonToolbarCheckable
little checkable button with icon placed in navigation toolbar
Definition: GUIDesigns.h:96
GNEFrame::show
virtual void show()
show Frame
Definition: GNEFrame.cpp:100
GNEAdditional::moveAdditionalGeometry
void moveAdditionalGeometry(const Position &offset)
change the position of the additional geometry
Definition: GNEAdditional.cpp:91
GNEPoly.h
RGBColor::CYAN
static const RGBColor CYAN
Definition: RGBColor.h:193
GNEUndoList::hasCommandGroup
bool hasCommandGroup() const
Check if undoList has command group.
Definition: GNEUndoList.cpp:178
GUISUMOAbstractView::myVisualizationSettings
GUIVisualizationSettings * myVisualizationSettings
visualization settings
Definition: GUISUMOAbstractView.h:398
MID_GNE_NODE_SHAPE
edit junction shape
Definition: GUIAppEnum.h:607
GNEAdditionalFrame::show
void show()
show additional frame and update use selected edges/lanes
Definition: GNEAdditionalFrame.cpp:410
GNENet::retrieveEdges
std::vector< GNEEdge * > retrieveEdges(bool onlySelected=false)
return all edges
Definition: GNENet.cpp:747
GNEViewNet::myMoveSrc
Position myMoveSrc
position from which to move edge geometry
Definition: GNEViewNet.h:363
Boundary::add
void add(SUMOReal x, SUMOReal y, SUMOReal z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:90
GNEViewNet::onCmdAddRestrictedLaneBikelane
long onCmdAddRestrictedLaneBikelane(FXObject *, FXSelector typeOfTransformation, void *)
Add restricted lane for bikes.
Definition: GNEViewNet.cpp:1312
SUMORTree::addAdditionalGLObject
void addAdditionalGLObject(GUIGlObject *o)
Adds an additional object (detector/shape/trigger) for visualisation.
Definition: SUMORTree.h:129
GNEAdditional
An Element which don&#39;t belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:62
GNEViewNet::myEditModeConnection
MFXCheckableButton * myEditModeConnection
chekable button for edit mode connection
Definition: GNEViewNet.h:410
GNEViewNet::showConnections
bool showConnections()
show connections over junctions
Definition: GNEViewNet.cpp:357
GUISUMOAbstractView::m2p
SUMOReal m2p(SUMOReal meter) const
meter-to-pixels conversion method
Definition: GUISUMOAbstractView.cpp:520
GNETLSEditorFrame::onCmdOK
long onCmdOK(FXObject *, FXSelector, void *)
Definition: GNETLSEditorFrame.cpp:214
GNEViewNet::onCmdReverseEdge
long onCmdReverseEdge(FXObject *, FXSelector, void *)
reverse edge
Definition: GNEViewNet.cpp:1186
GNEViewNet::onCmdSetModeTLS
long onCmdSetModeTLS(FXObject *, FXSelector, void *)
called when user press the button for traffic lights mode
Definition: GNEViewNet.cpp:1145
Position::y
SUMOReal y() const
Returns the y-position.
Definition: Position.h:68
MID_GNE_MODE_SELECT
mode for selecting objects
Definition: GUIAppEnum.h:442
GNEConnectorFrame::onCmdCancel
long onCmdCancel(FXObject *, FXSelector, void *)
Called when the user presses the Cancel-button discards any connection modifications.
Definition: GNEConnectorFrame.cpp:230
GNEViewNet::doPaintGL
int doPaintGL(int mode, const Boundary &bound)
do paintGL
Definition: GNEViewNet.cpp:393
GNEViewNet::myCreateEdgeSource
GNEJunction * myCreateEdgeSource
source junction for new edge 0 if no edge source is selected an existing (or newly created) junction ...
Definition: GNEViewNet.h:332
GNEJunction::move
void move(Position pos)
reposition the node at pos and informs the edges
Definition: GNEJunction.cpp:361
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:99
Position::set
void set(SUMOReal x, SUMOReal y)
set positions x and y
Definition: Position.h:93
GLO_EDGE
an edge
Definition: GUIGlObjectTypes.h:51
GNETLSEditorFrame.h
GNEViewNet::onCmdAddRestrictedLaneBuslane
long onCmdAddRestrictedLaneBuslane(FXObject *, FXSelector typeOfTransformation, void *)
Add restricted lane for buses.
Definition: GNEViewNet.cpp:1318
GNEViewNet::onCmdRemoveRestrictedLaneSidewalk
long onCmdRemoveRestrictedLaneSidewalk(FXObject *, FXSelector typeOfTransformation, void *)
remove restricted lane for pedestrians
Definition: GNEViewNet.cpp:1324
GNEDeleteFrame::getMarkedAttributeCarrier
GNEAttributeCarrier * getMarkedAttributeCarrier() const
returns marked atrribute carrier
Definition: GNEDeleteFrame.cpp:446
OptionsCont.h
GNEPoly::simplifyShape
void simplifyShape()
replace the current shape with a rectangle
Definition: GNEPoly.cpp:140
GNEDeleteFrame::showAttributeCarrierChilds
void showAttributeCarrierChilds(GNEAttributeCarrier *ac)
show child of attributeCarrier in frame if previously there isn&#39;t a marked element ...
Definition: GNEDeleteFrame.cpp:118
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:989
GUISelectedStorage::clear
void clear()
Clears the list of selected objects.
Definition: GUISelectedStorage.cpp:182
GNENet::deleteJunction
void deleteJunction(GNEJunction *junction, GNEUndoList *undoList)
removes junction and all incident edges
Definition: GNENet.cpp:307
GNECrossingFrame.h
MID_GNE_STRAIGHTEN
remove inner geometry
Definition: GUIAppEnum.h:615
GNESelectorFrame::handleIDs
void handleIDs(std::vector< GUIGlID > ids, bool selectEdges, SetOperation setop=SET_DEFAULT)
apply list of ids to the current selection according to SetOperation,
Definition: GNESelectorFrame.cpp:403
text
void text()
Definition: gl2psTest.c:260
GUIVisualizationSettings::showGrid
bool showGrid
Information whether a grid shall be shown.
Definition: GUIVisualizationSettings.h:137
MID_GNE_DELETE_GEOMETRY
delete geometry point
Definition: GUIAppEnum.h:619
GUISUMOAbstractView::drawDecals
void drawDecals()
Draws the stored decals.
Definition: GUISUMOAbstractView.cpp:1160
GNEInspectorFrame::show
void show()
show inspector frame
Definition: GNEInspectorFrame.cpp:173
GNEAdditional::isAdditionalBlocked
bool isAdditionalBlocked() const
Check if additional item is currently blocked (i.e. cannot be moved with mouse)
Definition: GNEAdditional.cpp:127
GNEViewNet::onCmdRestrictLaneSidewalk
long onCmdRestrictLaneSidewalk(FXObject *, FXSelector typeOfTransformation, void *)
restrict lane to pedestrians
Definition: GNEViewNet.cpp:1288
GNEViewNet::updateModeSpecificControls
void updateModeSpecificControls()
updates mode specific controls
Definition: GNEViewNet.cpp:1768
MID_GNE_MODE_DELETE
mode for deleting things
Definition: GUIAppEnum.h:438
GNEViewNet::myEditModeCrossing
MFXCheckableButton * myEditModeCrossing
chekable button for edit mode crossing
Definition: GNEViewNet.h:419
SUMORTree::Search
virtual int Search(const float a_min[2], const float a_max[2], const GUIVisualizationSettings &c) const
Find all within search rectangle.
Definition: SUMORTree.h:120
GUIDesigns.h
GNEAttributeCarrier::getTag
SumoXMLTag getTag() const
get XML Tag assigned to this object
Definition: GNEAttributeCarrier.cpp:116
GNENet::addReversedEdge
GNEEdge * addReversedEdge(GNEEdge *edge, GNEUndoList *undoList)
add reversed edge
Definition: GNENet.cpp:607
GNEViewNet::setStatusBarText
void setStatusBarText(const std::string &text)
set staturBar text
Definition: GNEViewNet.cpp:345
MID_GNE_ADD_LANE_BIKE
add bikelane
Definition: GUIAppEnum.h:633
GNEJunction.h
GUIAppEnum.h
GNEViewParent.h
GNEViewParent::hideAllFrames
void hideAllFrames()
hide all frames
Definition: GNEViewParent.cpp:166
GNEConnection.h
SUMOReal
#define SUMOReal
Definition: config.h:208
GNEViewNet::onCmdSetModeConnect
long onCmdSetModeConnect(FXObject *, FXSelector, void *)
called when user press the button for connect mode
Definition: GNEViewNet.cpp:1138
GNE_MODE_ADDITIONAL
Mode for editing additionals.
Definition: GNEViewNet.h:65
GNEViewNet::buildViewToolBars
virtual void buildViewToolBars(GUIGlChildWindow &)
builds the view toolbars
Definition: GNEViewNet.cpp:295
GNEEdge::setEndpoint
void setEndpoint(Position pos, GNEUndoList *undoList)
makes pos the new geometry endpoint at the appropriate end
Definition: GNEEdge.cpp:361
GUIDialog_ViewSettings.h
Boundary::ymax
SUMOReal ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:148
GUIColorScheme
GUIPropertyScheme< RGBColor > GUIColorScheme
Definition: GUIPropertyScheme.h:236
MID_LOCATEEDGE
Locate edge - button.
Definition: GUIAppEnum.h:175
GNENet::selectionColor
static const RGBColor selectionColor
color of selection
Definition: GNENet.h:96
GLO_MAX
empty max
Definition: GUIGlObjectTypes.h:81
GNE_MODE_CROSSING
Mode for editing crossing.
Definition: GNEViewNet.h:67
GUIGlObjectStorage::unblockObject
void unblockObject(GUIGlID id)
Marks an object as unblocked.
Definition: GUIGlObjectStorage.cpp:129
ICON_MODEDELETE
Definition: GUIIcons.h:203
GNEViewNet::onCmdStraightenEdges
long onCmdStraightenEdges(FXObject *, FXSelector, void *)
makes selected edges straight
Definition: GNEViewNet.cpp:1226
GNEViewNet::onCmdSetModeInspect
long onCmdSetModeInspect(FXObject *, FXSelector, void *)
called when user press the button for inspect mode
Definition: GNEViewNet.cpp:1124
GNE_MODE_CONNECT
mode for connecting lanes
Definition: GNEViewNet.h:61
GNEAdditionalHandler.h
GNE_MODE_CREATE_EDGE
mode for creating new edges
Definition: GNEViewNet.h:51
GNEEdge::getNBEdge
NBEdge * getNBEdge()
returns the internal NBEdge
Definition: GNEEdge.cpp:258
GNEViewParent::getTLSEditorFrame
GNETLSEditorFrame * getTLSEditorFrame() const
get frame for GNE_MODE_TLS
Definition: GNEViewParent.cpp:191
GNEViewNet::onDoubleClicked
long onDoubleClicked(FXObject *, FXSelector, void *)
called when user press mouse&#39;s left button two times
Definition: GNEViewNet.cpp:813
GUISUMOAbstractView::getPositionInformation
Position getPositionInformation() const
Returns the cursor&#39;s x/y position within the network.
Definition: GUISUMOAbstractView.cpp:175
GUISUMOAbstractView::getObjectUnderCursor
GUIGlID getObjectUnderCursor()
returns the id of the object under the cursor using GL_SELECT
Definition: GUISUMOAbstractView.cpp:288
GNEInspectorFrame::inspectMultisection
void inspectMultisection(const std::vector< GNEAttributeCarrier * > &ACs)
Inspect the given multi-selection.
Definition: GNEInspectorFrame.cpp:191
GNEViewNet::onCmdToogleShowBubbles
long onCmdToogleShowBubbles(FXObject *, FXSelector, void *)
toogle show bubbles
Definition: GNEViewNet.cpp:1676
GNENet::mergeJunctions
void mergeJunctions(GNEJunction *moved, GNEJunction *target, GNEUndoList *undoList)
merge the given junctions edges between the given junctions will be deleted
Definition: GNENet.cpp:640
GNEViewNet::getEdgeAtCursorPosition
GNEEdge * getEdgeAtCursorPosition(Position &pos)
try to retrieve an edge at the given position
Definition: GNEViewNet.cpp:1036
GNEViewNet::showJunctionAsBubbles
bool showJunctionAsBubbles() const
return true if junction must be showed as bubbles
Definition: GNEViewNet.cpp:387
GNEViewNet::onCmdNodeReplace
long onCmdNodeReplace(FXObject *, FXSelector, void *)
replace node by geometry
Definition: GNEViewNet.cpp:1651
GNEViewNet::hotkeyDel
void hotkeyDel()
handle del keypress
Definition: GNEViewNet.cpp:911
GNEViewNet::onCmdAddReversedEdge
long onCmdAddReversedEdge(FXObject *, FXSelector, void *)
add reversed edge
Definition: GNEViewNet.cpp:1196
GUIGlObjectStorage::getObjectBlocking
GUIGlObject * getObjectBlocking(GUIGlID id)
Returns the object from the container locking it.
Definition: GUIGlObjectStorage.cpp:72
PositionVector::closePolygon
void closePolygon()
ensures that the last position equals the first
Definition: PositionVector.cpp:1000
GNEPoly::getEditedJunction
GNEJunction * getEditedJunction() const
retrieve the junction of which the shape is being edited
Definition: GNEPoly.h:153
GNEViewNet::myAmInRectSelect
bool myAmInRectSelect
whether we have started rectangle-selection
Definition: GNEViewNet.h:378
GNEEdge::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNEEdge.cpp:565
GNENet::addSRestrictedLane
bool addSRestrictedLane(SUMOVehicleClass vclass, GNEEdge &edge, GNEUndoList *undoList)
add restricted lane to edge
Definition: GNENet.cpp:495
gSelected
GUISelectedStorage gSelected
A global holder of selected objects.
Definition: GUIGlobalSelection.cpp:45
GNEViewNet::myNet
GNENet * myNet
we are not responsible for deletion
Definition: GNEViewNet.h:306
GNEViewNet::hotkeyEnter
void hotkeyEnter()
handle enter keypress
Definition: GNEViewNet.cpp:924
GNEEdge::resetEndpoint
void resetEndpoint(const Position &pos, GNEUndoList *undoList)
restores the endpoint to the junction position at the appropriate end
Definition: GNEEdge.cpp:384
GUIIconSubSys::getIcon
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:416
ICON_MODEINSPECT
Definition: GUIIcons.h:204
GNEViewNet::onLeftBtnRelease
long onLeftBtnRelease(FXObject *, FXSelector, void *)
called when user releases mouse&#39;s left button
Definition: GNEViewNet.cpp:765
GNEEdge::getSplitPos
Position getSplitPos(const Position &clickPos)
Definition: GNEEdge.cpp:264
GNENet::requireRecompute
void requireRecompute()
inform the net about the need for recomputation
Definition: GNENet.cpp:978
NBNode::computeNodeShape
void computeNodeShape(SUMOReal mismatchThreshold)
Compute the junction shape for this node.
Definition: NBNode.cpp:785
GNENet::duplicateLane
void duplicateLane(GNELane *lane, GNEUndoList *undoList)
duplicates lane
Definition: GNENet.cpp:439
GNEViewNet::onCmdSetModeCreateEdge
long onCmdSetModeCreateEdge(FXObject *, FXSelector, void *)
Definition: GNEViewNet.cpp:1103
MFXImageHelper.h
GNEViewNet::onCmdSetModeDelete
long onCmdSetModeDelete(FXObject *, FXSelector, void *)
called when user press the button for delete mode
Definition: GNEViewNet.cpp:1117
GNEViewNet::deleteSelectedEdges
void deleteSelectedEdges()
delete all currently selected edges
Definition: GNEViewNet.cpp:1892
ICON_MODESELECT
Definition: GUIIcons.h:206
GNEViewNet::myUndoList
GNEUndoList * myUndoList
a reference to the undolist maintained in the application
Definition: GNEViewNet.h:432
GNEViewNet::myEditMode
EditMode myEditMode
the current edit mode
Definition: GNEViewNet.h:309
GNEViewNet::addRestrictedLane
bool addRestrictedLane(SUMOVehicleClass vclass)
add restricted lane
Definition: GNEViewNet.cpp:1407
GUISUMOAbstractView::getObjectsInBoundary
std::vector< GUIGlID > getObjectsInBoundary(const Boundary &bound)
returns the ids of all objects in the given boundary
Definition: GUISUMOAbstractView.cpp:367
GUIGlChildWindow::getLocatorPopup
FXPopup * getLocatorPopup()
Definition: GUIGlChildWindow.cpp:169
GNEAdditionalDialog.h
GNEViewNet::myTestingMode
bool myTestingMode
testing mode
Definition: GNEViewNet.h:441
MID_GNE_REMOVE_LANE_BUS
remove busLane
Definition: GUIAppEnum.h:641
GNEViewParent::getSelectorFrame
GNESelectorFrame * getSelectorFrame() const
get frame for GNE_MODE_SELECT
Definition: GNEViewParent.cpp:179
GLO_JUNCTION
a junction
Definition: GUIGlObjectTypes.h:55
GNEPoly::deleteGeometryNear
void deleteGeometryNear(const Position &pos)
delete the geometry point closest to the given pos
Definition: GNEPoly.cpp:152
GNEViewNet::myPolyToMove
GNEPoly * myPolyToMove
the poly of which geometry is being moved
Definition: GNEViewNet.h:348
GNENet::finishMoveSelection
void finishMoveSelection(GNEUndoList *undoList)
register changes to junction and edge positions with the undoList
Definition: GNENet.cpp:1177
GUISUMOAbstractView.h