Eclipse SUMO - Simulation of Urban MObility
GNEVehicleFrame.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // The Widget for add Vehicles/Flows/Trips/etc. elements
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <netedit/GNENet.h>
23 #include <netedit/GNEViewNet.h>
28 
29 #include "GNEVehicleFrame.h"
30 
31 // ===========================================================================
32 // method definitions
33 // ===========================================================================
34 
35 // ---------------------------------------------------------------------------
36 // GNEVehicleFrame::HelpCreation - methods
37 // ---------------------------------------------------------------------------
38 
40  FXGroupBoxModule(vehicleFrameParent->myContentFrame, "Help"),
41  myVehicleFrameParent(vehicleFrameParent) {
43 }
44 
45 
47 
48 
49 void
51  // first update help cration
52  updateHelpCreation();
53  // show modul
54  show();
55 }
56 
57 
58 void
60  hide();
61 }
62 
63 void
65  // create information label
66  std::ostringstream information;
67  // set text depending of selected vehicle type
68  switch (myVehicleFrameParent->myVehicleTagSelector->getCurrentTemplateAC()->getTagProperty().getTag()) {
69  case SUMO_TAG_VEHICLE:
70  information
71  << "- Click over a route to\n"
72  << " create a vehicle.";
73  break;
74  case SUMO_TAG_TRIP:
75  information
76  << "- Select two edges to\n"
77  << " create a Trip.";
78  break;
79  case GNE_TAG_FLOW_ROUTE:
80  information
81  << "- Click over a route to\n"
82  << " create a routeFlow.";
83  break;
84  case SUMO_TAG_FLOW:
85  information
86  << "- Select two edges to\n"
87  << " create a flow.";
88  break;
89  default:
90  break;
91  }
92  // set information label
93  myInformationLabel->setText(information.str().c_str());
94 }
95 
96 // ---------------------------------------------------------------------------
97 // GNEVehicleFrame - methods
98 // ---------------------------------------------------------------------------
99 
100 GNEVehicleFrame::GNEVehicleFrame(FXHorizontalFrame* horizontalFrameParent, GNEViewNet* viewNet) :
101  GNEFrame(horizontalFrameParent, viewNet, "Vehicles"),
102  myRouteHandler("", viewNet->getNet()),
103  myVehicleBaseObject(new CommonXMLStructure::SumoBaseObject(nullptr)) {
104 
105  // Create item Selector modul for vehicles
106  myVehicleTagSelector = new GNEFrameModules::TagSelector(this, GNETagProperties::TagType::VEHICLE, SUMO_TAG_TRIP);
107 
108  // Create vehicle type selector and set DEFAULT_VTYPE_ID as default element
110 
111  // Create vehicle parameters
113 
114  // create PathCreator Module
116 
117  // Create Help Creation Module
118  myHelpCreation = new HelpCreation(this);
119 }
120 
121 
123  delete myVehicleBaseObject;
124 }
125 
126 
127 void
129  // refresh tag selector
131  // show frame
132  GNEFrame::show();
133 }
134 
135 
136 void
138  // reset edge candidates
139  for (const auto& edge : myViewNet->getNet()->getAttributeCarriers()->getEdges()) {
140  edge.second->resetCandidateFlags();
141  }
142  // reset junctioncandidates
143  for (const auto& junction : myViewNet->getNet()->getAttributeCarriers()->getJunctions()) {
144  junction.second->resetCandidateFlags();
145  }
146  // hide frame
147  GNEFrame::hide();
148 }
149 
150 
151 bool
153  // check template AC
154  if (myVehicleTagSelector->getCurrentTemplateAC() == nullptr) {
155  return false;
156  }
157  // begin cleaning vehicle base object
159  // obtain tag (only for improve code legibility)
161  const bool addEdge = ((vehicleTag == SUMO_TAG_TRIP) || (vehicleTag == GNE_TAG_VEHICLE_WITHROUTE) || (vehicleTag == SUMO_TAG_FLOW) || (vehicleTag == GNE_TAG_FLOW_WITHROUTE));
162  const bool addJunction = ((vehicleTag == GNE_TAG_TRIP_JUNCTIONS) || (vehicleTag == GNE_TAG_FLOW_JUNCTIONS));
163  // first check that current selected vehicle is valid
164  if (vehicleTag == SUMO_TAG_NOTHING) {
165  myViewNet->setStatusBarText("Current selected vehicle isn't valid.");
166  return false;
167  }
168  // now check if VType is valid
169  if (myTypeSelector->getCurrentDemandElement() == nullptr) {
170  myViewNet->setStatusBarText("Current selected vehicle type isn't valid.");
171  return false;
172  }
173  // now check if parameters are valid
176  return false;
177  }
178  // get vehicle attributes
180  // Check if ID has to be generated
183  }
184  // add VType
186  // set route or edges depending of vehicle type
187  if ((vehicleTag == SUMO_TAG_VEHICLE) || (vehicleTag == GNE_TAG_FLOW_ROUTE)) {
188  // get route
189  const auto route = objectsUnderCursor.getDemandElementFront();
190  if (route && (route->getTagProperty().isRoute())) {
191  // check if departLane is valid
192  if ((route->getTagProperty().getTag() == SUMO_TAG_ROUTE) && myVehicleBaseObject->hasStringAttribute(SUMO_ATTR_DEPARTLANE) &&
193  GNEAttributeCarrier::canParse<double>(myVehicleBaseObject->getStringAttribute(SUMO_ATTR_DEPARTLANE))) {
194  double departLane = GNEAttributeCarrier::parse<double>(myVehicleBaseObject->getStringAttribute(SUMO_ATTR_DEPARTLANE));
195  if (departLane >= route->getParentEdges().front()->getLanes().size()) {
197  return false;
198  }
199  }
200  // check if departSpeed is valid
202  double departSpeed = GNEAttributeCarrier::parse<double>(myVehicleBaseObject->getStringAttribute(SUMO_ATTR_DEPARTSPEED));
205  return false;
206  }
207  }
208  // check if we're creating a vehicle or a flow
209  if (vehicleTag == SUMO_TAG_VEHICLE) {
210  // set tag
212  // Add parameter departure
215  }
216  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
218  // obtain vehicle parameters in vehicleParameters
219  SUMOVehicleParameter* vehicleParameters = SUMOVehicleParserHelper::parseVehicleAttributes(vehicleTag, SUMOSAXAttrs, false);
220  // check if vehicle was sucesfully created)
221  if (vehicleParameters) {
222  vehicleParameters->routeid = route->getID();
223  myVehicleBaseObject->setVehicleParameter(vehicleParameters);
224  // parse vehicle
226  // delete vehicleParameters and sumoBaseObject
227  delete vehicleParameters;
228  }
229  } else {
230  // set tag
232  // set begin and end attributes
235  }
238  }
239  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
241  // obtain routeFlow parameters in routeFlowParameters
242  SUMOVehicleParameter* routeFlowParameters = SUMOVehicleParserHelper::parseFlowAttributes(vehicleTag, SUMOSAXAttrs, false, true, 0, SUMOTime_MAX);
243  // check if flow was sucesfully created)
244  if (routeFlowParameters) {
245  routeFlowParameters->routeid = route->getID();
246  myVehicleBaseObject->setVehicleParameter(routeFlowParameters);
247  // parse flow
249  // delete vehicleParameters and sumoBaseObject
250  delete routeFlowParameters;
251  }
252  }
253  // center view after creation
255  if (vehicle && !myViewNet->getVisibleBoundary().around(vehicle->getPositionInView())) {
256  myViewNet->centerTo(vehicle->getPositionInView(), false);
257  }
258  // refresh myVehicleAttributes
260  // all ok, then return true;
261  return true;
262  } else {
263  myViewNet->setStatusBarText(toString(vehicleTag) + " has to be placed within a route.");
264  return false;
265  }
266  } else if (addEdge && objectsUnderCursor.getEdgeFront()) {
267  // add clicked edge in PathCreator
268  return myPathCreator->addEdge(objectsUnderCursor.getEdgeFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
269  } else if (addJunction && objectsUnderCursor.getJunctionFront()) {
270  // add clicked junction in PathCreator
271  return myPathCreator->addJunction(objectsUnderCursor.getJunctionFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
272  } else {
273  return false;
274  }
275 }
276 
277 
280  return myVehicleTagSelector;
281 }
282 
283 
286  return myPathCreator;
287 }
288 
289 // ===========================================================================
290 // protected
291 // ===========================================================================
292 
293 void
296  // show vehicle type selector modul
298  // show path creator modul
302  }
303  } else {
304  // hide all moduls if vehicle isn't valid
308  }
309 }
310 
311 
312 void
315  // get tag
317  // show vehicle attributes modul
319  // clear colors
322  // check if use junctions
323  if ((vehicleTag == GNE_TAG_TRIP_JUNCTIONS) || (vehicleTag == GNE_TAG_FLOW_JUNCTIONS)) {
325  } else {
326  // set current VTypeClass in TripCreator
328  // show path creator modul
329  if ((vehicleTag != SUMO_TAG_VEHICLE) && (vehicleTag != GNE_TAG_FLOW_ROUTE)) {
331  }
332  }
333  // show help creation
335  // show warning if we have selected a vType oriented to pedestrians or containers
337  WRITE_WARNING("Current selected vType is oriented to pedestrians");
339  WRITE_WARNING("Current selected vType is oriented to containers");
340  }
341  } else {
342  // hide all moduls if selected item isn't valid
346  // hide help creation
348 
349  }
350 }
351 
352 
353 void
355  // begin cleaning vehicle base object
357  // obtain tag (only for improve code legibility)
359  // check number of edges
360  if ((myPathCreator->getSelectedEdges().size() > 0) || (myPathCreator->getSelectedJunctions().size() > 0)) {
361  // Updated myVehicleBaseObject
363  // Check if ID has to be generated
366  }
367  // add VType
369  // extract via attribute
370  std::vector<std::string> viaEdges;
371  for (int i = 1; i < ((int)myPathCreator->getSelectedEdges().size() - 1); i++) {
372  viaEdges.push_back(myPathCreator->getSelectedEdges().at(i)->getID());
373  }
374  // continue depending of tag
375  if (vehicleTag == SUMO_TAG_TRIP) {
376  // set tag
378  // Add parameter departure
381  }
382  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
384  // obtain trip parameters
385  SUMOVehicleParameter* tripParameters = SUMOVehicleParserHelper::parseVehicleAttributes(vehicleTag, SUMOSAXAttrs, false);
386  // check trip parameters
387  if (tripParameters) {
388  myVehicleBaseObject->setVehicleParameter(tripParameters);
392  // parse vehicle
394  // delete tripParameters and base object
395  delete tripParameters;
396  }
397  } else if (vehicleTag == GNE_TAG_VEHICLE_WITHROUTE) {
398  // set tag
400  // Add parameter departure
403  }
404  // get route edges
405  std::vector<std::string> routeEdges;
406  for (const auto& subPath : myPathCreator->getPath()) {
407  for (const auto& edge : subPath.getSubPath()) {
408  routeEdges.push_back(edge->getID());
409  }
410  }
411  // avoid consecutive duplicated edges
412  routeEdges.erase(std::unique(routeEdges.begin(), routeEdges.end()), routeEdges.end());
413  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
415  // obtain vehicle parameters
416  SUMOVehicleParameter* vehicleParameters = SUMOVehicleParserHelper::parseVehicleAttributes(vehicleTag, SUMOSAXAttrs, false);
417  // continue depending of vehicleParameters
418  if (vehicleParameters) {
419  myVehicleBaseObject->setVehicleParameter(vehicleParameters);
420  // create route base object
422  embeddedRouteObject->setTag(SUMO_TAG_ROUTE);
423  embeddedRouteObject->addStringAttribute(SUMO_ATTR_ID, "");
424  embeddedRouteObject->addStringListAttribute(SUMO_ATTR_EDGES, routeEdges);
426  embeddedRouteObject->addIntAttribute(SUMO_ATTR_REPEAT, 0),
427  embeddedRouteObject->addTimeAttribute(SUMO_ATTR_CYCLETIME, 0),
428  // parse route
429  myRouteHandler.parseSumoBaseObject(embeddedRouteObject);
430  // delete vehicleParamters
431  delete vehicleParameters;
432  }
433  } else if (vehicleTag == SUMO_TAG_FLOW) {
434  // set tag
436  // set begin and end attributes
439  }
442  }
443  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
445  // obtain flow parameters
446  SUMOVehicleParameter* flowParameters = SUMOVehicleParserHelper::parseFlowAttributes(vehicleTag, SUMOSAXAttrs, false, true, 0, SUMOTime_MAX);
447  // check flowParameters
448  if (flowParameters) {
449  myVehicleBaseObject->setVehicleParameter(flowParameters);
453  // parse vehicle
455  // delete flowParameters and base object
456  delete flowParameters;
457  }
458  } else if (vehicleTag == GNE_TAG_FLOW_WITHROUTE) {
459  // set tag
461  // set begin and end attributes
464  }
467  }
468  // get route edges
469  std::vector<std::string> routeEdges;
470  for (const auto& subPath : myPathCreator->getPath()) {
471  for (const auto& edge : subPath.getSubPath()) {
472  routeEdges.push_back(edge->getID());
473  }
474  }
475  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
477  // obtain flow parameters
478  SUMOVehicleParameter* flowParameters = SUMOVehicleParserHelper::parseFlowAttributes(vehicleTag, SUMOSAXAttrs, false, true, 0, SUMOTime_MAX);
479  // continue depending of vehicleParameters
480  if (flowParameters) {
481  myVehicleBaseObject->setVehicleParameter(flowParameters);
482  // create under base object
484  embeddedRouteObject->setTag(SUMO_TAG_ROUTE);
485  embeddedRouteObject->addStringAttribute(SUMO_ATTR_ID, "");
486  embeddedRouteObject->addStringListAttribute(SUMO_ATTR_EDGES, routeEdges);
488  embeddedRouteObject->addIntAttribute(SUMO_ATTR_REPEAT, 0),
489  embeddedRouteObject->addTimeAttribute(SUMO_ATTR_CYCLETIME, 0),
490  // parse route
491  myRouteHandler.parseSumoBaseObject(embeddedRouteObject);
492  // delete vehicleParamters
493  delete flowParameters;
494  }
495  } else if (vehicleTag == GNE_TAG_TRIP_JUNCTIONS) {
496  // set tag
498  // Add parameter departure
501  }
502  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
504  // obtain trip parameters
505  SUMOVehicleParameter* tripParameters = SUMOVehicleParserHelper::parseVehicleAttributes(vehicleTag, SUMOSAXAttrs, false);
506  // check trip parameters
507  if (tripParameters) {
508  myVehicleBaseObject->setVehicleParameter(tripParameters);
511  // parse vehicle
513  // delete tripParameters and base object
514  delete tripParameters;
515  }
516  } else if (vehicleTag == GNE_TAG_FLOW_JUNCTIONS) {
517  // set tag
519  // set begin and end attributes
522  }
525  }
526  // declare SUMOSAXAttributesImpl_Cached to convert valuesMap into SUMOSAXAttributes
528  // obtain flow parameters
529  SUMOVehicleParameter* flowParameters = SUMOVehicleParserHelper::parseFlowAttributes(vehicleTag, SUMOSAXAttrs, false, true, 0, SUMOTime_MAX);
530  // check flowParameters
531  if (flowParameters) {
532  myVehicleBaseObject->setVehicleParameter(flowParameters);
535  // parse vehicle
537  // delete flowParameters and base object
538  delete flowParameters;
539  }
540  }
541  // abort path creation
543  // refresh myVehicleAttributes
545  }
546 }
547 
548 
549 /****************************************************************************/
#define GUIDesignLabelFrameInformation
label extended over frame without thick and with text justify to left, used to show information in fr...
Definition: GUIDesigns.h:244
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
#define SUMOTime_MAX
Definition: SUMOTime.h:33
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PEDESTRIAN
pedestrian
const std::string DEFAULT_VTYPE_ID
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ GNE_TAG_TRIP_JUNCTIONS
a trip between junctions (used in NETEDIT)
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_NOTHING
invalid tag
@ SUMO_TAG_VEHICLE
description of a vehicle
@ GNE_TAG_FLOW_ROUTE
a flow definition using a route instead of a from-to edges route (used in NETEDIT)
@ GNE_TAG_FLOW_JUNCTIONS
a flow between junctions (used in NETEDIT)
@ GNE_TAG_FLOW_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ GNE_TAG_VEHICLE_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ SUMO_ATTR_DEPART
@ SUMO_ATTR_VIA
@ SUMO_ATTR_FROMJUNCTION
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_REPEAT
@ SUMO_ATTR_CYCLETIME
@ SUMO_ATTR_TOJUNCTION
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
bool around(const Position &p, double offset=0) const
Returns whether the AbstractPoly the given coordinate.
Definition: Boundary.cpp:171
void addIntAttribute(const SumoXMLAttr attr, const int value)
add int attribute into current SumoBaseObject node
bool hasStringAttribute(const SumoXMLAttr attr) const
has function
std::map< std::string, std::string > getAllAttributes() const
get all attributes in string format
void setTag(const SumoXMLTag tag)
set SumoBaseObject tag
void addTimeAttribute(const SumoXMLAttr attr, const SUMOTime value)
add time attribute into current SumoBaseObject node
void addStringListAttribute(const SumoXMLAttr attr, const std::vector< std::string > &value)
add string list attribute into current SumoBaseObject node
void setVehicleParameter(const SUMOVehicleParameter *vehicleParameter)
set vehicle parameters
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
void clear()
clear SumoBaseObject
void addColorAttribute(const SumoXMLAttr attr, const RGBColor &value)
add color attribute into current SumoBaseObject node
const std::string & getStringAttribute(const SumoXMLAttr attr) const
get string attribute
FXGroupBoxModule (based on FXGroupBox)
FXVerticalFrame * getCollapsableFrame()
get collapsable frame (used by all elements that will be collapsed if button is toogled)
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
virtual SUMOVehicleClass getVClass() const =0
virtual double getAttributeDouble(SumoXMLAttr key) const =0
const std::string & getID() const
get ID
void showWarningMessage(std::string extra="") const
show warning message with information about non-valid attributes
bool areValuesValid() const
check if parameters of attributes are valid
void refreshAttributesCreator()
refresh attribute creator
void showAttributesCreatorModule(GNEAttributeCarrier *templateAC, const std::vector< SumoXMLAttr > &hiddenAttributes)
show AttributesCreator modul
void getAttributesAndValues(CommonXMLStructure::SumoBaseObject *baseObject, bool includeAll) const
get attributes and their values
GNEViewNet * myViewNet
View Net.
Definition: GNEFrame.h:114
virtual void show()
show Frame
Definition: GNEFrame.cpp:108
virtual void hide()
hide Frame
Definition: GNEFrame.cpp:117
const std::vector< std::string > & getPredefinedTagsMML() const
get predefinedTagsMML
Definition: GNEFrame.cpp:269
void showDemandElementSelector()
show demand element selector
GNEDemandElement * getCurrentDemandElement() const
get current demand element
void hideDemandElementSelector()
hide demand element selector
void setVClass(SUMOVehicleClass vClass)
set vClass
const std::vector< Path > & getPath() const
get path route
bool addEdge(GNEEdge *edge, const bool shiftKeyPressed, const bool controlKeyPressed)
add edge
void abortPathCreation()
abort path creation
void hidePathCreatorModule()
show PathCreator
void clearEdgeColors()
clear edge colors
void updateJunctionColors()
update junction colors
const std::vector< GNEEdge * > & getSelectedEdges() const
get current selected edges
void clearJunctionColors()
clear junction colors
bool addJunction(GNEJunction *junction, const bool shiftKeyPressed, const bool controlKeyPressed)
add junction
const std::vector< GNEJunction * > & getSelectedJunctions() const
get current selected junctions
void showPathCreatorModule(SumoXMLTag element, const bool firstElement, const bool consecutives)
show PathCreator for the given tag
void refreshTagSelector()
refresh tagSelector (used when frameParent is show)
GNEAttributeCarrier * getCurrentTemplateAC() const
get current templateAC
std::string generateDemandElementID(SumoXMLTag tag) const
generate demand element id
const std::map< std::string, GNEEdge * > & getEdges() const
map with the ID and pointer to edges of net
const std::map< std::string, GNEJunction * > & getJunctions() const
get junctions
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:125
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
void showHelpCreation()
show HelpCreation
void hideHelpCreation()
hide HelpCreation
void updateHelpCreation()
update HelpCreation
HelpCreation(GNEVehicleFrame *vehicleFrameParent)
constructor
FXLabel * myInformationLabel
Label with creation information.
void hide()
hide Frame
GNEFrameModules::DemandElementSelector * myTypeSelector
Vehicle Type selectors.
GNERouteHandler myRouteHandler
route handler
GNEFrameModules::TagSelector * myVehicleTagSelector
vehicle tag selector (used to select diffent kind of vehicles)
CommonXMLStructure::SumoBaseObject * myVehicleBaseObject
vehicle base object
GNEFrameModules::PathCreator * getPathCreator() const
get PathCreator modul
~GNEVehicleFrame()
Destructor.
void show()
show Frame
void createPath()
create path
GNEFrameAttributeModules::AttributesCreator * myVehicleAttributes
internal vehicle attributes
bool addVehicle(const GNEViewNetHelper::ObjectsUnderCursor &objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed &mouseButtonKeyPressed)
add vehicle element
GNEFrameModules::TagSelector * getVehicleTagSelector() const
get vehicle tag selector (needed for transform vehicles)
void tagSelected()
Tag selected in TagSelector.
GNEVehicleFrame(FXHorizontalFrame *horizontalFrameParent, GNEViewNet *viewNet)
Constructor.
HelpCreation * myHelpCreation
Help creation.
GNEFrameModules::PathCreator * myPathCreator
edge path creator (used for trips and flows)
void demandElementSelected()
selected vehicle type in DemandElementSelector
class used to group all variables related with objects under cursor after a click over view
GNEJunction * getJunctionFront() const
get front junction or a pointer to nullptr
GNEDemandElement * getDemandElementFront() const
get front demand element or a pointer to nullptr
GNEEdge * getEdgeFront() const
get front edge or a pointer to nullptr
GNENet * getNet() const
get the net object
void setStatusBarText(const std::string &text)
set staturBar text
Definition: GNEViewNet.cpp:629
Boundary getVisibleBoundary() const
get visible boundary
virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist=20)
centers to the chosen artifact
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
Encapsulated Xerces-SAX-attributes.
Structure representing possible vehicle parameter.
std::string routeid
The vehicle's route id.
static SUMOVehicleParameter * parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs, const bool hardFail, const bool needID, const SUMOTime beginDefault, const SUMOTime endDefault)
Parses a flow's attributes.
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false)
Parses a vehicle's attributes.
class used to group all variables related with mouse buttons and key pressed after certain events
bool shiftKeyPressed() const
check if SHIFT is pressed during current event
bool controlKeyPressed() const
check if CONTROL is pressed during current event