long
GNEConnectorFrame::onCmdSelectDeadStarts(FXObject*, FXSelector, void*) {
GNENet* net = myViewNet->getNet();
std::set<GUIGlID> selectIDs;
// every edge knows only its outgoing connections so we look at whole junctions
const std::vector<GNEJunction*> junctions = net->retrieveJunctions();
for (std::vector<GNEJunction*>::const_iterator junction_it = junctions.begin(); junction_it != junctions.end(); junction_it++) {
// first collect all outgoing lanes
const EdgeVector& outgoing = (*junction_it)->getNBNode()->getOutgoingEdges();
for (EdgeVector::const_iterator it = outgoing.begin(); it != outgoing.end(); it++) {
GNEEdge* edge = net->retrieveEdge((*it)->getID());
const std::set<GUIGlID> laneIDs = edge->getLaneGlIDs();
for (std::set<GUIGlID>::const_iterator lid_it = laneIDs.begin(); lid_it != laneIDs.end(); lid_it++) {
selectIDs.insert(*lid_it);
}
}
// then remove all approached lanes
const EdgeVector& incoming = (*junction_it)->getNBNode()->getIncomingEdges();
for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); it++) {
GNEEdge* edge = net->retrieveEdge((*it)->getID());
NBEdge* nbe = edge->getNBEdge();
const std::vector<NBEdge::Connection>& connections = nbe->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator con_it = connections.begin(); con_it != connections.end(); con_it++) {
GNEEdge* approachedEdge = net->retrieveEdge(con_it->toEdge->getID());
GNELane* approachedLane = approachedEdge->getLanes()[con_it->toLane];
selectIDs.erase(approachedLane->getGlID());
}
}
}
myViewNet->getViewParent()->getSelectorFrame()->handleIDs(
std::vector<GUIGlID>(selectIDs.begin(), selectIDs.end()),
false, GNESelectorFrame::SET_REPLACE);
return 1;
}
long
GNEConnectorFrame::onCmdSelectPass(FXObject*, FXSelector, void*) {
std::vector<GUIGlID> selectIDs;
const std::vector<GNEEdge*> edges = myViewNet->getNet()->retrieveEdges();
for (std::vector<GNEEdge*>::const_iterator edge_it = edges.begin(); edge_it != edges.end(); edge_it++) {
GNEEdge* edge = *edge_it;
NBEdge* nbe = edge->getNBEdge();
const std::vector<NBEdge::Connection>& connections = nbe->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator it = connections.begin(); it != connections.end(); ++it) {
if (it->mayDefinitelyPass) {
GNELane* lane = edge->getLanes()[it->fromLane];
selectIDs.push_back(lane->getGlID());
}
}
}
myViewNet->getViewParent()->getSelectorFrame()->handleIDs(selectIDs, false, GNESelectorFrame::SET_REPLACE);
return 1;
}
bool
GNEAccess::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_LANE: {
GNELane* lane = myViewNet->getNet()->retrieveLane(value, false);
if (lane != nullptr) {
if (getLaneParents().front()->getParentEdge().getID() != lane->getParentEdge().getID()) {
return GNEAdditionalHandler::accessCanBeCreated(getAdditionalParents().at(0), lane->getParentEdge());
} else {
return true;
}
} else {
return false;
}
}
case SUMO_ATTR_POSITION:
if (value.empty()) {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_LENGTH:
if (value.empty()) {
return true;
} else {
return (canParse<double>(value) && (parse<double>(value) >= 0));
}
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEFrame::ACHierarchy::showAttributeCarrierChilds(GNEAttributeCarrier *AC, FXTreeItem* itemParent) {
// Switch gl type of ac
switch (AC->getTag()) {
case SUMO_TAG_JUNCTION: {
// retrieve junction
GNEJunction* junction = myFrameParent->getViewNet()->getNet()->retrieveJunction(AC->getID(), false);
if(junction) {
// insert junction item
FXTreeItem* junctionItem = addACIntoList(AC, itemParent);
// insert edges
for (auto i : junction->getGNEEdges()) {
showAttributeCarrierChilds(i, junctionItem);
}
// insert crossings
for (auto i : junction->getGNECrossings()) {
showAttributeCarrierChilds(i, junctionItem);
}
}
break;
}
case SUMO_TAG_EDGE: {
// retrieve edge
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(AC->getID(), false);
if(edge) {
// insert edge item
FXTreeItem* edgeItem = addACIntoList(AC, itemParent);
// insert lanes
for (int i = 0; i < (int)edge->getLanes().size(); i++) {
showAttributeCarrierChilds(edge->getLanes().at(i), edgeItem);
}
// insert additionals of edge
for (auto i : edge->getAdditionalChilds()) {
showAttributeCarrierChilds(i, edgeItem);
}
}
break;
}
case SUMO_TAG_LANE: {
// retrieve lane
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(AC->getID(), false);
if(lane) {
// insert lane item
FXTreeItem* laneItem = addACIntoList(AC, itemParent);
// insert additionals of lanes
for (auto i : lane->getAdditionalChilds()) {
showAttributeCarrierChilds(i, laneItem);
}
// insert incoming connections of lanes (by default isn't expanded)
if (lane->getGNEIncomingConnections().size() > 0) {
std::vector<GNEConnection*> incomingLaneConnections = lane->getGNEIncomingConnections();
FXTreeItem* incomingConnections = myTreelist->insertItem(0, laneItem, "Incomings", incomingLaneConnections.front()->getIcon(), lane->getGNEIncomingConnections().front()->getIcon());
myTreeItemsConnections.insert(incomingConnections);
incomingConnections->setExpanded(false);
// insert incoming connections
for (auto i : incomingLaneConnections) {
showAttributeCarrierChilds(i, incomingConnections);
}
}
// insert outcoming connections of lanes (by default isn't expanded)
if (lane->getGNEOutcomingConnections().size() > 0) {
std::vector<GNEConnection*> outcomingLaneConnections = lane->getGNEOutcomingConnections();
FXTreeItem* outgoingConnections = myTreelist->insertItem(0, laneItem, "Outcomings", outcomingLaneConnections.front()->getIcon(), lane->getGNEOutcomingConnections().front()->getIcon());
myTreeItemsConnections.insert(outgoingConnections);
outgoingConnections->setExpanded(false);
// insert outcoming connections
for (auto i : outcomingLaneConnections) {
showAttributeCarrierChilds(i, outgoingConnections);
}
}
}
break;
}
case SUMO_TAG_POI:
case SUMO_TAG_POLY:
case SUMO_TAG_CROSSING:
case SUMO_TAG_CONNECTION: {
// insert connection item
addACIntoList(AC, itemParent);
break;
}
default: {
// check if is an additional
if(GNEAttributeCarrier::getTagProperties(AC->getTag()).isAdditional()) {
// retrieve additional
GNEAdditional *additional = myFrameParent->getViewNet()->getNet()->retrieveAdditional(AC->getTag(), AC->getID(), false);
if(additional) {
// insert additional item
FXTreeItem* additionalItem = addACIntoList(AC, itemParent);
// insert additionals childs
for (auto i : additional->getAdditionalChilds()) {
showAttributeCarrierChilds(i, additionalItem);
}
}
}
break;
}
}
}
FXTreeItem*
GNEFrame::ACHierarchy::showAttributeCarrierParents() {
// Switch gl type of ac
switch (myAC->getTag()) {
case SUMO_TAG_EDGE: {
// obtain Edge
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(myAC->getID(), false);
if(edge) {
// insert Junctions of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
// return junction destiny Item
return junctionDestinyItem;
} else {
return nullptr;
}
}
case SUMO_TAG_LANE: {
// obtain lane
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(myAC->getID(), false);
if(lane) {
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
// return edge item
return edgeItem;
} else {
return nullptr;
}
}
case SUMO_TAG_POILANE: {
// Obtain POILane
GNEPOI* POILane = myFrameParent->getViewNet()->getNet()->retrievePOI(myAC->getID(), false);
if(POILane) {
// obtain lane parent
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(POILane->getLane()->getID());
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Create lane item
FXTreeItem* laneItem = myTreelist->insertItem(0, edgeItem, lane->getHierarchyName().c_str(), lane->getIcon(), lane->getIcon());
laneItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
myTreeItemToACMap[laneItem] = lane;
// return Lane item
return laneItem;
} else {
return nullptr;
}
}
case SUMO_TAG_CROSSING: {
// obtain Crossing
GNECrossing* crossing = myFrameParent->getViewNet()->getNet()->retrieveCrossing(myAC->getID(), false);
if(crossing) {
// obtain junction
GNEJunction* junction = crossing->getParentJunction();
// create junction item
FXTreeItem* junctionItem = myTreelist->insertItem(nullptr, nullptr, junction->getHierarchyName().c_str(), junction->getIcon(), junction->getIcon());
junctionItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionItem] = junction;
// return junction Item
return junctionItem;
} else {
return nullptr;
}
}
case SUMO_TAG_CONNECTION: {
// obtain Connection
GNEConnection* connection = myFrameParent->getViewNet()->getNet()->retrieveConnection(myAC->getID(), false);
if(connection) {
// create edge from item
FXTreeItem* edgeFromItem = myTreelist->insertItem(nullptr, nullptr, connection->getEdgeFrom()->getHierarchyName().c_str(), connection->getEdgeFrom()->getIcon(), connection->getEdgeFrom()->getIcon());
edgeFromItem->setExpanded(true);
// create edge to item
FXTreeItem* edgeToItem = myTreelist->insertItem(nullptr, nullptr, connection->getEdgeTo()->getHierarchyName().c_str(), connection->getEdgeTo()->getIcon(), connection->getEdgeTo()->getIcon());
edgeToItem->setExpanded(true);
// create connection item
FXTreeItem* connectionItem = myTreelist->insertItem(0, edgeToItem, connection->getHierarchyName().c_str(), connection->getIcon(), connection->getIcon());
connectionItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[edgeFromItem] = connection->getEdgeFrom();
myTreeItemToACMap[edgeToItem] = connection->getEdgeTo();
myTreeItemToACMap[connectionItem] = connection;
// return connection item
return connectionItem;
} else {
return nullptr;
}
}
default: {
// obtain tag property (only for improve code legibility)
const auto &tagValue = GNEAttributeCarrier::getTagProperties(myAC->getTag());
// check if is an additional, and in other case return nullptr
if(tagValue.isAdditional()) {
// Obtain Additional
GNEAdditional* additional = myFrameParent->getViewNet()->getNet()->retrieveAdditional(myAC->getTag(), myAC->getID(), false);
if(additional) {
// first check if additional has another additional as parent (to add it into root)
if (tagValue.hasParent()) {
GNEAdditional* additionalParent = myFrameParent->getViewNet()->getNet()->retrieveAdditional(tagValue.getParentTag(), additional->getAttribute(GNE_ATTR_PARENT));
// create additional parent item
FXTreeItem* additionalParentItem = myTreelist->insertItem(0, 0, additionalParent->getHierarchyName().c_str(), additionalParent->getIcon(), additionalParent->getIcon());
additionalParentItem->setExpanded(true);
// Save it in myTreeItemToACMap
myTreeItemToACMap[additionalParentItem] = additionalParent;
}
if(tagValue.hasAttribute(SUMO_ATTR_EDGE)) {
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(additional->getAttribute(SUMO_ATTR_EDGE));
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
// return edge item
return edgeItem;
} else if (tagValue.hasAttribute(SUMO_ATTR_LANE)) {
// obtain lane parent
GNELane* lane = myFrameParent->getViewNet()->getNet()->retrieveLane(additional->getAttribute(SUMO_ATTR_LANE));
// obtain edge parent
GNEEdge* edge = myFrameParent->getViewNet()->getNet()->retrieveEdge(lane->getParentEdge().getID());
//inser Junctions of lane of edge in tree (Pararell because a edge has always two Junctions)
FXTreeItem* junctionSourceItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " origin").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
FXTreeItem* junctionDestinyItem = myTreelist->insertItem(nullptr, nullptr, (edge->getGNEJunctionSource()->getHierarchyName() + " destiny").c_str(), edge->getGNEJunctionSource()->getIcon(), edge->getGNEJunctionSource()->getIcon());
junctionDestinyItem->setExpanded(true);
// Create edge item
FXTreeItem* edgeItem = myTreelist->insertItem(nullptr, junctionDestinyItem, edge->getHierarchyName().c_str(), edge->getIcon(), edge->getIcon());
edgeItem->setExpanded(true);
// Create lane item
FXTreeItem* laneItem = myTreelist->insertItem(0, edgeItem, lane->getHierarchyName().c_str(), lane->getIcon(), lane->getIcon());
laneItem->setExpanded(true);
// Save items in myTreeItemToACMap
myTreeItemToACMap[junctionSourceItem] = edge->getGNEJunctionSource();
myTreeItemToACMap[junctionDestinyItem] = edge->getGNEJunctionDestiny();
myTreeItemToACMap[edgeItem] = edge;
myTreeItemToACMap[laneItem] = lane;
// return lane item
return laneItem;
}
}
}
return nullptr;
}
}
}
void
GNEDeleteFrame::removeAttributeCarrier(GNEAttributeCarrier* ac, bool ignoreOptions) {
// obtain clicked position
Position clickedPosition = myViewNet->getPositionInformation();
if (myDeleteOptions->deleteOnlyGeometryPoints() && !ignoreOptions) {
// check type of of GL object
switch (ac->getTag()) {
case SUMO_TAG_EDGE: {
GNEEdge* edge = dynamic_cast<GNEEdge*>(ac);
assert(edge);
if (edge->getVertexIndex(clickedPosition, false) != -1) {
edge->deleteGeometryPoint(clickedPosition);
}
break;
}
case SUMO_TAG_POLY: {
GNEPoly* polygon = dynamic_cast<GNEPoly*>(ac);
assert(polygon);
if (polygon->getVertexIndex(clickedPosition, false) != -1) {
polygon->deleteGeometryPoint(clickedPosition);
}
break;
}
default: {
break;
}
}
} else {
// check type of of GL object
switch (ac->getTag()) {
case SUMO_TAG_JUNCTION: {
GNEJunction* junction = dynamic_cast<GNEJunction*>(ac);
assert(junction);
// obtain number of additionals of junction's childs
int numberOfAdditionals = 0;
for (auto i : junction->getGNEEdges()) {
numberOfAdditionals += (int)i->getAdditionalChilds().size();
for (auto j : i->getLanes()) {
UNUSED_PARAMETER(j);
numberOfAdditionals += (int)i->getAdditionalChilds().size();
}
}
// Check if junction can be deleted
if (myDeleteOptions->forceDeleteAdditionals() || ignoreOptions) {
myViewNet->getNet()->deleteJunction(junction, myViewNet->getUndoList());
} else {
if (numberOfAdditionals > 0) {
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Opening FXMessageBox 'Force deletion needed'");
}
std::string plural = numberOfAdditionals > 1 ? "s" : "";
// Open warning DialogBox
FXMessageBox::warning(getViewNet()->getApp(), MBOX_OK, ("Problem deleting " + toString(junction->getTag())).c_str(), "%s",
(toString(junction->getTag()) + " '" + junction->getID() + "' cannot be deleted because owns " +
toString(numberOfAdditionals) + " additional child" + plural + ".\n Check 'Force deletion of additionals' to force deletion.").c_str());
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Closed FXMessageBox 'Force deletion needed' with 'OK'");
}
} else {
myViewNet->getNet()->deleteJunction(junction, myViewNet->getUndoList());
}
}
break;
}
case SUMO_TAG_EDGE: {
GNEEdge* edge = dynamic_cast<GNEEdge*>(ac);
assert(edge);
// check if click was over a geometry point or over a shape's edge
if (edge->getVertexIndex(clickedPosition, false) != -1) {
edge->deleteGeometryPoint(clickedPosition);
} else {
int numberOfAdditionalChilds = (int)edge->getAdditionalChilds().size();
int numberOfAdditionalParents = (int)edge->getAdditionalParents().size();
// Iterate over lanes and obtain total number of additional childs
for (auto i : edge->getLanes()) {
numberOfAdditionalChilds += (int)i->getAdditionalChilds().size();
}
// Check if edge can be deleted
if (myDeleteOptions->forceDeleteAdditionals() || ignoreOptions) {
// when deleting a single edge, keep all unaffected connections as they were
myViewNet->getNet()->deleteEdge(edge, myViewNet->getUndoList(), false);
} else {
if (numberOfAdditionalChilds > 0) {
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Opening FXMessageBox 'Force deletion needed'");
}
std::string plural = numberOfAdditionalChilds > 1 ? "s" : "";
// Open warning DialogBox
FXMessageBox::warning(getViewNet()->getApp(), MBOX_OK, ("Problem deleting " + toString(edge->getTag())).c_str(), "%s",
(toString(edge->getTag()) + " '" + edge->getID() + "' cannot be deleted because owns " +
toString(numberOfAdditionalChilds) + " additional" + plural + ".\n Check 'Force deletion of additionals' to force deletion.").c_str());
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Closed FXMessageBox 'Force deletion needed' with 'OK'");
}
} else if (numberOfAdditionalParents > 0) {
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Opening FXMessageBox 'Force deletion needed'");
}
std::string plural = numberOfAdditionalParents > 1 ? "s" : "";
// Open warning DialogBox
FXMessageBox::warning(getViewNet()->getApp(), MBOX_OK, ("Problem deleting " + toString(edge->getTag())).c_str(), "%s",
(toString(edge->getTag()) + " '" + edge->getID() + "' cannot be deleted because is part of " +
toString(numberOfAdditionalParents) + " additional" + plural + ".\n Check 'Force deletion of additionals' to force deletion.").c_str());
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Closed FXMessageBox 'Force deletion needed' with 'OK'");
}
} else {
// when deleting a single edge, keep all unaffected connections as they were
myViewNet->getNet()->deleteEdge(edge, myViewNet->getUndoList(), false);
}
}
}
break;
}
case SUMO_TAG_LANE: {
GNELane* lane = dynamic_cast<GNELane*>(ac);
assert(lane);
// Check if lane can be deleted
if (myDeleteOptions->forceDeleteAdditionals() || ignoreOptions) {
// when deleting a single lane, keep all unaffected connections as they were
myViewNet->getNet()->deleteLane(lane, myViewNet->getUndoList(), false);
} else {
if (lane->getAdditionalChilds().size() == 0) {
// when deleting a single lane, keep all unaffected connections as they were
myViewNet->getNet()->deleteLane(lane, myViewNet->getUndoList(), false);
} else {
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Opening FXMessageBox 'Force deletion needed'");
}
// open warning box
FXMessageBox::warning(getViewNet()->getApp(), MBOX_OK, ("Problem deleting " + toString(lane->getTag())).c_str(), "%s",
(toString(lane->getTag()) + " '" + lane->getID() + "' cannot be deleted because it has " +
toString(lane->getAdditionalChilds().size()) + " additional childs.\n Check 'Force deletion of Additionals' to force deletion.").c_str());
// write warning if netedit is running in testing mode
if (OptionsCont::getOptions().getBool("gui-testing-debug")) {
WRITE_WARNING("Closed FXMessageBox 'Force deletion needed' with 'OK'");
}
}
}
break;
}
case SUMO_TAG_CROSSING: {
GNECrossing* crossing = dynamic_cast<GNECrossing*>(ac);
assert(crossing);
myViewNet->getNet()->deleteCrossing(crossing, myViewNet->getUndoList());
break;
}
case SUMO_TAG_CONNECTION: {
GNEConnection* connection = dynamic_cast<GNEConnection*>(ac);
assert(connection);
myViewNet->getNet()->deleteConnection(connection, myViewNet->getUndoList());
break;
}
default: {
// obtain tag property (only for improve code legibility)
const auto &tagValue = GNEAttributeCarrier::getTagProperties(ac->getTag());
if(tagValue.isAdditional()) {
GNEAdditional* additional = dynamic_cast<GNEAdditional*>(ac);
assert(additional);
myViewNet->getViewParent()->getAdditionalFrame()->removeAdditional(additional);
} else if(tagValue.isShape()) {
GNEShape* shape = dynamic_cast<GNEShape*>(ac);
assert(shape);
myViewNet->getNet()->deleteShape(shape, myViewNet->getUndoList());
}
break;
}
}
}
// update view to show changes
myViewNet->update();
}
