GNEViewNet.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A view on the network being edited (adapted from GUIViewTraffic)
/****************************************************************************/
#ifndef GNEViewNet_h
#define GNEViewNet_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <string>
#include <utils/gui/globjects/GLIncludes.h>
#include <utils/geom/Boundary.h>
#include <utils/geom/Position.h>
#include <utils/common/RGBColor.h>
#include <utils/geom/PositionVector.h>
#include <utils/gui/windows/GUISUMOAbstractView.h>
#include <utils/common/StringBijection.h>
#include <utils/foxtools/MFXCheckableButton.h>
#include <utils/options/OptionsCont.h>


// ===========================================================================
// enum
// ===========================================================================

enum EditMode {
    GNE_MODE_DUMMY,
    GNE_MODE_CREATE_EDGE,
    GNE_MODE_MOVE,
    GNE_MODE_DELETE,
    GNE_MODE_INSPECT,
    GNE_MODE_SELECT,
    GNE_MODE_CONNECT,
    GNE_MODE_TLS,
    GNE_MODE_ADDITIONAL,
    GNE_MODE_CROSSING,
    GNE_MODE_POLYGON,
    GNE_MODE_PROHIBITION
};

// ===========================================================================
// class declarations
// ===========================================================================

class GNENet;
class GNENetElement;
class GNEJunction;
class GNEEdge;
class GNELane;
class GNEConnection;
class GNEViewParent;
class GNEUndoList;
class GNEAdditional;
class GNEShape;
class GNEPoly;
class GNEPOI;
class GNEFrame;
class GNENetElement;
class GNECrossing;
class GNEAttributeCarrier;

// ===========================================================================
// class definitions
// ===========================================================================
class GNEViewNet : public GUISUMOAbstractView {
    FXDECLARE(GNEViewNet)

public:
    /* @brief constructor
     * @param[in] tmpParent temporal FXFrame parent so that we can add items to view area in the desired order
     * @param[in] actualParent FXFrame parent of GNEViewNet
     * @param[in] app main windows
     * @param[in] viewParent viewParent of this viewNet
     * @param[in] net traffic net
     * @param[in] undoList pointer to UndoList modul
     * @param[in] glVis a reference to GLVisuals
     * @param[in] share a reference to FXCanvas
     * @param[in] toolbar A reference to the parents toolbar
     */
    GNEViewNet(FXComposite* tmpParent, FXComposite* actualParent, GUIMainWindow& app,
               GNEViewParent* viewParent, GNENet* net, GNEUndoList* undoList,
               FXGLVisual* glVis, FXGLCanvas* share, FXToolBar* toolBar);

    virtual ~GNEViewNet();

    virtual void buildViewToolBars(GUIGlChildWindow&);

    void buildSelectionACPopupEntry(GUIGLObjectPopupMenu* ret, GNEAttributeCarrier* AC);

    bool setColorScheme(const std::string& name);

    void buildColorRainbow(GUIColorScheme& scheme, int active, GUIGlObjectType objectType);

    long onLeftBtnPress(FXObject*, FXSelector, void*);

    long onLeftBtnRelease(FXObject*, FXSelector, void*);

    long onRightBtnPress(FXObject*, FXSelector, void*);

    long onRightBtnRelease(FXObject*, FXSelector, void*);

    long onMouseMove(FXObject*, FXSelector, void*);

    long onKeyPress(FXObject* o, FXSelector sel, void* data);

    long onKeyRelease(FXObject* o, FXSelector sel, void* data);

    long onCmdSetModeCreateEdge(FXObject*, FXSelector, void*);

    long onCmdSetModeMove(FXObject*, FXSelector, void*);

    long onCmdSetModeDelete(FXObject*, FXSelector, void*);

    long onCmdSetModeInspect(FXObject*, FXSelector, void*);

    long onCmdSetModeSelect(FXObject*, FXSelector, void*);

    long onCmdSetModeConnect(FXObject*, FXSelector, void*);

    long onCmdSetModeTLS(FXObject*, FXSelector, void*);

    long onCmdSetModeAdditional(FXObject*, FXSelector, void*);

    long onCmdSetModeCrossing(FXObject*, FXSelector, void*);

    long onCmdSetModePolygon(FXObject*, FXSelector, void*);

    long onCmdSetModeProhibition(FXObject*, FXSelector, void*);


    long onCmdSplitEdge(FXObject*, FXSelector, void*);

    long onCmdSplitEdgeBidi(FXObject*, FXSelector, void*);

    long onCmdReverseEdge(FXObject*, FXSelector, void*);

    long onCmdAddReversedEdge(FXObject*, FXSelector, void*);

    long onCmdEditEdgeEndpoint(FXObject*, FXSelector, void*);

    long onCmdResetEdgeEndpoint(FXObject*, FXSelector, void*);

    long onCmdStraightenEdges(FXObject*, FXSelector, void*);

    long onCmdSmoothEdges(FXObject*, FXSelector, void*);

    long onCmdStraightenEdgesElevation(FXObject*, FXSelector, void*);

    long onCmdSmoothEdgesElevation(FXObject*, FXSelector, void*);

    long onCmdSimplifyShape(FXObject*, FXSelector, void*);

    long onCmdDeleteGeometryPoint(FXObject*, FXSelector, void*);

    long onCmdClosePolygon(FXObject*, FXSelector, void*);

    long onCmdOpenPolygon(FXObject*, FXSelector, void*);

    long onCmdSetFirstGeometryPoint(FXObject*, FXSelector, void*);

    long onCmdTransformPOI(FXObject*, FXSelector, void*);

    long onCmdDuplicateLane(FXObject*, FXSelector, void*);

    long onCmdResetLaneCustomShape(FXObject*, FXSelector, void*);

    long onCmdRestrictLaneSidewalk(FXObject*, FXSelector, void*);

    long onCmdRestrictLaneBikelane(FXObject*, FXSelector, void*);

    long onCmdRestrictLaneBuslane(FXObject*, FXSelector, void*);

    long onCmdRestrictLaneGreenVerge(FXObject*, FXSelector, void*);

    long onCmdAddRestrictedLaneSidewalk(FXObject*, FXSelector, void*);

    long onCmdAddRestrictedLaneBikelane(FXObject*, FXSelector, void*);

    long onCmdAddRestrictedLaneBuslane(FXObject*, FXSelector, void*);

    long onCmdAddRestrictedLaneGreenVerge(FXObject*, FXSelector, void*);

    long onCmdRemoveRestrictedLaneSidewalk(FXObject*, FXSelector, void*);

    long onCmdRemoveRestrictedLaneBikelane(FXObject*, FXSelector, void*);

    long onCmdRemoveRestrictedLaneBuslane(FXObject*, FXSelector, void*);

    long onCmdRemoveRestrictedLaneGreenVerge(FXObject*, FXSelector, void*);

    long onCmdOpenAdditionalDialog(FXObject*, FXSelector, void*);

    long onCmdEditJunctionShape(FXObject*, FXSelector, void*);

    long onCmdResetJunctionShape(FXObject*, FXSelector, void*);

    long onCmdReplaceJunction(FXObject*, FXSelector, void*);

    long onCmdSplitJunction(FXObject*, FXSelector, void*);

    long onCmdClearConnections(FXObject*, FXSelector, void*);

    long onCmdResetConnections(FXObject*, FXSelector, void*);

    long onCmdEditConnectionShape(FXObject*, FXSelector, void*);

    long onCmdEditCrossingShape(FXObject*, FXSelector, void*);

    long onCmdToogleShowConnection(FXObject*, FXSelector, void*);

    long onCmdToogleSelectEdges(FXObject*, FXSelector, void*);

    long onCmdToogleShowBubbles(FXObject*, FXSelector, void*);

    long onCmdAddSelected(FXObject*, FXSelector, void*);

    long onCmdRemoveSelected(FXObject*, FXSelector, void*);

    long onCmdShowGrid(FXObject*, FXSelector, void*);

    void setEditModeFromHotkey(FXushort selid);

    void abortOperation(bool clearSelection = true);

    void hotkeyDel();

    void hotkeyEnter();

    void hotkeyFocusFrame();

    GNEViewParent* getViewParent() const;

    GNENet* getNet() const;

    GNEUndoList* getUndoList() const;

    EditMode getCurrentEditMode() const;

    FXMenuCheck* getMenuCheckShowGrid() const;

    const GNEAttributeCarrier* getACUnderCursor() const;

    void setACUnderCursor(const GNEAttributeCarrier* AC);

    bool showLockIcon() const;

    void setStatusBarText(const std::string& text);

    bool selectEdges();

    bool showConnections();

    bool autoSelectNodes();

    void setSelectionScaling(double selectionScale);

    void updateControls();

    bool changeAllPhases() const;

    bool showJunctionAsBubbles() const;

    void startEditCustomShape(GNENetElement* element, const PositionVector& shape, bool fill);

    void stopEditCustomShape();

    void beginMoveSelection(GNEAttributeCarrier* originAC, const Position& originPosition);

    void moveSelection(const Position& offset);

    void finishMoveSelection();

protected:
    GNEViewNet() {}

    int doPaintGL(int mode, const Boundary& bound);

    void doInit();

private:
    struct MovedItems {
        MovedItems() :
            junctionToMove(nullptr),
            edgeToMove(nullptr),
            polyToMove(nullptr),
            poiToMove(nullptr),
            additionalToMove(nullptr) {}

        GNEJunction* junctionToMove;

        GNEEdge* edgeToMove;

        GNEPoly* polyToMove;

        GNEPOI* poiToMove;

        GNEAdditional* additionalToMove;
    };

    struct MoveSingleElementValues {
        MoveSingleElementValues() :
            movingStartPos(false),
            movingEndPos(false),
            movingIndexShape(-1) {}

        Position movingReference;

        Position movingOriginalPosition;

        PositionVector movingOriginalShape;
        PositionVector movingOriginalShape2;

        bool movingStartPos;
        bool movingEndPos;

        int movingIndexShape;
    };

    class ObjectsUnderCursor {
    public:
        ObjectsUnderCursor():
            eventInfo(nullptr),
            glID(0),
            glType(GLO_NETWORK),
            attributeCarrier(nullptr),
            netElement(nullptr),
            additional(nullptr),
            shape(nullptr),
            junction(nullptr),
            edge(nullptr),
            lane(nullptr),
            crossing(nullptr),
            connection(nullptr),
            poi(nullptr),
            poly(nullptr) {}

        void updateObjectUnderCursor(GUIGlID glIDObject, GNEPoly* editedPolyShape, FXEvent* ev);

        void swapLane2Edge();

        bool shiftKeyPressed() const;

        bool controlKeyPressed() const;

        FXEvent* eventInfo;

        GUIGlID glID;

        GUIGlObjectType glType;

        GNEAttributeCarrier* attributeCarrier;

        GNENetElement* netElement;

        GNEAdditional* additional;

        GNEShape* shape;

        GNEJunction* junction;

        GNEEdge* edge;

        GNELane* lane;

        GNECrossing* crossing;

        GNEConnection* connection;

        GNEPOI* poi;

        GNEPoly* poly;
    };

    struct SelectingArea {
        SelectingArea() :
            selectingUsingRectangle(false) {}

        void processSelection(GNEViewNet* viewNet, bool shiftKeyPressed);

        bool selectingUsingRectangle;

        Position selectionCorner1;

        Position selectionCorner2;

        std::string reportDimensions();
    };

    struct testingMode {
        testingMode() :
            testingEnabled(OptionsCont::getOptions().getBool("gui-testing")),
            testingWidth(0),
            testingHeight(0) {}

        bool testingEnabled;

        int testingWidth;

        int testingHeight;
    };

    GNEViewParent* myViewParent;

    GNENet* myNet;

    EditMode myEditMode;

    GNEFrame* myCurrentFrame;

    FXMenuCheck* myMenuCheckSelectEdges;

    FXMenuCheck* myMenuCheckShowConnections;

    FXMenuCheck* myMenuCheckHideConnections;

    FXMenuCheck* myMenuCheckExtendToEdgeNodes;

    FXMenuCheck* myMenuCheckChangeAllPhases;

    FXMenuCheck* myMenuCheckShowGrid;

    bool myShowConnections;

    bool mySelectEdges;

    bool myShiftKeyPressed;

    // @{
    GNEJunction* myCreateEdgeSource;

    FXMenuCheck* myChainCreateEdge;
    FXMenuCheck* myAutoCreateOppositeEdge;
    // @}

    // @{
    FXMenuCheck* myMenuCheckWarnAboutMerge;

    FXMenuCheck* myMenuCheckShowBubbleOverJunction;

    FXMenuCheck* myMenuCheckMoveElevation;
    // @}

    ObjectsUnderCursor myObjectsUnderCursor;

    MovedItems myMovedItems;

    MoveSingleElementValues myMoveSingleElementValues;

    SelectingArea mySelectingArea;

    testingMode myTestingMode;

    bool myMovingSelection;


    std::map<GNEJunction*, Position> myOriginPositionOfMovedJunctions;

    std::map<GNEEdge*, PositionVector> myOriginShapesMovedEntireShapes;

    struct MovingEdges {
        PositionVector originalShape;
        int index;
        Position originalPosition;
    };

    std::map<GNEEdge*, MovingEdges> myOriginShapesMovedPartialShapes;
    // @}

    FXToolBar* myToolbar;

    MFXCheckableButton* myEditModeCreateEdge;

    MFXCheckableButton* myEditModeMove;

    MFXCheckableButton* myEditModeDelete;

    MFXCheckableButton* myEditModeInspect;

    MFXCheckableButton* myEditModeSelect;

    MFXCheckableButton* myEditModeConnection;

    MFXCheckableButton* myEditModeTrafficLight;

    MFXCheckableButton* myEditModeAdditional;

    MFXCheckableButton* myEditModeCrossing;

    MFXCheckableButton* myEditModePolygon;

    MFXCheckableButton* myEditModeProhibition;


    StringBijection<EditMode> myEditModeNames;

    StringBijection<EditMode> myEditAdditionalModeNames;

    GNEUndoList* myUndoList;

    const GNEAttributeCarrier* myACUnderCursor;

    GNEPoly* myEditShapePoly;

    EditMode myPreviousEditMode;

    void setEditMode(EditMode mode);

    void buildEditModeControls();

    void updateModeSpecificControls();

    void deleteSelectedJunctions();

    void deleteSelectedLanes();

    void deleteSelectedEdges();

    void deleteSelectedAdditionals();

    void deleteSelectedCrossings();

    void deleteSelectedConnections();

    void deleteSelectedShapes();

    bool mergeJunctions(GNEJunction* moved, const Position& oldPos);

    GNEEdge* getEdgeAtPopupPosition();

    GNELane* getLaneAtPopupPosition();

    GNEJunction* getJunctionAtPopupPosition();

    GNEConnection* getConnectionAtPopupPosition();

    GNECrossing* getCrossingAtPopupPosition();

    std::set<GNEEdge*> getEdgesAtPopupPosition();

    GNEAdditional* getAdditionalAtPopupPosition();

    GNEPoly* getPolygonAtPopupPosition();

    GNEPOI* getPOIAtPopupPosition();

    bool restrictLane(SUMOVehicleClass vclass);

    bool addRestrictedLane(SUMOVehicleClass vclass);

    bool removeRestrictedLane(SUMOVehicleClass vclass);

    void processClick(FXEvent* e, void* data);

    GNEViewNet(const GNEViewNet&) = delete;

    GNEViewNet& operator=(const GNEViewNet&) = delete;
};


#endif

/****************************************************************************/