Eclipse SUMO - Simulation of Urban MObility
GNECreateEdgeFrame.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 create edges (and junctions)
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <netedit/GNENet.h>
23 #include <netedit/GNEUndoList.h>
24 #include <netedit/GNEViewNet.h>
25 #include <netedit/GNEViewParent.h>
34 
35 
36 #include "GNECreateEdgeFrame.h"
37 
38 // ===========================================================================
39 // FOX callback mapping
40 // ===========================================================================
41 
49 };
50 
55 };
56 
57 // Object implementation
58 FXIMPLEMENT(GNECreateEdgeFrame::EdgeTypeSelector, MFXGroupBoxModule, EdgeTypeSelectorMap, ARRAYNUMBER(EdgeTypeSelectorMap))
59 FXIMPLEMENT(GNECreateEdgeFrame::LaneTypeSelector, MFXGroupBoxModule, LaneTypeSelectorMap, ARRAYNUMBER(LaneTypeSelectorMap))
60 
61 
62 // ===========================================================================
63 // method definitions
64 // ===========================================================================
65 
66 // ---------------------------------------------------------------------------
67 // GNECreateEdgeFrame::EdgeTypeSelector - methods
68 // ---------------------------------------------------------------------------
69 
71  MFXGroupBoxModule(createEdgeFrameParent, TL("Template selector")),
72  myCreateEdgeFrameParent(createEdgeFrameParent),
73  myDefaultEdgeType(new GNEEdgeType(createEdgeFrameParent)),
74  myCurrentIndex(0) {
75  // default edge radio button
76  myUseDefaultEdgeType = new FXRadioButton(getCollapsableFrame(), TL("Create default edge"),
78  // checkboxes
79  myNoPedestriansCheckButton = new FXCheckButton(getCollapsableFrame(), TL("Disallow for pedestrians"),
81  myAddSidewalkCheckButton = new FXCheckButton(getCollapsableFrame(), TL("Add Sidewalk"),
83  // use custom edge radio button
84  myUseCustomEdgeType = new FXRadioButton(getCollapsableFrame(), TL("Use edgeType/template"),
86  // edge types combo box
87  myEdgeTypesComboBox = new FXComboBox(getCollapsableFrame(), GUIDesignComboBoxNCol,
89  // create horizontal frame
90  FXHorizontalFrame* horizontalFrameButtons = new FXHorizontalFrame(getCollapsableFrame(), GUIDesignAuxiliarHorizontalFrame);
91  // create new edge type button
92  myAddEdgeTypeButton = new FXButton(horizontalFrameButtons, TL("Add\t\tAdd edge type"), GUIIconSubSys::getIcon(GUIIcon::ADD),
94  // create delete edge type button
95  myDeleteEdgeTypeButton = new FXButton(horizontalFrameButtons, TL("Delete\t\tDelete edge type"), GUIIconSubSys::getIcon(GUIIcon::REMOVE),
97  // create delete edge type button
98  myCreateFromTemplate = new FXButton(getCollapsableFrame(), TL("Create from template\t\tCreate edgeType from template"), GUIIconSubSys::getIcon(GUIIcon::EDGE),
100  // by default, create custom edge
101  myUseDefaultEdgeType->setCheck(TRUE);
102  // check if enable disable pedestrians
103  for (const auto& junction : createEdgeFrameParent->getViewNet()->getNet()->getAttributeCarriers()->getJunctions()) {
104  if (junction.second->getNBNode()->getCrossings().size() > 0) {
105  enableCheckBoxDisablePedestrians();
106  }
107  }
108 }
109 
110 
112  delete myDefaultEdgeType;
113 }
114 
115 
116 void
118  // get template editor
119  const GNEInspectorFrame::TemplateEditor* templateEditor = myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor();
120  // get current item
121  const int index = myEdgeTypesComboBox->getCurrentItem();
122  // fill combo box
123  fillComboBox();
124  // set default edgeType
125  if (myUseDefaultEdgeType->getCheck()) {
126  // enable check boxes
127  myAddSidewalkCheckButton->enable();
128  myNoPedestriansCheckButton->enable();
129  // disable create from template
130  myCreateFromTemplate->disable();
131  // disable comboBox
132  myEdgeTypesComboBox->disable();
133  // disable buttons
134  myAddEdgeTypeButton->disable();
135  myDeleteEdgeTypeButton->disable();
136  // show default edgeType attributes
137  myCreateEdgeFrameParent->myEdgeTypeAttributes->showAttributesCreatorModule(myDefaultEdgeType, {SUMO_ATTR_ID});
138  // show lane attributes
139  myCreateEdgeFrameParent->myLaneTypeSelector->showLaneTypeSelector();
140  } else if (myUseCustomEdgeType->getCheck()) {
141  // disable check boxes
142  myAddSidewalkCheckButton->disable();
143  myNoPedestriansCheckButton->disable();
144  // enable buttons
145  myAddEdgeTypeButton->enable();
146  myDeleteEdgeTypeButton->enable();
147  // check conditions
148  if (myEdgeTypesComboBox->getNumItems() == 0) {
149  // disable comboBox and edgeType
150  myEdgeTypesComboBox->disable();
151  myDeleteEdgeTypeButton->disable();
152  // hide attributes creators
153  myCreateEdgeFrameParent->myEdgeTypeAttributes->hideAttributesCreatorModule();
154  myCreateEdgeFrameParent->myLaneTypeSelector->hideLaneTypeSelector();
155  } else if (templateEditor->getEdgeTemplate() && (index == 0)) {
156  // enable create from template
157  myCreateFromTemplate->enable();
158  // enable comboBox
159  myEdgeTypesComboBox->enable();
160  // disable delete edge type button (because templates cannot be deleted)
161  myDeleteEdgeTypeButton->disable();
162  // show edgeType attributes and disable
163  myCreateEdgeFrameParent->myEdgeTypeAttributes->showAttributesCreatorModule(templateEditor->getEdgeTemplate(), {SUMO_ATTR_ID});
164  myCreateEdgeFrameParent->myEdgeTypeAttributes->disableAttributesCreator();
165  // show lane attributes (will be automatic disabled)
166  myCreateEdgeFrameParent->myLaneTypeSelector->showLaneTypeSelector();
167  } else {
168  // disable create from template
169  myCreateFromTemplate->disable();
170  // enable comboBox
171  myEdgeTypesComboBox->enable();
172  // get edgeType
173  myEdgeTypeSelected = myCreateEdgeFrameParent->getViewNet()->getNet()->getAttributeCarriers()->retrieveEdgeType(myEdgeTypesComboBox->getText().text(), false);
174  // check if exist
175  if (myEdgeTypeSelected) {
176  // show edgeType attributes
177  myCreateEdgeFrameParent->myEdgeTypeAttributes->showAttributesCreatorModule(myEdgeTypeSelected, {});
178  // show lane attributes
179  myCreateEdgeFrameParent->myLaneTypeSelector->showLaneTypeSelector();
180  } else {
181  // hide edgeType attributes
182  myCreateEdgeFrameParent->myEdgeTypeAttributes->hideAttributesCreatorModule();
183  // hide lane attributes
184  myCreateEdgeFrameParent->myLaneTypeSelector->hideLaneTypeSelector();
185  // set comboBox text
186  myEdgeTypesComboBox->setTextColor(FXRGB(255, 0, 0));
187  }
188  }
189  }
190  // recalc
191  recalc();
192 }
193 
194 
195 void
196 GNECreateEdgeFrame::EdgeTypeSelector::updateIDinComboBox(const std::string& oldID, const std::string& newID) {
197  for (int i = 0; i < myEdgeTypesComboBox->getNumItems(); i++) {
198  if (myEdgeTypesComboBox->getItem(i).text() == oldID) {
199  myEdgeTypesComboBox->setItemText(i, newID.c_str());
200  }
201  }
202 }
203 
204 
205 bool
207  if (myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate()) {
208  if ((myUseCustomEdgeType->getCheck() == TRUE) && (myEdgeTypesComboBox->getCurrentItem() == 0)) {
209  return true;
210  } else {
211  return false;
212  }
213  } else {
214  return false;
215  }
216 }
217 
218 
219 bool
221  return (myUseDefaultEdgeType->getCheck() == TRUE);
222 }
223 
224 
225 void
227  myNoPedestriansCheckButton->setCheck(TRUE);
228 }
229 
230 
233  return myDefaultEdgeType;
234 }
235 
236 
239  if (myUseDefaultEdgeType->getCheck() == TRUE) {
240  return myDefaultEdgeType;
241  } else {
242  return myEdgeTypeSelected;
243  }
244 }
245 
246 
247 bool
249  return (myNoPedestriansCheckButton->getCheck() == TRUE);
250 }
251 
252 
253 bool
255  return (myAddSidewalkCheckButton->getCheck() == TRUE);
256 }
257 
258 
259 void
261  myEdgeTypeSelected = nullptr;
262  myCurrentIndex--;
263  if (myCurrentIndex < 0) {
264  myCurrentIndex = 0;
265  }
266 }
267 
268 
269 void
271  for (int i = 0; i < myEdgeTypesComboBox->getNumItems(); i++) {
272  if (myEdgeTypesComboBox->getItem(i).text() == edgeType->getID()) {
273  // set current item and index
274  myEdgeTypesComboBox->setCurrentItem(i);
275  myCurrentIndex = i;
276  // set buttons
277  myUseDefaultEdgeType->setCheck(FALSE);
278  myUseCustomEdgeType->setCheck(TRUE);
279  // refresh
280  refreshEdgeTypeSelector();
281  }
282  }
283 }
284 
285 
286 void
288  myUseDefaultEdgeType->setCheck(FALSE);
289  myUseCustomEdgeType->setCheck(TRUE);
290  refreshEdgeTypeSelector();
291 }
292 
293 
294 long
296  // check what object was pressed
297  if (obj == myUseDefaultEdgeType) {
298  // update radio buttons
299  myUseDefaultEdgeType->setCheck(TRUE);
300  myUseCustomEdgeType->setCheck(FALSE);
301  } else {
302  // update radio buttons
303  myUseDefaultEdgeType->setCheck(FALSE);
304  myUseCustomEdgeType->setCheck(TRUE);
305  }
306  // refresh template selector
307  refreshEdgeTypeSelector();
308  return 0;
309 }
310 
311 
312 long
314  // create new edge type
315  GNEEdgeType* edgeType = new GNEEdgeType(myCreateEdgeFrameParent->getViewNet()->getNet());
316  // add it using undoList
317  myCreateEdgeFrameParent->getViewNet()->getUndoList()->begin(GUIIcon::EDGE, "create new edge type");
318  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(edgeType, true), true);
319  myCreateEdgeFrameParent->getViewNet()->getUndoList()->end();
320  // update myEdgeTypeSelected
321  myEdgeTypeSelected = edgeType;
322  // select last item
323  myCurrentIndex = (myEdgeTypesComboBox->getNumItems() - 1);
324  // refresh EdgeTypeSelector
325  refreshEdgeTypeSelector();
326  return 0;
327 }
328 
329 
330 long
332  // first check if we have to reset myEdgeTypeSelected
333  if (myEdgeTypeSelected && (myEdgeTypeSelected->getID() == myEdgeTypesComboBox->getText().text())) {
334  myEdgeTypeSelected = nullptr;
335  }
336  // get edgeType to remove
337  GNEEdgeType* edgeType = myCreateEdgeFrameParent->getViewNet()->getNet()->getAttributeCarriers()->retrieveEdgeType(myEdgeTypesComboBox->getText().text());
338  // remove it using undoList
339  myCreateEdgeFrameParent->getViewNet()->getUndoList()->begin(GUIIcon::EDGE, "delete edge type");
340  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(edgeType, false), true);
341  myCreateEdgeFrameParent->getViewNet()->getUndoList()->end();
342  // refresh EdgeTypeSelector
343  refreshEdgeTypeSelector();
344  return 0;
345 }
346 
347 
348 long
350  // update current index
351  myCurrentIndex = myEdgeTypesComboBox->getCurrentItem();
352  // refresh edgeType selector
353  refreshEdgeTypeSelector();
354  return 0;
355 }
356 
357 
358 long
360  if (myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate()) {
361  // create new edge type
362  GNEEdgeType* edgeType = new GNEEdgeType(myCreateEdgeFrameParent->getViewNet()->getNet());
363  // copy all template values
364  edgeType->copyTemplate(myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate());
365  // add it using undoList
366  myCreateEdgeFrameParent->getViewNet()->getUndoList()->begin(GUIIcon::EDGE, "create new edge type");
367  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(edgeType, true), true);
368  myCreateEdgeFrameParent->getViewNet()->getUndoList()->end();
369  // update myEdgeTypeSelected
370  myEdgeTypeSelected = edgeType;
371  // select last item
372  myCurrentIndex = (myEdgeTypesComboBox->getNumItems() - 1);
373  // refresh EdgeTypeSelector
374  refreshEdgeTypeSelector();
375  }
376  return 0;
377 }
378 
379 
380 long
382  if (myAddSidewalkCheckButton->getCheck() == TRUE) {
383  myNoPedestriansCheckButton->setCheck(TRUE);
384  myNoPedestriansCheckButton->disable();
385  } else {
386  myNoPedestriansCheckButton->enable();
387  }
388  return 1;
389 }
390 
391 
392 void
394  // get template editor
395  const GNEInspectorFrame::TemplateEditor* templateEditor = myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor();
396  // get edge types
397  const auto& edgeTypes = myCreateEdgeFrameParent->getViewNet()->getNet()->getAttributeCarriers()->getEdgeTypes();
398  // clear edge types
399  myEdgeTypesComboBox->clearItems();
400  // set comboBox text color
401  myEdgeTypesComboBox->setTextColor(FXRGB(0, 0, 0));
402  // add template
403  if (templateEditor->getEdgeTemplate()) {
404  myEdgeTypesComboBox->appendItem(("template: " + templateEditor->getEdgeTemplate()->getID()).c_str(), nullptr);
405  }
406  // add edge types
407  for (const auto& edgeType : edgeTypes) {
408  myEdgeTypesComboBox->appendItem(edgeType.second->getID().c_str(), nullptr);
409  }
410  // set num visible antes
411  if (myEdgeTypesComboBox->getNumItems() <= 10) {
412  myEdgeTypesComboBox->setNumVisible(myEdgeTypesComboBox->getNumItems());
413  } else {
414  myEdgeTypesComboBox->setNumVisible(10);
415  }
416  // set current item
417  if ((myCurrentIndex < 0) || (myCurrentIndex >= myEdgeTypesComboBox->getNumItems())) {
418  myCurrentIndex = myEdgeTypesComboBox->getNumItems() - 1;
419  }
420  myEdgeTypesComboBox->setCurrentItem(myCurrentIndex);
421 }
422 
423 // ---------------------------------------------------------------------------
424 // GNECreateEdgeFrame::LaneTypeSelector - methods
425 // ---------------------------------------------------------------------------
426 
428  MFXGroupBoxModule(createEdgeFrameParent, TL("LaneType selector")),
429  myCreateEdgeFrameParent(createEdgeFrameParent),
430  myLaneIndex(0) {
431  // lane types combo box
433  // create horizontal frame
434  FXHorizontalFrame* horizontalFrameButtons = new FXHorizontalFrame(getCollapsableFrame(), GUIDesignAuxiliarHorizontalFrame);
435  // create new lane type button
436  myAddLaneTypeButton = new FXButton(horizontalFrameButtons, TL("Add\t\tAdd lane type"), GUIIconSubSys::getIcon(GUIIcon::ADD),
438  // create delete lane type button
439  myDeleteLaneTypeButton = new FXButton(horizontalFrameButtons, TL("Delete\t\tDelete lane type"), GUIIconSubSys::getIcon(GUIIcon::REMOVE),
441 }
442 
443 
445 }
446 
447 
448 void
450  // start at first lane
451  myLaneIndex = 0;
452  // refresh laneTypeSelector
453  refreshLaneTypeSelector();
454  // show
455  show();
456 }
457 
458 
459 void
461  // hide attributes creator modul
462  myCreateEdgeFrameParent->myLaneTypeAttributes->hideAttributesCreatorModule();
463  // hide
464  hide();
465 }
466 
467 
468 void
470  // clear lane types
471  myLaneTypesComboBox->clearItems();
472  // first check if use template
473  if (myCreateEdgeFrameParent->myEdgeTypeSelector->useEdgeTemplate()) {
474  const GNEEdgeTemplate* edgeTemplate = myCreateEdgeFrameParent->getViewNet()->getViewParent()->getInspectorFrame()->getTemplateEditor()->getEdgeTemplate();
475  // fill comboBox
476  for (const auto& laneTemplate : edgeTemplate->getLaneTemplates()) {
477  myLaneTypesComboBox->appendItem(laneTemplate->getAttribute(SUMO_ATTR_ID).c_str(), nullptr);
478  }
479  // update comboBox
480  updateComboBox();
481  // show laneTypeAttributes
482  myCreateEdgeFrameParent->myLaneTypeAttributes->showAttributesCreatorModule(edgeTemplate->getLaneTemplates().at(myLaneIndex), {SUMO_ATTR_ID});
483  // disable laneAttributes (because is a template)
484  myCreateEdgeFrameParent->myLaneTypeAttributes->disableAttributesCreator();
485  // disable add and remove buttons
486  myAddLaneTypeButton->disable();
487  myDeleteLaneTypeButton->disable();
488  } else {
489  // get edgeType
490  const GNEEdgeType* edgeType = myCreateEdgeFrameParent->myEdgeTypeSelector->getEdgeTypeSelected();
491  // fill comboBox
492  for (const auto& laneType : edgeType->getLaneTypes()) {
493  myLaneTypesComboBox->appendItem(laneType->getAttribute(SUMO_ATTR_ID).c_str(), nullptr);
494  }
495  // update comboBox
496  updateComboBox();
497  // show laneTypeAttributes
498  myCreateEdgeFrameParent->myLaneTypeAttributes->showAttributesCreatorModule(edgeType->getLaneTypes().at(myLaneIndex), {});
499  // enable add and remove buttons
500  myAddLaneTypeButton->enable();
501  // check if enable or disable remove lane button
502  if (edgeType->getLaneTypes().size() > 1) {
503  myDeleteLaneTypeButton->enable();
504  } else {
505  myDeleteLaneTypeButton->disable();
506  }
507  }
508  // recalc
509  recalc();
510 }
511 
512 
513 long
515  // check what edgeType is being edited
516  if (myCreateEdgeFrameParent->myEdgeTypeSelector->useDefaultEdgeType()) {
517  // add new lane in default edge type
518  myCreateEdgeFrameParent->myEdgeTypeSelector->getDefaultEdgeType()->addLaneType(new GNELaneType(myCreateEdgeFrameParent->myEdgeTypeSelector->getDefaultEdgeType()));
519  // refresh laneTypeSelector
520  refreshLaneTypeSelector();
521  // set combo box
522  myLaneTypesComboBox->setCurrentItem(myLaneTypesComboBox->getNumItems() - 1);
523  } else if (!myCreateEdgeFrameParent->myEdgeTypeSelector->useEdgeTemplate()) {
524  // get selected
525  const auto edgeType = myCreateEdgeFrameParent->myEdgeTypeSelector->getEdgeTypeSelected();
526  if (edgeType) {
527  // create new edgeType
528  GNEEdgeType* newEdgeType = new GNEEdgeType(edgeType);
529  // create laneTypes
530  for (const auto& laneType : edgeType->getLaneTypes()) {
531  newEdgeType->addLaneType(new GNELaneType(newEdgeType, laneType));
532  }
533  // add new lane
534  newEdgeType->addLaneType(new GNELaneType(newEdgeType));
535  // remove old edgeTyp und and newEdgeType
536  myCreateEdgeFrameParent->getViewNet()->getUndoList()->begin(GUIIcon::LANE, "add laneType");
537  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(edgeType, false), true);
538  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(newEdgeType, true), true);
539  myCreateEdgeFrameParent->getViewNet()->getUndoList()->end();
540  // update index
541  myLaneIndex = myLaneTypesComboBox->getNumItems() - 1;
542  // set current edgeType in selector
543  myCreateEdgeFrameParent->myEdgeTypeSelector->setCurrentEdgeType(newEdgeType);
544  }
545  }
546  return 0;
547 }
548 
549 
550 long
552  // check what edgeType is being edited
553  if (myCreateEdgeFrameParent->myEdgeTypeSelector->useDefaultEdgeType()) {
554  // add new lane in default edge type
555  myCreateEdgeFrameParent->myEdgeTypeSelector->getDefaultEdgeType()->removeLaneType(myLaneIndex);
556  // refresh laneTypeSelector
557  refreshLaneTypeSelector();
558  // set combo box
559  myLaneTypesComboBox->setCurrentItem(0);
560  } else if (!myCreateEdgeFrameParent->myEdgeTypeSelector->useEdgeTemplate()) {
561  // get selected
562  const auto edgeType = myCreateEdgeFrameParent->myEdgeTypeSelector->getEdgeTypeSelected();
563  if (edgeType) {
564  // create new edgeType
565  GNEEdgeType* newEdgeType = new GNEEdgeType(edgeType);
566  // create laneTypes (except current)
567  for (int i = 0; i < (int)edgeType->getLaneTypes().size(); i++) {
568  if (i != myLaneIndex) {
569  newEdgeType->addLaneType(new GNELaneType(newEdgeType, edgeType->getLaneTypes().at(i)));
570  }
571  }
572  // remove old edgeTyp und and newEdgeType
573  myCreateEdgeFrameParent->getViewNet()->getUndoList()->begin(GUIIcon::LANE, "remove laneType");
574  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(edgeType, false), true);
575  myCreateEdgeFrameParent->getViewNet()->getUndoList()->add(new GNEChange_EdgeType(newEdgeType, true), true);
576  myCreateEdgeFrameParent->getViewNet()->getUndoList()->end();
577  // update index
578  myLaneIndex = myLaneTypesComboBox->getNumItems() - 1;
579  // set current edgeType in selector
580  myCreateEdgeFrameParent->myEdgeTypeSelector->setCurrentEdgeType(newEdgeType);
581  }
582  }
583  return 0;
584 }
585 
586 
587 long
589  // update index
590  myLaneIndex = myLaneTypesComboBox->getCurrentItem();
591  // refresh laneType selector
592  refreshLaneTypeSelector();
593  return 0;
594 }
595 
596 
597 void
599  // check lane index
600  if (myLaneIndex > myLaneTypesComboBox->getNumItems()) {
601  myLaneIndex = 0;
602  }
603  // set current item
604  myLaneTypesComboBox->setCurrentItem(myLaneIndex);
605  // set num visible items
606  if (myLaneTypesComboBox->getNumItems() <= 10) {
607  myLaneTypesComboBox->setNumVisible(myLaneTypesComboBox->getNumItems());
608  } else {
609  myLaneTypesComboBox->setNumVisible(10);
610  }
611 }
612 
613 // ---------------------------------------------------------------------------
614 // GNECreateEdgeFrame::Legend - methods
615 // ---------------------------------------------------------------------------
616 
618  MFXGroupBoxModule(createEdgeFrameParent, TL("Information")) {
619  std::ostringstream information;
620  // add label for shift+click
621  information
622  << TL("- ESC:") << "\n"
623  << TL(" Deselect origin") << "\n"
624  << TL("- Control+Click:") << "\n"
625  << TL(" Move view") << "\n"
626  << TL("- Shift+Click:") << "\n"
627  << TL(" Splits edge in both directions") << "\n"
628  << TL("- Alt+Shift+Click:") << "\n"
629  << TL(" Splits edge in one direction");
630  // create label
631  new FXLabel(getCollapsableFrame(), information.str().c_str(), 0, GUIDesignLabelFrameInformation);
632 }
633 
634 
636 
637 // ---------------------------------------------------------------------------
638 // GNECreateEdgeFrame - methods
639 // ---------------------------------------------------------------------------
640 
642  GNEFrame(viewParent, viewNet, "Create Edge"),
644  myCreateEdgeSource(nullptr) {
645  // create custom edge selector
647  // Create edgeType parameters
649  // lane type selector
651  // Create laneType parameters
653  // create edge selector legend
654  myLegend = new Legend(this);
655 }
656 
657 
659 
660 
661 void
662 GNECreateEdgeFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor,
663  const bool oppositeEdge, const bool chainEdge) {
664  // first check if there is an edge template, an edge type (default or custom)
666  WRITE_WARNING(TL("Select either default edgeType or a custom edgeType or template"));
667  } else if (!myEdgeTypeAttributes->areValuesValid()) {
668  WRITE_WARNING(TL("Invalid edge attributes"));
669  } else if (!myLaneTypeAttributes->areValuesValid()) {
670  WRITE_WARNING(TL("Invalid lane attributes"));
671  } else {
672  // obtain junction depending of gridEnabled
673  GNEJunction* junction = nullptr;
674  if (objectsUnderCursor.getJunctionFront()) {
675  junction = objectsUnderCursor.getJunctionFront();
678  }
679  // begin undo list
682  }
683  // if we didn't clicked over another junction, then create a new
684  if (junction == nullptr) {
685  junction = myViewNet->getNet()->createJunction(myViewNet->snapToActiveGrid(clickedPosition), myViewNet->getUndoList());
686  }
687  // now check if we have to create a new edge
688  if (myCreateEdgeSource == nullptr) {
689  myCreateEdgeSource = junction;
691  update();
692  } else {
693  // make sure that junctions source and destiny are different
694  if (myCreateEdgeSource != junction) {
695  // may fail to prevent double edges
696  GNEEdge* newEdge = myViewNet->getNet()->createEdge(myCreateEdgeSource, junction, nullptr, myViewNet->getUndoList());
697  // check if edge was successfully created
698  if (newEdge) {
699  // set parameters
702  } else if (myEdgeTypeSelector->useDefaultEdgeType()) {
704  // check pedestrians and sidewalks
706  disablePedestrians(newEdge);
707  }
709  addSidewalk(newEdge);
710  }
711  } else {
713  }
714  // create another edge, if create opposite edge is enabled
715  if (oppositeEdge && (myViewNet->getNet()->getAttributeCarriers()->retrieveEdges(junction, myCreateEdgeSource).size() == 0)) {
716  GNEEdge* newOppositeEdge = myViewNet->getNet()->createEdge(junction, myCreateEdgeSource, nullptr,
717  myViewNet->getUndoList(), "-" + newEdge->getNBEdge()->getID());
718  // set parameters
721  } else if (myEdgeTypeSelector->useDefaultEdgeType()) {
723  // check pedestrians and sidewalks
725  disablePedestrians(newOppositeEdge);
726  }
728  addSidewalk(newOppositeEdge);
729  }
730  } else {
732  }
733  }
734  // edge created, then unmark as create edge source
736  // end undo list
738  myViewNet->getUndoList()->end();
739  } else {
740  std::cout << "edge created without an open CommandGroup )-:\n";
741  }
742  // if we're creating edges in chain mode, mark junction as junction edge source
743  if (chainEdge) {
744  myCreateEdgeSource = junction;
747  } else {
748  myCreateEdgeSource = nullptr;
749  }
750  } else {
751  myViewNet->setStatusBarText("An " + toString(SUMO_TAG_EDGE) + " with the same geometry already exists!");
752  }
753  } else {
754  myViewNet->setStatusBarText("Start- and endpoint for an " + toString(SUMO_TAG_EDGE) + " must be distinct!");
755  }
756  update();
757  }
758  }
759 }
760 
761 
762 void
764  // if myCreateEdgeSource exist, unmark ist as create edge source
765  if (myCreateEdgeSource != nullptr) {
766  // remove current created edge source
768  myCreateEdgeSource = nullptr;
769  }
770 }
771 
772 
773 const GNEJunction*
775  return myCreateEdgeSource;
776 }
777 
778 
779 void
780 GNECreateEdgeFrame::updateObjectsUnderSnappedCursor(const std::vector<GUIGlObject*>& GUIGlObjects) {
782 }
783 
784 
785 void
787  // refresh template selector
789  // show frame
790  GNEFrame::show();
791 }
792 
793 
794 void
796  // hide frame
797  GNEFrame::hide();
798 }
799 
800 
803  return myEdgeTypeSelector;
804 }
805 
806 
809  return myEdgeTypeAttributes;
810 }
811 
812 
815  return myLaneTypeSelector;
816 }
817 
818 
821  return myLaneTypeAttributes;
822 }
823 
824 
825 void
829 }
830 
831 
832 void
834  // iterate over lanes
835  for (const auto& lane : edge->getLanes()) {
836  // avoid sidelwalks
837  if (lane->getAttribute(SUMO_ATTR_ALLOW) != "pedestrian") {
838  // extract disallow list
839  std::vector<std::string> disallowList = GNEAttributeCarrier::parse<std::vector<std::string> >(lane->getAttribute(SUMO_ATTR_DISALLOW));
840  // check if append pedestrian to disallow
841  if (std::find(disallowList.begin(), disallowList.end(), "pedestrian") == disallowList.end()) {
842  disallowList.push_back("pedestrian");
843  }
844  // update attribute
845  lane->setAttribute(SUMO_ATTR_DISALLOW, toString(disallowList), myViewNet->getUndoList());
846  }
847  }
848 }
849 
850 
851 void
853  bool sidewalkFound = false;
854  // iterate over lanes
855  for (const auto& lane : edge->getLanes()) {
856  // check if there is already a SideWalk
857  if (lane->getAttribute(SUMO_ATTR_ALLOW) == "pedestrian") {
858  sidewalkFound = true;
859  }
860  }
861  // only add if previously there is no Sidewalk
862  if (!sidewalkFound) {
863  // update num lanes
864  edge->setAttribute(SUMO_ATTR_NUMLANES, toString(edge->getLanes().size() + 1), myViewNet->getUndoList());
865  // set last lane allow atribute
866  edge->getLanes().front()->setAttribute(SUMO_ATTR_ALLOW, "pedestrian", myViewNet->getUndoList());
867  }
868 }
869 
870 /****************************************************************************/
FXDEFMAP(GNECreateEdgeFrame::EdgeTypeSelector) EdgeTypeSelectorMap[]
@ MID_GNE_CREATEEDGEFRAME_CREATEFROMTEMPLATE
create edge type from template
Definition: GUIAppEnum.h:1025
@ MID_GNE_CREATEEDGEFRAME_CHECKBUTTON
check button
Definition: GUIAppEnum.h:1027
@ MID_GNE_CREATEEDGEFRAME_SELECTTEMPLATE
select edge template
Definition: GUIAppEnum.h:1021
@ MID_GNE_CREATEEDGEFRAME_DELETE
delete edge type
Definition: GUIAppEnum.h:1017
@ MID_GNE_CREATEEDGEFRAME_ADD
add new edge type
Definition: GUIAppEnum.h:1015
@ MID_GNE_CREATEEDGEFRAME_SELECTLANE
select lane (used for default and template edges)
Definition: GUIAppEnum.h:1023
@ MID_GNE_CREATEEDGEFRAME_SELECTRADIOBUTTON
Definition: GUIAppEnum.h:1013
#define GUIDesignButton
Definition: GUIDesigns.h:77
#define GUIDesignComboBoxAttribute
Combo box static (cannot be edited) extended over the matrix column.
Definition: GUIDesigns.h:315
#define GUIDesignComboBoxNCol
number of column of every combo box
Definition: GUIDesigns.h:321
#define GUIDesignAuxiliarHorizontalFrame
design for auxiliar (Without borders) horizontal frame used to pack another frames
Definition: GUIDesigns.h:397
#define GUIDesignCheckButton
checkButton placed in left position
Definition: GUIDesigns.h:169
#define GUIDesignRadioButton
Definition: GUIDesigns.h:203
#define GUIDesignLabelFrameInformation
label extended over frame without thick and with text justify to left, used to show information in fr...
Definition: GUIDesigns.h:271
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
@ SUMO_TAG_EDGE
begin/end of the description of an edge
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_NUMLANES
@ SUMO_ATTR_ID
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
const std::string getID() const
get ID (all Attribute Carriers have one)
GNENet * getNet() const
get pointer to net
bool areValuesValid() const
check if parameters of attributes are valid
GNEEdgeType * getEdgeTypeSelected() const
get edgeType selected
GNEEdgeType * getDefaultEdgeType() const
get default edgeType
bool useEdgeTemplate() const
check if we have to use edge template
void updateIDinComboBox(const std::string &oldID, const std::string &newID)
update id in comboBox
long onCmdAddEdgeType(FXObject *, FXSelector, void *)
Called when the user press button for add a new edge type.
void enableCheckBoxDisablePedestrians()
void enable checkbox for disable pedestrians
bool useDefaultEdgeType() const
check if we're using default edge type
long onCmdDeleteEdgeType(FXObject *, FXSelector, void *)
Called when the user press button for delete edge type.
long onUpdAddSideWalk(FXObject *, FXSelector, void *)
Called when add sidewalk check buton is updated.
GNEEdgeType * myDefaultEdgeType
default edge type
long onCmdCreateFromTemplate(FXObject *, FXSelector, void *)
Called when the user press create edgeType from Template.
bool isAddSidewalkEnabled() const
check if add sidewalk check button is enabled
void refreshEdgeTypeSelector()
refresh edge type selector
bool isNoPedestriansEnabled() const
check if no pedestrian check button is enabled
long onCmdRadioButton(FXObject *, FXSelector, void *)
void setCurrentEdgeType(const GNEEdgeType *edgeType)
set current edgeType
void clearEdgeTypeSelected()
clear edgeType selected
long onCmdSelectEdgeTypeOrTemplate(FXObject *, FXSelector, void *)
Called when the user press select an edgeType or template in comboBox.
long onCmdSelectLaneType(FXObject *, FXSelector, void *)
Called when the user press select an laneType in comboBox.
FXButton * myDeleteLaneTypeButton
button for delete lane type
FXComboBox * myLaneTypesComboBox
ComboBox for lane types.
void showLaneTypeSelector()
show lane type selector
LaneTypeSelector(GNECreateEdgeFrame *createEdgeFrameParent)
FOX-declaration.
void hideLaneTypeSelector()
hide lane type selector
long onCmdAddLaneType(FXObject *, FXSelector, void *)
FXButton * myAddLaneTypeButton
button for create new lane type
long onCmdDeleteLaneType(FXObject *, FXSelector, void *)
Called when the user press button for delete lane type.
void refreshLaneTypeSelector()
refresh LaneTypeSelector
Legend(GNECreateEdgeFrame *createEdgeFrameParent)
constructor
void processClick(const Position &clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor &objectsUnderCursor, const bool oppositeEdge, const bool chainEdge)
handle processClick and set the relative colouring
EdgeTypeSelector * getEdgeTypeSelector() const
get edgeType selector
void abortEdgeCreation()
abort current edge creation
void show()
show create edge frame
GNECreateEdgeFrame::LaneTypeSelector * myLaneTypeSelector
lane type selector
GNEAttributesCreator * getLaneTypeAttributes() const
get laneType attributes
void updateObjectsUnderSnappedCursor(const std::vector< GUIGlObject * > &GUIGlObjects)
update objects under snapped cursor
GNEAttributesCreator * myEdgeTypeAttributes
internal edgeType attributes
GNEAttributesCreator * getEdgeTypeAttributes() const
get edgeType attributes
const GNEJunction * getJunctionSource() const
get junction source for new edge
GNEAttributesCreator * myLaneTypeAttributes
internal laneType attributes
~GNECreateEdgeFrame()
Destructor.
void disablePedestrians(GNEEdge *edge) const
disable pedestrians in the given edge (within undoRedo)
GNECreateEdgeFrame::Legend * myLegend
Legend.
GNEJunction * myCreateEdgeSource
source junction for new edge
GNEViewNetHelper::ObjectsUnderCursor myObjectsUnderSnappedCursor
objects under snapped cursor
GNECreateEdgeFrame(GNEViewParent *viewParent, GNEViewNet *viewNet)
Constructor.
void hide()
hide create edge frame
void addSidewalk(GNEEdge *edge) const
disable pedestrians in the given edge (within undoRedo)
EdgeTypeSelector * myEdgeTypeSelector
edge type selector
void setUseEdgeTemplate()
set default to using edge template
LaneTypeSelector * getLaneTypeSelector()
get lane type selector
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
void copyEdgeType(const GNEEdgeType *edgeType, GNEUndoList *undoList)
copy edge attributes from edgeType
Definition: GNEEdge.cpp:784
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:481
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:839
void copyTemplate(const GNEEdgeTemplate *edgeTemplate, GNEUndoList *undoList)
copy edge attributes from edgetemplate
Definition: GNEEdge.cpp:749
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition: GNEEdge.cpp:957
const std::vector< GNELaneTemplate * > & getLaneTemplates() const
get vector with the lane templates of this edge
void copyTemplate(const GNEEdgeTemplate *edgeTemplate)
copy edge template
Definition: GNEEdgeType.cpp:92
const std::vector< GNELaneType * > & getLaneTypes() const
get laneTypes
void addLaneType(GNELaneType *laneType)
add laneType
GNEViewNet * myViewNet
FOX need this.
Definition: GNEFrame.h:117
virtual void show()
show Frame
Definition: GNEFrame.cpp:115
virtual void hide()
hide Frame
Definition: GNEFrame.cpp:124
GNEEdgeTemplate * getEdgeTemplate() const
get edge template (to copy attributes from)
TemplateEditor * getTemplateEditor() const
get template editor
void markAsCreateEdgeSource()
marks as first junction in createEdge-mode
void unMarkAsCreateEdgeSource()
removes mark as first junction in createEdge-mode
std::vector< GNEEdge * > retrieveEdges(GNEJunction *from, GNEJunction *to) const
get all edges by from and to GNEJunction
GNEEdgeType * retrieveEdgeType(const std::string &id, bool hardFail=true) const
get edge type by id
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:132
GNEEdge * createEdge(GNEJunction *src, GNEJunction *dest, GNEEdge *edgeTemplate, GNEUndoList *undoList, const std::string &suggestedName="", bool wasSplit=false, bool allowDuplicateGeom=false, bool recomputeConnections=true)
creates a new edge (unless an edge with the same geometry already exists)
Definition: GNENet.cpp:237
GNEJunction * createJunction(const Position &pos, GNEUndoList *undoList)
creates a new junction
Definition: GNENet.cpp:221
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
bool hasCommandGroup() const
Check if undoList has command group.
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
class used to group all variables related with objects under cursor after a click over view
void updateObjectUnderCursor(const std::vector< GUIGlObject * > &GUIGlObjects)
update objects under cursor (Called only in onLeftBtnPress(...) function)
GNEJunction * getJunctionFront() const
get front junction or a pointer to nullptr
GNENet * getNet() const
get the net object
GNEViewParent * getViewParent() const
get the net object
GNEUndoList * getUndoList() const
get the undoList object
void setStatusBarText(const std::string &text)
set statusBar text
Definition: GNEViewNet.cpp:768
A single child window which contains a view of the simulation area.
Definition: GNEViewParent.h:84
GNEInspectorFrame * getInspectorFrame() const
get frame for inspect elements
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Position snapToActiveGrid(const Position &pos, bool snapXY=true) const
Returns a position that is mapped to the closest grid point if the grid is active.
MFXGroupBoxModule (based on FXGroupBox)
FXVerticalFrame * getCollapsableFrame()
get collapsable frame (used by all elements that will be collapsed if button is toggled)
const std::string & getID() const
Definition: NBEdge.h:1526
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37