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>
34
35
36#include "GNECreateEdgeFrame.h"
37
38// ===========================================================================
39// FOX callback mapping
40// ===========================================================================
41
49};
50
55};
56
57// Object implementation
58FXIMPLEMENT(GNECreateEdgeFrame::EdgeTypeSelector, MFXGroupBoxModule, EdgeTypeSelectorMap, ARRAYNUMBER(EdgeTypeSelectorMap))
59FXIMPLEMENT(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
116void
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
195void
196GNECreateEdgeFrame::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
205bool
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
219bool
221 return (myUseDefaultEdgeType->getCheck() == TRUE);
222}
223
224
225void
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
247bool
249 return (myNoPedestriansCheckButton->getCheck() == TRUE);
250}
251
252
253bool
255 return (myAddSidewalkCheckButton->getCheck() == TRUE);
256}
257
258
259void
261 myEdgeTypeSelected = nullptr;
262 myCurrentIndex--;
263 if (myCurrentIndex < 0) {
264 myCurrentIndex = 0;
265 }
266}
267
268
269void
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
286void
288 myUseDefaultEdgeType->setCheck(FALSE);
289 myUseCustomEdgeType->setCheck(TRUE);
290 refreshEdgeTypeSelector();
291}
292
293
294long
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
312long
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
330long
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
348long
350 // update current index
351 myCurrentIndex = myEdgeTypesComboBox->getCurrentItem();
352 // refresh edgeType selector
353 refreshEdgeTypeSelector();
354 return 0;
355}
356
357
358long
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
380long
382 if (myAddSidewalkCheckButton->getCheck() == TRUE) {
383 myNoPedestriansCheckButton->setCheck(TRUE);
384 myNoPedestriansCheckButton->disable();
385 } else {
386 myNoPedestriansCheckButton->enable();
387 }
388 return 1;
389}
390
391
392void
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
448void
450 // start at first lane
451 myLaneIndex = 0;
452 // refresh laneTypeSelector
453 refreshLaneTypeSelector();
454 // show
455 show();
456}
457
458
459void
461 // hide attributes creator modul
462 myCreateEdgeFrameParent->myLaneTypeAttributes->hideAttributesCreatorModule();
463 // hide
464 hide();
465}
466
467
468void
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
513long
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
550long
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
587long
589 // update index
590 myLaneIndex = myLaneTypesComboBox->getCurrentItem();
591 // refresh laneType selector
592 refreshLaneTypeSelector();
593 return 0;
594}
595
596
597void
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
661void
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
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
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
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
762void
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
773const GNEJunction*
775 return myCreateEdgeSource;
776}
777
778
779void
780GNECreateEdgeFrame::updateObjectsUnderSnappedCursor(const std::vector<GUIGlObject*>& GUIGlObjects) {
782}
783
784
785void
787 // refresh template selector
789 // show frame
791}
792
793
794void
796 // hide frame
798}
799
800
803 return myEdgeTypeSelector;
804}
805
806
810}
811
812
815 return myLaneTypeSelector;
816}
817
818
822}
823
824
825void
829}
830
831
832void
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
851void
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
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