diff --git a/src/netedit/GNEPathManager.cpp b/src/netedit/GNEPathManager.cpp
index 167833db5131..46672fbd72e3 100644
--- a/src/netedit/GNEPathManager.cpp
+++ b/src/netedit/GNEPathManager.cpp
@@ -553,7 +553,7 @@ GNEPathManager::PathDraw::clearPathDraw() {
 bool
 GNEPathManager::PathDraw::checkDrawPathGeometry(const GUIVisualizationSettings& s, const GNELane* lane, SumoXMLTag tag) {
     // check conditions
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         return true;
     } else if (myLaneDrawedElements.count(lane) > 0) {
         // check tag
@@ -578,7 +578,7 @@ GNEPathManager::PathDraw::checkDrawPathGeometry(const GUIVisualizationSettings&
 bool
 GNEPathManager::PathDraw::checkDrawPathGeometry(const GUIVisualizationSettings& s, const Segment* segment, SumoXMLTag tag) {
     // check conditions
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         return true;
     } else {
         // declare lane2lane
diff --git a/src/netedit/GNEViewNet.cpp b/src/netedit/GNEViewNet.cpp
index 75592c3d5d0d..83e50d825241 100644
--- a/src/netedit/GNEViewNet.cpp
+++ b/src/netedit/GNEViewNet.cpp
@@ -247,7 +247,7 @@ GNEViewNet::GNEViewNet(FXComposite* tmpParent, FXComposite* actualParent, GUIMai
     GUISUMOAbstractView(tmpParent, app, viewParent, net->getGrid(), glVis, share),
     myEditModes(this),
     myTestingMode(this),
-    myObjectsUnderCursor(this),
+    myViewObjectsSelector(this),
     myCommonCheckableButtons(this),
     myNetworkCheckableButtons(this),
     myDemandCheckableButtons(this),
@@ -329,8 +329,8 @@ GNEViewNet::doInit() {}
 
 GUIGlID
 GNEViewNet::getToolTipID() {
-    if (myObjectsUnderCursor.getGUIGlObjectFront()) {
-        return myObjectsUnderCursor.getGUIGlObjectFront()->getGlID();
+    if (myViewObjectsSelector.getGUIGlObjectFront()) {
+        return myViewObjectsSelector.getGUIGlObjectFront()->getGlID();
     } else {
         return 0;
     }
@@ -464,9 +464,9 @@ GNEViewNet::viewUpdated() {
 }
 
 
-const GNEViewNetHelper::ObjectsUnderCursor&
+const GNEViewNetHelper::ViewObjectsSelector&
 GNEViewNet::getObjectsUnderCursor() const {
-    return myObjectsUnderCursor;
+    return myViewObjectsSelector;
 }
 
 
@@ -479,11 +479,11 @@ GNEViewNet::updateObjectsInBoundary(const Boundary &boundary) {
     // push matrix
     GLHelper::pushMatrix();
     // enable draw for object under cursor
-    myVisualizationSettings->drawForObjectUnderCursor = true;
+    myVisualizationSettings->drawForViewObjectsHandler = true;
     // draw all GL elements within the small boundary
     drawGLElements(boundary);
     // restore draw for object under cursor
-    myVisualizationSettings->drawForObjectUnderCursor = false;
+    myVisualizationSettings->drawForViewObjectsHandler = false;
     // pop matrix
     GLHelper::popMatrix();
     // check if update front element
@@ -491,7 +491,7 @@ GNEViewNet::updateObjectsInBoundary(const Boundary &boundary) {
         gViewObjectsHandler.updateFrontElement(myFrontAttributeCarrier->getGUIGlObject());
     }
     // after draw elements, update objects under cursor
-    myObjectsUnderCursor.updateObjectUnderCursor();
+    myViewObjectsSelector.updateObjects();
 }
 
 
@@ -508,11 +508,11 @@ GNEViewNet::updateObjectsInPosition(const Position &pos) {
     // push matrix
     GLHelper::pushMatrix();
     // enable draw for object under cursor
-    myVisualizationSettings->drawForObjectUnderCursor = true;
+    myVisualizationSettings->drawForViewObjectsHandler = true;
     // draw all GL elements within the small boundary
     drawGLElements(positionBoundary);
     // restore draw for object under cursor
-    myVisualizationSettings->drawForObjectUnderCursor = false;
+    myVisualizationSettings->drawForViewObjectsHandler = false;
     // pop matrix
     GLHelper::popMatrix();
     // check if update front element
@@ -520,7 +520,7 @@ GNEViewNet::updateObjectsInPosition(const Position &pos) {
         gViewObjectsHandler.updateFrontElement(myFrontAttributeCarrier->getGUIGlObject());
     }
     // after draw elements, update objects under cursor
-    myObjectsUnderCursor.updateObjectUnderCursor();
+    myViewObjectsSelector.updateObjects();
 }
 
 
@@ -568,10 +568,10 @@ GNEViewNet::openObjectDialogAtCursor(const FXEvent* /*ev*/) {
             // set clicked popup position
             myClickedPopupPosition = getPositionInformation();
             // create cursor popup dialog for mark front element
-            myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::FRONT_ELEMENT, this, myObjectsUnderCursor.getClickedGLObjects());
+            myPopup = new GUICursorDialog(GUIGLObjectPopupMenu::PopupType::FRONT_ELEMENT, this, myViewObjectsSelector.getGLObjects());
             // open popup dialog
             openPopupDialog();
-        } else if (myObjectsUnderCursor.getClickedGLObjects().empty()) {
+        } else if (myViewObjectsSelector.getGLObjects().empty()) {
             openObjectDialog({myNet});
         } else {
             // declare filtered objects
@@ -588,7 +588,7 @@ GNEViewNet::openObjectDialogAtCursor(const FXEvent* /*ev*/) {
             bool connections = false;
             bool TLS = false;
             // fill filtered objects
-            for (const auto& glObject : myObjectsUnderCursor.getClickedGLObjects()) {
+            for (const auto& glObject : myViewObjectsSelector.getGLObjects()) {
                 // always avoid edges
                 if (glObject->getType() == GLO_EDGE) {
                     continue;
@@ -1219,7 +1219,7 @@ GNEViewNet::removeRestrictedLane(GNELane* lane, SUMOVehicleClass vclass) {
 GNEViewNet::GNEViewNet() :
     myEditModes(this),
     myTestingMode(this),
-    myObjectsUnderCursor(this),
+    myViewObjectsSelector(this),
     myCommonCheckableButtons(this),
     myNetworkCheckableButtons(this),
     myDemandCheckableButtons(this),
@@ -1945,13 +1945,13 @@ GNEViewNet::checkOverLockedElement(const GUIGlObject* GLObject, const bool isSel
         return false;
     }
     // get front GLObject
-    const auto glObjectFront = myObjectsUnderCursor.getGUIGlObjectFront();
+    const auto glObjectFront = myViewObjectsSelector.getGUIGlObjectFront();
     // check if element is under cursor
     if (glObjectFront) {
         if (glObjectFront == GLObject) {
             return true;
         } else if (glObjectFront->getType() == GLObject->getType()) {
-            for (const auto &glObjectUnderCursor : myObjectsUnderCursor.getClickedGLObjects()) {
+            for (const auto &glObjectUnderCursor : myViewObjectsSelector.getGLObjects()) {
                 if (glObjectUnderCursor == GLObject){
                     return true;
                 }
@@ -2728,7 +2728,7 @@ GNEViewNet::onCmdSelectPolygonElements(FXObject*, FXSelector, void*) {
         // declare filtered ACs
         std::vector<GNEAttributeCarrier*> filteredACs;
         // iterate over obtained GUIGlIDs
-        for (const auto& AC : myObjectsUnderCursor.getClickedAttributeCarriers()) {
+        for (const auto& AC : myViewObjectsSelector.getAttributeCarriers()) {
             if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
                 if (myNetworkViewOptions.selectEdges() && myNet->getAttributeCarriers()->isNetworkElementAroundShape(AC, polygonUnderMouse->getShape())) {
                     filteredACs.push_back(AC);
@@ -5504,18 +5504,18 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_INSPECT: {
             // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
             if (myNetworkViewOptions.selectEdges() && (myMouseButtonKeyPressed.shiftKeyPressed() == false)) {
-                myObjectsUnderCursor.filterLanes();
+                myViewObjectsSelector.filterLanes();
             } else {
-                myObjectsUnderCursor.filterEdges();
+                myViewObjectsSelector.filterEdges();
             }
             // now filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // check if we're selecting a new parent for the current inspected element
             if (myViewParent->getInspectorFrame()->getNeteditAttributesEditor()->isSelectingParent()) {
-                myViewParent->getInspectorFrame()->getNeteditAttributesEditor()->setNewParent(myObjectsUnderCursor.getAttributeCarrierFront());
+                myViewParent->getInspectorFrame()->getNeteditAttributesEditor()->setNewParent(myViewObjectsSelector.getAttributeCarrierFront());
             } else {
                 // process left click in Inspector Frame
-                myViewParent->getInspectorFrame()->processNetworkSupermodeClick(getPositionInformation(), myObjectsUnderCursor);
+                myViewParent->getInspectorFrame()->processNetworkSupermodeClick(getPositionInformation(), myViewObjectsSelector);
             }
             // process click
             processClick(eventData);
@@ -5524,26 +5524,26 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_DELETE: {
             // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
             if (myNetworkViewOptions.selectEdges() && (myMouseButtonKeyPressed.shiftKeyPressed() == false)) {
-                myObjectsUnderCursor.filterLanes();
+                myViewObjectsSelector.filterLanes();
             } else {
-                myObjectsUnderCursor.filterEdges();
+                myViewObjectsSelector.filterEdges();
             }
             // now filter locked elements forcing excluding walkingAreas
-            myObjectsUnderCursor.filterLockedElements({GLO_WALKINGAREA});
+            myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
             // continue depending of AC
-            if (myObjectsUnderCursor.getAttributeCarrierFront()) {
+            if (myViewObjectsSelector.getAttributeCarrierFront()) {
                 // now check if we want only delete geometry points
                 if (myViewParent->getDeleteFrame()->getDeleteOptions()->deleteOnlyGeometryPoints()) {
                     // only remove geometry point
-                    myViewParent->getDeleteFrame()->removeGeometryPoint(myObjectsUnderCursor);
-                } else if (myObjectsUnderCursor.getAttributeCarrierFront()->isAttributeCarrierSelected()) {
+                    myViewParent->getDeleteFrame()->removeGeometryPoint(myViewObjectsSelector);
+                } else if (myViewObjectsSelector.getAttributeCarrierFront()->isAttributeCarrierSelected()) {
                     // remove all selected attribute carriers
-                    if (!myObjectsUnderCursor.getAttributeCarrierFront()->getGUIGlObject()->isGLObjectLocked()) {
+                    if (!myViewObjectsSelector.getAttributeCarrierFront()->getGUIGlObject()->isGLObjectLocked()) {
                         myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
                     }
                 } else {
                     // remove attribute carrier under cursor
-                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myObjectsUnderCursor);
+                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
                 }
             } else {
                 // process click
@@ -5554,19 +5554,19 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_SELECT:
             // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
             if (myNetworkViewOptions.selectEdges() && (myMouseButtonKeyPressed.shiftKeyPressed() == false)) {
-                myObjectsUnderCursor.filterLanes();
+                myViewObjectsSelector.filterLanes();
             } else {
-                myObjectsUnderCursor.filterEdges();
+                myViewObjectsSelector.filterEdges();
             }
             // now filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // avoid to select if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
                 // check if a rect for selecting is being created
                 if (myMouseButtonKeyPressed.shiftKeyPressed()) {
                     // begin rectangle selection
                     mySelectingArea.beginRectangleSelection();
-                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myObjectsUnderCursor)) {
+                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
                     // process click
                     processClick(eventData);
                 }
@@ -5579,7 +5579,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
             // check what buttons are pressed
             if (myMouseButtonKeyPressed.shiftKeyPressed()) {
                 // get edge under cursor
-                GNEEdge* edge = myObjectsUnderCursor.getEdgeFront();
+                GNEEdge* edge = myViewObjectsSelector.getEdgeFront();
                 if (edge) {
                     // obtain reverse edge
                     const auto oppositeEdges = edge->getOppositeEdges();
@@ -5601,7 +5601,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
                 }
                 // process left click in create edge frame Frame
                 myViewParent->getCreateEdgeFrame()->processClick(getPositionInformation(),
-                        myObjectsUnderCursor,
+                        myViewObjectsSelector,
                         (myNetworkViewOptions.menuCheckAutoOppositeEdge->amChecked() == TRUE),
                         (myNetworkViewOptions.menuCheckChainEdges->amChecked() == TRUE));
             }
@@ -5612,19 +5612,19 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_MOVE: {
             // first swap lane to edges if mySelectEdges is enabled and shift key isn't pressed
             if (myNetworkViewOptions.selectEdges() && (myMouseButtonKeyPressed.shiftKeyPressed() == false)) {
-                myObjectsUnderCursor.filterLanes();
+                myViewObjectsSelector.filterLanes();
             } else {
-                myObjectsUnderCursor.filterEdges();
+                myViewObjectsSelector.filterEdges();
             }
             // filter locked elements
-            myObjectsUnderCursor.filterLockedElements({GLO_WALKINGAREA});
+            myViewObjectsSelector.filterLockedElements({GLO_WALKINGAREA});
             // check if we're editing a shape
             if (myEditNetworkElementShapes.getEditedNetworkElement()) {
                 // check if we're removing a geometry point
                 if (myMouseButtonKeyPressed.shiftKeyPressed()) {
                     // remove geometry point
-                    if (myObjectsUnderCursor.getNetworkElementFront() == myEditNetworkElementShapes.getEditedNetworkElement()) {
-                        myObjectsUnderCursor.getNetworkElementFront()->removeGeometryPoint(getPositionInformation(), myUndoList);
+                    if (myViewObjectsSelector.getNetworkElementFront() == myEditNetworkElementShapes.getEditedNetworkElement()) {
+                        myViewObjectsSelector.getNetworkElementFront()->removeGeometryPoint(getPositionInformation(), myUndoList);
                     }
                 } else if (!myMoveSingleElementValues.beginMoveNetworkElementShape()) {
                     // process click  if there isn't movable elements (to move camera using drag an drop)
@@ -5632,7 +5632,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
                 }
             } else {
                 // get AC under cursor
-                auto AC = myObjectsUnderCursor.getAttributeCarrierFront();
+                auto AC = myViewObjectsSelector.getAttributeCarrierFront();
                 // check that AC is an network or additional element
                 if (AC && (AC->getTagProperty().isNetworkElement() || AC->getTagProperty().isAdditionalElement())) {
                     // check if we're moving a set of selected items
@@ -5654,9 +5654,9 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         }
         case NetworkEditMode::NETWORK_CONNECT: {
             // check if we're clicked over a non locked lane
-            if (myObjectsUnderCursor.getLaneFrontNonLocked()) {
+            if (myViewObjectsSelector.getLaneFrontNonLocked()) {
                 // Handle laneclick (shift key may pass connections, Control key allow conflicts)
-                myViewParent->getConnectorFrame()->handleLaneClick(myObjectsUnderCursor);
+                myViewParent->getConnectorFrame()->handleLaneClick(myViewObjectsSelector);
                 updateViewNet();
             }
             // process click
@@ -5664,9 +5664,9 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
             break;
         }
         case NetworkEditMode::NETWORK_TLS: {
-            if (myObjectsUnderCursor.getJunctionFront() || myObjectsUnderCursor.getAdditionalFront()) {
+            if (myViewObjectsSelector.getJunctionFront() || myViewObjectsSelector.getAdditionalFront()) {
                 // edit TLS in TLSEditor frame
-                myViewParent->getTLSEditorFrame()->editTLS(getPositionInformation(), myObjectsUnderCursor);
+                myViewParent->getTLSEditorFrame()->editTLS(getPositionInformation(), myViewObjectsSelector);
                 updateViewNet();
             }
             // process click
@@ -5678,7 +5678,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
                 if ((getPositionInformation() == myLastClickedPosition) && !myMouseButtonKeyPressed.shiftKeyPressed()) {
                     WRITE_WARNING(TL("Shift + click to create two additionals in the same position"));
-                } else if (myViewParent->getAdditionalFrame()->addAdditional(myObjectsUnderCursor)) {
+                } else if (myViewParent->getAdditionalFrame()->addAdditional(myViewObjectsSelector)) {
                     // save last mouse position
                     myLastClickedPosition = getPositionInformation();
                     // update view to show the new additional
@@ -5691,7 +5691,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         }
         case NetworkEditMode::NETWORK_CROSSING: {
             // call function addCrossing from crossing frame
-            myViewParent->getCrossingFrame()->addCrossing(myObjectsUnderCursor);
+            myViewParent->getCrossingFrame()->addCrossing(myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
@@ -5705,7 +5705,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
                     mySelectingArea.beginRectangleSelection();
                 } else {
                     // check if process click was successfully
-                    if (myViewParent->getTAZFrame()->processClick(snapToActiveGrid(getPositionInformation()), myObjectsUnderCursor)) {
+                    if (myViewParent->getTAZFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector)) {
                         // view net must be always update
                         updateViewNet();
                     }
@@ -5721,11 +5721,11 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_SHAPE: {
             // avoid create shapes if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
-                if (!myObjectsUnderCursor.getPOIFront()) {
+                if (!myViewObjectsSelector.getPOIFront()) {
                     // declare processClick flag
                     bool updateTemporalShape = false;
                     // process click
-                    myViewParent->getShapeFrame()->processClick(snapToActiveGrid(getPositionInformation()), myObjectsUnderCursor, updateTemporalShape);
+                    myViewParent->getShapeFrame()->processClick(snapToActiveGrid(getPositionInformation()), myViewObjectsSelector, updateTemporalShape);
                     // view net must be always update
                     updateViewNet();
                     // process click depending of the result of "process click"
@@ -5741,9 +5741,9 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
             break;
         }
         case NetworkEditMode::NETWORK_PROHIBITION: {
-            if (myObjectsUnderCursor.getConnectionFront()) {
+            if (myViewObjectsSelector.getConnectionFront()) {
                 // shift key may pass connections, Control key allow conflicts.
-                myViewParent->getProhibitionFrame()->handleProhibitionClick(myObjectsUnderCursor);
+                myViewParent->getProhibitionFrame()->handleProhibitionClick(myViewObjectsSelector);
                 updateViewNet();
             }
             // process click
@@ -5753,7 +5753,7 @@ GNEViewNet::processLeftButtonPressNetwork(void* eventData) {
         case NetworkEditMode::NETWORK_WIRE: {
             // avoid create wires if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
-                myViewParent->getWireFrame()->addWire(myObjectsUnderCursor);
+                myViewParent->getWireFrame()->addWire(myViewObjectsSelector);
                 // update view to show the new wire
                 updateViewNet();
             }
@@ -5791,12 +5791,12 @@ GNEViewNet::processLeftButtonReleaseNetwork() {
             }
         } else if (myMouseButtonKeyPressed.shiftKeyPressed()) {
             // check if there is a lane in objects under cursor
-            if (myObjectsUnderCursor.getLaneFront()) {
+            if (myViewObjectsSelector.getLaneFront()) {
                 // if we clicked over an lane with shift key pressed, select or unselect it
-                if (myObjectsUnderCursor.getLaneFront()->isAttributeCarrierSelected()) {
-                    myObjectsUnderCursor.getLaneFront()->unselectAttributeCarrier();
+                if (myViewObjectsSelector.getLaneFront()->isAttributeCarrierSelected()) {
+                    myViewObjectsSelector.getLaneFront()->unselectAttributeCarrier();
                 } else {
-                    myObjectsUnderCursor.getLaneFront()->selectAttributeCarrier();
+                    myViewObjectsSelector.getLaneFront()->selectAttributeCarrier();
                 }
             }
         }
@@ -5834,14 +5834,14 @@ GNEViewNet::processMoveMouseNetwork(const bool mouseLeftButtonPressed) {
 void
 GNEViewNet::processLeftButtonPressDemand(void* eventData) {
     // get front AC
-    const auto AC = myObjectsUnderCursor.getAttributeCarrierFront();
+    const auto AC = myViewObjectsSelector.getAttributeCarrierFront();
     // decide what to do based on mode
     switch (myEditModes.demandEditMode) {
         case DemandEditMode::DEMAND_INSPECT: {
             // filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // process left click in Inspector Frame
-            myViewParent->getInspectorFrame()->processDemandSupermodeClick(getPositionInformation(), myObjectsUnderCursor);
+            myViewParent->getInspectorFrame()->processDemandSupermodeClick(getPositionInformation(), myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
@@ -5855,7 +5855,7 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
                         myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
                     }
                 } else {
-                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myObjectsUnderCursor);
+                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
                 }
             } else {
                 // process click
@@ -5865,14 +5865,14 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
         }
         case DemandEditMode::DEMAND_SELECT:
             // filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // avoid to select if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
                 // check if a rect for selecting is being created
                 if (myMouseButtonKeyPressed.shiftKeyPressed()) {
                     // begin rectangle selection
                     mySelectingArea.beginRectangleSelection();
-                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myObjectsUnderCursor)) {
+                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
                     // process click
                     processClick(eventData);
                 }
@@ -5903,9 +5903,9 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
         }
         case DemandEditMode::DEMAND_ROUTE: {
             // check if we clicked over a lane
-            if (myObjectsUnderCursor.getLaneFront()) {
+            if (myViewObjectsSelector.getLaneFront()) {
                 // Handle edge click
-                myViewParent->getRouteFrame()->addEdgeRoute(myObjectsUnderCursor.getLaneFront()->getParentEdge(), myMouseButtonKeyPressed);
+                myViewParent->getRouteFrame()->addEdgeRoute(myViewObjectsSelector.getLaneFront()->getParentEdge(), myMouseButtonKeyPressed);
             }
             // process click
             processClick(eventData);
@@ -5913,7 +5913,7 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
         }
         case DemandEditMode::DEMAND_VEHICLE: {
             // Handle click
-            myViewParent->getVehicleFrame()->addVehicle(myObjectsUnderCursor, myMouseButtonKeyPressed);
+            myViewParent->getVehicleFrame()->addVehicle(myViewObjectsSelector, myMouseButtonKeyPressed);
             // process click
             processClick(eventData);
             break;
@@ -5922,7 +5922,7 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
             // Handle click
             if ((getPositionInformation() == myLastClickedPosition) && !myMouseButtonKeyPressed.controlKeyPressed()) {
                 WRITE_WARNING(TL("Control + click to create two stop in the same position"));
-            } else if (myViewParent->getStopFrame()->addStop(myObjectsUnderCursor, myMouseButtonKeyPressed)) {
+            } else if (myViewParent->getStopFrame()->addStop(myViewObjectsSelector, myMouseButtonKeyPressed)) {
                 // save last mouse position
                 myLastClickedPosition = getPositionInformation();
                 // update view to show the new additional
@@ -5934,28 +5934,28 @@ GNEViewNet::processLeftButtonPressDemand(void* eventData) {
         }
         case DemandEditMode::DEMAND_PERSON: {
             // Handle click
-            myViewParent->getPersonFrame()->addPerson(myObjectsUnderCursor);
+            myViewParent->getPersonFrame()->addPerson(myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
         }
         case DemandEditMode::DEMAND_PERSONPLAN: {
             // Handle person plan click
-            myViewParent->getPersonPlanFrame()->addPersonPlanElement(myObjectsUnderCursor);
+            myViewParent->getPersonPlanFrame()->addPersonPlanElement(myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
         }
         case DemandEditMode::DEMAND_CONTAINER: {
             // Handle click
-            myViewParent->getContainerFrame()->addContainer(myObjectsUnderCursor);
+            myViewParent->getContainerFrame()->addContainer(myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
         }
         case DemandEditMode::DEMAND_CONTAINERPLAN: {
             // Handle container plan click
-            myViewParent->getContainerPlanFrame()->addContainerPlanElement(myObjectsUnderCursor);
+            myViewParent->getContainerPlanFrame()->addContainerPlanElement(myViewObjectsSelector);
             // process click
             processClick(eventData);
             break;
@@ -6002,17 +6002,17 @@ GNEViewNet::processMoveMouseDemand(const bool mouseLeftButtonPressed) {
 void
 GNEViewNet::processLeftButtonPressData(void* eventData) {
     // get AC
-    const auto AC = myObjectsUnderCursor.getAttributeCarrierFront();
+    const auto AC = myViewObjectsSelector.getAttributeCarrierFront();
     // decide what to do based on mode
     switch (myEditModes.dataEditMode) {
         case DataEditMode::DATA_INSPECT: {
             // filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // process left click in Inspector Frame
             if (AC && AC->getTagProperty().getTag() == SUMO_TAG_TAZ) {
                 myViewParent->getInspectorFrame()->inspectSingleElement(AC);
             } else {
-                myViewParent->getInspectorFrame()->processDataSupermodeClick(getPositionInformation(), myObjectsUnderCursor);
+                myViewParent->getInspectorFrame()->processDataSupermodeClick(getPositionInformation(), myViewObjectsSelector);
             }
             // process click
             processClick(eventData);
@@ -6027,7 +6027,7 @@ GNEViewNet::processLeftButtonPressData(void* eventData) {
                         myViewParent->getDeleteFrame()->removeSelectedAttributeCarriers();
                     }
                 } else {
-                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myObjectsUnderCursor);
+                    myViewParent->getDeleteFrame()->removeAttributeCarrier(myViewObjectsSelector);
                 }
             } else {
                 // process click
@@ -6037,14 +6037,14 @@ GNEViewNet::processLeftButtonPressData(void* eventData) {
         }
         case DataEditMode::DATA_SELECT:
             // filter locked elements
-            myObjectsUnderCursor.filterLockedElements();
+            myViewObjectsSelector.filterLockedElements();
             // avoid to select if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
                 // check if a rect for selecting is being created
                 if (myMouseButtonKeyPressed.shiftKeyPressed()) {
                     // begin rectangle selection
                     mySelectingArea.beginRectangleSelection();
-                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myObjectsUnderCursor)) {
+                } else if (!myViewParent->getSelectorFrame()->selectAttributeCarrier(myViewObjectsSelector)) {
                     // process click
                     processClick(eventData);
                 }
@@ -6056,7 +6056,7 @@ GNEViewNet::processLeftButtonPressData(void* eventData) {
         case DataEditMode::DATA_EDGEDATA:
             // avoid create edgeData if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
-                if (myViewParent->getEdgeDataFrame()->addEdgeData(myObjectsUnderCursor, myMouseButtonKeyPressed)) {
+                if (myViewParent->getEdgeDataFrame()->addEdgeData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
                     // update view to show the new edge data
                     updateViewNet();
                 }
@@ -6067,7 +6067,7 @@ GNEViewNet::processLeftButtonPressData(void* eventData) {
         case DataEditMode::DATA_EDGERELDATA:
             // avoid create edgeData if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
-                if (myViewParent->getEdgeRelDataFrame()->addEdgeRelationData(myObjectsUnderCursor, myMouseButtonKeyPressed)) {
+                if (myViewParent->getEdgeRelDataFrame()->addEdgeRelationData(myViewObjectsSelector, myMouseButtonKeyPressed)) {
                     // update view to show the new edge data
                     updateViewNet();
                 }
@@ -6078,7 +6078,7 @@ GNEViewNet::processLeftButtonPressData(void* eventData) {
         case DataEditMode::DATA_TAZRELDATA:
             // avoid create TAZData if control key is pressed
             if (!myMouseButtonKeyPressed.controlKeyPressed()) {
-                if (myViewParent->getTAZRelDataFrame()->setTAZ(myObjectsUnderCursor)) {
+                if (myViewParent->getTAZRelDataFrame()->setTAZ(myViewObjectsSelector)) {
                     // update view to show the new TAZ data
                     updateViewNet();
                 }
diff --git a/src/netedit/GNEViewNet.h b/src/netedit/GNEViewNet.h
index d84c991d7013..d4ff0ea1c278 100644
--- a/src/netedit/GNEViewNet.h
+++ b/src/netedit/GNEViewNet.h
@@ -81,7 +81,7 @@ class GNEViewNet : public GUISUMOAbstractView {
     void viewUpdated();
 
     /// @brief get objects under cursor
-    const GNEViewNetHelper::ObjectsUnderCursor& getObjectsUnderCursor() const;
+    const GNEViewNetHelper::ViewObjectsSelector& getObjectsUnderCursor() const;
 
     /// @brief get move multiple element values
     const GNEViewNetHelper::MoveMultipleElementValues& getMoveMultipleElementValues() const;
@@ -615,8 +615,6 @@ class GNEViewNet : public GUISUMOAbstractView {
     /// @brief variable used to save key status after certain events
     GNEViewNetHelper::MouseButtonKeyPressed myMouseButtonKeyPressed;
 
-    /// @brief variable use to save all pointers to objects under cursor after a click
-    GNEViewNetHelper::ObjectsUnderCursor myObjectsUnderCursor;
     /// @}
 
     /// @name structs related with checkable buttons
@@ -670,6 +668,9 @@ class GNEViewNet : public GUISUMOAbstractView {
     GNEViewNetHelper::VehicleTypeOptions myVehicleTypeOptions;
     // @}
 
+    /// @brief variable use to select objects in view
+    GNEViewNetHelper::ViewObjectsSelector myViewObjectsSelector;
+
     /// @brief variable used for grouping all variables related with salve elements
     GNEViewNetHelper::SaveElements mySaveElements;
 
diff --git a/src/netedit/GNEViewNetHelper.cpp b/src/netedit/GNEViewNetHelper.cpp
index baf85ad5b057..9ea98580fe67 100644
--- a/src/netedit/GNEViewNetHelper.cpp
+++ b/src/netedit/GNEViewNetHelper.cpp
@@ -211,50 +211,50 @@ GNEViewNetHelper::LockManager::OperationLocked::getSupermode() const {
 }
 
 // ---------------------------------------------------------------------------
-// GNEViewNetHelper::ObjectsUnderCursor - methods
+// GNEViewNetHelper::ViewObjectsSelector - methods
 // ---------------------------------------------------------------------------
 
-GNEViewNetHelper::ObjectsUnderCursor::ObjectsUnderCursor(GNEViewNet* viewNet) :
+GNEViewNetHelper::ViewObjectsSelector::ViewObjectsSelector(GNEViewNet* viewNet) :
     myViewNet(viewNet) {
 }
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateObjectUnderCursor() {
+GNEViewNetHelper::ViewObjectsSelector::updateObjects() {
     // clear elements
-    myObjects.clearElements();
+    myViewObjects.clearElements();
     // process GUIGLObjects using elements under cursor
     processGUIGlObjects(gViewObjectsHandler.getSelectedObjects());
 }
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::filterEdges() {
+GNEViewNetHelper::ViewObjectsSelector::filterEdges() {
     // get all edges to filter
     std::vector<const GUIGlObject*> edges;
-    for (const auto &edge : myObjects.edges) {
+    for (const auto &edge : myViewObjects.edges) {
         edges.push_back(edge);
     }
-    myObjects.filterElements(edges);
+    myViewObjects.filterElements(edges);
 }
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::filterLanes() {
+GNEViewNetHelper::ViewObjectsSelector::filterLanes() {
     // get all lanes to filter
     std::vector<const GUIGlObject*> lanes;
-    for (const auto &lane : myObjects.lanes) {
+    for (const auto &lane : myViewObjects.lanes) {
         lanes.push_back(lane);
     }
-    myObjects.filterElements(lanes);
+    myViewObjects.filterElements(lanes);
 }
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::filterLockedElements(const std::vector<GUIGlObjectType> ignoreFilter) {
+GNEViewNetHelper::ViewObjectsSelector::filterLockedElements(const std::vector<GUIGlObjectType> ignoreFilter) {
     std::vector<const GUIGlObject*> GUIGlObjects;
     // get all locked elements
-    for (const auto &GUIGlObject : myObjects.GUIGlObjects) {
+    for (const auto &GUIGlObject : myViewObjects.GUIGlObjects) {
         if (GUIGlObject->isGLObjectLocked()) {
             GUIGlObjects.push_back(GUIGlObject);
         }
@@ -271,34 +271,14 @@ GNEViewNetHelper::ObjectsUnderCursor::filterLockedElements(const std::vector<GUI
         }
     }
     // filter objects
-    myObjects.filterElements(GUIGlObjects);
-}
-
-
-GUIGlID
-GNEViewNetHelper::ObjectsUnderCursor::getGlIDFront() const {
-    if (getGUIGlObjectFront()) {
-        return getGUIGlObjectFront()->getGlID();
-    } else {
-        return 0;
-    }
-}
-
-
-GUIGlObjectType
-GNEViewNetHelper::ObjectsUnderCursor::getGlTypeFront() const {
-    if (getGUIGlObjectFront()) {
-        return getGUIGlObjectFront()->getType();
-    } else {
-        return GLO_NETWORK;
-    }
+    myViewObjects.filterElements(GUIGlObjects);
 }
 
 
 const GUIGlObject*
-GNEViewNetHelper::ObjectsUnderCursor::getGUIGlObjectFront() const {
-    if (myObjects.attributeCarriers.size() > 0) {
-        return myObjects.GUIGlObjects.front();
+GNEViewNetHelper::ViewObjectsSelector::getGUIGlObjectFront() const {
+    if (myViewObjects.attributeCarriers.size() > 0) {
+        return myViewObjects.GUIGlObjects.front();
     } else {
         return nullptr;
     }
@@ -306,9 +286,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getGUIGlObjectFront() const {
 
 
 GNEAttributeCarrier*
-GNEViewNetHelper::ObjectsUnderCursor::getAttributeCarrierFront() const {
-    if (myObjects.attributeCarriers.size() > 0) {
-        return myObjects.attributeCarriers.front();
+GNEViewNetHelper::ViewObjectsSelector::getAttributeCarrierFront() const {
+    if (myViewObjects.attributeCarriers.size() > 0) {
+        return myViewObjects.attributeCarriers.front();
     } else {
         return nullptr;
     }
@@ -316,9 +296,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getAttributeCarrierFront() const {
 
 
 GNENetworkElement*
-GNEViewNetHelper::ObjectsUnderCursor::getNetworkElementFront() const {
-    if (myObjects.networkElements.size() > 0) {
-        return myObjects.networkElements.front();
+GNEViewNetHelper::ViewObjectsSelector::getNetworkElementFront() const {
+    if (myViewObjects.networkElements.size() > 0) {
+        return myViewObjects.networkElements.front();
     } else {
         return nullptr;
     }
@@ -326,9 +306,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getNetworkElementFront() const {
 
 
 GNEAdditional*
-GNEViewNetHelper::ObjectsUnderCursor::getAdditionalFront() const {
-    if (myObjects.additionals.size() > 0) {
-        return myObjects.additionals.front();
+GNEViewNetHelper::ViewObjectsSelector::getAdditionalFront() const {
+    if (myViewObjects.additionals.size() > 0) {
+        return myViewObjects.additionals.front();
     } else {
         return nullptr;
     }
@@ -336,9 +316,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getAdditionalFront() const {
 
 
 GNEDemandElement*
-GNEViewNetHelper::ObjectsUnderCursor::getDemandElementFront() const {
-    if (myObjects.demandElements.size() > 0) {
-        return myObjects.demandElements.front();
+GNEViewNetHelper::ViewObjectsSelector::getDemandElementFront() const {
+    if (myViewObjects.demandElements.size() > 0) {
+        return myViewObjects.demandElements.front();
     } else {
         return nullptr;
     }
@@ -346,9 +326,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getDemandElementFront() const {
 
 
 GNEGenericData*
-GNEViewNetHelper::ObjectsUnderCursor::getGenericDataElementFront() const {
-    if (myObjects.genericDatas.size() > 0) {
-        return myObjects.genericDatas.front();
+GNEViewNetHelper::ViewObjectsSelector::getGenericDataElementFront() const {
+    if (myViewObjects.genericDatas.size() > 0) {
+        return myViewObjects.genericDatas.front();
     } else {
         return nullptr;
     }
@@ -356,9 +336,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getGenericDataElementFront() const {
 
 
 GNEJunction*
-GNEViewNetHelper::ObjectsUnderCursor::getJunctionFront() const {
-    if (myObjects.junctions.size() > 0) {
-        return myObjects.junctions.front();
+GNEViewNetHelper::ViewObjectsSelector::getJunctionFront() const {
+    if (myViewObjects.junctions.size() > 0) {
+        return myViewObjects.junctions.front();
     } else {
         return nullptr;
     }
@@ -366,9 +346,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getJunctionFront() const {
 
 
 GNEEdge*
-GNEViewNetHelper::ObjectsUnderCursor::getEdgeFront() const {
-    if (myObjects.edges.size() > 0) {
-        return myObjects.edges.front();
+GNEViewNetHelper::ViewObjectsSelector::getEdgeFront() const {
+    if (myViewObjects.edges.size() > 0) {
+        return myViewObjects.edges.front();
     } else {
         return nullptr;
     }
@@ -376,9 +356,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getEdgeFront() const {
 
 
 GNELane*
-GNEViewNetHelper::ObjectsUnderCursor::getLaneFront() const {
-    if (myObjects.lanes.size() > 0) {
-        return myObjects.lanes.front();
+GNEViewNetHelper::ViewObjectsSelector::getLaneFront() const {
+    if (myViewObjects.lanes.size() > 0) {
+        return myViewObjects.lanes.front();
     } else {
         return nullptr;
     }
@@ -386,9 +366,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getLaneFront() const {
 
 
 GNELane*
-GNEViewNetHelper::ObjectsUnderCursor::getLaneFrontNonLocked() const {
-    if (myObjects.lanes.size() > 0) {
-        for (auto& lane : myObjects.lanes) {
+GNEViewNetHelper::ViewObjectsSelector::getLaneFrontNonLocked() const {
+    if (myViewObjects.lanes.size() > 0) {
+        for (auto& lane : myViewObjects.lanes) {
             if (!(lane->isAttributeCarrierSelected() || lane->getParentEdge()->isAttributeCarrierSelected()) ||
                     !myViewNet->getViewParent()->getGNEAppWindows()->getLockMenuCommands().menuCheckLockSelectedElements->getCheck()) {
                 return lane;
@@ -403,15 +383,15 @@ GNEViewNetHelper::ObjectsUnderCursor::getLaneFrontNonLocked() const {
 
 
 const std::vector<GNELane*>&
-GNEViewNetHelper::ObjectsUnderCursor::getLanes() const {
-    return myObjects.lanes;
+GNEViewNetHelper::ViewObjectsSelector::getLanes() const {
+    return myViewObjects.lanes;
 }
 
 
 GNECrossing*
-GNEViewNetHelper::ObjectsUnderCursor::getCrossingFront() const {
-    if (myObjects.crossings.size() > 0) {
-        return myObjects.crossings.front();
+GNEViewNetHelper::ViewObjectsSelector::getCrossingFront() const {
+    if (myViewObjects.crossings.size() > 0) {
+        return myViewObjects.crossings.front();
     } else {
         return nullptr;
     }
@@ -419,9 +399,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getCrossingFront() const {
 
 
 GNEWalkingArea*
-GNEViewNetHelper::ObjectsUnderCursor::getWalkingAreaFront() const {
-    if (myObjects.walkingAreas.size() > 0) {
-        return myObjects.walkingAreas.front();
+GNEViewNetHelper::ViewObjectsSelector::getWalkingAreaFront() const {
+    if (myViewObjects.walkingAreas.size() > 0) {
+        return myViewObjects.walkingAreas.front();
     } else {
         return nullptr;
     }
@@ -429,9 +409,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getWalkingAreaFront() const {
 
 
 GNEConnection*
-GNEViewNetHelper::ObjectsUnderCursor::getConnectionFront() const {
-    if (myObjects.connections.size() > 0) {
-        return myObjects.connections.front();
+GNEViewNetHelper::ViewObjectsSelector::getConnectionFront() const {
+    if (myViewObjects.connections.size() > 0) {
+        return myViewObjects.connections.front();
     } else {
         return nullptr;
     }
@@ -439,9 +419,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getConnectionFront() const {
 
 
 GNEInternalLane*
-GNEViewNetHelper::ObjectsUnderCursor::getInternalLaneFront() const {
-    if (myObjects.internalLanes.size() > 0) {
-        return myObjects.internalLanes.front();
+GNEViewNetHelper::ViewObjectsSelector::getInternalLaneFront() const {
+    if (myViewObjects.internalLanes.size() > 0) {
+        return myViewObjects.internalLanes.front();
     } else {
         return nullptr;
     }
@@ -449,9 +429,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getInternalLaneFront() const {
 
 
 GNEPOI*
-GNEViewNetHelper::ObjectsUnderCursor::getPOIFront() const {
-    if (myObjects.POIs.size() > 0) {
-        return myObjects.POIs.front();
+GNEViewNetHelper::ViewObjectsSelector::getPOIFront() const {
+    if (myViewObjects.POIs.size() > 0) {
+        return myViewObjects.POIs.front();
     } else {
         return nullptr;
     }
@@ -459,9 +439,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getPOIFront() const {
 
 
 GNEPoly*
-GNEViewNetHelper::ObjectsUnderCursor::getPolyFront() const {
-    if (myObjects.polys.size() > 0) {
-        return myObjects.polys.front();
+GNEViewNetHelper::ViewObjectsSelector::getPolyFront() const {
+    if (myViewObjects.polys.size() > 0) {
+        return myViewObjects.polys.front();
     } else {
         return nullptr;
     }
@@ -469,9 +449,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getPolyFront() const {
 
 
 GNETAZ*
-GNEViewNetHelper::ObjectsUnderCursor::getTAZFront() const {
-    if (myObjects.TAZs.size() > 0) {
-        return myObjects.TAZs.front();
+GNEViewNetHelper::ViewObjectsSelector::getTAZFront() const {
+    if (myViewObjects.TAZs.size() > 0) {
+        return myViewObjects.TAZs.front();
     } else {
         return nullptr;
     }
@@ -479,9 +459,9 @@ GNEViewNetHelper::ObjectsUnderCursor::getTAZFront() const {
 
 
 GNEEdgeData*
-GNEViewNetHelper::ObjectsUnderCursor::getEdgeDataElementFront() const {
-    if (myObjects.edgeDatas.size() > 0) {
-        return myObjects.edgeDatas.front();
+GNEViewNetHelper::ViewObjectsSelector::getEdgeDataElementFront() const {
+    if (myViewObjects.edgeDatas.size() > 0) {
+        return myViewObjects.edgeDatas.front();
     } else {
         return nullptr;
     }
@@ -489,49 +469,49 @@ GNEViewNetHelper::ObjectsUnderCursor::getEdgeDataElementFront() const {
 
 
 GNEEdgeRelData*
-GNEViewNetHelper::ObjectsUnderCursor::getEdgeRelDataElementFront() const {
-    if (myObjects.edgeRelDatas.size() > 0) {
-        return myObjects.edgeRelDatas.front();
+GNEViewNetHelper::ViewObjectsSelector::getEdgeRelDataElementFront() const {
+    if (myViewObjects.edgeRelDatas.size() > 0) {
+        return myViewObjects.edgeRelDatas.front();
     } else {
         return nullptr;
     }
 }
 
 const std::vector<GUIGlObject*>&
-GNEViewNetHelper::ObjectsUnderCursor::getClickedGLObjects() const {
-    return myObjects.GUIGlObjects;
+GNEViewNetHelper::ViewObjectsSelector::getGLObjects() const {
+    return myViewObjects.GUIGlObjects;
 }
 
 
 const std::vector<GNEAttributeCarrier*>&
-GNEViewNetHelper::ObjectsUnderCursor::getClickedAttributeCarriers() const {
-    return myObjects.attributeCarriers;
+GNEViewNetHelper::ViewObjectsSelector::getAttributeCarriers() const {
+    return myViewObjects.attributeCarriers;
 }
 
 
 const std::vector<GNEJunction*>&
-GNEViewNetHelper::ObjectsUnderCursor::getClickedJunctions() const {
-    return myObjects.junctions;
+GNEViewNetHelper::ViewObjectsSelector::getJunctions() const {
+    return myViewObjects.junctions;
 }
 
 
 const std::vector<GNEEdge*>&
-GNEViewNetHelper::ObjectsUnderCursor::getEdges() const {
-    return myObjects.edges;
+GNEViewNetHelper::ViewObjectsSelector::getEdges() const {
+    return myViewObjects.edges;
 }
 
 
 const std::vector<GNEDemandElement*>&
-GNEViewNetHelper::ObjectsUnderCursor::getClickedDemandElements() const {
-    return myObjects.demandElements;
+GNEViewNetHelper::ViewObjectsSelector::getDemandElements() const {
+    return myViewObjects.demandElements;
 }
 
 
-GNEViewNetHelper::ObjectsUnderCursor::ObjectsContainer::ObjectsContainer() {}
+GNEViewNetHelper::ViewObjectsSelector::ViewObjectsContainer::ViewObjectsContainer() {}
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::ObjectsContainer::clearElements() {
+GNEViewNetHelper::ViewObjectsSelector::ViewObjectsContainer::clearElements() {
     // just clear all containers
     GUIGlObjects.clear();
     attributeCarriers.clear();
@@ -555,7 +535,7 @@ GNEViewNetHelper::ObjectsUnderCursor::ObjectsContainer::clearElements() {
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::ObjectsContainer::filterElements(const std::vector<const GUIGlObject*> &objects) {
+GNEViewNetHelper::ViewObjectsSelector::ViewObjectsContainer::filterElements(const std::vector<const GUIGlObject*> &objects) {
     for (const auto &object : objects) {
         // remove from GUIGlObjects
         auto itGlObjects = GUIGlObjects.begin();
@@ -724,7 +704,7 @@ GNEViewNetHelper::ObjectsUnderCursor::ObjectsContainer::filterElements(const std
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateNetworkElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateNetworkElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // get front AC
     const auto frontGLObject = myViewNet->getFrontGLObject();
     // cast specific network element
@@ -867,7 +847,7 @@ GNEViewNetHelper::ObjectsUnderCursor::updateNetworkElements(ObjectsContainer& co
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateAdditionalElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateAdditionalElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // get additional element
     auto additionalElement = myViewNet->getNet()->getAttributeCarriers()->retrieveAdditional(glObject, false);
     if (additionalElement) {
@@ -888,7 +868,7 @@ GNEViewNetHelper::ObjectsUnderCursor::updateAdditionalElements(ObjectsContainer&
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateShapeElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateShapeElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // cast specific shape
     if (glObject->getType() == GLO_POI) {
         // cast POI
@@ -917,7 +897,7 @@ GNEViewNetHelper::ObjectsUnderCursor::updateShapeElements(ObjectsContainer& cont
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateTAZElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateTAZElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // cast specific TAZ
     if (glObject->getType() == GLO_TAZ) {
         // cast TAZ
@@ -935,7 +915,7 @@ GNEViewNetHelper::ObjectsUnderCursor::updateTAZElements(ObjectsContainer& contai
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateDemandElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateDemandElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // get demandElement
     GNEDemandElement* demandElement = myViewNet->getNet()->getAttributeCarriers()->retrieveDemandElement(glObject, false);
     if (demandElement) {
@@ -956,7 +936,7 @@ GNEViewNetHelper::ObjectsUnderCursor::updateDemandElements(ObjectsContainer& con
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::updateGenericDataElements(ObjectsContainer& container, const GUIGlObject* glObject) {
+GNEViewNetHelper::ViewObjectsSelector::updateGenericDataElements(ViewObjectsContainer& container, const GUIGlObject* glObject) {
     // cast specific generic data
     switch (glObject->getType()) {
         case GLO_EDGEDATA: {
@@ -1004,23 +984,23 @@ GNEViewNetHelper::ObjectsUnderCursor::updateGenericDataElements(ObjectsContainer
 
 
 void
-GNEViewNetHelper::ObjectsUnderCursor::processGUIGlObjects(const GUIViewObjectsHandler::GLObjectsSortedContainer& objectsContainer) {
+GNEViewNetHelper::ViewObjectsSelector::processGUIGlObjects(const GUIViewObjectsHandler::GLObjectsSortedContainer& objectsContainer) {
     // iterate over filtered edge objects
     for (const auto& glObjectLayer : objectsContainer) {
         for (const auto &glObject : glObjectLayer.second) {
             // update all elements by categories
-            updateNetworkElements(myObjects, glObject.object);
-            updateAdditionalElements(myObjects, glObject.object);
-            updateShapeElements(myObjects, glObject.object);
-            updateTAZElements(myObjects, glObject.object);
-            updateDemandElements(myObjects, glObject.object);
-            updateGenericDataElements(myObjects, glObject.object);
+            updateNetworkElements(myViewObjects, glObject.object);
+            updateAdditionalElements(myViewObjects, glObject.object);
+            updateShapeElements(myViewObjects, glObject.object);
+            updateTAZElements(myViewObjects, glObject.object);
+            updateDemandElements(myViewObjects, glObject.object);
+            updateGenericDataElements(myViewObjects, glObject.object);
         }
     }
 }
 
 
-GNEViewNetHelper::ObjectsUnderCursor::ObjectsUnderCursor() :
+GNEViewNetHelper::ViewObjectsSelector::ViewObjectsSelector() :
     myViewNet(nullptr) {
 }
 
@@ -1104,9 +1084,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveNetworkElementShape() {
     // get edited element
     const GNENetworkElement* editedElement = myViewNet->myEditNetworkElementShapes.getEditedNetworkElement();
     // check what type of AC will be moved
-    if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (myViewNet->myObjectsUnderCursor.getJunctionFront() == editedElement)) {
+    if (myViewNet->myViewObjectsSelector.getJunctionFront() && (myViewNet->myViewObjectsSelector.getJunctionFront() == editedElement)) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getJunctionFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1114,9 +1094,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveNetworkElementShape() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getLaneFront() && (myViewNet->myObjectsUnderCursor.getLaneFront() == editedElement)) {
+    } else if (myViewNet->myViewObjectsSelector.getLaneFront() && (myViewNet->myViewObjectsSelector.getLaneFront() == editedElement)) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getLaneFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getLaneFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1124,9 +1104,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveNetworkElementShape() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getCrossingFront() && (myViewNet->myObjectsUnderCursor.getCrossingFront() == editedElement)) {
+    } else if (myViewNet->myViewObjectsSelector.getCrossingFront() && (myViewNet->myViewObjectsSelector.getCrossingFront() == editedElement)) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getCrossingFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getCrossingFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1134,9 +1114,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveNetworkElementShape() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getConnectionFront() && (myViewNet->myObjectsUnderCursor.getConnectionFront() == editedElement)) {
+    } else if (myViewNet->myViewObjectsSelector.getConnectionFront() && (myViewNet->myViewObjectsSelector.getConnectionFront() == editedElement)) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getConnectionFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getConnectionFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1144,9 +1124,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveNetworkElementShape() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() && (myViewNet->myObjectsUnderCursor.getWalkingAreaFront() == editedElement)) {
+    } else if (myViewNet->myViewObjectsSelector.getWalkingAreaFront() && (myViewNet->myViewObjectsSelector.getWalkingAreaFront() == editedElement)) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getWalkingAreaFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getWalkingAreaFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1166,11 +1146,11 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
     // first obtain moving reference (common for all)
     myRelativeClickedPosition = myViewNet->getPositionInformation();
     // get front AC
-    const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
+    const GNEAttributeCarrier* frontAC = myViewNet->myViewObjectsSelector.getAttributeCarrierFront();
     // check what type of AC will be moved
-    if (myViewNet->myObjectsUnderCursor.getPolyFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPolyFront())) {
+    if (myViewNet->myViewObjectsSelector.getPolyFront() && (frontAC == myViewNet->myViewObjectsSelector.getPolyFront())) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPolyFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getPolyFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1178,9 +1158,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getPOIFront() && (frontAC == myViewNet->myObjectsUnderCursor.getPOIFront())) {
+    } else if (myViewNet->myViewObjectsSelector.getPOIFront() && (frontAC == myViewNet->myViewObjectsSelector.getPOIFront())) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getPOIFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getPOIFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1188,9 +1168,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getAdditionalFront() && (frontAC == myViewNet->myObjectsUnderCursor.getAdditionalFront())) {
+    } else if (myViewNet->myViewObjectsSelector.getAdditionalFront() && (frontAC == myViewNet->myViewObjectsSelector.getAdditionalFront())) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getAdditionalFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getAdditionalFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1198,11 +1178,11 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
         } else {
             return false;
         }
-    } else if (myViewNet->myObjectsUnderCursor.getJunctionFront() && (frontAC == myViewNet->myObjectsUnderCursor.getJunctionFront())) {
+    } else if (myViewNet->myViewObjectsSelector.getJunctionFront() && (frontAC == myViewNet->myViewObjectsSelector.getJunctionFront())) {
         // check if over junction there is a geometry point
-        if (myViewNet->myObjectsUnderCursor.getEdgeFront() && (myViewNet->myObjectsUnderCursor.getEdgeFront()->clickedOverGeometryPoint(myRelativeClickedPosition))) {
+        if (myViewNet->myViewObjectsSelector.getEdgeFront() && (myViewNet->myViewObjectsSelector.getEdgeFront()->clickedOverGeometryPoint(myRelativeClickedPosition))) {
             // get move operation
-            GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getEdgeFront()->getMoveOperation();
+            GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getEdgeFront()->getMoveOperation();
             // continue if move operation is valid
             if (moveOperation) {
                 myMoveOperations.push_back(moveOperation);
@@ -1212,7 +1192,7 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
             }
         } else {
             // get move operation
-            GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getJunctionFront()->getMoveOperation();
+            GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getJunctionFront()->getMoveOperation();
             // continue if move operation is valid
             if (moveOperation) {
                 myMoveOperations.push_back(moveOperation);
@@ -1221,16 +1201,16 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
                 return false;
             }
         }
-    } else if (myViewNet->myObjectsUnderCursor.getEdgeFront() && (frontAC == myViewNet->myObjectsUnderCursor.getEdgeFront())) {
+    } else if (myViewNet->myViewObjectsSelector.getEdgeFront() && (frontAC == myViewNet->myViewObjectsSelector.getEdgeFront())) {
         // calculate Edge movement values (can be entire shape, single geometry points, altitude, etc.)
         if (myViewNet->myMouseButtonKeyPressed.shiftKeyPressed()) {
             // edit end point
-            myViewNet->myObjectsUnderCursor.getEdgeFront()->editEndpoint(myViewNet->getPositionInformation(), myViewNet->myUndoList);
+            myViewNet->myViewObjectsSelector.getEdgeFront()->editEndpoint(myViewNet->getPositionInformation(), myViewNet->myUndoList);
             // edge values wasn't calculated, then return false
             return false;
         } else {
             // get move operation
-            GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getEdgeFront()->getMoveOperation();
+            GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getEdgeFront()->getMoveOperation();
             // continue if move operation is valid
             if (moveOperation) {
                 myMoveOperations.push_back(moveOperation);
@@ -1239,9 +1219,9 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementNetworkMode() {
                 return false;
             }
         }
-    } else if (myViewNet->myObjectsUnderCursor.getLaneFront() && (frontAC == myViewNet->myObjectsUnderCursor.getLaneFront())) {
+    } else if (myViewNet->myViewObjectsSelector.getLaneFront() && (frontAC == myViewNet->myViewObjectsSelector.getLaneFront())) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getLaneFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getLaneFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1261,11 +1241,11 @@ GNEViewNetHelper::MoveSingleElementValues::beginMoveSingleElementDemandMode() {
     // first obtain moving reference (common for all)
     myRelativeClickedPosition = myViewNet->getPositionInformation();
     // get front AC
-    const GNEAttributeCarrier* frontAC = myViewNet->myObjectsUnderCursor.getAttributeCarrierFront();
+    const GNEAttributeCarrier* frontAC = myViewNet->myViewObjectsSelector.getAttributeCarrierFront();
     // check demand element
-    if (myViewNet->myObjectsUnderCursor.getDemandElementFront() && (frontAC == myViewNet->myObjectsUnderCursor.getDemandElementFront())) {
+    if (myViewNet->myViewObjectsSelector.getDemandElementFront() && (frontAC == myViewNet->myViewObjectsSelector.getDemandElementFront())) {
         // get move operation
-        GNEMoveOperation* moveOperation = myViewNet->myObjectsUnderCursor.getDemandElementFront()->getMoveOperation();
+        GNEMoveOperation* moveOperation = myViewNet->myViewObjectsSelector.getDemandElementFront()->getMoveOperation();
         // continue if move operation is valid
         if (moveOperation) {
             myMoveOperations.push_back(moveOperation);
@@ -1352,10 +1332,10 @@ GNEViewNetHelper::MoveMultipleElementValues::beginMoveSelection() {
     // save clicked position (to calculate offset)
     myClickedPosition = myViewNet->getPositionInformation();
     // continue depending of clicked element
-    if (myViewNet->myObjectsUnderCursor.getJunctionFront()) {
+    if (myViewNet->myViewObjectsSelector.getJunctionFront()) {
         calculateJunctionSelection();
-    } else if (myViewNet->myObjectsUnderCursor.getEdgeFront()) {
-        calculateEdgeSelection(myViewNet->myObjectsUnderCursor.getEdgeFront());
+    } else if (myViewNet->myViewObjectsSelector.getEdgeFront()) {
+        calculateEdgeSelection(myViewNet->myViewObjectsSelector.getEdgeFront());
     }
 }
 
@@ -1651,7 +1631,7 @@ GNEViewNetHelper::SelectingArea::processBoundarySelection(const Boundary& bounda
     myViewNet->updateObjectsInBoundary(boundary);
     // filter ACsInBoundary depending of current supermode
     std::set<GNEAttributeCarrier*> ACsFiltered;
-    for (const auto& AC : myViewNet->getObjectsUnderCursor().getClickedAttributeCarriers()) {
+    for (const auto& AC : myViewNet->getObjectsUnderCursor().getAttributeCarriers()) {
         if (myViewNet->myEditModes.isCurrentSupermodeNetwork()) {
             if (AC->getTagProperty().isNetworkElement() || AC->getTagProperty().isAdditionalElement()) {
                 ACsFiltered.insert(AC);
diff --git a/src/netedit/GNEViewNetHelper.h b/src/netedit/GNEViewNetHelper.h
index 81022232732e..be0cdc95a19d 100644
--- a/src/netedit/GNEViewNetHelper.h
+++ b/src/netedit/GNEViewNetHelper.h
@@ -219,14 +219,14 @@ struct GNEViewNetHelper {
     };
 
     /// @brief class used to group all variables related with objects under cursor after a click over view
-    class ObjectsUnderCursor {
+    class ViewObjectsSelector {
 
     public:
         /// @brief constructor
-        ObjectsUnderCursor(GNEViewNet* viewNet);
+        ViewObjectsSelector(GNEViewNet* viewNet);
 
-        /// @brief update objects under cursor (using gObjectsInPosition)
-        void updateObjectUnderCursor();
+        /// @brief update objects (using gViewObjectsHandler)
+        void updateObjects();
 
         /// @brief filter (remove) edges
         void filterEdges();
@@ -237,12 +237,6 @@ struct GNEViewNetHelper {
         /// @brief filter locked elements (except the ignoreFilter)
         void filterLockedElements(const std::vector<GUIGlObjectType> ignoreFilter = {});
 
-        /// @brief get front GUI GL ID or a pointer to nullptr
-        GUIGlID getGlIDFront() const;
-
-        /// @brief get front GUI GL object type or a pointer to nullptr
-        GUIGlObjectType getGlTypeFront() const;
-
         /// @brief get front attribute carrier or a pointer to nullptr
         const GUIGlObject* getGUIGlObjectFront() const;
 
@@ -303,28 +297,28 @@ struct GNEViewNetHelper {
         /// @brief get edge rel data element or a pointer to nullptr
         GNEEdgeRelData* getEdgeRelDataElementFront() const;
 
-        /// @brief get vector with clicked GL objects
-        const std::vector<GUIGlObject*>& getClickedGLObjects() const;
+        /// @brief get vector with GL objects
+        const std::vector<GUIGlObject*>& getGLObjects() const;
 
-        /// @brief get vector with clicked ACs
-        const std::vector<GNEAttributeCarrier*>& getClickedAttributeCarriers() const;
+        /// @brief get vector with ACs
+        const std::vector<GNEAttributeCarrier*>& getAttributeCarriers() const;
 
-        /// @brief get vector with clicked junctions
-        const std::vector<GNEJunction*>& getClickedJunctions() const;
+        /// @brief get vector with junctions
+        const std::vector<GNEJunction*>& getJunctions() const;
 
-        /// @brief get vector with clicked junctions
+        /// @brief get vector with edges
         const std::vector<GNEEdge*>& getEdges() const;
 
-        /// @brief get vector with clicked Demand Elements
-        const std::vector<GNEDemandElement*>& getClickedDemandElements() const;
+        /// @brief get vector with Demand Elements
+        const std::vector<GNEDemandElement*>& getDemandElements() const;
 
     protected:
         /// @brief objects container
-        class ObjectsContainer {
+        class ViewObjectsContainer {
 
         public:
             /// @brief constructor
-            ObjectsContainer();
+            ViewObjectsContainer();
 
             /// @brief clear elements
             void clearElements();
@@ -332,101 +326,101 @@ struct GNEViewNetHelper {
             /// @brief filter elements
             void filterElements(const std::vector<const GUIGlObject*> &objects);
 
-            /// @brief vector with the clicked GUIGlObjects
+            /// @brief vector with the GUIGlObjects
             std::vector<GUIGlObject*> GUIGlObjects;
 
-            /// @brief vector with the clicked attribute carriers
+            /// @brief vector with the attribute carriers
             std::vector<GNEAttributeCarrier*> attributeCarriers;
 
-            /// @brief vector with the clicked network elements
+            /// @brief vector with the network elements
             std::vector<GNENetworkElement*> networkElements;
 
-            /// @brief vector with the clicked additional elements
+            /// @brief vector with the additional elements
             std::vector<GNEAdditional*> additionals;
 
-            /// @brief vector with the clicked demand elements
+            /// @brief vector with the demand elements
             std::vector<GNEDemandElement*> demandElements;
 
-            /// @brief vector with the clicked generic datas
+            /// @brief vector with the generic datas
             std::vector<GNEGenericData*> genericDatas;
 
-            /// @brief vector with the clicked junctions
+            /// @brief vector with the junctions
             std::vector<GNEJunction*> junctions;
 
-            /// @brief vector with the clicked edges
+            /// @brief vector with the  edges
             std::vector<GNEEdge*> edges;
 
-            /// @brief vector with the clicked lanes
+            /// @brief vector with the lanes
             std::vector<GNELane*> lanes;
 
-            /// @brief vector with the clicked crossings
+            /// @brief vector with the crossings
             std::vector<GNECrossing*> crossings;
 
-            /// @brief vector with the clicked walkingAreas
+            /// @brief vector with the walkingAreas
             std::vector<GNEWalkingArea*> walkingAreas;
 
-            /// @brief vector with the clicked connections
+            /// @brief vector with the connections
             std::vector<GNEConnection*> connections;
 
-            /// @brief vector with the clicked internal lanes
+            /// @brief vector with the internal lanes
             std::vector<GNEInternalLane*> internalLanes;
 
-            /// @brief vector with the clicked TAZ elements
+            /// @brief vector with the TAZ elements
             std::vector<GNETAZ*> TAZs;
 
-            /// @brief vector with the clicked POIs
+            /// @brief vector with the POIs
             std::vector<GNEPOI*> POIs;
 
-            /// @brief vector with the clicked polys
+            /// @brief vector with the polys
             std::vector<GNEPoly*> polys;
 
-            /// @brief vector with the clicked edge datas
+            /// @brief vector with the edge datas
             std::vector<GNEEdgeData*> edgeDatas;
 
-            /// @brief vector with the clicked edge relation datas
+            /// @brief vector with the edge relation datas
             std::vector<GNEEdgeRelData*> edgeRelDatas;
 
         private:
             /// @brief Invalidated copy constructor.
-            ObjectsContainer(const ObjectsContainer&) = delete;
+            ViewObjectsContainer(const ViewObjectsContainer&) = delete;
         };
 
         /// @brief pointer to viewNet
         const GNEViewNet* myViewNet;
 
         /// @brief objects container with selected objects
-        ObjectsContainer myObjects;
+        ViewObjectsContainer myViewObjects;
 
     private:
         /// @brief update network elements
-        void updateNetworkElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateNetworkElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief update additional elements
-        void updateAdditionalElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateAdditionalElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief update shape elements
-        void updateShapeElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateShapeElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief update TAZ elements
-        void updateTAZElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateTAZElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief update demand elements
-        void updateDemandElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateDemandElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief update generic data elements
-        void updateGenericDataElements(ObjectsContainer& container, const GUIGlObject* glObject);
+        void updateGenericDataElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
         /// @brief process GL objects
         void processGUIGlObjects(const GUIViewObjectsHandler::GLObjectsSortedContainer& objectsContainer);
 
         /// @brief default constructor
-        ObjectsUnderCursor();
+        ViewObjectsSelector();
 
         /// @brief Invalidated copy constructor.
-        ObjectsUnderCursor(const ObjectsUnderCursor&) = delete;
+        ViewObjectsSelector(const ViewObjectsSelector&) = delete;
 
         /// @brief Invalidated assignment operator.
-        ObjectsUnderCursor& operator=(const ObjectsUnderCursor&) = delete;
+        ViewObjectsSelector& operator=(const ViewObjectsSelector&) = delete;
     };
 
     /// @brief class used to group all variables related with mouse buttons and key pressed after certain events
diff --git a/src/netedit/elements/GNEContour.cpp b/src/netedit/elements/GNEContour.cpp
index f290bbc7e0b9..95126d8ecd12 100644
--- a/src/netedit/elements/GNEContour.cpp
+++ b/src/netedit/elements/GNEContour.cpp
@@ -65,7 +65,7 @@ void
 GNEContour::calculateContourClosedShape(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d,
                                         const GUIGlObject* glObject, const PositionVector& shape, const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // calculate closed shape contour
         buildContourClosedShape(s, d, shape, scale);
         // check if position or bondary is within closed shape
@@ -80,7 +80,7 @@ GNEContour::calculateContourExtrudedShape(const GUIVisualizationSettings& s, con
                                           const double scale, const bool closeFirstExtrem, const bool closeLastExtrem,
                                           const double offset) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // calculate extruded shape
         buildContourExtrudedShape(s, d, shape, extrusionWidth, scale, closeFirstExtrem, closeLastExtrem, offset);
         // check if position or bondary is within extruded shape
@@ -94,7 +94,7 @@ GNEContour::calculateContourRectangleShape(const GUIVisualizationSettings& s, co
                                            const GUIGlObject* glObject, const Position& pos, const double width, const double height,
                                            const double offsetX, const double offsetY, const double rot, const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // calculate rectangle shape
         buildContourRectangle(s, d, pos, width, height, offsetX, offsetY, rot, scale);
         // check if position or bondary is within rectangle shape
@@ -107,7 +107,7 @@ void
 GNEContour::calculateContourCircleShape(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d,
                                         const GUIGlObject* glObject, const Position& pos, double radius, const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // calculate circle shape
         buildContourCircle(s, d, pos, radius, scale);
         // check if position or bondary is within circle shape
@@ -119,7 +119,7 @@ void
 GNEContour::calculateContourEdge(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d,
                                  const GNEEdge* edge, const bool closeFirstExtrem, const bool closeLastExtrem) const {
     // check if mouse is within two lines (only in rectangle selection mode)
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // calculate contour edge shape
         buildContourEdge(s, d, edge, closeFirstExtrem, closeLastExtrem);
         // check if position or bondary is within contour shape
@@ -141,7 +141,7 @@ GNEContour::calculateContourFirstGeometryPoint(const GUIVisualizationSettings& s
                                                const GUIGlObject* glObject, const PositionVector& shape, double radius,
                                                const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor && (shape.size() > 0)) {
+    if (s.drawForViewObjectsHandler && (shape.size() > 0)) {
         // check position within geometry of first geometry point
         gViewObjectsHandler.checkGeometryPoint(d, glObject, shape, 0, (radius * scale));
     }
@@ -153,7 +153,7 @@ GNEContour::calculateContourLastGeometryPoint(const GUIVisualizationSettings& s,
                                               const GUIGlObject* glObject, const PositionVector& shape, double radius,
                                               const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor && (shape.size() > 0)) {
+    if (s.drawForViewObjectsHandler && (shape.size() > 0)) {
         // check position within geometry of last geometry point
         gViewObjectsHandler.checkGeometryPoint(d, glObject, shape, (int)shape.size() - 1, (radius * scale));
     }
@@ -165,7 +165,7 @@ GNEContour::calculateContourMiddleGeometryPoints(const GUIVisualizationSettings&
                                                  const GUIGlObject* glObject, const PositionVector& shape, double radius,
                                                  const double scale) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // check position within geometry of middle geometry points
         for (int i = 1; i < (int)shape.size() - 1; i++) {
             gViewObjectsHandler.checkGeometryPoint(d, glObject, shape, i, (radius * scale));
@@ -181,7 +181,7 @@ GNEContour::calculateContourAllGeometryPoints(const GUIVisualizationSettings& s,
                                               const GUIGlObject* glObject, const PositionVector& shape, double radius,
                                               const double scale, const bool calculatePosOverShape) const {
     // check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor) {
+    if (s.drawForViewObjectsHandler) {
         // check position within geometry of middle geometry points
         for (int i = 0; i < (int)shape.size(); i++) {
             gViewObjectsHandler.checkGeometryPoint(d, glObject, shape, i, (radius * scale));
@@ -199,7 +199,7 @@ GNEContour::calculateContourEdgeGeometryPoints(const GUIVisualizationSettings& s
                                                const GNEEdge* edge, const double radius, const bool calculatePosOverShape,
                                                const bool firstExtrem, const bool lastExtrem) const {
     // first check if we're in drawForObjectUnderCursor
-    if (s.drawForObjectUnderCursor && (gViewObjectsHandler.getSelectionPosition() != Position::INVALID)) {
+    if (s.drawForViewObjectsHandler && (gViewObjectsHandler.getSelectionPosition() != Position::INVALID)) {
         // get edge geometry
         const auto &edgeGeometry = edge->getNBEdge()->getGeometry();
         // calculate last geometry point index
diff --git a/src/netedit/elements/additional/GNEAccess.cpp b/src/netedit/elements/additional/GNEAccess.cpp
index 22b625c4bc77..7a2ee0e37028 100644
--- a/src/netedit/elements/additional/GNEAccess.cpp
+++ b/src/netedit/elements/additional/GNEAccess.cpp
@@ -207,7 +207,7 @@ GNEAccess::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // radius depends if mouse is over element
             const double radius = gViewObjectsHandler.isElementSelected(this)? 1 : 0.5;
             // get color
diff --git a/src/netedit/elements/additional/GNEAdditional.cpp b/src/netedit/elements/additional/GNEAdditional.cpp
index 69c1d7059c04..7e21b084fc40 100644
--- a/src/netedit/elements/additional/GNEAdditional.cpp
+++ b/src/netedit/elements/additional/GNEAdditional.cpp
@@ -711,7 +711,7 @@ GNEAdditional::drawSquaredAdditional(const GUIVisualizationSettings& s, const Po
         // get detail level
         const auto d = s.getDetailLevel(exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // Add layer matrix
             GLHelper::pushMatrix();
             // translate to front
@@ -775,7 +775,7 @@ GNEAdditional::drawListedAdditional(const GUIVisualizationSettings& s, const Pos
         // calculate signPosition position
         Position signPosition = parentPosition;
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // set position depending of indexes
             signPosition.add(4.5 + (baseOffsetX * offsetX), (drawPositionIndex * -1) - extraOffsetY + 1, 0);
             // calculate colors
@@ -1235,7 +1235,7 @@ GNEAdditional::drawSemiCircleGeometryPoint(const GUIVisualizationSettings& s, co
         const Position& pos, const double rot, const RGBColor& baseColor, const double fromAngle, const double toAngle,
         const bool ignoreShift) const {
     // check if draw geometry point
-    if (!s.drawForObjectUnderCursor && (d <= GUIVisualizationSettings::Detail::GeometryPoint)) {
+    if (!s.drawForViewObjectsHandler && (d <= GUIVisualizationSettings::Detail::GeometryPoint)) {
         // push matrix
         GLHelper::pushMatrix();
         // translated to front
diff --git a/src/netedit/elements/additional/GNEBusStop.cpp b/src/netedit/elements/additional/GNEBusStop.cpp
index e7decdf2448b..ff08f7b1b83c 100644
--- a/src/netedit/elements/additional/GNEBusStop.cpp
+++ b/src/netedit/elements/additional/GNEBusStop.cpp
@@ -131,7 +131,7 @@ GNEBusStop::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(busStopExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor baseColor, signColor;
             // set colors
diff --git a/src/netedit/elements/additional/GNECalibrator.cpp b/src/netedit/elements/additional/GNECalibrator.cpp
index 3c59d639d727..de34f3d92831 100644
--- a/src/netedit/elements/additional/GNECalibrator.cpp
+++ b/src/netedit/elements/additional/GNECalibrator.cpp
@@ -436,7 +436,7 @@ void
 GNECalibrator::drawCalibratorSymbol(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d, const double exaggeration,
         const Position& pos, const double rot) const {
     // draw geometry only if we'rent in drawForObjectUnderCursor mode
-    if (!s.drawForObjectUnderCursor) {
+    if (!s.drawForViewObjectsHandler) {
         // push layer matrix
         GLHelper::pushMatrix();
         // translate to front
diff --git a/src/netedit/elements/additional/GNEChargingStation.cpp b/src/netedit/elements/additional/GNEChargingStation.cpp
index fa5bb1ad48e2..3a83ce69bdc2 100644
--- a/src/netedit/elements/additional/GNEChargingStation.cpp
+++ b/src/netedit/elements/additional/GNEChargingStation.cpp
@@ -133,7 +133,7 @@ GNEChargingStation::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(chargingStationExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor baseColor, signColor;
             // set colors
diff --git a/src/netedit/elements/additional/GNEContainerStop.cpp b/src/netedit/elements/additional/GNEContainerStop.cpp
index 89ae5c5ce3c8..c9564e7c28d1 100644
--- a/src/netedit/elements/additional/GNEContainerStop.cpp
+++ b/src/netedit/elements/additional/GNEContainerStop.cpp
@@ -127,7 +127,7 @@ GNEContainerStop::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(containerStopExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor baseColor, signColor;
             // set colors
diff --git a/src/netedit/elements/additional/GNEEntryExitDetector.cpp b/src/netedit/elements/additional/GNEEntryExitDetector.cpp
index 56f3c568e322..16e0777c8673 100644
--- a/src/netedit/elements/additional/GNEEntryExitDetector.cpp
+++ b/src/netedit/elements/additional/GNEEntryExitDetector.cpp
@@ -131,7 +131,7 @@ GNEEntryExitDetector::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(entryExitExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw parent and child lines
             drawParentChildLines(s, s.additionalSettings.connectionColor);
             // Push layer matrix
diff --git a/src/netedit/elements/additional/GNEInductionLoopDetector.cpp b/src/netedit/elements/additional/GNEInductionLoopDetector.cpp
index f8ed4bc5c8b1..6c9f747ff067 100644
--- a/src/netedit/elements/additional/GNEInductionLoopDetector.cpp
+++ b/src/netedit/elements/additional/GNEInductionLoopDetector.cpp
@@ -164,7 +164,7 @@ GNEInductionLoopDetector::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(E1Exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor mainColor, secondColor, textColor;
             // set color
diff --git a/src/netedit/elements/additional/GNEInstantInductionLoopDetector.cpp b/src/netedit/elements/additional/GNEInstantInductionLoopDetector.cpp
index 9e9709c44723..e4dfd4bdf15d 100644
--- a/src/netedit/elements/additional/GNEInstantInductionLoopDetector.cpp
+++ b/src/netedit/elements/additional/GNEInstantInductionLoopDetector.cpp
@@ -146,7 +146,7 @@ GNEInstantInductionLoopDetector::drawGL(const GUIVisualizationSettings& s) const
         // get detail level
         const auto d = s.getDetailLevel(E1InstantExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor mainColor, secondColor, textColor;
             // set color
diff --git a/src/netedit/elements/additional/GNELaneAreaDetector.cpp b/src/netedit/elements/additional/GNELaneAreaDetector.cpp
index ac28c05eb8fc..7569949577aa 100644
--- a/src/netedit/elements/additional/GNELaneAreaDetector.cpp
+++ b/src/netedit/elements/additional/GNELaneAreaDetector.cpp
@@ -278,7 +278,7 @@ GNELaneAreaDetector::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(E2Exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw E2
             drawE2(s, d, E2Exaggeration);
             // draw lock icon
@@ -341,7 +341,7 @@ GNELaneAreaDetector::drawLanePartialGL(const GUIVisualizationSettings& s, const
             E2Geometry = segment->getLane()->getLaneGeometry();
         }
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw E2 partial
             drawE2PartialLane(s, d, segment, offsetFront, E2Geometry, E2Exaggeration);
             // draw additional ID
@@ -373,7 +373,7 @@ GNELaneAreaDetector::drawJunctionPartialGL(const GUIVisualizationSettings& s, co
         const GUIGeometry& E2Geometry = connectionExist? segment->getPreviousLane()->getLane2laneConnections().getLane2laneGeometry(segment->getNextLane()) :
                                                          GUIGeometry({segment->getPreviousLane()->getLaneShape().back(), segment->getNextLane()->getLaneShape().front()});
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw E2 partial
             drawE2PartialJunction(s, d, onlyContour, offsetFront, E2Geometry, E2Exaggeration);
             // draw dotted contour
diff --git a/src/netedit/elements/additional/GNEOverheadWire.cpp b/src/netedit/elements/additional/GNEOverheadWire.cpp
index a9de6b944548..c127879160a9 100644
--- a/src/netedit/elements/additional/GNEOverheadWire.cpp
+++ b/src/netedit/elements/additional/GNEOverheadWire.cpp
@@ -278,7 +278,7 @@ GNEOverheadWire::drawLanePartialGL(const GUIVisualizationSettings& s, const GNEP
         overheadWireGeometryTop.moveGeometryToSide(overheadWireWidth * 0.5);
         overheadWireGeometryBot.moveGeometryToSide(overheadWireWidth * -0.5);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // obtain color
             const RGBColor overheadWireColorTop = drawUsingSelectColor() ? s.colorSettings.selectedAdditionalColor : s.additionalSettings.overheadWireColorTop;
             const RGBColor overheadWireColorBot = drawUsingSelectColor() ? s.colorSettings.selectedAdditionalColor : s.additionalSettings.overheadWireColorBot;
@@ -340,7 +340,7 @@ GNEOverheadWire::drawJunctionPartialGL(const GUIVisualizationSettings& s, const
         overheadWireGeometryTop.moveGeometryToSide(overheadWireWidth * 0.5);
         overheadWireGeometryBot.moveGeometryToSide(overheadWireWidth * -0.5);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // Add a draw matrix
             GLHelper::pushMatrix();
             // Start with the drawing of the area traslating matrix to origin
diff --git a/src/netedit/elements/additional/GNEPOI.cpp b/src/netedit/elements/additional/GNEPOI.cpp
index fb8e93096a8b..455c6a07df08 100644
--- a/src/netedit/elements/additional/GNEPOI.cpp
+++ b/src/netedit/elements/additional/GNEPOI.cpp
@@ -345,7 +345,7 @@ GNEPOI::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(POIExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw POI
             drawPOI(s, d);
             // draw lock icon
diff --git a/src/netedit/elements/additional/GNEParkingArea.cpp b/src/netedit/elements/additional/GNEParkingArea.cpp
index 25cd9a49e277..f3b063237bae 100644
--- a/src/netedit/elements/additional/GNEParkingArea.cpp
+++ b/src/netedit/elements/additional/GNEParkingArea.cpp
@@ -160,7 +160,7 @@ GNEParkingArea::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(parkingAreaExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor baseColor, signColor;
             // set colors
diff --git a/src/netedit/elements/additional/GNEParkingSpace.cpp b/src/netedit/elements/additional/GNEParkingSpace.cpp
index 41bb349cbd0d..c10af7820c8b 100644
--- a/src/netedit/elements/additional/GNEParkingSpace.cpp
+++ b/src/netedit/elements/additional/GNEParkingSpace.cpp
@@ -210,7 +210,7 @@ GNEParkingSpace::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(spaceExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw space
             drawSpace(s, d, parkingSpaceWidth);
             // draw parent and child lines
diff --git a/src/netedit/elements/additional/GNEPoly.cpp b/src/netedit/elements/additional/GNEPoly.cpp
index 358339782fc9..eb6c8cd0a711 100644
--- a/src/netedit/elements/additional/GNEPoly.cpp
+++ b/src/netedit/elements/additional/GNEPoly.cpp
@@ -293,7 +293,7 @@ GNEPoly::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(polyExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // get colors
             const RGBColor color = isAttributeCarrierSelected() ? s.colorSettings.selectionColor : getShapeColor();
             // push layer matrix
diff --git a/src/netedit/elements/additional/GNERerouterSymbol.cpp b/src/netedit/elements/additional/GNERerouterSymbol.cpp
index 61aceb8ea5cd..bcac7426999a 100644
--- a/src/netedit/elements/additional/GNERerouterSymbol.cpp
+++ b/src/netedit/elements/additional/GNERerouterSymbol.cpp
@@ -139,7 +139,7 @@ GNERerouterSymbol::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(rerouteExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw rerouter symbol
             drawRerouterSymbol(s, d, rerouteExaggeration);
             // draw parent and child lines
diff --git a/src/netedit/elements/additional/GNERouteProbe.cpp b/src/netedit/elements/additional/GNERouteProbe.cpp
index 0c0006ffea7c..73e62c60f28f 100644
--- a/src/netedit/elements/additional/GNERouteProbe.cpp
+++ b/src/netedit/elements/additional/GNERouteProbe.cpp
@@ -161,7 +161,7 @@ GNERouteProbe::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(routeProbeExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw parent and child lines
             drawParentChildLines(s, s.additionalSettings.connectionColor);
             // Add layer matrix matrix
diff --git a/src/netedit/elements/additional/GNETAZ.cpp b/src/netedit/elements/additional/GNETAZ.cpp
index 086589ef9929..36bdb715e5fd 100644
--- a/src/netedit/elements/additional/GNETAZ.cpp
+++ b/src/netedit/elements/additional/GNETAZ.cpp
@@ -296,7 +296,7 @@ GNETAZ::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(TAZExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // Obtain constants
             const Position mousePosition = myNet->getViewNet()->getPositionInformation();
             const bool drawFill = (myNet->getViewNet()->getEditModes().isCurrentSupermodeData() && myNet->getViewNet()->getDataViewOptions().TAZDrawFill()) ? true : getFill();
diff --git a/src/netedit/elements/additional/GNEVaporizer.cpp b/src/netedit/elements/additional/GNEVaporizer.cpp
index beb45b6c3ac9..ba25253bfac3 100644
--- a/src/netedit/elements/additional/GNEVaporizer.cpp
+++ b/src/netedit/elements/additional/GNEVaporizer.cpp
@@ -138,7 +138,7 @@ GNEVaporizer::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(vaporizerExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // declare colors
             RGBColor vaporizerColor, centralLineColor;
             // set colors
diff --git a/src/netedit/elements/additional/GNEVariableSpeedSignSymbol.cpp b/src/netedit/elements/additional/GNEVariableSpeedSignSymbol.cpp
index fed125efbb09..9b8ca5e1542c 100644
--- a/src/netedit/elements/additional/GNEVariableSpeedSignSymbol.cpp
+++ b/src/netedit/elements/additional/GNEVariableSpeedSignSymbol.cpp
@@ -122,7 +122,7 @@ GNEVariableSpeedSignSymbol::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(VSSExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw variable speed sign symbol
             drawVSSSymbol(s, d, VSSExaggeration);
             // draw parent and child lines
diff --git a/src/netedit/elements/data/GNEEdgeData.cpp b/src/netedit/elements/data/GNEEdgeData.cpp
index 210e541d03e0..8047b72f1ea2 100644
--- a/src/netedit/elements/data/GNEEdgeData.cpp
+++ b/src/netedit/elements/data/GNEEdgeData.cpp
@@ -207,7 +207,7 @@ GNEEdgeData::drawLanePartialGL(const GUIVisualizationSettings& s, const GNEPathM
         // get detail level
         const auto d = s.getDetailLevel(1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw over all edge's lanes
             for (const auto& laneEdge : segment->getLane()->getParentEdge()->getLanes()) {
                 // Add a draw matrix
diff --git a/src/netedit/elements/data/GNETAZRelData.cpp b/src/netedit/elements/data/GNETAZRelData.cpp
index 25753dfe875f..2072382c3f2e 100644
--- a/src/netedit/elements/data/GNETAZRelData.cpp
+++ b/src/netedit/elements/data/GNETAZRelData.cpp
@@ -258,7 +258,7 @@ GNETAZRelData::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             const auto& color = setColor(s);
             // get flag for only draw contour
             const bool onlyDrawContour = !isGenericDataVisible();
diff --git a/src/netedit/elements/demand/GNEContainer.cpp b/src/netedit/elements/demand/GNEContainer.cpp
index 5e9878688a1c..b1353c3ca1d8 100644
--- a/src/netedit/elements/demand/GNEContainer.cpp
+++ b/src/netedit/elements/demand/GNEContainer.cpp
@@ -346,7 +346,7 @@ GNEContainer::drawGL(const GUIVisualizationSettings& s) const {
         // obtain position
         const Position containerPosition = getAttributePosition(SUMO_ATTR_DEPARTPOS);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // obtain img file
             const std::string file = getTypeParent()->getAttribute(SUMO_ATTR_IMGFILE);
             // push draw matrix
diff --git a/src/netedit/elements/demand/GNEDemandElementPlan.cpp b/src/netedit/elements/demand/GNEDemandElementPlan.cpp
index 643e8a9d2a65..f8643d623cc9 100644
--- a/src/netedit/elements/demand/GNEDemandElementPlan.cpp
+++ b/src/netedit/elements/demand/GNEDemandElementPlan.cpp
@@ -1111,7 +1111,7 @@ GNEDemandElementPlan::drawPlanGL(const bool drawPlan, const GUIVisualizationSett
         // calculate path width
         const double pathWidth = 0.25 * (duplicateWidth ? 2 : 1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // push matrix
             GLHelper::pushMatrix();
             // translate to front
@@ -1183,7 +1183,7 @@ GNEDemandElementPlan::drawPlanLanePartial(const bool drawPlan, const GUIVisualiz
             planGeometry = segment->getLane()->getLaneGeometry();
         }
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // Add a draw matrix
             GLHelper::pushMatrix();
             // Start with the drawing of the area traslating matrix to origin
@@ -1240,7 +1240,7 @@ GNEDemandElementPlan::drawPlanJunctionPartial(const bool drawPlan, const GUIVisu
         // calculate path width
         const double pathWidth = s.addSize.getExaggeration(s, segment->getPreviousLane()) * planWidth * (duplicateWidth ? 2 : 1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // push a draw matrix
             GLHelper::pushMatrix();
             // Start with the drawing of the area traslating matrix to origin
diff --git a/src/netedit/elements/demand/GNEPerson.cpp b/src/netedit/elements/demand/GNEPerson.cpp
index 85fe7f8b77c4..0967305cef96 100644
--- a/src/netedit/elements/demand/GNEPerson.cpp
+++ b/src/netedit/elements/demand/GNEPerson.cpp
@@ -350,7 +350,7 @@ GNEPerson::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // obtain width and length
             const double length = getTypeParent()->getAttributeDouble(SUMO_ATTR_LENGTH);
             const double width = getTypeParent()->getAttributeDouble(SUMO_ATTR_WIDTH);
diff --git a/src/netedit/elements/demand/GNERoute.cpp b/src/netedit/elements/demand/GNERoute.cpp
index 6267054e730c..d65504b1c22e 100644
--- a/src/netedit/elements/demand/GNERoute.cpp
+++ b/src/netedit/elements/demand/GNERoute.cpp
@@ -458,7 +458,7 @@ GNERoute::drawLanePartialGL(const GUIVisualizationSettings& s, const GNEPathMana
             routeGeometry = segment->getLane()->getLaneGeometry();
         }
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw route partial lane
             drawRoutePartialLane(s, d, segment, offsetFront, routeGeometry, exaggeration);
             // draw name
@@ -491,7 +491,7 @@ GNERoute::drawJunctionPartialGL(const GUIVisualizationSettings& s, const GNEPath
         const GUIGeometry& routeGeometry = connectionExist? segment->getPreviousLane()->getLane2laneConnections().getLane2laneGeometry(segment->getNextLane()) :
                                                          GUIGeometry({segment->getPreviousLane()->getLaneShape().back(), segment->getNextLane()->getLaneShape().front()});
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw route partial
             drawRoutePartialJunction(s, d, offsetFront, routeGeometry, routeExaggeration);
             // draw dotted contour
diff --git a/src/netedit/elements/demand/GNEStop.cpp b/src/netedit/elements/demand/GNEStop.cpp
index 2e801dc2e2a1..95c770c2b75a 100644
--- a/src/netedit/elements/demand/GNEStop.cpp
+++ b/src/netedit/elements/demand/GNEStop.cpp
@@ -382,7 +382,7 @@ GNEStop::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // get color
             const auto color = drawUsingSelectColor() ? s.colorSettings.selectedRouteColor : getColor();
             // Add a layer matrix
diff --git a/src/netedit/elements/demand/GNEStopPlan.cpp b/src/netedit/elements/demand/GNEStopPlan.cpp
index 9e5e41429bda..350eb5521299 100644
--- a/src/netedit/elements/demand/GNEStopPlan.cpp
+++ b/src/netedit/elements/demand/GNEStopPlan.cpp
@@ -395,7 +395,7 @@ GNEStopPlan::getACParametersMap() const {
 void
 GNEStopPlan::drawStopOverEdge(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d, const double exaggeration) const {
     // draw geometry only if we'rent in drawForObjectUnderCursor mode
-    if (!s.drawForObjectUnderCursor) {
+    if (!s.drawForViewObjectsHandler) {
         // declare stop color
         const RGBColor stopColor = drawUsingSelectColor() ? s.colorSettings.selectedPersonPlanColor : s.colorSettings.stopColor;
         // Add layer matrix matrix
@@ -458,7 +458,7 @@ GNEStopPlan::drawStopOverEdge(const GUIVisualizationSettings& s, const GUIVisual
 void
 GNEStopPlan::drawStopOverStoppingPlace(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d, const double exaggeration) const {
     // draw geometry only if we'rent in drawForObjectUnderCursor mode
-    if (!s.drawForObjectUnderCursor) {
+    if (!s.drawForViewObjectsHandler) {
         // declare stop color
         const RGBColor stopColor = drawUsingSelectColor() ? s.colorSettings.selectedPersonPlanColor : s.colorSettings.stopColor;
         // Add layer matrix matrix
diff --git a/src/netedit/elements/demand/GNEVehicle.cpp b/src/netedit/elements/demand/GNEVehicle.cpp
index 3a0c98c12b6d..8be0bb3dba63 100644
--- a/src/netedit/elements/demand/GNEVehicle.cpp
+++ b/src/netedit/elements/demand/GNEVehicle.cpp
@@ -871,7 +871,7 @@ GNEVehicle::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(exaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // first check if if mouse is enough near to this vehicle to draw it
             if (s.drawForRectangleSelection && (myNet->getViewNet()->getPositionInformation().distanceSquaredTo2D(vehiclePosition) >= (vehicleSizeSquared + 2))) {
                 // push draw matrix
@@ -1064,7 +1064,7 @@ GNEVehicle::drawLanePartialGL(const GUIVisualizationSettings& s, const GNEPathMa
             vehicleGeometry = segment->getLane()->getLaneGeometry();
         }
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // obtain color
             const RGBColor pathColor = drawUsingSelectColor() ? s.colorSettings.selectedVehicleColor : s.colorSettings.vehicleTripColor;
             // Add a draw matrix
@@ -1147,7 +1147,7 @@ GNEVehicle::drawJunctionPartialGL(const GUIVisualizationSettings& s, const GNEPa
         // calculate width
         const double width = s.vehicleSize.getExaggeration(s, segment->getPreviousLane()) * s.widthSettings.tripWidth;
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // Add a draw matrix
             GLHelper::pushMatrix();
             // Start with the drawing of the area translating matrix to origin
diff --git a/src/netedit/elements/network/GNEConnection.cpp b/src/netedit/elements/network/GNEConnection.cpp
index aa7542630727..3cb0c697bafd 100644
--- a/src/netedit/elements/network/GNEConnection.cpp
+++ b/src/netedit/elements/network/GNEConnection.cpp
@@ -404,7 +404,7 @@ GNEConnection::drawGL(const GUIVisualizationSettings& s) const {
             shapeSuperposed.move2side(0.5);
         }
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw connection
             drawConnection(s, d, shapeSuperposed, connectionExaggeration);
             // draw lock icon
diff --git a/src/netedit/elements/network/GNECrossing.cpp b/src/netedit/elements/network/GNECrossing.cpp
index 1bb448bd52c7..f89c57445d68 100644
--- a/src/netedit/elements/network/GNECrossing.cpp
+++ b/src/netedit/elements/network/GNECrossing.cpp
@@ -235,7 +235,7 @@ GNECrossing::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(crossingExaggeration);
         // check if draw geometry
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw crossing
             drawCrossing(s, d, NBCrossing, crossingWidth, crossingExaggeration);
             // draw TLS Links No
diff --git a/src/netedit/elements/network/GNEEdge.cpp b/src/netedit/elements/network/GNEEdge.cpp
index da65cce5c0a7..86e11d4a2540 100644
--- a/src/netedit/elements/network/GNEEdge.cpp
+++ b/src/netedit/elements/network/GNEEdge.cpp
@@ -586,7 +586,7 @@ GNEEdge::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level from the first lane
         const auto d = myLanes.front()->getDrawingConstants()->getDetail();
         // check if draw details
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw geometry points
             drawEdgeGeometryPoints(s, d);
             // draw edge shape (a red line only visible if lane shape is strange)
@@ -2728,7 +2728,7 @@ GNEEdge::drawLaneStopOffset(const GUIVisualizationSettings& s, const GUIVisualiz
 void
 GNEEdge::drawChildrens(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const {
     // check if draw children elements
-    if (s.drawForObjectUnderCursor || (d <= GUIVisualizationSettings::Detail::Additionals)) {
+    if (s.drawForViewObjectsHandler || (d <= GUIVisualizationSettings::Detail::Additionals)) {
         // draw child additional
         for (const auto& additional : getChildAdditionals()) {
             additional->drawGL(s);
diff --git a/src/netedit/elements/network/GNEInternalLane.cpp b/src/netedit/elements/network/GNEInternalLane.cpp
index 07cf03704b23..25c1e1152e88 100644
--- a/src/netedit/elements/network/GNEInternalLane.cpp
+++ b/src/netedit/elements/network/GNEInternalLane.cpp
@@ -188,7 +188,7 @@ GNEInternalLane::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(1);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // get link state color
             const auto linkStateColor = colorForLinksState(myState);
             // push layer matrix
diff --git a/src/netedit/elements/network/GNEJunction.cpp b/src/netedit/elements/network/GNEJunction.cpp
index 8e7236397512..7e06ffa145fe 100644
--- a/src/netedit/elements/network/GNEJunction.cpp
+++ b/src/netedit/elements/network/GNEJunction.cpp
@@ -635,7 +635,7 @@ GNEJunction::drawGL(const GUIVisualizationSettings& s) const {
             // check if draw junction as shape
             const bool drawBubble = drawAsBubble(s);
             // draw geometry only if we'rent in drawForObjectUnderCursor mode
-            if (!s.drawForObjectUnderCursor) {
+            if (!s.drawForViewObjectsHandler) {
                 // push layer matrix
                 GLHelper::pushMatrix();
                 // translate to front
@@ -1722,7 +1722,7 @@ GNEJunction::drawJunctionName(const GUIVisualizationSettings& s, const GUIVisual
 void
 GNEJunction::drawJunctionChildren(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d) const {
     // check if draw junction elements
-    if (s.drawForObjectUnderCursor || (d <= GUIVisualizationSettings::Detail::JunctionElement)) {
+    if (s.drawForViewObjectsHandler || (d <= GUIVisualizationSettings::Detail::JunctionElement)) {
         // draw crossings
         for (const auto& crossing : myGNECrossings) {
             crossing->drawGL(s);
@@ -1911,7 +1911,7 @@ void
 GNEJunction::commitMoveShape(const GNEMoveResult& moveResult, GNEUndoList* undoList) {
     // check if there is another junction in the same position
     GNEJunction* secondJunction = nullptr;
-    const auto& clickedJunctions = myNet->getViewNet()->getObjectsUnderCursor().getClickedJunctions();
+    const auto& clickedJunctions = myNet->getViewNet()->getObjectsUnderCursor().getJunctions();
     for (auto it = clickedJunctions.begin(); (it != clickedJunctions.end()) && (secondJunction == nullptr); it++) {
         if (*it != this) {
             secondJunction = *it;
diff --git a/src/netedit/elements/network/GNELane.cpp b/src/netedit/elements/network/GNELane.cpp
index 0a3a5ebb2067..1c0a1395e981 100644
--- a/src/netedit/elements/network/GNELane.cpp
+++ b/src/netedit/elements/network/GNELane.cpp
@@ -468,7 +468,7 @@ GNELane::drawGL(const GUIVisualizationSettings& s) const {
     // update lane drawing constan
     myDrawingConstants->update(s);
     // check drawing conditions
-    if (!s.drawForObjectUnderCursor) {
+    if (!s.drawForViewObjectsHandler) {
         // draw lane
         drawLane(s);
         // draw lock icon
@@ -1105,7 +1105,7 @@ GNELane::drawShapeEdited(const GUIVisualizationSettings& s) const {
 void
 GNELane::drawChildren(const GUIVisualizationSettings& s) const {
     // check if draw children elements
-    if (s.drawForObjectUnderCursor || (myDrawingConstants->getDetail() <= GUIVisualizationSettings::Detail::Additionals)) {
+    if (s.drawForViewObjectsHandler || (myDrawingConstants->getDetail() <= GUIVisualizationSettings::Detail::Additionals)) {
         // draw additional children
         for (const auto& additional : getChildAdditionals()) {
             // check that ParkingAreas aren't draw two times
diff --git a/src/netedit/elements/network/GNEWalkingArea.cpp b/src/netedit/elements/network/GNEWalkingArea.cpp
index 6e2253d426c2..ab497be7eed4 100644
--- a/src/netedit/elements/network/GNEWalkingArea.cpp
+++ b/src/netedit/elements/network/GNEWalkingArea.cpp
@@ -161,7 +161,7 @@ GNEWalkingArea::drawGL(const GUIVisualizationSettings& s) const {
         // get detail level
         const auto d = s.getDetailLevel(walkingAreaExaggeration);
         // draw geometry only if we'rent in drawForObjectUnderCursor mode
-        if (!s.drawForObjectUnderCursor) {
+        if (!s.drawForViewObjectsHandler) {
             // draw walking area
             drawWalkingArea(s, d, walkingAreaShape, walkingAreaExaggeration);
             // draw walkingArea name
diff --git a/src/netedit/frames/GNEOverlappedInspection.cpp b/src/netedit/frames/GNEOverlappedInspection.cpp
index c64a4196e4e4..88f02b4ed576 100644
--- a/src/netedit/frames/GNEOverlappedInspection.cpp
+++ b/src/netedit/frames/GNEOverlappedInspection.cpp
@@ -72,11 +72,11 @@ GNEOverlappedInspection::~GNEOverlappedInspection() {}
 
 
 void
-GNEOverlappedInspection::showOverlappedInspection(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const Position& clickedPosition) {
+GNEOverlappedInspection::showOverlappedInspection(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const Position& clickedPosition) {
     // first clear myOverlappedACs
     myOverlappedACs.clear();
     // get cliked ACs
-    auto clickedACs = objectsUnderCursor.getClickedAttributeCarriers();
+    auto clickedACs = viewObjects.getAttributeCarriers();
     // check if filter edges
     if ((clickedACs.size() > 0) && (clickedACs.front()->getTagProperty().getTag() == SUMO_TAG_LANE)) {
         // iterate over clickedAcs and remove edges
diff --git a/src/netedit/frames/GNEOverlappedInspection.h b/src/netedit/frames/GNEOverlappedInspection.h
index 9c9190071c97..07715932bd3b 100644
--- a/src/netedit/frames/GNEOverlappedInspection.h
+++ b/src/netedit/frames/GNEOverlappedInspection.h
@@ -47,7 +47,7 @@ class GNEOverlappedInspection : public MFXGroupBoxModule {
     ~GNEOverlappedInspection();
 
     /// @brief show template editor
-    void showOverlappedInspection(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const Position& clickedPosition);
+    void showOverlappedInspection(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const Position& clickedPosition);
 
     /// @brief hide template editor
     void hideOverlappedInspection();
diff --git a/src/netedit/frames/common/GNEDeleteFrame.cpp b/src/netedit/frames/common/GNEDeleteFrame.cpp
index afbdbad97aab..5be48a2cce2d 100644
--- a/src/netedit/frames/common/GNEDeleteFrame.cpp
+++ b/src/netedit/frames/common/GNEDeleteFrame.cpp
@@ -414,14 +414,14 @@ GNEDeleteFrame::removeSelectedAttributeCarriers() {
 
 
 void
-GNEDeleteFrame::removeAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEDeleteFrame::removeAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // disable update geometry
     myViewNet->getNet()->disableUpdateGeometry();
     // first check if there more than one clicked GL object under cursor
-    if (objectsUnderCursor.getClickedGLObjects().size() > 1) {
+    if (viewObjects.getGLObjects().size() > 1) {
         std::vector<GUIGlObject*> filteredGLObjects;
         // filter objects
-        for (const auto& glObject : objectsUnderCursor.getClickedGLObjects()) {
+        for (const auto& glObject : viewObjects.getGLObjects()) {
             if (glObject->isGLObjectLocked()) {
                 continue;
             }
@@ -436,9 +436,9 @@ GNEDeleteFrame::removeAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCurso
         } else if (filteredGLObjects.size() > 0) {
             filteredGLObjects.front()->deleteGLObject();
         }
-    } else if ((objectsUnderCursor.getClickedGLObjects().size() > 0) &&
-               !objectsUnderCursor.getClickedGLObjects().front()->isGLObjectLocked()) {
-        objectsUnderCursor.getClickedGLObjects().front()->deleteGLObject();
+    } else if ((viewObjects.getGLObjects().size() > 0) &&
+               !viewObjects.getGLObjects().front()->isGLObjectLocked()) {
+        viewObjects.getGLObjects().front()->deleteGLObject();
     }
     // enable update geometry
     myViewNet->getNet()->enableUpdateGeometry();
@@ -448,19 +448,19 @@ GNEDeleteFrame::removeAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCurso
 
 
 bool
-GNEDeleteFrame::removeGeometryPoint(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEDeleteFrame::removeGeometryPoint(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get clicked position
     const Position clickedPosition = myViewNet->getPositionInformation();
     // filter elements with geometry points
-    for (const auto& AC : objectsUnderCursor.getClickedAttributeCarriers()) {
+    for (const auto& AC : viewObjects.getAttributeCarriers()) {
         if (AC->getTagProperty().getTag() == SUMO_TAG_EDGE) {
-            objectsUnderCursor.getEdgeFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
+            viewObjects.getEdgeFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
             return true;
         } else if (AC->getTagProperty().getTag() == SUMO_TAG_POLY) {
-            objectsUnderCursor.getPolyFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
+            viewObjects.getPolyFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
             return true;
         } else if (AC->getTagProperty().getTag() == SUMO_TAG_TAZ) {
-            objectsUnderCursor.getTAZFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
+            viewObjects.getTAZFront()->removeGeometryPoint(clickedPosition, myViewNet->getUndoList());
             return true;
         }
     }
diff --git a/src/netedit/frames/common/GNEDeleteFrame.h b/src/netedit/frames/common/GNEDeleteFrame.h
index 8cf9e94962a8..f93041d656e0 100644
--- a/src/netedit/frames/common/GNEDeleteFrame.h
+++ b/src/netedit/frames/common/GNEDeleteFrame.h
@@ -223,14 +223,14 @@ class GNEDeleteFrame : public GNEFrame {
     void removeSelectedAttributeCarriers();
 
     /**@brief remove attribute carrier (element)
-     * @param objectsUnderCursor objects under cursors
+     * @param viewObjects objects under cursors
      */
-    void removeAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    void removeAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /**@brief remove geometry point
-     * @param objectsUnderCursor objects under cursors
+     * @param viewObjects objects under cursors
      */
-    bool removeGeometryPoint(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool removeGeometryPoint(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get delete options modul
     DeleteOptions* getDeleteOptions() const;
diff --git a/src/netedit/frames/common/GNEInspectorFrame.cpp b/src/netedit/frames/common/GNEInspectorFrame.cpp
index 83626eb820b0..ef1b980453b2 100644
--- a/src/netedit/frames/common/GNEInspectorFrame.cpp
+++ b/src/netedit/frames/common/GNEInspectorFrame.cpp
@@ -882,9 +882,9 @@ GNEInspectorFrame::hide() {
 
 
 bool
-GNEInspectorFrame::processNetworkSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEInspectorFrame::processNetworkSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get unlocked attribute carrier front
-    auto AC = objectsUnderCursor.getAttributeCarrierFront();
+    auto AC = viewObjects.getAttributeCarrierFront();
     // first check if we have clicked over an Attribute Carrier
     if (AC) {
         // if Control key is Pressed, select instead inspect element
@@ -900,11 +900,11 @@ GNEInspectorFrame::processNetworkSupermodeClick(const Position& clickedPosition,
             if (myViewNet->getMouseButtonKeyPressed().shiftKeyPressed()) {
                 if (!myOverlappedInspection->previousElement(clickedPosition)) {
                     // inspect attribute carrier, (or multiselection if AC is selected)
-                    inspectClickedElement(objectsUnderCursor, clickedPosition);
+                    inspectClickedElement(viewObjects, clickedPosition);
                 }
             } else if (!myOverlappedInspection->nextElement(clickedPosition)) {
                 // inspect attribute carrier, (or multiselection if AC is selected)
-                inspectClickedElement(objectsUnderCursor, clickedPosition);
+                inspectClickedElement(viewObjects, clickedPosition);
             }
             // focus upper element of inspector frame
             focusUpperElement();
@@ -917,9 +917,9 @@ GNEInspectorFrame::processNetworkSupermodeClick(const Position& clickedPosition,
 
 
 bool
-GNEInspectorFrame::processDemandSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEInspectorFrame::processDemandSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get unlocked attribute carrier front
-    auto AC = objectsUnderCursor.getAttributeCarrierFront();
+    auto AC = viewObjects.getAttributeCarrierFront();
     // first check if we have clicked over a demand element
     if (AC) {
         // if Control key is Pressed, select instead inspect element
@@ -935,11 +935,11 @@ GNEInspectorFrame::processDemandSupermodeClick(const Position& clickedPosition,
             if (myViewNet->getMouseButtonKeyPressed().shiftKeyPressed()) {
                 if (!myOverlappedInspection->previousElement(clickedPosition)) {
                     // inspect attribute carrier, (or multiselection if AC is selected)
-                    inspectClickedElement(objectsUnderCursor, clickedPosition);
+                    inspectClickedElement(viewObjects, clickedPosition);
                 }
             } else  if (!myOverlappedInspection->nextElement(clickedPosition)) {
                 // inspect attribute carrier, (or multiselection if AC is selected)
-                inspectClickedElement(objectsUnderCursor, clickedPosition);
+                inspectClickedElement(viewObjects, clickedPosition);
             }
             // focus upper element of inspector frame
             focusUpperElement();
@@ -952,9 +952,9 @@ GNEInspectorFrame::processDemandSupermodeClick(const Position& clickedPosition,
 
 
 bool
-GNEInspectorFrame::processDataSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEInspectorFrame::processDataSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get unlocked attribute carrier front
-    auto AC = objectsUnderCursor.getAttributeCarrierFront();
+    auto AC = viewObjects.getAttributeCarrierFront();
     // first check if we have clicked over a data element
     if (AC) {
         // if Control key is Pressed, select instead inspect element
@@ -970,11 +970,11 @@ GNEInspectorFrame::processDataSupermodeClick(const Position& clickedPosition, GN
             if (myViewNet->getMouseButtonKeyPressed().shiftKeyPressed()) {
                 if (!myOverlappedInspection->previousElement(clickedPosition)) {
                     // inspect attribute carrier, (or multiselection if AC is selected)
-                    inspectClickedElement(objectsUnderCursor, clickedPosition);
+                    inspectClickedElement(viewObjects, clickedPosition);
                 }
             } else  if (!myOverlappedInspection->nextElement(clickedPosition)) {
                 // inspect attribute carrier, (or multiselection if AC is selected)
-                inspectClickedElement(objectsUnderCursor, clickedPosition);
+                inspectClickedElement(viewObjects, clickedPosition);
             }
             // focus upper element of inspector frame
             focusUpperElement();
@@ -1205,15 +1205,15 @@ GNEInspectorFrame::selectedOverlappedElement(GNEAttributeCarrier* AC) {
 
 
 void
-GNEInspectorFrame::inspectClickedElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const Position& clickedPosition) {
+GNEInspectorFrame::inspectClickedElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const Position& clickedPosition) {
     // get front unlocked AC
-    const auto AC = objectsUnderCursor.getAttributeCarrierFront();
+    const auto AC = viewObjects.getAttributeCarrierFront();
     // check if selection is blocked
     if (AC) {
         // inspect front element
         inspectSingleElement(AC);
         // show Overlapped Inspection module
-        myOverlappedInspection->showOverlappedInspection(objectsUnderCursor, clickedPosition);
+        myOverlappedInspection->showOverlappedInspection(viewObjects, clickedPosition);
     }
 }
 
diff --git a/src/netedit/frames/common/GNEInspectorFrame.h b/src/netedit/frames/common/GNEInspectorFrame.h
index 7fab93f229da..f856182defb9 100644
--- a/src/netedit/frames/common/GNEInspectorFrame.h
+++ b/src/netedit/frames/common/GNEInspectorFrame.h
@@ -318,24 +318,24 @@ class GNEInspectorFrame : public GNEFrame {
 
     /**@brief process click over Viewnet in Supermode Network
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param[in] objectsUnderCursor objects under cursors
+     * @param[in] viewObjects objects under cursors
      * @return true if something was sucefully done
      */
-    bool processNetworkSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processNetworkSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /**@brief process click over Viewnet in Supermode Demand
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param[in] objectsUnderCursor objects under cursors
+     * @param[in] viewObjects objects under cursors
      * @return true if something was sucefully done
      */
-    bool processDemandSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processDemandSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /**@brief process click over Viewnet in Supermode Data
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param[in] objectsUnderCursor objects under cursors
+     * @param[in] viewObjects objects under cursors
      * @return true if something was sucefully done
      */
-    bool processDataSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processDataSupermodeClick(const Position& clickedPosition, GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief Inspect a single element
     void inspectSingleElement(GNEAttributeCarrier* AC);
@@ -385,7 +385,7 @@ class GNEInspectorFrame : public GNEFrame {
     FOX_CONSTRUCTOR(GNEInspectorFrame)
 
     /// @brief Inspect a singe element (the front of AC AttributeCarriers of ObjectUnderCursor
-    void inspectClickedElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const Position& clickedPosition);
+    void inspectClickedElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const Position& clickedPosition);
 
     /// @brief function called after set a valid attribute in AttributeEditor
     void attributeUpdated(SumoXMLAttr attribute);
diff --git a/src/netedit/frames/common/GNEMoveFrame.cpp b/src/netedit/frames/common/GNEMoveFrame.cpp
index 14c7aac15b7e..e0ac82c74980 100644
--- a/src/netedit/frames/common/GNEMoveFrame.cpp
+++ b/src/netedit/frames/common/GNEMoveFrame.cpp
@@ -680,8 +680,8 @@ GNEMoveFrame::~GNEMoveFrame() {}
 
 void
 GNEMoveFrame::processClick(const Position& /*clickedPosition*/,
-                           const GNEViewNetHelper::ObjectsUnderCursor& /*objectsUnderCursor*/,
-                           const GNEViewNetHelper::ObjectsUnderCursor& /*objectsUnderGrippedCursor*/) {
+                           const GNEViewNetHelper::ViewObjectsSelector& /*viewObjects*/,
+                           const GNEViewNetHelper::ViewObjectsSelector& /*objectsUnderGrippedCursor*/) {
     // currently unused
 }
 
diff --git a/src/netedit/frames/common/GNEMoveFrame.h b/src/netedit/frames/common/GNEMoveFrame.h
index 9d7caa139ceb..404ba547973f 100644
--- a/src/netedit/frames/common/GNEMoveFrame.h
+++ b/src/netedit/frames/common/GNEMoveFrame.h
@@ -317,12 +317,12 @@ class GNEMoveFrame : public GNEFrame {
 
     /**@brief handle processClick and set the relative coloring
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @param objectsUnderGrippedCursor collection of objects under gripped cursor after click over view
      */
     void processClick(const Position& clickedPosition,
-                      const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor,
-                      const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderGrippedCursor);
+                      const GNEViewNetHelper::ViewObjectsSelector& viewObjects,
+                      const GNEViewNetHelper::ViewObjectsSelector& objectsUnderGrippedCursor);
 
     /// @brief show prohibition frame
     void show();
diff --git a/src/netedit/frames/common/GNESelectorFrame.cpp b/src/netedit/frames/common/GNESelectorFrame.cpp
index 4425e6398c2f..f5214ad28cf0 100644
--- a/src/netedit/frames/common/GNESelectorFrame.cpp
+++ b/src/netedit/frames/common/GNESelectorFrame.cpp
@@ -1370,9 +1370,9 @@ GNESelectorFrame::clearCurrentSelection() const {
 
 
 bool
-GNESelectorFrame::selectAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNESelectorFrame::selectAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get front AC
-    auto AC = objectsUnderCursor.getAttributeCarrierFront();
+    auto AC = viewObjects.getAttributeCarrierFront();
     // check AC
     if (AC == nullptr) {
         return false;
@@ -1393,7 +1393,7 @@ GNESelectorFrame::selectAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCur
         return false;
     }
     // filter GLObjects by layer
-    auto filteredGLObjects = GNEViewNetHelper::filterElementsByLayer(objectsUnderCursor.getClickedGLObjects());
+    auto filteredGLObjects = GNEViewNetHelper::filterElementsByLayer(viewObjects.getGLObjects());
     // check if we have to open dialog
     if (filteredGLObjects.size() > 1) {
         myViewNet->openSelectDialogAtCursor(filteredGLObjects);
diff --git a/src/netedit/frames/common/GNESelectorFrame.h b/src/netedit/frames/common/GNESelectorFrame.h
index c1657dbfc59d..bd2ff795db5e 100644
--- a/src/netedit/frames/common/GNESelectorFrame.h
+++ b/src/netedit/frames/common/GNESelectorFrame.h
@@ -398,9 +398,9 @@ class GNESelectorFrame : public GNEFrame {
     void clearCurrentSelection() const;
 
     /**@brief select attribute carrier (element)
-     * @param objectsUnderCursor objects under cursors
+     * @param viewObjects objects under cursors
      */
-    bool selectAttributeCarrier(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool selectAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /**@brief apply list of ids to the current selection according to Operation,
      * @note if setop==DEFAULT than the currently set mode (myOperation) is used
diff --git a/src/netedit/frames/data/GNEEdgeDataFrame.cpp b/src/netedit/frames/data/GNEEdgeDataFrame.cpp
index bf2b36c9f230..1daab7535280 100644
--- a/src/netedit/frames/data/GNEEdgeDataFrame.cpp
+++ b/src/netedit/frames/data/GNEEdgeDataFrame.cpp
@@ -41,14 +41,14 @@ GNEEdgeDataFrame::~GNEEdgeDataFrame() {}
 
 
 bool
-GNEEdgeDataFrame::addEdgeData(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& /*mouseButtonKeyPressed*/) {
+GNEEdgeDataFrame::addEdgeData(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& /*mouseButtonKeyPressed*/) {
     // first check if we clicked over an edge
-    if (objectsUnderCursor.getEdgeFront() && myDataSetSelector->getDataSet() && myIntervalSelector->getDataInterval()) {
+    if (viewObjects.getEdgeFront() && myDataSetSelector->getDataSet() && myIntervalSelector->getDataInterval()) {
         // first check if the given interval there is already a EdgeData for the given ID
         for (const auto& genericData : myIntervalSelector->getDataInterval()->getGenericDataChildren()) {
-            if ((genericData->getTagProperty().getTag() == GNE_TAG_EDGEREL_SINGLE) && (genericData->getParentEdges().front() == objectsUnderCursor.getEdgeFront())) {
+            if ((genericData->getTagProperty().getTag() == GNE_TAG_EDGEREL_SINGLE) && (genericData->getParentEdges().front() == viewObjects.getEdgeFront())) {
                 // write warning
-                WRITE_WARNINGF(TL("There is already a % in edge '%'"), genericData->getTagStr(), objectsUnderCursor.getEdgeFront()->getID());
+                WRITE_WARNINGF(TL("There is already a % in edge '%'"), genericData->getTagStr(), viewObjects.getEdgeFront()->getID());
                 // abort edge data creation
                 return false;
             }
@@ -64,7 +64,7 @@ GNEEdgeDataFrame::addEdgeData(const GNEViewNetHelper::ObjectsUnderCursor& object
             CommonXMLStructure::SumoBaseObject* genericDataBaseObject = new CommonXMLStructure::SumoBaseObject(intervalBaseObject);
             // finally create edgeData
             GNEDataHandler dataHandler(myViewNet->getNet(), "", true, false);
-            dataHandler.buildEdgeData(genericDataBaseObject, objectsUnderCursor.getEdgeFront()->getID(), myGenericDataAttributes->getParametersMap());
+            dataHandler.buildEdgeData(genericDataBaseObject, viewObjects.getEdgeFront()->getID(), myGenericDataAttributes->getParametersMap());
             // delete intervalBaseObject (and genericDataBaseObject)
             delete intervalBaseObject;
             // edgeData created, then return true
diff --git a/src/netedit/frames/data/GNEEdgeDataFrame.h b/src/netedit/frames/data/GNEEdgeDataFrame.h
index 75cfc65d087e..d8b920cf1422 100644
--- a/src/netedit/frames/data/GNEEdgeDataFrame.h
+++ b/src/netedit/frames/data/GNEEdgeDataFrame.h
@@ -43,11 +43,11 @@ class GNEEdgeDataFrame : public GNEGenericDataFrame {
     ~GNEEdgeDataFrame();
 
     /**@brief add additional element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @param mouseButtonKeyPressed key pressed during click
      * @return true if additional was successfully added
      */
-    bool addEdgeData(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
+    bool addEdgeData(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
 
 private:
     /// @brief Invalidated copy constructor.
diff --git a/src/netedit/frames/data/GNEEdgeRelDataFrame.cpp b/src/netedit/frames/data/GNEEdgeRelDataFrame.cpp
index bb2a63f86d52..1f75680d181e 100644
--- a/src/netedit/frames/data/GNEEdgeRelDataFrame.cpp
+++ b/src/netedit/frames/data/GNEEdgeRelDataFrame.cpp
@@ -40,10 +40,10 @@ GNEEdgeRelDataFrame::~GNEEdgeRelDataFrame() {}
 
 
 bool
-GNEEdgeRelDataFrame::addEdgeRelationData(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
+GNEEdgeRelDataFrame::addEdgeRelationData(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
     // first check if we clicked over an edge
-    if (objectsUnderCursor.getEdgeFront() && myDataSetSelector->getDataSet() && myIntervalSelector->getDataInterval()) {
-        return myPathCreator->addEdge(objectsUnderCursor.getEdgeFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
+    if (viewObjects.getEdgeFront() && myDataSetSelector->getDataSet() && myIntervalSelector->getDataInterval()) {
+        return myPathCreator->addEdge(viewObjects.getEdgeFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
     } else {
         // invalid parent parameters
         return false;
diff --git a/src/netedit/frames/data/GNEEdgeRelDataFrame.h b/src/netedit/frames/data/GNEEdgeRelDataFrame.h
index 92e4253c3212..bfddeaaafdd5 100644
--- a/src/netedit/frames/data/GNEEdgeRelDataFrame.h
+++ b/src/netedit/frames/data/GNEEdgeRelDataFrame.h
@@ -43,10 +43,10 @@ class GNEEdgeRelDataFrame : public GNEGenericDataFrame {
     ~GNEEdgeRelDataFrame();
 
     /**@brief add additional element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if additional was successfully added
      */
-    bool addEdgeRelationData(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
+    bool addEdgeRelationData(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
 
 protected:
     /// @brief create path
diff --git a/src/netedit/frames/data/GNETAZRelDataFrame.cpp b/src/netedit/frames/data/GNETAZRelDataFrame.cpp
index 93004fc4bc00..23d32473068b 100644
--- a/src/netedit/frames/data/GNETAZRelDataFrame.cpp
+++ b/src/netedit/frames/data/GNETAZRelDataFrame.cpp
@@ -146,21 +146,21 @@ GNETAZRelDataFrame::~GNETAZRelDataFrame() {}
 
 
 bool
-GNETAZRelDataFrame::setTAZ(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNETAZRelDataFrame::setTAZ(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // check if myFirstTAZElement is empty
     if (myFirstTAZ) {
         if (mySecondTAZ) {
             // both already defined
             return false;
-        } else if (objectsUnderCursor.getTAZFront()) {
-            mySecondTAZ = objectsUnderCursor.getTAZFront();
+        } else if (viewObjects.getTAZFront()) {
+            mySecondTAZ = viewObjects.getTAZFront();
             myLegend->setLabels(myFirstTAZ, mySecondTAZ);
             return true;
         } else {
             return false;
         }
-    } else if (objectsUnderCursor.getTAZFront()) {
-        myFirstTAZ = objectsUnderCursor.getTAZFront();
+    } else if (viewObjects.getTAZFront()) {
+        myFirstTAZ = viewObjects.getTAZFront();
         myLegend->setLabels(myFirstTAZ, mySecondTAZ);
         return true;
     } else {
diff --git a/src/netedit/frames/data/GNETAZRelDataFrame.h b/src/netedit/frames/data/GNETAZRelDataFrame.h
index 30644af82a20..71187d00ddf4 100644
--- a/src/netedit/frames/data/GNETAZRelDataFrame.h
+++ b/src/netedit/frames/data/GNETAZRelDataFrame.h
@@ -106,7 +106,7 @@ class GNETAZRelDataFrame : public GNEGenericDataFrame {
     ~GNETAZRelDataFrame();
 
     /// @brief set clicked TAZ
-    bool setTAZ(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool setTAZ(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief build TAZRelation data
     void buildTAZRelationData();
diff --git a/src/netedit/frames/demand/GNEContainerFrame.cpp b/src/netedit/frames/demand/GNEContainerFrame.cpp
index 03edaa5647e7..db2a27ebd5c7 100644
--- a/src/netedit/frames/demand/GNEContainerFrame.cpp
+++ b/src/netedit/frames/demand/GNEContainerFrame.cpp
@@ -95,14 +95,14 @@ GNEContainerFrame::hide() {
 
 
 bool
-GNEContainerFrame::addContainer(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEContainerFrame::addContainer(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that we clicked over an AC
-    if (objectsUnderCursor.getAttributeCarrierFront() == nullptr) {
+    if (viewObjects.getAttributeCarrierFront() == nullptr) {
         return false;
     }
     // obtain tags (only for improve code legibility)
     SumoXMLTag containerTag = myContainerTagSelector->getCurrentTemplateAC()->getTagProperty().getTag();
-    SumoXMLTag clickedACTag = objectsUnderCursor.getAttributeCarrierFront()->getTagProperty().getTag();
+    SumoXMLTag clickedACTag = viewObjects.getAttributeCarrierFront()->getTagProperty().getTag();
     // first check that current selected container is valid
     if (containerTag == SUMO_TAG_NOTHING) {
         myViewNet->setStatusBarText(TL("Current selected container isn't valid."));
@@ -120,15 +120,15 @@ GNEContainerFrame::addContainer(const GNEViewNetHelper::ObjectsUnderCursor& obje
     }
     // add elements to path creator
     if (clickedACTag == SUMO_TAG_LANE) {
-        return myPlanCreator->addEdge(objectsUnderCursor.getLaneFront());
-    } else if (objectsUnderCursor.getAttributeCarrierFront()->getTagProperty().isStoppingPlace()) {
-        return myPlanCreator->addStoppingPlace(objectsUnderCursor.getAdditionalFront());
+        return myPlanCreator->addEdge(viewObjects.getLaneFront());
+    } else if (viewObjects.getAttributeCarrierFront()->getTagProperty().isStoppingPlace()) {
+        return myPlanCreator->addStoppingPlace(viewObjects.getAdditionalFront());
     } else if (clickedACTag == SUMO_TAG_ROUTE) {
-        return myPlanCreator->addRoute(objectsUnderCursor.getDemandElementFront());
+        return myPlanCreator->addRoute(viewObjects.getDemandElementFront());
     } else if (clickedACTag == SUMO_TAG_JUNCTION) {
-        return myPlanCreator->addJunction(objectsUnderCursor.getJunctionFront());
+        return myPlanCreator->addJunction(viewObjects.getJunctionFront());
     } else if (clickedACTag == SUMO_TAG_TAZ) {
-        return myPlanCreator->addTAZ(objectsUnderCursor.getTAZFront());
+        return myPlanCreator->addTAZ(viewObjects.getTAZFront());
     } else {
         return false;
     }
diff --git a/src/netedit/frames/demand/GNEContainerFrame.h b/src/netedit/frames/demand/GNEContainerFrame.h
index 4adf092c3837..a8ef0df1669b 100644
--- a/src/netedit/frames/demand/GNEContainerFrame.h
+++ b/src/netedit/frames/demand/GNEContainerFrame.h
@@ -56,10 +56,10 @@ class GNEContainerFrame : public GNEFrame {
     void hide();
 
     /**@brief add vehicle element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if vehicle was successfully added
      */
-    bool addContainer(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addContainer(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get plan creator module
     GNEPlanCreator* getPlanCreator() const;
diff --git a/src/netedit/frames/demand/GNEContainerPlanFrame.cpp b/src/netedit/frames/demand/GNEContainerPlanFrame.cpp
index 97fbd4eddbcc..fc5e9e25b533 100644
--- a/src/netedit/frames/demand/GNEContainerPlanFrame.cpp
+++ b/src/netedit/frames/demand/GNEContainerPlanFrame.cpp
@@ -102,21 +102,21 @@ GNEContainerPlanFrame::hide() {
 
 
 bool
-GNEContainerPlanFrame::addContainerPlanElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEContainerPlanFrame::addContainerPlanElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that we clicked over an AC
-    if (objectsUnderCursor.getAttributeCarrierFront() == nullptr) {
+    if (viewObjects.getAttributeCarrierFront() == nullptr) {
         return false;
     }
     // check if we have to select a new container
     if (myContainerSelector->getCurrentDemandElement() == nullptr) {
-        if (objectsUnderCursor.getDemandElementFront() && objectsUnderCursor.getDemandElementFront()->getTagProperty().isContainer()) {
+        if (viewObjects.getDemandElementFront() && viewObjects.getDemandElementFront()->getTagProperty().isContainer()) {
             // continue depending of number of demand elements under cursor
-            if (objectsUnderCursor.getClickedDemandElements().size() > 1) {
+            if (viewObjects.getDemandElements().size() > 1) {
                 // Filter containers
-                myContainerSelector->setDemandElements(objectsUnderCursor.getClickedDemandElements());
+                myContainerSelector->setDemandElements(viewObjects.getDemandElements());
             } else {
                 // select new container
-                myContainerSelector->setDemandElement(objectsUnderCursor.getDemandElementFront());
+                myContainerSelector->setDemandElement(viewObjects.getDemandElementFront());
             }
             return true;
         } else {
@@ -130,18 +130,18 @@ GNEContainerPlanFrame::addContainerPlanElement(const GNEViewNetHelper::ObjectsUn
         return false;
     }
     // continue depending of marked elements
-    if (myPlanSelector->markRoutes() && objectsUnderCursor.getDemandElementFront() &&
-            (objectsUnderCursor.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
-        return myPlanCreator->addRoute(objectsUnderCursor.getDemandElementFront());
-    } else if (myPlanSelector->markContainerStops() && objectsUnderCursor.getAdditionalFront() &&
-               (objectsUnderCursor.getAdditionalFront()->getTagProperty().isStoppingPlace())) {
-        return myPlanCreator->addStoppingPlace(objectsUnderCursor.getAdditionalFront());
-    } else if (myPlanSelector->markEdges() && objectsUnderCursor.getLaneFront()) {
-        return myPlanCreator->addEdge(objectsUnderCursor.getLaneFront());
-    } else if (myPlanSelector->markJunctions() && objectsUnderCursor.getJunctionFront()) {
-        return myPlanCreator->addJunction(objectsUnderCursor.getJunctionFront());
-    } else if (myPlanSelector->markTAZs() && objectsUnderCursor.getTAZFront()) {
-        return myPlanCreator->addTAZ(objectsUnderCursor.getTAZFront());
+    if (myPlanSelector->markRoutes() && viewObjects.getDemandElementFront() &&
+            (viewObjects.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
+        return myPlanCreator->addRoute(viewObjects.getDemandElementFront());
+    } else if (myPlanSelector->markContainerStops() && viewObjects.getAdditionalFront() &&
+               (viewObjects.getAdditionalFront()->getTagProperty().isStoppingPlace())) {
+        return myPlanCreator->addStoppingPlace(viewObjects.getAdditionalFront());
+    } else if (myPlanSelector->markEdges() && viewObjects.getLaneFront()) {
+        return myPlanCreator->addEdge(viewObjects.getLaneFront());
+    } else if (myPlanSelector->markJunctions() && viewObjects.getJunctionFront()) {
+        return myPlanCreator->addJunction(viewObjects.getJunctionFront());
+    } else if (myPlanSelector->markTAZs() && viewObjects.getTAZFront()) {
+        return myPlanCreator->addTAZ(viewObjects.getTAZFront());
     } else {
         return false;
     }
diff --git a/src/netedit/frames/demand/GNEContainerPlanFrame.h b/src/netedit/frames/demand/GNEContainerPlanFrame.h
index 2e9e806edd5f..21c65c2ab6ef 100644
--- a/src/netedit/frames/demand/GNEContainerPlanFrame.h
+++ b/src/netedit/frames/demand/GNEContainerPlanFrame.h
@@ -57,10 +57,10 @@ class GNEContainerPlanFrame : public GNEFrame {
     void hide();
 
     /**@brief add container plan element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if element was successfully added
      */
-    bool addContainerPlanElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addContainerPlanElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief reset selected container
     void resetSelectedContainer();
diff --git a/src/netedit/frames/demand/GNEPersonFrame.cpp b/src/netedit/frames/demand/GNEPersonFrame.cpp
index 6b3d1fb90f08..57fa06c17afc 100644
--- a/src/netedit/frames/demand/GNEPersonFrame.cpp
+++ b/src/netedit/frames/demand/GNEPersonFrame.cpp
@@ -95,14 +95,14 @@ GNEPersonFrame::hide() {
 
 
 bool
-GNEPersonFrame::addPerson(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEPersonFrame::addPerson(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that we clicked over an AC
-    if (objectsUnderCursor.getAttributeCarrierFront() == nullptr) {
+    if (viewObjects.getAttributeCarrierFront() == nullptr) {
         return false;
     }
     // obtain tags (only for improve code legibility)
     SumoXMLTag personTag = myPersonTagSelector->getCurrentTemplateAC()->getTagProperty().getTag();
-    SumoXMLTag clickedACTag = objectsUnderCursor.getAttributeCarrierFront()->getTagProperty().getTag();
+    SumoXMLTag clickedACTag = viewObjects.getAttributeCarrierFront()->getTagProperty().getTag();
     // first check that current selected person is valid
     if (personTag == SUMO_TAG_NOTHING) {
         myViewNet->setStatusBarText(TL("Current selected person isn't valid."));
@@ -120,15 +120,15 @@ GNEPersonFrame::addPerson(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnd
     }
     // add elements to path creator
     if (clickedACTag == SUMO_TAG_LANE) {
-        return myPlanCreator->addEdge(objectsUnderCursor.getLaneFront());
-    } else if (objectsUnderCursor.getAttributeCarrierFront()->getTagProperty().isStoppingPlace()) {
-        return myPlanCreator->addStoppingPlace(objectsUnderCursor.getAdditionalFront());
+        return myPlanCreator->addEdge(viewObjects.getLaneFront());
+    } else if (viewObjects.getAttributeCarrierFront()->getTagProperty().isStoppingPlace()) {
+        return myPlanCreator->addStoppingPlace(viewObjects.getAdditionalFront());
     } else if (clickedACTag == SUMO_TAG_ROUTE) {
-        return myPlanCreator->addRoute(objectsUnderCursor.getDemandElementFront());
+        return myPlanCreator->addRoute(viewObjects.getDemandElementFront());
     } else if (clickedACTag == SUMO_TAG_JUNCTION) {
-        return myPlanCreator->addJunction(objectsUnderCursor.getJunctionFront());
+        return myPlanCreator->addJunction(viewObjects.getJunctionFront());
     } else if (clickedACTag == SUMO_TAG_TAZ) {
-        return myPlanCreator->addTAZ(objectsUnderCursor.getTAZFront());
+        return myPlanCreator->addTAZ(viewObjects.getTAZFront());
     } else {
         return false;
     }
diff --git a/src/netedit/frames/demand/GNEPersonFrame.h b/src/netedit/frames/demand/GNEPersonFrame.h
index 7e68f9768996..01f8df3632af 100644
--- a/src/netedit/frames/demand/GNEPersonFrame.h
+++ b/src/netedit/frames/demand/GNEPersonFrame.h
@@ -56,10 +56,10 @@ class GNEPersonFrame : public GNEFrame {
     void hide();
 
     /**@brief add vehicle element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if vehicle was successfully added
      */
-    bool addPerson(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addPerson(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get plan creator module
     GNEPlanCreator* getPlanCreator() const;
diff --git a/src/netedit/frames/demand/GNEPersonPlanFrame.cpp b/src/netedit/frames/demand/GNEPersonPlanFrame.cpp
index f6e2cd88412a..e50a3adc3c80 100644
--- a/src/netedit/frames/demand/GNEPersonPlanFrame.cpp
+++ b/src/netedit/frames/demand/GNEPersonPlanFrame.cpp
@@ -102,21 +102,21 @@ GNEPersonPlanFrame::hide() {
 
 
 bool
-GNEPersonPlanFrame::addPersonPlanElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEPersonPlanFrame::addPersonPlanElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that we clicked over an AC
-    if (objectsUnderCursor.getAttributeCarrierFront() == nullptr) {
+    if (viewObjects.getAttributeCarrierFront() == nullptr) {
         return false;
     }
     // check if we have to select a new person
     if (myPersonSelector->getCurrentDemandElement() == nullptr) {
-        if (objectsUnderCursor.getDemandElementFront() && objectsUnderCursor.getDemandElementFront()->getTagProperty().isPerson()) {
+        if (viewObjects.getDemandElementFront() && viewObjects.getDemandElementFront()->getTagProperty().isPerson()) {
             // continue depending of number of demand elements under cursor
-            if (objectsUnderCursor.getClickedDemandElements().size() > 1) {
+            if (viewObjects.getDemandElements().size() > 1) {
                 // Filter persons
-                myPersonSelector->setDemandElements(objectsUnderCursor.getClickedDemandElements());
+                myPersonSelector->setDemandElements(viewObjects.getDemandElements());
             } else {
                 // select new person
-                myPersonSelector->setDemandElement(objectsUnderCursor.getDemandElementFront());
+                myPersonSelector->setDemandElement(viewObjects.getDemandElementFront());
             }
             return true;
         } else {
@@ -130,18 +130,18 @@ GNEPersonPlanFrame::addPersonPlanElement(const GNEViewNetHelper::ObjectsUnderCur
         return false;
     }
     // continue depending of marked elements
-    if (myPlanSelector->markRoutes() && objectsUnderCursor.getDemandElementFront() &&
-            (objectsUnderCursor.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
-        return myPlanCreator->addRoute(objectsUnderCursor.getDemandElementFront());
-    } else if ((myPlanSelector->markBusStops() || myPlanSelector->markTrainStops()) && objectsUnderCursor.getAdditionalFront() &&
-               (objectsUnderCursor.getAdditionalFront()->getTagProperty().isStoppingPlace())) {
-        return myPlanCreator->addStoppingPlace(objectsUnderCursor.getAdditionalFront());
-    } else if (myPlanSelector->markEdges() && objectsUnderCursor.getLaneFront()) {
-        return myPlanCreator->addEdge(objectsUnderCursor.getLaneFront());
-    } else if (myPlanSelector->markJunctions() && objectsUnderCursor.getJunctionFront()) {
-        return myPlanCreator->addJunction(objectsUnderCursor.getJunctionFront());
-    } else if (myPlanSelector->markTAZs() && objectsUnderCursor.getTAZFront()) {
-        return myPlanCreator->addTAZ(objectsUnderCursor.getTAZFront());
+    if (myPlanSelector->markRoutes() && viewObjects.getDemandElementFront() &&
+            (viewObjects.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
+        return myPlanCreator->addRoute(viewObjects.getDemandElementFront());
+    } else if ((myPlanSelector->markBusStops() || myPlanSelector->markTrainStops()) && viewObjects.getAdditionalFront() &&
+               (viewObjects.getAdditionalFront()->getTagProperty().isStoppingPlace())) {
+        return myPlanCreator->addStoppingPlace(viewObjects.getAdditionalFront());
+    } else if (myPlanSelector->markEdges() && viewObjects.getLaneFront()) {
+        return myPlanCreator->addEdge(viewObjects.getLaneFront());
+    } else if (myPlanSelector->markJunctions() && viewObjects.getJunctionFront()) {
+        return myPlanCreator->addJunction(viewObjects.getJunctionFront());
+    } else if (myPlanSelector->markTAZs() && viewObjects.getTAZFront()) {
+        return myPlanCreator->addTAZ(viewObjects.getTAZFront());
     } else {
         return false;
     }
diff --git a/src/netedit/frames/demand/GNEPersonPlanFrame.h b/src/netedit/frames/demand/GNEPersonPlanFrame.h
index 6994a3cb8b1f..97720a6744e6 100644
--- a/src/netedit/frames/demand/GNEPersonPlanFrame.h
+++ b/src/netedit/frames/demand/GNEPersonPlanFrame.h
@@ -57,10 +57,10 @@ class GNEPersonPlanFrame : public GNEFrame {
     void hide();
 
     /**@brief add person plan element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if element was successfully added
      */
-    bool addPersonPlanElement(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addPersonPlanElement(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief reset selected person
     void resetSelectedPerson();
diff --git a/src/netedit/frames/demand/GNEStopFrame.cpp b/src/netedit/frames/demand/GNEStopFrame.cpp
index 1006b0d407d2..21f83d78b8ce 100644
--- a/src/netedit/frames/demand/GNEStopFrame.cpp
+++ b/src/netedit/frames/demand/GNEStopFrame.cpp
@@ -183,7 +183,7 @@ GNEStopFrame::show() {
 
 
 bool
-GNEStopFrame::addStop(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
+GNEStopFrame::addStop(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
     // first check stop type
     if (myStopTagSelector->getCurrentTemplateAC() == nullptr) {
         WRITE_WARNING(TL("Selected Stop type isn't valid."));
@@ -191,10 +191,10 @@ GNEStopFrame::addStop(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCu
     }
     // check if we're selecting a new stop parent
     if (mouseButtonKeyPressed.shiftKeyPressed()) {
-        if (objectsUnderCursor.getDemandElementFront() &&
-                (objectsUnderCursor.getDemandElementFront()->getTagProperty().isVehicle() || objectsUnderCursor.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
-            myStopParentSelector->setDemandElement(objectsUnderCursor.getDemandElementFront());
-            WRITE_WARNINGF(TL("Selected % '%' as stop parent."), objectsUnderCursor.getDemandElementFront()->getTagStr(), objectsUnderCursor.getDemandElementFront()->getID());
+        if (viewObjects.getDemandElementFront() &&
+                (viewObjects.getDemandElementFront()->getTagProperty().isVehicle() || viewObjects.getDemandElementFront()->getTagProperty().getTag() == SUMO_TAG_ROUTE)) {
+            myStopParentSelector->setDemandElement(viewObjects.getDemandElementFront());
+            WRITE_WARNINGF(TL("Selected % '%' as stop parent."), viewObjects.getDemandElementFront()->getTagStr(), viewObjects.getDemandElementFront()->getID());
             return true;
         } else {
             WRITE_WARNING(TL("Selected Stop parent isn't valid."));
@@ -208,7 +208,7 @@ GNEStopFrame::addStop(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCu
         }
         // create stop base object
         getStopParameter(myStopTagSelector->getCurrentTemplateAC()->getTagProperty().getTag(),
-                         objectsUnderCursor.getLaneFront(), objectsUnderCursor.getAdditionalFront());
+                         viewObjects.getLaneFront(), viewObjects.getAdditionalFront());
         if (myStopParentBaseObject->getTag() != SUMO_TAG_NOTHING) {
             myRouteHandler.buildStop(myStopParentBaseObject->getSumoBaseObjectChildren().front(),
                                      myStopParentBaseObject->getSumoBaseObjectChildren().front()->getStopParameter());
diff --git a/src/netedit/frames/demand/GNEStopFrame.h b/src/netedit/frames/demand/GNEStopFrame.h
index e3684d926153..c07482feac5f 100644
--- a/src/netedit/frames/demand/GNEStopFrame.h
+++ b/src/netedit/frames/demand/GNEStopFrame.h
@@ -83,11 +83,11 @@ class GNEStopFrame : public GNEFrame {
     void show();
 
     /**@brief add Stop element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @param mouseButtonKeyPressed key pressed during click
      * @return true if Stop was successfully added
      */
-    bool addStop(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
+    bool addStop(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
 
     /// @brief get stop parameters
     bool getStopParameter(const SumoXMLTag stopTag, const GNELane* lane, const GNEAdditional* stoppingPlace);
diff --git a/src/netedit/frames/demand/GNEVehicleFrame.cpp b/src/netedit/frames/demand/GNEVehicleFrame.cpp
index 96344226ecee..ce3249bf9245 100644
--- a/src/netedit/frames/demand/GNEVehicleFrame.cpp
+++ b/src/netedit/frames/demand/GNEVehicleFrame.cpp
@@ -174,7 +174,7 @@ GNEVehicleFrame::hide() {
 
 
 bool
-GNEVehicleFrame::addVehicle(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
+GNEVehicleFrame::addVehicle(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed) {
     // check template AC
     if (myVehicleTagSelector->getCurrentTemplateAC() == nullptr) {
         return false;
@@ -211,16 +211,16 @@ GNEVehicleFrame::addVehicle(const GNEViewNetHelper::ObjectsUnderCursor& objectsU
     myVehicleBaseObject->addStringAttribute(SUMO_ATTR_TYPE, myTypeSelector->getCurrentDemandElement()->getID());
     // set route or edges depending of vehicle type
     if (myVehicleTagSelector->getCurrentTemplateAC()->getTagProperty().vehicleRoute()) {
-        return buildVehicleOverRoute(vehicleTag, objectsUnderCursor.getDemandElementFront());
-    } else if (addEdge && objectsUnderCursor.getEdgeFront()) {
+        return buildVehicleOverRoute(vehicleTag, viewObjects.getDemandElementFront());
+    } else if (addEdge && viewObjects.getEdgeFront()) {
         // add clicked edge in GNEPathCreator
-        return myPathCreator->addEdge(objectsUnderCursor.getEdgeFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
-    } else if (addJunction && objectsUnderCursor.getJunctionFront()) {
+        return myPathCreator->addEdge(viewObjects.getEdgeFront(), mouseButtonKeyPressed.shiftKeyPressed(), mouseButtonKeyPressed.controlKeyPressed());
+    } else if (addJunction && viewObjects.getJunctionFront()) {
         // add clicked junction in GNEPathCreator
-        return myPathCreator->addJunction(objectsUnderCursor.getJunctionFront());
-    } else if (addTAZ && objectsUnderCursor.getTAZFront()) {
+        return myPathCreator->addJunction(viewObjects.getJunctionFront());
+    } else if (addTAZ && viewObjects.getTAZFront()) {
         // add clicked TAZ in GNEPathCreator
-        return myPathCreator->addTAZ(objectsUnderCursor.getTAZFront());
+        return myPathCreator->addTAZ(viewObjects.getTAZFront());
     } else {
         return false;
     }
diff --git a/src/netedit/frames/demand/GNEVehicleFrame.h b/src/netedit/frames/demand/GNEVehicleFrame.h
index afe46c0c7111..e30c33dba51a 100644
--- a/src/netedit/frames/demand/GNEVehicleFrame.h
+++ b/src/netedit/frames/demand/GNEVehicleFrame.h
@@ -89,11 +89,11 @@ class GNEVehicleFrame : public GNEFrame {
     void hide();
 
     /**@brief add vehicle element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @param mouseButtonKeyPressed key pressed during click
      * @return true if element was successfully added
      */
-    bool addVehicle(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
+    bool addVehicle(const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const GNEViewNetHelper::MouseButtonKeyPressed& mouseButtonKeyPressed);
 
     /// @brief get vehicle tag selector (needed for transform vehicles)
     GNETagSelector* getVehicleTagSelector() const;
diff --git a/src/netedit/frames/network/GNEAdditionalFrame.cpp b/src/netedit/frames/network/GNEAdditionalFrame.cpp
index 2892979cd849..1b2d012f9af4 100644
--- a/src/netedit/frames/network/GNEAdditionalFrame.cpp
+++ b/src/netedit/frames/network/GNEAdditionalFrame.cpp
@@ -184,20 +184,20 @@ GNEAdditionalFrame::show() {
 
 
 bool
-GNEAdditionalFrame::addAdditional(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEAdditionalFrame::addAdditional(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that current selected additional is valid
     if (myAdditionalTagSelector->getCurrentTemplateAC() == nullptr) {
         myViewNet->setStatusBarText(TL("Current selected additional isn't valid."));
         return false;
     }
     // check if add or remove edge
-    if (myEdgesSelector->isShown() && objectsUnderCursor.getEdgeFront()) {
-        myEdgesSelector->toggleSelectedElement(objectsUnderCursor.getEdgeFront());
+    if (myEdgesSelector->isShown() && viewObjects.getEdgeFront()) {
+        myEdgesSelector->toggleSelectedElement(viewObjects.getEdgeFront());
         return true;
     }
     // check if add or remove lane
-    if (myLanesSelector->isShown() && objectsUnderCursor.getLaneFront()) {
-        myLanesSelector->toggleSelectedElement(objectsUnderCursor.getLaneFront());
+    if (myLanesSelector->isShown() && viewObjects.getLaneFront()) {
+        myLanesSelector->toggleSelectedElement(viewObjects.getLaneFront());
         return true;
     }
     // show warning dialogbox and stop check if input parameters are valid
@@ -214,16 +214,16 @@ GNEAdditionalFrame::addAdditional(const GNEViewNetHelper::ObjectsUnderCursor& ob
     // obtain attributes and values
     myAdditionalAttributes->getAttributesAndValues(myBaseAdditional, true);
     // fill netedit attributes
-    if (!myNeteditAttributes->getNeteditAttributesAndValues(myBaseAdditional, objectsUnderCursor.getLaneFront())) {
+    if (!myNeteditAttributes->getNeteditAttributesAndValues(myBaseAdditional, viewObjects.getLaneFront())) {
         return false;
     }
     // If consecutive Lane Selector is enabled, it means that either we're selecting lanes or we're finished or we'rent started
     if (tagProperties.hasAttribute(SUMO_ATTR_EDGE) || (tagProperties.getTag() == SUMO_TAG_VAPORIZER)) {
-        return buildAdditionalOverEdge(objectsUnderCursor.getLaneFront(), tagProperties);
+        return buildAdditionalOverEdge(viewObjects.getLaneFront(), tagProperties);
     } else if (tagProperties.hasAttribute(SUMO_ATTR_LANE)) {
-        return buildAdditionalOverLane(objectsUnderCursor.getLaneFront(), tagProperties);
+        return buildAdditionalOverLane(viewObjects.getLaneFront(), tagProperties);
     } else if (tagProperties.getTag() == GNE_TAG_MULTI_LANE_AREA_DETECTOR) {
-        return myConsecutiveLaneSelector->addLane(objectsUnderCursor.getLaneFront());
+        return myConsecutiveLaneSelector->addLane(viewObjects.getLaneFront());
     } else {
         return buildAdditionalOverView(tagProperties);
     }
diff --git a/src/netedit/frames/network/GNEAdditionalFrame.h b/src/netedit/frames/network/GNEAdditionalFrame.h
index e9b60581e817..ce1c79eb6579 100644
--- a/src/netedit/frames/network/GNEAdditionalFrame.h
+++ b/src/netedit/frames/network/GNEAdditionalFrame.h
@@ -102,10 +102,10 @@ class GNEAdditionalFrame : public GNEFrame {
     void show();
 
     /**@brief add additional element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if additional was successfully added
      */
-    bool addAdditional(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addAdditional(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get edges selector
     GNENetworkSelector* getEdgesSelector() const;
diff --git a/src/netedit/frames/network/GNEConnectorFrame.cpp b/src/netedit/frames/network/GNEConnectorFrame.cpp
index 795bc7fb74f9..dfc91cc43d00 100644
--- a/src/netedit/frames/network/GNEConnectorFrame.cpp
+++ b/src/netedit/frames/network/GNEConnectorFrame.cpp
@@ -379,11 +379,11 @@ GNEConnectorFrame::~GNEConnectorFrame() {}
 
 
 void
-GNEConnectorFrame::handleLaneClick(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEConnectorFrame::handleLaneClick(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // get lane front
-    GNELane* clickedLane = objectsUnderCursor.getLaneFrontNonLocked();
+    GNELane* clickedLane = viewObjects.getLaneFrontNonLocked();
     // iterate over lanes
-    for (const auto& lane : objectsUnderCursor.getLanes()) {
+    for (const auto& lane : viewObjects.getLanes()) {
         // if parent edge of lane is front element, update clickedLane
         if (lane->getParentEdge() == myViewNet->getFrontAttributeCarrier()) {
             clickedLane = lane;
diff --git a/src/netedit/frames/network/GNEConnectorFrame.h b/src/netedit/frames/network/GNEConnectorFrame.h
index 44356f073417..c66dc06473e4 100644
--- a/src/netedit/frames/network/GNEConnectorFrame.h
+++ b/src/netedit/frames/network/GNEConnectorFrame.h
@@ -202,9 +202,9 @@ class GNEConnectorFrame : public GNEFrame {
     ~GNEConnectorFrame();
 
     /**@brief either sets the current lane or toggles the connection of the
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      */
-    void handleLaneClick(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    void handleLaneClick(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get pointer to ConnectionModifications modul
     ConnectionModifications* getConnectionModifications() const;
diff --git a/src/netedit/frames/network/GNECreateEdgeFrame.cpp b/src/netedit/frames/network/GNECreateEdgeFrame.cpp
index f3079f319b60..dac985685ae8 100644
--- a/src/netedit/frames/network/GNECreateEdgeFrame.cpp
+++ b/src/netedit/frames/network/GNECreateEdgeFrame.cpp
@@ -685,7 +685,7 @@ GNECreateEdgeFrame::~GNECreateEdgeFrame() {}
 
 
 void
-GNECreateEdgeFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor,
+GNECreateEdgeFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects,
                                  const bool oppositeEdge, const bool chainEdge) {
     // first check if there is an edge template, an edge type (default or custom)
     if (!myEdgeTypeSelector->useDefaultEdgeType() && !myEdgeTypeSelector->useDefaultEdgeTypeShort() &&
@@ -698,8 +698,8 @@ GNECreateEdgeFrame::processClick(const Position& clickedPosition, const GNEViewN
     } else {
         // obtain junction depending of gridEnabled
         GNEJunction* junction = nullptr;
-        if (objectsUnderCursor.getJunctionFront()) {
-            junction = objectsUnderCursor.getJunctionFront();
+        if (viewObjects.getJunctionFront()) {
+            junction = viewObjects.getJunctionFront();
         } else if (myObjectsUnderSnappedCursor.getJunctionFront()) {
             junction = myObjectsUnderSnappedCursor.getJunctionFront();
         }
@@ -843,7 +843,7 @@ GNECreateEdgeFrame::getJunctionSource() const {
 
 void
 GNECreateEdgeFrame::updateObjectsUnderSnappedCursor(const std::vector<GUIGlObject*>& GUIGlObjects) {
-    myObjectsUnderSnappedCursor.updateObjectUnderCursor(/*GUIGlObjects*/);
+    myObjectsUnderSnappedCursor.updateObjects(/*GUIGlObjects*/);
 }
 
 
diff --git a/src/netedit/frames/network/GNECreateEdgeFrame.h b/src/netedit/frames/network/GNECreateEdgeFrame.h
index 451f43a21319..86009d33626e 100644
--- a/src/netedit/frames/network/GNECreateEdgeFrame.h
+++ b/src/netedit/frames/network/GNECreateEdgeFrame.h
@@ -256,11 +256,11 @@ class GNECreateEdgeFrame : public GNEFrame {
 
     /**@brief handle processClick and set the relative coloring
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @param oppositeEdge automatically create an opposite edge
      * @param chainEdge create edges in chain mode
      */
-    void processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const bool oppositeEdge, const bool chainEdge);
+    void processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects, const bool oppositeEdge, const bool chainEdge);
 
     /// @brief abort current edge creation
     void abortEdgeCreation();
@@ -319,7 +319,7 @@ class GNECreateEdgeFrame : public GNEFrame {
 
 private:
     /// @brief objects under snapped cursor
-    GNEViewNetHelper::ObjectsUnderCursor myObjectsUnderSnappedCursor;
+    GNEViewNetHelper::ViewObjectsSelector myObjectsUnderSnappedCursor;
 
     /// @brief source junction for new edge
     GNEJunction* myJunctionSource;
diff --git a/src/netedit/frames/network/GNECrossingFrame.cpp b/src/netedit/frames/network/GNECrossingFrame.cpp
index b3952a26fa3e..5755f4407156 100644
--- a/src/netedit/frames/network/GNECrossingFrame.cpp
+++ b/src/netedit/frames/network/GNECrossingFrame.cpp
@@ -593,20 +593,20 @@ GNECrossingFrame::hide() {
 
 
 void
-GNECrossingFrame::addCrossing(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNECrossingFrame::addCrossing(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // If current element is a junction
-    if (objectsUnderCursor.getJunctionFront()) {
+    if (viewObjects.getJunctionFront()) {
         // change label
-        myJunctionInformation->updateCurrentJunctionLabel(objectsUnderCursor.getJunctionFront()->getID());
+        myJunctionInformation->updateCurrentJunctionLabel(viewObjects.getJunctionFront()->getID());
         // Enable edge selector and crossing parameters
-        myEdgeSelector->enableEdgeSelector(objectsUnderCursor.getJunctionFront());
-        myCrossingParameters->enableCrossingParameters(objectsUnderCursor.getJunctionFront()->getNBNode()->isTLControlled());
+        myEdgeSelector->enableEdgeSelector(viewObjects.getJunctionFront());
+        myCrossingParameters->enableCrossingParameters(viewObjects.getJunctionFront()->getNBNode()->isTLControlled());
         // clears selected edges
         myCrossingParameters->clearEdges();
-    } else if (objectsUnderCursor.getEdgeFront()) {
+    } else if (viewObjects.getEdgeFront()) {
         // check if mark edge
-        if (!objectsUnderCursor.getEdgeFront()->isInvalidCandidate()) {
-            myCrossingParameters->markEdge(objectsUnderCursor.getEdgeFront());
+        if (!viewObjects.getEdgeFront()->isInvalidCandidate()) {
+            myCrossingParameters->markEdge(viewObjects.getEdgeFront());
         }
     } else {
         // set default label
diff --git a/src/netedit/frames/network/GNECrossingFrame.h b/src/netedit/frames/network/GNECrossingFrame.h
index c270b458c573..b5d202b7894d 100644
--- a/src/netedit/frames/network/GNECrossingFrame.h
+++ b/src/netedit/frames/network/GNECrossingFrame.h
@@ -283,9 +283,9 @@ class GNECrossingFrame : public GNEFrame {
     void hide();
 
     /**@brief add Crossing element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      */
-    void addCrossing(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    void addCrossing(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief create crossing (used when user press ENTER key in Crossing mode)
     void createCrossingHotkey();
diff --git a/src/netedit/frames/network/GNEProhibitionFrame.cpp b/src/netedit/frames/network/GNEProhibitionFrame.cpp
index 261256896520..3b0a50a95f1b 100644
--- a/src/netedit/frames/network/GNEProhibitionFrame.cpp
+++ b/src/netedit/frames/network/GNEProhibitionFrame.cpp
@@ -244,9 +244,9 @@ GNEProhibitionFrame::~GNEProhibitionFrame() {}
 
 
 void
-GNEProhibitionFrame::handleProhibitionClick(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEProhibitionFrame::handleProhibitionClick(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // build prohibition
-    buildProhibition(objectsUnderCursor.getConnectionFront(), myViewNet->getMouseButtonKeyPressed().shiftKeyPressed(), myViewNet->getMouseButtonKeyPressed().controlKeyPressed(), true);
+    buildProhibition(viewObjects.getConnectionFront(), myViewNet->getMouseButtonKeyPressed().shiftKeyPressed(), myViewNet->getMouseButtonKeyPressed().controlKeyPressed(), true);
 }
 
 
diff --git a/src/netedit/frames/network/GNEProhibitionFrame.h b/src/netedit/frames/network/GNEProhibitionFrame.h
index aae875abe0ba..7fdfe9b14713 100644
--- a/src/netedit/frames/network/GNEProhibitionFrame.h
+++ b/src/netedit/frames/network/GNEProhibitionFrame.h
@@ -168,9 +168,9 @@ class GNEProhibitionFrame : public GNEFrame {
     ~GNEProhibitionFrame();
 
     /**@brief handle prohibitions and set the relative coloring
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      */
-    void handleProhibitionClick(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    void handleProhibitionClick(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief show prohibition frame
     void show();
diff --git a/src/netedit/frames/network/GNEShapeFrame.cpp b/src/netedit/frames/network/GNEShapeFrame.cpp
index 1e32ed438a5b..03e4457f4e85 100644
--- a/src/netedit/frames/network/GNEShapeFrame.cpp
+++ b/src/netedit/frames/network/GNEShapeFrame.cpp
@@ -263,7 +263,7 @@ GNEShapeFrame::show() {
 
 
 bool
-GNEShapeFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, bool& updateTemporalShape) {
+GNEShapeFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects, bool& updateTemporalShape) {
     // reset updateTemporalShape
     updateTemporalShape = false;
     // check if current selected shape is valid
@@ -273,11 +273,11 @@ GNEShapeFrame::processClick(const Position& clickedPosition, const GNEViewNetHel
         // continue depending of tag
         switch (shapeTag) {
             case SUMO_TAG_POI:
-                return processClickPOI(shapeTag, clickedPosition, objectsUnderCursor);
+                return processClickPOI(shapeTag, clickedPosition, viewObjects);
             case GNE_TAG_POIGEO:
-                return processClickPOIGeo(clickedPosition, objectsUnderCursor);
+                return processClickPOIGeo(clickedPosition, viewObjects);
             case GNE_TAG_POILANE:
-                return processClickPOILanes(clickedPosition, objectsUnderCursor);
+                return processClickPOILanes(clickedPosition, viewObjects);
             case SUMO_TAG_POLY:
             case GNE_TAG_JPS_WALKABLEAREA:
             case GNE_TAG_JPS_OBSTACLE:
@@ -427,7 +427,7 @@ GNEShapeFrame::processClickPolygons(const Position& clickedPosition, bool& updat
 
 
 bool
-GNEShapeFrame::processClickPOI(SumoXMLTag POITag, const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEShapeFrame::processClickPOI(SumoXMLTag POITag, const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // show warning dialogbox and stop if input parameters are invalid
     if (myShapeAttributes->areValuesValid() == false) {
         myShapeAttributes->showWarningMessage();
@@ -438,7 +438,7 @@ GNEShapeFrame::processClickPOI(SumoXMLTag POITag, const Position& clickedPositio
     // obtain shape attributes and values
     myShapeAttributes->getAttributesAndValues(myBaseShape, true);
     // obtain netedit attributes and values
-    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, objectsUnderCursor.getLaneFront());
+    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, viewObjects.getLaneFront());
     // Check if ID has to be generated
     if (!myBaseShape->hasStringAttribute(SUMO_ATTR_ID)) {
         myBaseShape->addStringAttribute(SUMO_ATTR_ID, myViewNet->getNet()->getAttributeCarriers()->generateAdditionalID(POITag));
@@ -458,7 +458,7 @@ GNEShapeFrame::processClickPOI(SumoXMLTag POITag, const Position& clickedPositio
 
 
 bool
-GNEShapeFrame::processClickPOIGeo(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEShapeFrame::processClickPOIGeo(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // show warning dialogbox and stop if input parameters are invalid
     if (myShapeAttributes->areValuesValid() == false) {
         myShapeAttributes->showWarningMessage();
@@ -469,7 +469,7 @@ GNEShapeFrame::processClickPOIGeo(const Position& clickedPosition, const GNEView
     // obtain shape attributes and values
     myShapeAttributes->getAttributesAndValues(myBaseShape, true);
     // obtain netedit attributes and values
-    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, objectsUnderCursor.getLaneFront());
+    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, viewObjects.getLaneFront());
     // Check if ID has to be generated
     if (!myBaseShape->hasStringAttribute(SUMO_ATTR_ID)) {
         myBaseShape->addStringAttribute(SUMO_ATTR_ID, myViewNet->getNet()->getAttributeCarriers()->generateAdditionalID(SUMO_TAG_POI));
@@ -492,9 +492,9 @@ GNEShapeFrame::processClickPOIGeo(const Position& clickedPosition, const GNEView
 
 
 bool
-GNEShapeFrame::processClickPOILanes(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEShapeFrame::processClickPOILanes(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // abort if lane is nullptr
-    if (objectsUnderCursor.getLaneFront() == nullptr) {
+    if (viewObjects.getLaneFront() == nullptr) {
         WRITE_WARNING(TL("POILane can be only placed over lanes"));
         return false;
     }
@@ -508,15 +508,15 @@ GNEShapeFrame::processClickPOILanes(const Position& clickedPosition, const GNEVi
     // obtain shape attributes and values
     myShapeAttributes->getAttributesAndValues(myBaseShape, true);
     // obtain netedit attributes and values
-    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, objectsUnderCursor.getLaneFront());
+    myNeteditAttributes->getNeteditAttributesAndValues(myBaseShape, viewObjects.getLaneFront());
     // Check if ID has to be generated
     if (!myBaseShape->hasStringAttribute(SUMO_ATTR_ID)) {
         myBaseShape->addStringAttribute(SUMO_ATTR_ID, myViewNet->getNet()->getAttributeCarriers()->generateAdditionalID(SUMO_TAG_POI));
     }
     // obtain Lane
-    myBaseShape->addStringAttribute(SUMO_ATTR_LANE, objectsUnderCursor.getLaneFront()->getID());
+    myBaseShape->addStringAttribute(SUMO_ATTR_LANE, viewObjects.getLaneFront()->getID());
     // obtain position over lane
-    myBaseShape->addDoubleAttribute(SUMO_ATTR_POSITION, objectsUnderCursor.getLaneFront()->getLaneShape().nearest_offset_to_point2D(clickedPosition));
+    myBaseShape->addDoubleAttribute(SUMO_ATTR_POSITION, viewObjects.getLaneFront()->getLaneShape().nearest_offset_to_point2D(clickedPosition));
     // add shape
     addShape();
     // refresh shape attributes
diff --git a/src/netedit/frames/network/GNEShapeFrame.h b/src/netedit/frames/network/GNEShapeFrame.h
index a2ee7757336f..d991e15a18dd 100644
--- a/src/netedit/frames/network/GNEShapeFrame.h
+++ b/src/netedit/frames/network/GNEShapeFrame.h
@@ -111,10 +111,10 @@ class GNEShapeFrame : public GNEFrame {
 
     /**@brief process click over Viewnet
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param[in] ObjectsUnderCursor objects under cursor after click over view
+     * @param[in] viewObjects objects under cursor after click over view
      * @return AddShapeStatus with the result of operation
      */
-    bool processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, bool& updateTemporalShape);
+    bool processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects, bool& updateTemporalShape);
 
     /// @brief get list of selecte id's in string format
     static std::string getIdsSelected(const FXList* list);
@@ -145,13 +145,13 @@ class GNEShapeFrame : public GNEFrame {
     bool processClickPolygons(const Position& clickedPosition, bool& updateTemporalShape);
 
     /// @brief process click for POIs over view
-    bool processClickPOI(SumoXMLTag POITag, const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processClickPOI(SumoXMLTag POITag, const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief process click for POIGeo
-    bool processClickPOIGeo(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processClickPOIGeo(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief process click for POILanes
-    bool processClickPOILanes(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processClickPOILanes(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
 private:
     /// @brief shape tag selector
diff --git a/src/netedit/frames/network/GNETAZFrame.cpp b/src/netedit/frames/network/GNETAZFrame.cpp
index 4143e8276733..acb6e7882b3d 100644
--- a/src/netedit/frames/network/GNETAZFrame.cpp
+++ b/src/netedit/frames/network/GNETAZFrame.cpp
@@ -1492,7 +1492,7 @@ GNETAZFrame::hide() {
 
 
 bool
-GNETAZFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNETAZFrame::processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // Declare map to keep values
     std::map<SumoXMLAttr, std::string> valuesOfElement;
     if (myDrawingShape->isDrawing()) {
@@ -1503,11 +1503,11 @@ GNETAZFrame::processClick(const Position& clickedPosition, const GNEViewNetHelpe
             myDrawingShape->addNewPoint(clickedPosition);
         }
         return true;
-    } else if ((myCurrentTAZ->getTAZ() == nullptr) || (objectsUnderCursor.getTAZFront() && myCurrentTAZ->getTAZ() && !myTAZSaveChanges->isChangesPending())) {
+    } else if ((myCurrentTAZ->getTAZ() == nullptr) || (viewObjects.getTAZFront() && myCurrentTAZ->getTAZ() && !myTAZSaveChanges->isChangesPending())) {
         // if user click over an TAZ and there isn't changes pending, then select a new TAZ
-        if (objectsUnderCursor.getTAZFront()) {
+        if (viewObjects.getTAZFront()) {
             // avoid reset of Frame if user doesn't click over an TAZ
-            myCurrentTAZ->setTAZ(objectsUnderCursor.getTAZFront());
+            myCurrentTAZ->setTAZ(viewObjects.getTAZFront());
             // update TAZStatistics
             myCurrentTAZ->getTAZ()->updateTAZStatistic();
             myTAZCommonStatistics->updateStatistics();
@@ -1515,20 +1515,20 @@ GNETAZFrame::processClick(const Position& clickedPosition, const GNEViewNetHelpe
         } else {
             return false;
         }
-    } else if (objectsUnderCursor.getEdgeFront()) {
+    } else if (viewObjects.getEdgeFront()) {
         // if toggle Edge is enabled, select edge. In other case create two new source/Sinks
         if (myTAZChildDefaultParameters->getToggleMembership()) {
             // create new source/Sinks or delete it
-            return addOrRemoveTAZMember(objectsUnderCursor.getEdgeFront());
+            return addOrRemoveTAZMember(viewObjects.getEdgeFront());
         } else {
             // first check if clicked edge was previously selected
-            if (myTAZSelectionStatistics->isEdgeSelected(objectsUnderCursor.getEdgeFront())) {
+            if (myTAZSelectionStatistics->isEdgeSelected(viewObjects.getEdgeFront())) {
                 // clear selected edges
                 myTAZSelectionStatistics->clearSelectedEdges();
             } else {
                 // iterate over TAZEdges saved in CurrentTAZ (it contains the Edge and Source/sinks)
                 for (const auto& TAZEdgeColor : myCurrentTAZ->getTAZEdges()) {
-                    if (TAZEdgeColor.edge == objectsUnderCursor.getEdgeFront()) {
+                    if (TAZEdgeColor.edge == viewObjects.getEdgeFront()) {
                         // clear current selection (to avoid having two or more edges selected at the same time using mouse clicks)
                         myTAZSelectionStatistics->clearSelectedEdges();
                         // now select edge
diff --git a/src/netedit/frames/network/GNETAZFrame.h b/src/netedit/frames/network/GNETAZFrame.h
index 5f1ed076ecfa..16527e7a998d 100644
--- a/src/netedit/frames/network/GNETAZFrame.h
+++ b/src/netedit/frames/network/GNETAZFrame.h
@@ -532,10 +532,10 @@ class GNETAZFrame : public GNEFrame {
 
     /**@brief process click over Viewnet
      * @param[in] clickedPosition clicked position over ViewNet
-     * @param[in] objectsUnderCursor objects under cursors
+     * @param[in] viewObjects objects under cursors
      * @return true if something (select TAZ or add edge) was sucefully done
      */
-    bool processClick(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief process selection of edges in view net
     void processEdgeSelection(const std::vector<GNEEdge*>& edges);
diff --git a/src/netedit/frames/network/GNETLSEditorFrame.cpp b/src/netedit/frames/network/GNETLSEditorFrame.cpp
index 15f97b65bdc6..4aa59ddb1072 100644
--- a/src/netedit/frames/network/GNETLSEditorFrame.cpp
+++ b/src/netedit/frames/network/GNETLSEditorFrame.cpp
@@ -163,24 +163,24 @@ GNETLSEditorFrame::frameWidthUpdated() {
 
 
 void
-GNETLSEditorFrame::editTLS(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
-    // first check if in objectsUnderCursor there is a junction
-    if (objectsUnderCursor.getJunctionFront()) {
+GNETLSEditorFrame::editTLS(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
+    // first check if in viewObjects there is a junction
+    if (viewObjects.getJunctionFront()) {
         // show objects under cursor
-        myOverlappedInspection->showOverlappedInspection(objectsUnderCursor, clickedPosition);
+        myOverlappedInspection->showOverlappedInspection(viewObjects, clickedPosition);
         // hide if we inspect only one junction
         if (myOverlappedInspection->getNumberOfOverlappedACs() == 1) {
             myOverlappedInspection->hideOverlappedInspection();
         }
         // check if we're adding or removing joined TLSs
         if (myTLSJunction->isJoiningJunctions()) {
-            myTLSJunction->toggleJunctionSelected(objectsUnderCursor.getJunctionFront());
+            myTLSJunction->toggleJunctionSelected(viewObjects.getJunctionFront());
         } else {
-            editJunction(objectsUnderCursor.getJunctionFront());
+            editJunction(viewObjects.getJunctionFront());
         }
-    } else if (objectsUnderCursor.getAdditionalFront() && myTLSAttributes->isSetDetectorsToggleButtonEnabled() &&
-               (objectsUnderCursor.getAdditionalFront()->getTagProperty().getTag() == SUMO_TAG_INDUCTION_LOOP)) {
-        myTLSAttributes->toggleE1DetectorSelection(objectsUnderCursor.getAdditionalFront());
+    } else if (viewObjects.getAdditionalFront() && myTLSAttributes->isSetDetectorsToggleButtonEnabled() &&
+               (viewObjects.getAdditionalFront()->getTagProperty().getTag() == SUMO_TAG_INDUCTION_LOOP)) {
+        myTLSAttributes->toggleE1DetectorSelection(viewObjects.getAdditionalFront());
     } else {
         myViewNet->setStatusBarText(TL("Click over a junction to edit a TLS"));
     }
diff --git a/src/netedit/frames/network/GNETLSEditorFrame.h b/src/netedit/frames/network/GNETLSEditorFrame.h
index 8c50d8383499..a5528db5ebf3 100644
--- a/src/netedit/frames/network/GNETLSEditorFrame.h
+++ b/src/netedit/frames/network/GNETLSEditorFrame.h
@@ -583,9 +583,9 @@ class GNETLSEditorFrame : public GNEFrame {
 
     /**@brief edits the traffic light for the given clicked junction
      * @param[in] clickedPosition clicked position
-     * @param[in] objectsUnderCursor The clicked objects under cursor
+     * @param[in] viewObjects The clicked objects under cursor
      */
-    void editTLS(const Position& clickedPosition, const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    void editTLS(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief check if modifications in TLS was saved
     bool isTLSSaved();
diff --git a/src/netedit/frames/network/GNEWireFrame.cpp b/src/netedit/frames/network/GNEWireFrame.cpp
index fe685b923a6a..3a8614fbeeac 100644
--- a/src/netedit/frames/network/GNEWireFrame.cpp
+++ b/src/netedit/frames/network/GNEWireFrame.cpp
@@ -69,7 +69,7 @@ GNEWireFrame::show() {
 
 
 bool
-GNEWireFrame::addWire(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor) {
+GNEWireFrame::addWire(const GNEViewNetHelper::ViewObjectsSelector& viewObjects) {
     // first check that current selected wire is valid
     if (myWireTagSelector->getCurrentTemplateAC() == nullptr) {
         myViewNet->setStatusBarText(TL("Current selected wire isn't valid."));
@@ -89,11 +89,11 @@ GNEWireFrame::addWire(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCu
     // obtain attributes and values
     myWireAttributes->getAttributesAndValues(myBaseWire, true);
     // fill netedit attributes
-    if (!myNeteditAttributes->getNeteditAttributesAndValues(myBaseWire, objectsUnderCursor.getLaneFront())) {
+    if (!myNeteditAttributes->getNeteditAttributesAndValues(myBaseWire, viewObjects.getLaneFront())) {
         return false;
     }
     if (tagProperties.getTag() == SUMO_TAG_OVERHEAD_WIRE_SECTION) {
-        return myConsecutiveLaneSelector->addLane(objectsUnderCursor.getLaneFront());
+        return myConsecutiveLaneSelector->addLane(viewObjects.getLaneFront());
     } else {
         // build wire over view
         return buildWireOverView(tagProperties);
diff --git a/src/netedit/frames/network/GNEWireFrame.h b/src/netedit/frames/network/GNEWireFrame.h
index cbefc479edb5..82f2517ffc1d 100644
--- a/src/netedit/frames/network/GNEWireFrame.h
+++ b/src/netedit/frames/network/GNEWireFrame.h
@@ -51,10 +51,10 @@ class GNEWireFrame : public GNEFrame {
     void show();
 
     /**@brief add wire element
-     * @param objectsUnderCursor collection of objects under cursor after click over view
+     * @param viewObjects collection of objects under cursor after click over view
      * @return true if wire was successfully added
      */
-    bool addWire(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor);
+    bool addWire(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
     /// @brief get consecutive lane selector
     GNEConsecutiveSelector* getConsecutiveLaneSelector() const;
diff --git a/src/utils/gui/settings/GUIVisualizationSettings.cpp b/src/utils/gui/settings/GUIVisualizationSettings.cpp
index 2036d7a6dca1..b873e44532b7 100644
--- a/src/utils/gui/settings/GUIVisualizationSettings.cpp
+++ b/src/utils/gui/settings/GUIVisualizationSettings.cpp
@@ -596,7 +596,7 @@ GUIVisualizationSettings::GUIVisualizationSettings(const std::string& _name, boo
     gaming(false),
     drawBoundaries(false),
     selectorFrameScale(1.),
-    drawForObjectUnderCursor(false),
+    drawForViewObjectsHandler(false),
     drawForRectangleSelection(false),
     forceDrawForRectangleSelection(false),
     disableDottedContours(false),
@@ -2387,7 +2387,7 @@ GUIVisualizationSettings::flippedTextAngle(double objectAngle) const {
 bool
 GUIVisualizationSettings::checkBoundarySizeDrawing(const double w, const double h) const {
     const double size = MAX2(w, h);
-    if (drawForObjectUnderCursor) {
+    if (drawForViewObjectsHandler) {
         return true;
     } else {
         // for low computers 20. for high 10
diff --git a/src/utils/gui/settings/GUIVisualizationSettings.h b/src/utils/gui/settings/GUIVisualizationSettings.h
index 1b8b328b9007..f7c2c7124752 100644
--- a/src/utils/gui/settings/GUIVisualizationSettings.h
+++ b/src/utils/gui/settings/GUIVisualizationSettings.h
@@ -972,8 +972,8 @@ class GUIVisualizationSettings {
     /// @brief the current selection scaling in netedit (set in SelectorFrame)
     double selectorFrameScale;
 
-    /// @brief whether drawing is performed for the purpose of selecting objects under cursor
-    bool drawForObjectUnderCursor;
+    /// @brief whether drawing is performed for the purpose of selecting objects in view using ViewObjectsHandler
+    bool drawForViewObjectsHandler;
 
     /// @brief whether drawing is performed for the purpose of selecting objects using a rectangle
     bool drawForRectangleSelection;