void GNEDetectorE2::commitGeometryMoving(GNEUndoList* undoList) { // commit geometry moving depending of number of lanes if (getLaneParents().size() == 1) { // commit new position allowing undo/redo undoList->p_begin("position of " + getTagStr()); undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition)); undoList->p_end(); } else { undoList->p_begin("position of " + getTagStr()); undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition)); undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_ENDPOS, toString(myEndPositionOverLane), true, myMove.secondOriginalPosition)); undoList->p_end(); } }
void GNEClosingReroute::setAttribute(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: changeAdditionalID(value); break; case SUMO_ATTR_EDGE: myClosedEdge = myViewNet->getNet()->retrieveEdge(value); break; case SUMO_ATTR_ALLOW: myPermissions = parseVehicleClasses(value); break; case SUMO_ATTR_DISALLOW: myPermissions = invertPermissions(parseVehicleClasses(value)); break; case GNE_ATTR_GENERIC: setGenericParametersStr(value); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } // check if updated attribute requieres update geometry if (myTagProperty.hasAttribute(key) && myTagProperty.getAttributeProperties(key).requiereUpdateGeometry()) { updateGeometry(); } }
std::string GNECrossing::getAttribute(SumoXMLAttr key) const { auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges, (key != SUMO_ATTR_ID)); switch (key) { case SUMO_ATTR_ID: // get attribute requieres a special case if (crossing) { return crossing->id; } else { return "Temporal Unreferenced"; } case SUMO_ATTR_WIDTH: return toString(crossing->customWidth); case SUMO_ATTR_PRIORITY: return crossing->priority ? "true" : "false"; case SUMO_ATTR_EDGES: return toString(crossing->edges); case SUMO_ATTR_TLLINKINDEX: return toString(crossing->customTLIndex); case SUMO_ATTR_TLLINKINDEX2: return toString(crossing->customTLIndex2); case SUMO_ATTR_CUSTOMSHAPE: return toString(crossing->customShape); case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
std::string GNEAccess::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return getAdditionalID(); case SUMO_ATTR_LANE: return getLaneParents().front()->getID(); case SUMO_ATTR_POSITION: return toString(myPositionOverLane); case SUMO_ATTR_LENGTH: return toString(myLength); case SUMO_ATTR_FRIENDLY_POS: return toString(myFriendlyPosition); case GNE_ATTR_BLOCK_MOVEMENT: return toString(myBlockMovement); case GNE_ATTR_PARENT: return getAdditionalParents().at(0)->getID(); case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
std::string GNEDetectorE1::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return getAdditionalID(); case SUMO_ATTR_LANE: return getLaneParents().front()->getID(); case SUMO_ATTR_POSITION: return toString(myPositionOverLane); case SUMO_ATTR_FREQUENCY: return toString(myFreq); case SUMO_ATTR_NAME: return myAdditionalName; case SUMO_ATTR_FILE: return myFilename; case SUMO_ATTR_VTYPES: return myVehicleTypes; case SUMO_ATTR_FRIENDLY_POS: return toString(myFriendlyPosition); case GNE_ATTR_BLOCK_MOVEMENT: return toString(myBlockMovement); case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEDetectorE2::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) { if (value == getAttribute(key)) { return; //avoid needless changes, later logic relies on the fact that attributes have changed } switch (key) { case SUMO_ATTR_ID: case SUMO_ATTR_LANE: case SUMO_ATTR_LANES: case SUMO_ATTR_POSITION: case SUMO_ATTR_ENDPOS: case SUMO_ATTR_FREQUENCY: case SUMO_ATTR_LENGTH: case SUMO_ATTR_NAME: case SUMO_ATTR_FILE: case SUMO_ATTR_VTYPES: case SUMO_ATTR_HALTING_TIME_THRESHOLD: case SUMO_ATTR_HALTING_SPEED_THRESHOLD: case SUMO_ATTR_JAM_DIST_THRESHOLD: case SUMO_ATTR_FRIENDLY_POS: case GNE_ATTR_BLOCK_MOVEMENT: case GNE_ATTR_SELECTED: case GNE_ATTR_GENERIC: undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value)); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEPOI::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) { if (value == getAttribute(key)) { return; //avoid needless changes, later logic relies on the fact that attributes have changed } switch (key) { case SUMO_ATTR_ID: case SUMO_ATTR_COLOR: case SUMO_ATTR_LANE: case SUMO_ATTR_POSITION: case SUMO_ATTR_POSITION_LAT: case SUMO_ATTR_GEOPOSITION: case SUMO_ATTR_GEO: case SUMO_ATTR_TYPE: case SUMO_ATTR_LAYER: case SUMO_ATTR_IMGFILE: case SUMO_ATTR_RELATIVEPATH: case SUMO_ATTR_WIDTH: case SUMO_ATTR_HEIGHT: case SUMO_ATTR_ANGLE: case GNE_ATTR_BLOCK_MOVEMENT: case GNE_ATTR_SELECTED: case GNE_ATTR_GENERIC: undoList->p_add(new GNEChange_Attribute(this, myNet, key, value)); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
std::string GNECalibrator::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return getAdditionalID(); case SUMO_ATTR_EDGE: return getEdgeParents().front()->getID(); case SUMO_ATTR_LANE: return getLaneParents().front()->getID(); case SUMO_ATTR_POSITION: return toString(myPositionOverLane); case SUMO_ATTR_FREQUENCY: return toString(myFrequency); case SUMO_ATTR_NAME: return myAdditionalName; case SUMO_ATTR_OUTPUT: return myOutput; case SUMO_ATTR_ROUTEPROBE: return myRouteProbe; case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNECalibratorFlow::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) { if (value == getAttribute(key)) { return; //avoid needless changes, later logic relies on the fact that attributes have changed } switch (key) { case SUMO_ATTR_ID: case SUMO_ATTR_TYPE: case SUMO_ATTR_ROUTE: case SUMO_ATTR_COLOR: case SUMO_ATTR_VEHSPERHOUR: case SUMO_ATTR_SPEED: case SUMO_ATTR_BEGIN: case SUMO_ATTR_END: case SUMO_ATTR_DEPARTLANE: case SUMO_ATTR_DEPARTPOS: case SUMO_ATTR_DEPARTSPEED: case SUMO_ATTR_ARRIVALLANE: case SUMO_ATTR_ARRIVALPOS: case SUMO_ATTR_ARRIVALSPEED: case SUMO_ATTR_LINE: case SUMO_ATTR_PERSON_NUMBER: case SUMO_ATTR_CONTAINER_NUMBER: case SUMO_ATTR_REROUTE: case SUMO_ATTR_DEPARTPOS_LAT: case SUMO_ATTR_ARRIVALPOS_LAT: case GNE_ATTR_GENERIC: undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value)); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEDetectorE1::commitGeometryMoving(GNEUndoList* undoList) { // commit new position allowing undo/redo undoList->p_begin("position of " + getTagStr()); undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition)); undoList->p_end(); }
static STDataItem stringToItem(const STString &str) { STString itemTag = getFirstTagName(str); if (itemTag.empty() ) { return STDataItem(""); } STString interTagStr = getTagStr(str, itemTag, false); if (interTagStr.empty() ) { return STDataItem(""); } STDataItem item(itemTag); if (isValueStr(interTagStr)) { STString valueTag = getFirstTagName(interTagStr); STString valueStr = getTagStr(interTagStr, valueTag); if ("bool" == valueTag) { item = stringToBool(valueStr); } else if ("int" == valueTag) { item = stringToInt(valueStr); } else if ("string" == valueTag) { item = valueStr; } } else { STString childStr = interTagStr; int childPos = -1; STString childTag = getFirstTagName(childStr, childPos); while (!childTag.empty()) { STString realChildStr = getTagStr(childStr, childTag, true); STDataItem child = stringToItem(getTagStr(childStr, childTag, true)); if ( child.isValid() ) { item.addChild(child); } childStr = childStr.substr(childPos+realChildStr.size() , childStr.size()-childPos-realChildStr.size()); childTag = getFirstTagName(childStr, childPos); } } return item; }
bool GNEDetectorE2::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return isValidDetectorID(value); case SUMO_ATTR_LANE: if (value.empty()) { return false; } else { return canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false); } case SUMO_ATTR_LANES: if (value.empty()) { return false; } else if (canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false)) { // check if lanes are consecutives return lanesConsecutives(parse<std::vector<GNELane*> >(myViewNet->getNet(), value)); } else { return false; } case SUMO_ATTR_POSITION: return canParse<double>(value); case SUMO_ATTR_ENDPOS: return canParse<double>(value); case SUMO_ATTR_FREQUENCY: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_LENGTH: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_NAME: return SUMOXMLDefinitions::isValidAttribute(value); case SUMO_ATTR_FILE: return SUMOXMLDefinitions::isValidFilename(value); case SUMO_ATTR_VTYPES: if (value.empty()) { return true; } else { return SUMOXMLDefinitions::isValidListOfTypeID(value); } case SUMO_ATTR_HALTING_TIME_THRESHOLD: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_HALTING_SPEED_THRESHOLD: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_JAM_DIST_THRESHOLD: 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) + "'"); } }
bool GNEPOI::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return SUMOXMLDefinitions::isValidNetID(value) && (myNet->retrievePOI(value, false) == nullptr); case SUMO_ATTR_COLOR: return canParse<RGBColor>(value); case SUMO_ATTR_LANE: return (myNet->retrieveLane(value, false) != nullptr); case SUMO_ATTR_POSITION: if (getLaneParents().size() > 0) { return canParse<double>(value); } else { return canParse<Position>(value); } case SUMO_ATTR_POSITION_LAT: return canParse<double>(value); case SUMO_ATTR_GEOPOSITION: { return canParse<Position>(value); } case SUMO_ATTR_GEO: return canParse<bool>(value); case SUMO_ATTR_TYPE: return true; case SUMO_ATTR_LAYER: if (value == "default") { return true; } else { return canParse<double>(value); } case SUMO_ATTR_IMGFILE: if (value == "") { return true; } else { // check that image can be loaded return GUITexturesHelper::getTextureID(value) != -1; } case SUMO_ATTR_RELATIVEPATH: return canParse<bool>(value); case SUMO_ATTR_WIDTH: return canParse<double>(value) && (parse<double>(value) >= 0); case SUMO_ATTR_HEIGHT: return canParse<double>(value) && (parse<double>(value) >= 0); case SUMO_ATTR_ANGLE: return canParse<double>(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 GNEPOI::commitGeometryMoving(const Position& oldPos, GNEUndoList* undoList) { if (!myBlockMovement) { // restore original Position before moving (to avoid problems in GL Tree) Position myNewPosition(*this); set(oldPos); // commit new position allowing undo/redo if (getLaneParents().size() > 0) { // restore old position before commit new position double originalPosOverLane = getLaneParents().at(0)->getGeometry().shape.nearest_offset_to_point2D(oldPos, false); undoList->p_begin("position of " + getTagStr()); undoList->p_add(new GNEChange_Attribute(this, myNet, SUMO_ATTR_POSITION, toString(myPosOverLane), true, toString(originalPosOverLane))); undoList->p_end(); } else { undoList->p_begin("position of " + getTagStr()); undoList->p_add(new GNEChange_Attribute(this, myNet, SUMO_ATTR_POSITION, toString(myNewPosition), true, toString(oldPos))); undoList->p_end(); } } }
void GNEConnection::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) { switch (key) { case SUMO_ATTR_FROM: case SUMO_ATTR_TO: case SUMO_ATTR_FROM_LANE: case SUMO_ATTR_TO_LANE: case SUMO_ATTR_PASS: case SUMO_ATTR_KEEP_CLEAR: case SUMO_ATTR_CONTPOS: case SUMO_ATTR_UNCONTROLLED: case SUMO_ATTR_VISIBILITY_DISTANCE: case SUMO_ATTR_SPEED: case SUMO_ATTR_CUSTOMSHAPE: case GNE_ATTR_SELECTED: case GNE_ATTR_GENERIC: // no special handling undoList->p_add(new GNEChange_Attribute(this, myNet, key, value)); break; case SUMO_ATTR_TLLINKINDEX: if (value != getAttribute(key)) { // trigger GNEChange_TLS undoList->p_begin("change tls linkIndex for connection"); // make a copy std::set<NBTrafficLightDefinition*> defs = getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS(); for (NBTrafficLightDefinition* tlDef : defs) { NBLoadedSUMOTLDef* sumoDef = dynamic_cast<NBLoadedSUMOTLDef*>(tlDef); NBTrafficLightLogic* tllogic = sumoDef ? sumoDef->getLogic() : tlDef->compute(OptionsCont::getOptions()); if (tllogic != nullptr) { NBLoadedSUMOTLDef* newDef = new NBLoadedSUMOTLDef(tlDef, tllogic); newDef->addConnection(getEdgeFrom()->getNBEdge(), getEdgeTo()->getNBEdge(), getLaneFrom()->getIndex(), getLaneTo()->getIndex(), parse<int>(value), false); std::vector<NBNode*> nodes = tlDef->getNodes(); for (NBNode* node : nodes) { GNEJunction* junction = getNet()->retrieveJunction(node->getID()); undoList->add(new GNEChange_TLS(junction, tlDef, false), true); undoList->add(new GNEChange_TLS(junction, newDef, true), true); } } else { WRITE_ERROR("Could not set attribute '" + toString(key) + "' (tls is broken)"); } } undoList->p_end(); } break; case SUMO_ATTR_DIR: throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified"); case SUMO_ATTR_STATE: throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified"); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEDemandElement::changeDemandElementID(const std::string& newID) { if (myViewNet->getNet()->retrieveDemandElement(myTagProperty.getTag(), newID, false) != nullptr) { throw InvalidArgument("An DemandElement with tag " + getTagStr() + " and ID = " + newID + " already exists"); } else { // Save old ID std::string oldID = getMicrosimID(); // set New ID setMicrosimID(newID); // update demand element ID in the container of net myViewNet->getNet()->updateDemandElementID(oldID, this); } }
std::string GNECalibratorFlow::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return getAdditionalID(); case SUMO_ATTR_TYPE: return myVehicleType->getID(); case SUMO_ATTR_ROUTE: return myRoute->getID(); case SUMO_ATTR_VEHSPERHOUR: return toString(myVehsPerHour); case SUMO_ATTR_SPEED: return toString(mySpeed); case SUMO_ATTR_COLOR: return toString(myColor); case SUMO_ATTR_BEGIN: return toString(myBegin); case SUMO_ATTR_END: return toString(myEnd); case SUMO_ATTR_DEPARTLANE: return myDepartLane; case SUMO_ATTR_DEPARTPOS: return myDepartPos; case SUMO_ATTR_DEPARTSPEED: return myDepartSpeed; case SUMO_ATTR_ARRIVALLANE: return myArrivalLane; case SUMO_ATTR_ARRIVALPOS: return myArrivalPos; case SUMO_ATTR_ARRIVALSPEED: return myArrivalSpeed; case SUMO_ATTR_LINE: return myLine; case SUMO_ATTR_PERSON_NUMBER: return toString(myPersonNumber); case SUMO_ATTR_CONTAINER_NUMBER: return toString(myContainerNumber); case SUMO_ATTR_REROUTE: return toString(myReroute); case SUMO_ATTR_DEPARTPOS_LAT: return myDepartPosLat; case SUMO_ATTR_ARRIVALPOS_LAT: return myArrivalPosLat; case GNE_ATTR_PARENT: return getAdditionalParents().at(0)->getID(); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEConnection::setAttribute(SumoXMLAttr key, const std::string& value) { NBEdge::Connection& nbCon = getNBEdgeConnection(); switch (key) { case SUMO_ATTR_PASS: nbCon.mayDefinitelyPass = parse<bool>(value); break; case SUMO_ATTR_KEEP_CLEAR: nbCon.keepClear = parse<bool>(value); break; case SUMO_ATTR_UNCONTROLLED: nbCon.uncontrolled = parse<bool>(value); break; case SUMO_ATTR_CONTPOS: nbCon.contPos = parse<double>(value); break; case SUMO_ATTR_VISIBILITY_DISTANCE: nbCon.visibility = parse<double>(value); break; case SUMO_ATTR_SPEED: nbCon.speed = parse<double>(value); break; case SUMO_ATTR_STATE: throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified"); case SUMO_ATTR_DIR: throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified"); case SUMO_ATTR_CUSTOMSHAPE: { nbCon.customShape = parse<PositionVector>(value); break; } case GNE_ATTR_SELECTED: if (parse<bool>(value)) { selectAttributeCarrier(); } else { unselectAttributeCarrier(); } break; case GNE_ATTR_GENERIC: setGenericParametersStr(value); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } // Update Geometry after setting a new attribute (but avoided for certain attributes) if ((key != SUMO_ATTR_ID) && (key != GNE_ATTR_GENERIC) && (key != GNE_ATTR_SELECTED)) { const bool init = (myShape.size() == 0); markConnectionGeometryDeprecated(); updateGeometry(!init); } }
bool GNECrossing::isValid(SumoXMLAttr key, const std::string& value) { auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges); switch (key) { case SUMO_ATTR_ID: return false; case SUMO_ATTR_EDGES: if (canParse<std::vector<GNEEdge*> >(myNet, value, false)) { // parse edges and save their IDs in a set std::vector<GNEEdge*> parsedEdges = parse<std::vector<GNEEdge*> >(myNet, value); EdgeVector nbEdges; for (auto i : parsedEdges) { nbEdges.push_back(i->getNBEdge()); } std::sort(nbEdges.begin(), nbEdges.end()); // EdgeVector originalEdges = crossing->edges; std::sort(originalEdges.begin(), originalEdges.end()); // return true if we're setting the same edges if (toString(nbEdges) == toString(originalEdges)) { return true; } else { return !myParentJunction->getNBNode()->checkCrossingDuplicated(nbEdges); } } else { return false; } case SUMO_ATTR_WIDTH: return canParse<double>(value) && ((parse<double>(value) > 0) || (parse<double>(value) == -1)); // kann NICHT 0 sein, oder -1 (bedeutet default) case SUMO_ATTR_PRIORITY: return canParse<bool>(value); case SUMO_ATTR_TLLINKINDEX: case SUMO_ATTR_TLLINKINDEX2: return (crossing->tlID != "" && canParse<int>(value) // -1 means that tlLinkIndex2 takes on the same value as tlLinkIndex when setting idnices && ((parse<double>(value) >= 0) || ((parse<double>(value) == -1) && (key == SUMO_ATTR_TLLINKINDEX2))) && myParentJunction->getNBNode()->getControllingTLS().size() > 0 && (*myParentJunction->getNBNode()->getControllingTLS().begin())->getMaxValidIndex() >= parse<int>(value)); case SUMO_ATTR_CUSTOMSHAPE: { // empty shapes are allowed return canParse<PositionVector>(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 GNEStop::commitGeometryMoving(GNEUndoList* undoList) { // only commit geometry moving if at leats start or end positions is defined if ((getLaneParents().size() > 0) && ((parametersSet & STOP_START_SET) || (parametersSet & STOP_END_SET))) { undoList->p_begin("position of " + getTagStr()); if (parametersSet & STOP_START_SET) { undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_STARTPOS, toString(startPos), true, myMove.firstOriginalLanePosition)); } if (parametersSet & STOP_END_SET) { undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_ENDPOS, toString(endPos), true, myMove.secondOriginalPosition)); } undoList->p_end(); } }
GUIGLObjectPopupMenu* GNEDemandElement::getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent) { GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this); // build header buildPopupHeader(ret, app); // build menu command for center button and copy cursor position to clipboard buildCenterPopupEntry(ret); buildPositionCopyEntry(ret, false); // buld menu commands for names new FXMenuCommand(ret, ("Copy " + getTagStr() + " name to clipboard").c_str(), nullptr, ret, MID_COPY_NAME); new FXMenuCommand(ret, ("Copy " + getTagStr() + " typed name to clipboard").c_str(), nullptr, ret, MID_COPY_TYPED_NAME); new FXMenuSeparator(ret); // build selection and show parameters menu myViewNet->buildSelectionACPopupEntry(ret, this); buildShowParamsPopupEntry(ret); // show option to open demand element dialog if (myTagProperty.hasDialog()) { new FXMenuCommand(ret, ("Open " + getTagStr() + " Dialog").c_str(), getIcon(), &parent, MID_OPEN_ADDITIONAL_DIALOG); new FXMenuSeparator(ret); } new FXMenuCommand(ret, ("Cursor position in view: " + toString(getPositionInView().x()) + "," + toString(getPositionInView().y())).c_str(), nullptr, nullptr, 0); return ret; }
std::string GNEPOI::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return myID; case SUMO_ATTR_COLOR: return toString(getShapeColor()); case SUMO_ATTR_LANE: return myLane; case SUMO_ATTR_POSITION: if (getLaneParents().size() > 0) { return toString(myPosOverLane); } else { return toString(*this); } case SUMO_ATTR_POSITION_LAT: return toString(myPosLat); case SUMO_ATTR_GEOPOSITION: return toString(myGEOPosition, gPrecisionGeo); case SUMO_ATTR_GEO: return toString(myGeo); case SUMO_ATTR_TYPE: return getShapeType(); case SUMO_ATTR_LAYER: if (getShapeLayer() == Shape::DEFAULT_LAYER_POI) { return "default"; } else { return toString(getShapeLayer()); } case SUMO_ATTR_IMGFILE: return getShapeImgFile(); case SUMO_ATTR_RELATIVEPATH: return toString(getShapeRelativePath()); case SUMO_ATTR_WIDTH: return toString(getWidth()); case SUMO_ATTR_HEIGHT: return toString(getHeight()); case SUMO_ATTR_ANGLE: return toString(getShapeNaviDegree()); case GNE_ATTR_BLOCK_MOVEMENT: return toString(myBlockMovement); case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " attribute '" + toString(key) + "' not allowed"); } }
bool GNERouteProbReroute::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return isValidAdditionalID(value); case SUMO_ATTR_ROUTE: return SUMOXMLDefinitions::isValidVehicleID(value); case SUMO_ATTR_PROB: return canParse<double>(value); case GNE_ATTR_GENERIC: return isGenericParametersValid(value); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNEDetectorE1::setAttribute(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: changeAdditionalID(value); break; case SUMO_ATTR_LANE: changeLaneParents(this, value); break; case SUMO_ATTR_POSITION: myPositionOverLane = parse<double>(value); break; case SUMO_ATTR_FREQUENCY: myFreq = parse<double>(value); break; case SUMO_ATTR_FILE: myFilename = value; break; case SUMO_ATTR_NAME: myAdditionalName = value; break; case SUMO_ATTR_VTYPES: myVehicleTypes = value; break; case SUMO_ATTR_FRIENDLY_POS: myFriendlyPosition = parse<bool>(value); break; case GNE_ATTR_BLOCK_MOVEMENT: myBlockMovement = parse<bool>(value); break; case GNE_ATTR_SELECTED: if (parse<bool>(value)) { selectAttributeCarrier(); } else { unselectAttributeCarrier(); } break; case GNE_ATTR_GENERIC: setGenericParametersStr(value); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } // check if updated attribute requieres update geometry if (myTagProperty.hasAttribute(key) && myTagProperty.getAttributeProperties(key).requiereUpdateGeometry()) { updateGeometry(); } }
bool GNEClosingLaneReroute::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return isValidAdditionalID(value); case SUMO_ATTR_LANE: return (myViewNet->getNet()->retrieveLane(value, false) != nullptr); case SUMO_ATTR_ALLOW: case SUMO_ATTR_DISALLOW: return canParseVehicleClasses(value); case GNE_ATTR_GENERIC: return isGenericParametersValid(value); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void GNERouteProbReroute::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) { if (value == getAttribute(key)) { return; //avoid needless changes, later logic relies on the fact that attributes have changed } switch (key) { case SUMO_ATTR_ID: case SUMO_ATTR_ROUTE: case SUMO_ATTR_PROB: case GNE_ATTR_GENERIC: undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value)); break; default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
bool GNEConnection::isValid(SumoXMLAttr key, const std::string& value) { // Currently ignored before implementation to avoid warnings switch (key) { case SUMO_ATTR_FROM: case SUMO_ATTR_TO: case SUMO_ATTR_FROM_LANE: case SUMO_ATTR_TO_LANE: return false; case SUMO_ATTR_PASS: return canParse<bool>(value); case SUMO_ATTR_KEEP_CLEAR: return canParse<bool>(value); case SUMO_ATTR_CONTPOS: return canParse<double>(value); case SUMO_ATTR_UNCONTROLLED: return canParse<bool>(value); case SUMO_ATTR_VISIBILITY_DISTANCE: return canParse<double>(value) && (parse<double>(value) > 0); case SUMO_ATTR_TLLINKINDEX: if (getNBEdgeConnection().uncontrolled == false && getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().size() > 0 && canParse<int>(value) && parse<int>(value) >= 0) { NBTrafficLightDefinition* def = *getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().begin(); return def->getMaxValidIndex() >= parse<int>(value); } else { return false; } case SUMO_ATTR_SPEED: return canParse<double>(value) && (parse<double>(value) > 0); case SUMO_ATTR_CUSTOMSHAPE: { // empty custom shapes are allowed return canParse<PositionVector>(value); } case SUMO_ATTR_STATE: return false; case SUMO_ATTR_DIR: return false; 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) + "'"); } }
std::string GNEConnection::getAttribute(SumoXMLAttr key) const { if (key == SUMO_ATTR_ID) { // used by GNEReferenceCounter // @note: may be called for connections without a valid nbCon reference return getMicrosimID(); } NBEdge::Connection& nbCon = getNBEdgeConnection(); switch (key) { case SUMO_ATTR_FROM: return getEdgeFrom()->getID(); case SUMO_ATTR_TO: return nbCon.toEdge->getID(); case SUMO_ATTR_FROM_LANE: return toString(nbCon.toLane); case SUMO_ATTR_TO_LANE: return toString(nbCon.toLane); case SUMO_ATTR_PASS: return toString(nbCon.mayDefinitelyPass); case SUMO_ATTR_KEEP_CLEAR: return toString(nbCon.keepClear); case SUMO_ATTR_CONTPOS: return toString(nbCon.contPos); case SUMO_ATTR_UNCONTROLLED: return toString(nbCon.uncontrolled); case SUMO_ATTR_VISIBILITY_DISTANCE: return toString(nbCon.visibility); case SUMO_ATTR_TLLINKINDEX: return toString(nbCon.tlLinkIndex); case SUMO_ATTR_SPEED: return toString(nbCon.speed); case SUMO_ATTR_DIR: return toString(getEdgeFrom()->getNBEdge()->getToNode()->getDirection( getEdgeFrom()->getNBEdge(), nbCon.toEdge, OptionsCont::getOptions().getBool("lefthand"))); case SUMO_ATTR_STATE: return toString(getEdgeFrom()->getNBEdge()->getToNode()->getLinkState( getEdgeFrom()->getNBEdge(), nbCon.toEdge, nbCon.fromLane, nbCon.toLane, nbCon.mayDefinitelyPass, nbCon.tlID)); case SUMO_ATTR_CUSTOMSHAPE: return toString(nbCon.customShape); case GNE_ATTR_SELECTED: return toString(isAttributeCarrierSelected()); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
std::string GNERouteProbReroute::getAttribute(SumoXMLAttr key) const { switch (key) { case SUMO_ATTR_ID: return getAdditionalID(); case SUMO_ATTR_ROUTE: return myNewRouteId; case SUMO_ATTR_PROB: return toString(myProbability); case GNE_ATTR_PARENT: return getAdditionalParents().at(0)->getID(); case GNE_ATTR_GENERIC: return getGenericParametersStr(); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
bool GNECalibrator::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return isValidAdditionalID(value); case SUMO_ATTR_EDGE: if (myViewNet->getNet()->retrieveEdge(value, false) != nullptr) { return true; } else { return false; } case SUMO_ATTR_LANE: if (myViewNet->getNet()->retrieveLane(value, false) != nullptr) { return true; } else { return false; } case SUMO_ATTR_POSITION: if (canParse<double>(value)) { // obtain position and check if is valid double newPosition = parse<double>(value); PositionVector shape = (getLaneParents().size() > 0) ? getLaneParents().front()->getGeometry().shape : getEdgeParents().front()->getLanes().at(0)->getGeometry().shape; if ((newPosition < 0) || (newPosition > shape.length())) { return false; } else { return true; } } else { return false; } case SUMO_ATTR_FREQUENCY: return (canParse<double>(value) && parse<double>(value) >= 0); case SUMO_ATTR_NAME: return SUMOXMLDefinitions::isValidAttribute(value); case SUMO_ATTR_OUTPUT: return SUMOXMLDefinitions::isValidFilename(value); case SUMO_ATTR_ROUTEPROBE: return SUMOXMLDefinitions::isValidNetID(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) + "'"); } }