GNEFrameModules.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Auxiliar class for GNEFrame Modules
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netedit/GNEViewNetHelper.h>
#include <netedit/elements/GNEAttributeCarrier.h>
#include <utils/foxtools/FXGroupBoxModule.h>
#include <utils/foxtools/FXTreeListDinamic.h>
#include <utils/foxtools/MFXIconComboBox.h>
 
// ===========================================================================
// class declaration
// ===========================================================================
 
class GNEFrame;
class GNEDataSet;
class GNEDataInterval;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEFrameModules {
 
public:
    // ===========================================================================
    // class TagSelector
    // ===========================================================================
 
    class TagSelector : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::TagSelector)
 
    public:
        TagSelector(GNEFrame* frameParent, GNETagProperties::TagType type, SumoXMLTag tag, bool onlyDrawables = true);
 
        ~TagSelector();
 
        void showTagSelector();
 
        void hideTagSelector();
 
        GNEAttributeCarrier* getTemplateAC(SumoXMLTag ACTag) const;
 
        GNEAttributeCarrier* getCurrentTemplateAC() const;
 
        void setCurrentTagType(GNETagProperties::TagType tagType, const bool onlyDrawables, const bool notifyFrameParent = true);
 
        void setCurrentTag(SumoXMLTag newTag, const bool notifyFrameParent = true);
 
        void refreshTagSelector();
 
        long onCmdSelectTag(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TagSelector)
 
    private:
        class ACTemplate {
 
        public:
            ACTemplate(GNENet* net, const GNETagProperties tagProperty);
 
            ~ACTemplate();
 
            GNEAttributeCarrier* getAC() const;
 
        private:
            GNEAttributeCarrier* myAC;
 
            ACTemplate(const ACTemplate&) = delete;
 
            ACTemplate& operator=(const ACTemplate& src) = delete;
        };
 
        GNEFrame* myFrameParent;
 
        GNETagProperties::TagType myTagType;
 
        MFXIconComboBox* myTagsMatchBox;
 
        GNEAttributeCarrier* myCurrentTemplateAC;
 
        std::vector<ACTemplate*> myACTemplates;
    };
 
    // ===========================================================================
    // class DemandElementSelector
    // ===========================================================================
 
    class DemandElementSelector : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::DemandElementSelector)
 
    public:
        DemandElementSelector(GNEFrame* frameParent, SumoXMLTag demandElementTag, GNEDemandElement* defaultElement = nullptr);
 
        DemandElementSelector(GNEFrame* frameParent, const std::vector<GNETagProperties::TagType>& tagTypes);
 
        ~DemandElementSelector();
 
        GNEDemandElement* getCurrentDemandElement() const;
 
        // @brief obtain allowed tags (derived from tagTypes)
        const std::vector<SumoXMLTag>& getAllowedTags() const;
 
        void setDemandElement(GNEDemandElement* demandElement);
 
        void showDemandElementSelector();
 
        void hideDemandElementSelector();
 
        bool isDemandElementSelectorShown() const;
 
        void refreshDemandElementSelector();
 
        GNEEdge* getPersonPlanPreviousEdge() const;
 
        GNEEdge* getContainerPlanPreviousEdge() const;
 
        long onCmdSelectDemandElement(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(DemandElementSelector)
 
    private:
        GNEFrame* myFrameParent;
 
        MFXIconComboBox* myDemandElementsMatchBox;
 
        GNEDemandElement* myCurrentDemandElement;
 
        std::vector<SumoXMLTag> myDemandElementTags;
    };
 
    // ===========================================================================
    // class HierarchicalElementTree
    // ===========================================================================
 
    class HierarchicalElementTree : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::HierarchicalElementTree)
 
    public:
        HierarchicalElementTree(GNEFrame* frameParent);
 
        ~HierarchicalElementTree();
 
        void showHierarchicalElementTree(GNEAttributeCarrier* AC);
 
        void hideHierarchicalElementTree();
 
        void refreshHierarchicalElementTree();
 
        void removeCurrentEditedAttributeCarrier(const GNEAttributeCarrier* HE);
 
        long onCmdShowChildMenu(FXObject*, FXSelector, void* data);
 
        long onCmdCenterItem(FXObject*, FXSelector, void*);
 
        long onCmdInspectItem(FXObject*, FXSelector, void*);
 
        long onCmdDeleteItem(FXObject*, FXSelector, void*);
 
        long onCmdMoveItemUp(FXObject*, FXSelector, void*);
 
        long onCmdMoveItemDown(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(HierarchicalElementTree)
 
        // @brief create pop-up menu in the positions X-Y for the clicked attribute carrier
        void createPopUpMenu(int X, int Y, GNEAttributeCarrier* clickedAC);
 
        FXTreeItem* showAttributeCarrierParents();
 
        void showHierarchicalElementChildren(GNEHierarchicalElement* HE, FXTreeItem* itemParent);
 
        FXTreeItem* addListItem(GNEAttributeCarrier* AC, FXTreeItem* itemParent = nullptr, std::string prefix = "", std::string sufix = "");
 
        FXTreeItem* addListItem(FXTreeItem* itemParent, const std::string& text, FXIcon* icon, bool expanded);
 
    private:
        GNEFrame* myFrameParent;
 
        GNEHierarchicalElement* myHE;
 
        GNEAttributeCarrier* myClickedAC;
 
        GNEJunction* myClickedJunction;
 
        GNEEdge* myClickedEdge;
 
        GNELane* myClickedLane;
 
        GNECrossing* myClickedCrossing;
 
        GNEConnection* myClickedConnection;
 
        GNEAdditional* myClickedAdditional;
 
        GNEDemandElement* myClickedDemandElement;
 
        GNEDataSet* myClickedDataSet;
 
        GNEDataInterval* myClickedDataInterval;
 
        GNEGenericData* myClickedGenericData;
 
        FXTreeListDinamic* myTreeListDinamic = nullptr;
 
        std::map<FXTreeItem*, GNEAttributeCarrier*> myTreeItemToACMap;
 
        std::set<FXTreeItem*> myTreeItemsConnections;
    };
 
    // ===========================================================================
    // class DrawingShape
    // ===========================================================================
 
    class DrawingShape : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::DrawingShape)
 
    public:
        DrawingShape(GNEFrame* frameParent);
 
        ~DrawingShape();
 
        void showDrawingShape();
 
        void hideDrawingShape();
 
        void startDrawing();
 
        void stopDrawing();
 
        void abortDrawing();
 
        void addNewPoint(const Position& P);
 
        void removeLastPoint();
 
        const PositionVector& getTemporalShape() const;
 
        bool isDrawing() const;
 
        void setDeleteLastCreatedPoint(bool value);
 
        bool getDeleteLastCreatedPoint();
 
        long onCmdStartDrawing(FXObject*, FXSelector, void*);
 
        long onCmdStopDrawing(FXObject*, FXSelector, void*);
 
        long onCmdAbortDrawing(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(DrawingShape)
 
    private:
        GNEFrame* myFrameParent;
 
        bool myDeleteLastCreatedPoint;
 
        PositionVector myTemporalShape;
 
        FXButton* myStartDrawingButton;
 
        FXButton* myStopDrawingButton;
 
        FXButton* myAbortDrawingButton;
 
        FXLabel* myInformationLabel;
    };
 
    // ===========================================================================
    // class SelectorParent
    // ===========================================================================
 
    class SelectorParent : public FXGroupBoxModule {
    public:
        SelectorParent(GNEFrame* frameParent);
 
        ~SelectorParent();
 
        std::string getIdSelected() const;
 
        void setIDSelected(const std::string& id);
 
        void showSelectorParentModule(const std::vector<SumoXMLTag>& parentTags);
 
        void hideSelectorParentModule();
 
        void refreshSelectorParentModule();
 
    private:
        GNEFrame* myFrameParent;
 
        std::vector<SumoXMLTag> myParentTags;
 
        FXLabel* myParentsLabel;
 
        FXList* myParentsList;
    };
 
    // ===========================================================================
    // class OverlappedInspection
    // ===========================================================================
 
    class OverlappedInspection : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::OverlappedInspection)
 
    public:
        OverlappedInspection(GNEFrame* frameParent);
 
        OverlappedInspection(GNEFrame* frameParent, const SumoXMLTag filteredTag);
 
        ~OverlappedInspection();
 
        void showOverlappedInspection(const GNEViewNetHelper::ObjectsUnderCursor& objectsUnderCursor, const Position& clickedPosition);
 
        void hideOverlappedInspection();
 
        bool overlappedInspectionShown() const;
 
        int getNumberOfOverlappedACs() const;
 
        bool checkSavedPosition(const Position& clickedPosition) const;
 
        bool nextElement(const Position& clickedPosition);
 
        bool previousElement(const Position& clickedPosition);
 
 
        long onCmdNextElement(FXObject*, FXSelector, void*);
 
        long onCmdPreviousElement(FXObject*, FXSelector, void*);
 
        long onCmdShowList(FXObject*, FXSelector, void*);
 
        long onCmdListItemSelected(FXObject*, FXSelector, void*);
 
        long onCmdOverlappingHelp(FXObject*, FXSelector, void*);
 
    protected:
        OverlappedInspection();
 
        void buildFXElements();
 
    private:
        GNEFrame* myFrameParent;
 
        FXButton* myPreviousElement;
 
        FXButton* myCurrentIndexButton;
 
        FXButton* myNextElement;
 
        FXList* myOverlappedElementList;
 
        FXButton* myHelpButton;
 
        const SumoXMLTag myFilteredTag;
 
        std::vector<GNEAttributeCarrier*> myOverlappedACs;
 
        size_t myItemIndex;
 
        Position mySavedClickedPosition;
    };
 
    // ===========================================================================
    // class PathCreator
    // ===========================================================================
 
    class PathCreator : public FXGroupBoxModule {
        FXDECLARE(GNEFrameModules::PathCreator)
 
    public:
        class Path {
 
        public:
            Path(const SUMOVehicleClass vClass, GNEEdge* edge);
 
            Path(GNEViewNet* viewNet, const SUMOVehicleClass vClass, GNEEdge* edgeFrom, GNEEdge* edgeTo);
 
            const std::vector<GNEEdge*>& getSubPath() const;
 
            GNEAdditional* getFromBusStop() const;
 
            GNEAdditional* getToBusStop() const;
 
            bool isConflictVClass() const;
 
            bool isConflictDisconnected() const;
 
        protected:
            std::vector<GNEEdge*> mySubPath;
 
            GNEAdditional* myFromBusStop;
 
            GNEAdditional* myToBusStop;
 
            bool myConflictVClass;
 
            bool myConflictDisconnected;
 
        private:
            Path();
 
            Path(Path*) = delete;
 
            Path& operator=(Path*) = delete;
        };
 
        PathCreator(GNEFrame* frameParent);
 
        ~PathCreator();
 
        void showPathCreatorModule(SumoXMLTag element, const bool firstElement, const bool consecutives);
 
        void hidePathCreatorModule();
 
        SUMOVehicleClass getVClass() const;
 
        void setVClass(SUMOVehicleClass vClass);
 
        bool addJunction(GNEJunction* junction, const bool shiftKeyPressed, const bool controlKeyPressed);
 
        bool addEdge(GNEEdge* edge, const bool shiftKeyPressed, const bool controlKeyPressed);
 
        const std::vector<GNEEdge*>& getSelectedEdges() const;
 
        const std::vector<GNEJunction*>& getSelectedJunctions() const;
 
        bool addStoppingPlace(GNEAdditional* stoppingPlace, const bool shiftKeyPressed, const bool controlKeyPressed);
 
        GNEAdditional* getToStoppingPlace(SumoXMLTag expectedTag) const;
 
        bool addRoute(GNEDemandElement* route, const bool shiftKeyPressed, const bool controlKeyPressed);
 
        GNEDemandElement* getRoute() const;
 
        void removeRoute();
 
        const std::vector<Path>& getPath() const;
 
        bool drawCandidateEdgesWithSpecialColor() const;
 
        void updateJunctionColors();
 
        void updateEdgeColors();
 
        void clearJunctionColors();
 
        void clearEdgeColors();
 
        void drawTemporalRoute(const GUIVisualizationSettings& s) const;
 
        void createPath();
 
        void abortPathCreation();
 
        void removeLastElement();
 
        long onCmdCreatePath(FXObject*, FXSelector, void*);
 
        long onCmdAbortPathCreation(FXObject*, FXSelector, void*);
 
        long onCmdRemoveLastElement(FXObject*, FXSelector, void*);
 
        long onCmdShowCandidateEdges(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(PathCreator)
 
        // @brief creation mode
        enum Mode {
            CONSECUTIVE_EDGES        = 1 << 0,   // Path's edges are consecutives
            NONCONSECUTIVE_EDGES     = 1 << 1,   // Path's edges aren't consecutives
            START_EDGE               = 1 << 2,   // Path begins in an edge
            END_EDGE                 = 1 << 3,   // Path ends in an edge
            START_JUNCTION           = 1 << 4,   // Path begins in an edge
            END_JUNCTION             = 1 << 5,   // Path ends in an edge
            SINGLE_ELEMENT           = 1 << 6,   // Path only had one element
            ONLY_FROMTO              = 1 << 7,   // Path only had two elements (first and last)
            END_BUSSTOP              = 1 << 8,   // Path ends in a busStop
            ROUTE                    = 1 << 9,   // Path uses a route
            REQUIRE_FIRSTELEMENT     = 1 << 10,  // Path start always in a previous element
            SHOW_CANDIDATE_EDGES     = 1 << 11,  // Show candidate edges
            SHOW_CANDIDATE_JUNCTIONS = 1 << 12,  // show candidate junctions
        };
 
        void updateInfoRouteLabel();
 
        void clearPath();
 
        void recalculatePath();
 
        void setSpecialCandidates(GNEEdge* originEdge);
 
        void setPossibleCandidates(GNEEdge* originEdge, const SUMOVehicleClass vClass);
 
        GNEFrame* myFrameParent;
 
        SUMOVehicleClass myVClass;
 
        int myCreationMode;
 
        std::vector<GNEJunction*> mySelectedJunctions;
 
        std::vector<GNEEdge*> mySelectedEdges;
 
        GNEAdditional* myToStoppingPlace;
 
        GNEDemandElement* myRoute;
 
        std::vector<Path> myPath;
 
        FXLabel* myInfoRouteLabel;
 
        FXButton* myFinishCreationButton;
 
        FXButton* myAbortCreationButton;
 
        FXButton* myRemoveLastInsertedElement;
 
        FXCheckButton* myShowCandidateEdges;
 
        FXLabel* myShiftLabel;
 
        FXLabel* myControlLabel;
 
    private:
        PathCreator(PathCreator*) = delete;
 
        PathCreator& operator=(PathCreator*) = delete;
    };
 
    // ===========================================================================
    // class PathLegend
    // ===========================================================================
 
    class PathLegend : public FXGroupBoxModule {
 
    public:
        PathLegend(GNEFrame* frameParent);
 
        ~PathLegend();
 
        void showPathLegendModule();
 
        void hidePathLegendModule();
    };
 
    // ===========================================================================
    // Functions
    // ===========================================================================
 
    static FXLabel* buildRainbow(FXComposite* parent);
};