GNETAZFrame.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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
/****************************************************************************/
// The Widget for add TAZ elements
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netedit/frames/GNEFrame.h>
#include <netedit/frames/GNEDrawingShape.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNETAZ;
class GNETAZSourceSink;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNETAZFrame : public GNEFrame {
 
public:
    // ===========================================================================
    // class CurrentTAZ
    // ===========================================================================
 
    class CurrentTAZ : public MFXGroupBoxModule {
 
    public:
        class TAZEdgeColor {
 
        public:
            TAZEdgeColor(CurrentTAZ* CurrentTAZParent, GNEEdge* _edge, GNETAZSourceSink* _source, GNETAZSourceSink* _sink);
 
            ~TAZEdgeColor();
 
            void updateColors();
 
            GNEEdge* edge;
 
            GNETAZSourceSink* source;
 
            GNETAZSourceSink* sink;
 
            int sourceColor;
 
            int sinkColor;
 
            int sourcePlusSinkColor;
 
            int sourceMinusSinkColor;
 
        private:
            CurrentTAZ* myCurrentTAZParent;
 
            TAZEdgeColor();
        };
 
        CurrentTAZ(GNETAZFrame* TAZFrameParent);
 
        ~CurrentTAZ();
 
        void setTAZ(GNETAZ* editedTAZ);
 
        GNETAZ* getTAZ() const;
 
        bool isTAZEdge(GNEEdge* edge) const;
 
        const std::vector<GNEEdge*>& getSelectedEdges() const;
 
        const std::vector<CurrentTAZ::TAZEdgeColor>& getTAZEdges() const;
 
        void refreshTAZEdges();
 
    protected:
        void addTAZChild(GNETAZSourceSink* additional);
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        GNETAZ* myEditedTAZ;
 
        std::vector<GNEEdge*> mySelectedEdges;
 
        std::vector<TAZEdgeColor> myTAZEdgeColors;
 
        FXLabel* myCurrentTAZLabel;
 
        double myMaxSourcePlusSinkWeight;
 
        double myMinSourcePlusSinkWeight;
 
        double myMaxSourceMinusSinkWeight;
 
        double myMinSourceMinusSinkWeight;
    };
 
    // ===========================================================================
    // class TAZCommonStatistics
    // ===========================================================================
 
    class TAZCommonStatistics : public MFXGroupBoxModule {
 
    public:
        TAZCommonStatistics(GNETAZFrame* TAZFrameParent);
 
        ~TAZCommonStatistics();
 
        void showTAZCommonStatisticsModule();
 
        void hideTAZCommonStatisticsModule();
 
        void updateStatistics();
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        FXLabel* myStatisticsLabel;
    };
 
    // ===========================================================================
    // class TAZSaveChanges
    // ===========================================================================
 
    class TAZSaveChanges : public MFXGroupBoxModule {
        FXDECLARE(GNETAZFrame::TAZSaveChanges)
 
    public:
        TAZSaveChanges(GNETAZFrame* TAZFrameParent);
 
        ~TAZSaveChanges();
 
        void showTAZSaveChangesModule();
 
        void hideTAZSaveChangesModule();
 
        void enableButtonsAndBeginUndoList();
 
        bool isChangesPending() const;
 
        long onCmdSaveChanges(FXObject*, FXSelector, void*);
 
        long onCmdCancelChanges(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TAZSaveChanges)
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        FXButton* mySaveChangesButton;
 
        FXButton* myCancelChangesButton;
    };
 
    // ===========================================================================
    // class TAZChildDefaultParameters
    // ===========================================================================
 
    class TAZChildDefaultParameters : public MFXGroupBoxModule {
        FXDECLARE(GNETAZFrame::TAZChildDefaultParameters)
 
    public:
        TAZChildDefaultParameters(GNETAZFrame* TAZFrameParent);
 
        ~TAZChildDefaultParameters();
 
        void extendTAZChildDefaultParameters();
 
        void collapseTAZChildDefaultParameters();
 
        void updateSelectEdgesButton();
 
        double getDefaultTAZSourceWeight() const;
 
        double getDefaultTAZSinkWeight() const;
 
        bool getToggleMembership() const;
 
        long onCmdSetDefaultValues(FXObject* obj, FXSelector, void*);
 
        long onCmdUseSelectedEdges(FXObject* obj, FXSelector, void*);
 
        long onCmdSetZeroFringeProbabilities(FXObject* obj, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TAZChildDefaultParameters)
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        FXCheckButton* myToggleMembership;
 
        FXHorizontalFrame* myToggleMembershipFrame;
 
        FXHorizontalFrame* myDefaultTAZSourceFrame;
 
        FXTextField* myTextFieldDefaultValueTAZSources;
 
        FXHorizontalFrame* myDefaultTAZSinkFrame;
 
        FXTextField* myTextFieldDefaultValueTAZSinks;
 
        FXButton* myUseSelectedEdges;
 
        FXButton* myZeroFringeProbabilities;
 
        FXLabel* myInformationLabel;
 
        double myDefaultTAZSourceWeight;
 
        double myDefaultTAZSinkWeight;
    };
 
    // ===========================================================================
    // class TAZSelectionStatistics
    // ===========================================================================
 
    class TAZSelectionStatistics : public MFXGroupBoxModule {
        FXDECLARE(GNETAZFrame::TAZSelectionStatistics)
 
    public:
        TAZSelectionStatistics(GNETAZFrame* TAZFrameParent);
 
        ~TAZSelectionStatistics();
 
        void showTAZSelectionStatisticsModule();
 
        void hideTAZSelectionStatisticsModule();
 
        bool selectEdge(const CurrentTAZ::TAZEdgeColor& edge);
 
        bool unselectEdge(GNEEdge* edge);
 
        bool isEdgeSelected(GNEEdge* edge);
 
        void clearSelectedEdges();
 
        const std::vector<CurrentTAZ::TAZEdgeColor>& getEdgeAndTAZChildrenSelected() const;
 
        long onCmdSetNewValues(FXObject* obj, FXSelector, void*);
 
        long onCmdSelectEdges(FXObject* obj, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TAZSelectionStatistics)
 
        
        void updateStatistics();
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        FXHorizontalFrame* myTAZSourceFrame;
 
        FXTextField* myTextFieldTAZSourceWeight;
 
        FXHorizontalFrame* myTAZSinkFrame;
 
        FXTextField* myTextFieldTAZSinkWeight;
 
        FXLabel* myStatisticsLabel;
 
        std::vector<CurrentTAZ::TAZEdgeColor> myEdgeAndTAZChildrenSelected;
    };
 
    // ===========================================================================
    // class TAZParameters
    // ===========================================================================
 
    class TAZParameters : public MFXGroupBoxModule {
        FXDECLARE(GNETAZFrame::TAZParameters)
 
    public:
        TAZParameters(GNETAZFrame* TAZFrameParent);
 
        ~TAZParameters();
 
        void showTAZParametersModule();
 
        void hideTAZParametersModule();
 
        bool isCurrentParametersValid() const;
 
        bool isAddEdgesWithinEnabled() const;
 
        void getAttributesAndValues() const;
 
        long onCmdSetColorAttribute(FXObject*, FXSelector, void*);
 
        long onCmdSetAttribute(FXObject*, FXSelector, void*);
 
        long onCmdHelp(FXObject*, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TAZParameters)
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        GNETAZ* myTAZTemplate;
 
        FXButton* myColorEditor;
 
        FXTextField* myTextFieldCenter;
 
        FXCheckButton* myCheckButtonFill;
 
        FXTextField* myTextFieldColor;
 
        FXTextField* myTextFieldName;
 
        FXCheckButton* myAddEdgesWithinCheckButton;
 
        FXButton* myHelpTAZAttribute;
    };
 
    // ===========================================================================
    // class TAZEdgesGraphic
    // ===========================================================================
 
    class TAZEdgesGraphic : public MFXGroupBoxModule {
        FXDECLARE(GNETAZFrame::TAZEdgesGraphic)
 
    public:
        TAZEdgesGraphic(GNETAZFrame* TAZFrameParent);
 
        ~TAZEdgesGraphic();
 
        void showTAZEdgesGraphicModule();
 
        void hideTAZEdgesGraphicModule();
 
        void updateEdgeColors();
 
        long onCmdChoosenBy(FXObject* obj, FXSelector, void*);
 
    protected:
        FOX_CONSTRUCTOR(TAZEdgesGraphic)
 
    private:
        GNETAZFrame* myTAZFrameParent;
 
        FXRadioButton* myColorBySourceWeight;
 
        FXRadioButton* myColorBySinkWeight;
 
        FXRadioButton* myColorBySourcePlusSinkWeight;
 
        FXRadioButton* myColorBySourceMinusSinkWeight;
 
        RGBColor myEdgeDefaultColor;
 
        RGBColor myEdgeSelectedColor;
    };
 
    GNETAZFrame(GNEViewParent* viewParent, GNEViewNet* viewNet);
 
    ~GNETAZFrame();
 
    void hide();
 
    bool processClick(const Position& clickedPosition, const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
    void processEdgeSelection(const std::vector<GNEEdge*>& edges);
 
    GNEDrawingShape* getDrawingShapeModule() const;
 
    CurrentTAZ* getCurrentTAZModule() const;
 
    TAZSelectionStatistics* getTAZSelectionStatisticsModule() const;
 
    TAZSaveChanges* getTAZSaveChangesModule() const;
 
protected:
    CommonXMLStructure::SumoBaseObject* myBaseTAZ;
 
    bool shapeDrawed();
 
    bool addOrRemoveTAZMember(GNEEdge* edge);
 
    void dropTAZMembers();
 
private:
    CurrentTAZ* myCurrentTAZ;
 
    TAZCommonStatistics* myTAZCommonStatistics;
 
    TAZParameters* myTAZParameters;
 
    GNEDrawingShape* myDrawingShape;
 
    TAZSaveChanges* myTAZSaveChanges;
 
    TAZChildDefaultParameters* myTAZChildDefaultParameters;
 
    TAZSelectionStatistics* myTAZSelectionStatistics;
 
    TAZEdgesGraphic* myTAZEdgesGraphic;
};