GNESelectorFrame.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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 modifying selections of network-elements
// (some elements adapted from GUIDialog_GLChosenEditor)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <unordered_map>
#include <netedit/frames/GNEFrame.h>
#include <netedit/GNEViewNetHelper.h>
#include <utils/foxtools/MFXComboBoxIcon.h>
 
// ===========================================================================
// class declaration
// ===========================================================================
 
class GNEAttributeProperties;
class GNEMatchAttribute;
class GNEMatchGenericDataAttribute;
class GNETagProperties;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNESelectorFrame : public GNEFrame {
 
public:
    // ===========================================================================
    // class SelectionInformation
    // ===========================================================================
 
    class SelectionInformation : public MFXGroupBoxModule {
 
    public:
        SelectionInformation(GNESelectorFrame* selectorFrameParent);
 
        ~SelectionInformation();
 
        void updateInformationLabel();
 
    protected:
        void updateInformationLabel(const std::string& element, int number);
 
    private:
        std::string myInformation;
 
        FXLabel* myInformationLabel;
 
        GNESelectorFrame* mySelectorFrameParent;
 
        SelectionInformation(const SelectionInformation&) = delete;
 
        SelectionInformation& operator=(const SelectionInformation&) = delete;
    };
    class SelectionInformation : public MFXGroupBoxModule {…};
 
    // ===========================================================================
    // class ModificationMode
    // ===========================================================================
 
    class ModificationMode : public MFXGroupBoxModule {
        FXDECLARE(GNESelectorFrame::ModificationMode)
 
    public:
        enum class Operation {
            ADD,
            SUB,
            RESTRICT,
            REPLACE,
            DEFAULT
        };
        enum class Operation {…};
 
        ModificationMode(GNESelectorFrame* selectorFrameParent);
 
        ~ModificationMode();
 
        Operation getModificationMode() const;
 
        long onCmdSelectModificationMode(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(ModificationMode)
 
    private:
        FXRadioButton* myAddRadioButton;
 
        FXRadioButton* myRemoveRadioButton;
 
        FXRadioButton* myKeepRadioButton;
 
        FXRadioButton* myReplaceRadioButton;
 
        Operation myModificationModeType;
 
        ModificationMode(const ModificationMode&) = delete;
 
        ModificationMode& operator=(const ModificationMode&) = delete;
    };
    class ModificationMode : public MFXGroupBoxModule {…};
 
    // ===========================================================================
    // class VisualScaling
    // ===========================================================================
 
    class VisualScaling : public MFXGroupBoxModule {
        FXDECLARE(GNESelectorFrame::VisualScaling)
 
    public:
        VisualScaling(GNESelectorFrame* selectorFrameParent);
 
        ~VisualScaling();
 
 
        long onCmdScaleSelection(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(VisualScaling)
 
    private:
        GNESelectorFrame* mySelectorFrameParent;
 
        FXRealSpinner* mySelectionScaling;
 
        VisualScaling(const VisualScaling&) = delete;
 
        VisualScaling& operator=(const VisualScaling&) = delete;
    };
    class VisualScaling : public MFXGroupBoxModule {…};
 
    // ===========================================================================
    // class SelectionOperation
    // ===========================================================================
 
    class SelectionOperation : public MFXGroupBoxModule {
        FXDECLARE(GNESelectorFrame::SelectionOperation)
 
    public:
        SelectionOperation(GNESelectorFrame* selectorFrameParent);
 
        ~SelectionOperation();
 
        void loadFromFile(const std::string& file) const;
 
 
        long onCmdLoad(FXObject*, FXSelector, void*);
 
        long onCmdSave(FXObject*, FXSelector, void*);
 
        long onCmdClear(FXObject*, FXSelector, void*);
 
        long onCmdDelete(FXObject*, FXSelector, void*);
 
        long onCmdInvert(FXObject*, FXSelector, void*);
 
        long onCmdReduce(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(SelectionOperation)
 
        
        struct MassiveSelection {
 
            MassiveSelection(const int bucketSize);
 
            ~MassiveSelection();
 
            bool isElementToProcess() const;
 
            std::unordered_map<GNEAttributeCarrier*, bool> ACsToSelect;
 
            std::unordered_map<GNEAttributeCarrier*, bool> ACsToUnselect;
 
            std::map<GUIGlObjectType, bool> lockedTypes;
 
        private:
            MassiveSelection();
        };
        struct MassiveSelection {…};
 
        MassiveSelection processMassiveNetworkElementSelection(const bool filterLanes) const;
 
        MassiveSelection processMassiveDemandElementSelection() const;
 
        MassiveSelection processMassiveDataElementSelection() const;
 
        bool askContinueIfLock() const;
 
    private:
        GNESelectorFrame* mySelectorFrameParent;
 
        SelectionOperation(const SelectionOperation&) = delete;
 
        SelectionOperation& operator=(const SelectionOperation&) = delete;
    };
    class SelectionOperation : public MFXGroupBoxModule {…};
 
    // ===========================================================================
    // class SelectionHierarchy
    // ===========================================================================
 
    class SelectionHierarchy : public MFXGroupBoxModule {
        FXDECLARE(GNESelectorFrame::SelectionHierarchy)
 
    public:
        SelectionHierarchy(GNESelectorFrame* selectorFrameParent);
 
        ~SelectionHierarchy();
 
 
        long onCmdSelectItem(FXObject* obj, FXSelector, void*);
 
        long onCmdParents(FXObject* obj, FXSelector, void*);
 
        long onCmdChildren(FXObject* obj, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(SelectionHierarchy)
 
    private:
        enum class Selection {
            ALL,
            JUNCTION,
            EDGE,
            LANE,
            CONNECTION,
            CROSSING,
            ADDITIONAL,
            WIRE,
            SHAPE,
            DEMAND,
            DATA,
            NOTHING,
        };
        enum class Selection {…};
 
        GNESelectorFrame* mySelectorFrameParent;
 
        MFXComboBoxIcon* myParentsComboBox = nullptr;
 
        MFXComboBoxIcon* myChildrenComboBox = nullptr;
 
        FXButton* mySelectParentsButton = nullptr;
 
        FXButton* myUnselectParentsButton = nullptr;
 
        FXButton* mySelectChildrenButton = nullptr;
 
        FXButton* myUnselectChildrenButton = nullptr;
 
        // @brief items
        const std::vector<std::pair<Selection, std::string> > myItems = {
            std::make_pair(Selection::ALL, "all"),
            std::make_pair(Selection::JUNCTION, "junction"),
            std::make_pair(Selection::EDGE, "edge"),
            std::make_pair(Selection::LANE, "lane"),
            std::make_pair(Selection::CONNECTION, "connection"),
            std::make_pair(Selection::CROSSING, "crossing"),
            std::make_pair(Selection::ADDITIONAL, "additionalElements"),
            std::make_pair(Selection::WIRE, "wireElements"),
            std::make_pair(Selection::SHAPE, "shapeElements"),
            std::make_pair(Selection::DEMAND, "demandElements"),
            std::make_pair(Selection::DATA, "dataElements")
        };
        const std::vector<std::pair<Selection, std::string> > myItems = {…};
 
        Selection myCurrentSelectedParent;
 
        Selection myCurrentSelectedChild;
 
        SelectionHierarchy(const SelectionHierarchy&) = delete;
 
        SelectionHierarchy& operator=(const SelectionHierarchy&) = delete;
    };
    class SelectionHierarchy : public MFXGroupBoxModule {…};
 
    // ===========================================================================
    // class Legend
    // ===========================================================================
 
    class Information : public MFXGroupBoxModule {
 
    public:
        Information(GNESelectorFrame* selectorFrameParent);
 
        ~Information();
    };
    class Information : public MFXGroupBoxModule {…};
 
    GNESelectorFrame(GNEViewParent* viewParent, GNEViewNet* viewNet);
 
    ~GNESelectorFrame();
 
    void show();
 
    void hide();
 
    void updateFrameAfterUndoRedo();
 
    void clearCurrentSelection() const;
 
    bool selectAttributeCarrier(const GNEViewNetHelper::ViewObjectsSelector& viewObjects);
 
    void handleIDs(const std::vector<GNEAttributeCarrier*>& ACs, const ModificationMode::Operation setop = ModificationMode::Operation::DEFAULT);
 
    FXVerticalFrame* getContentFrame() const;
 
    ModificationMode* getModificationModeModul() const;
 
    GNESelectorFrame::SelectionOperation* getSelectionOperationModul() const;
 
    SelectionInformation* getSelectionInformation() const;
 
private:
    GNESelectorFrame::SelectionInformation* mySelectionInformation = nullptr;
 
    GNESelectorFrame::ModificationMode* myModificationMode = nullptr;
 
    GNEMatchAttribute* myMatchAttribute = nullptr;
 
    GNESelectorFrame::VisualScaling* myVisualScaling = nullptr;
 
    GNESelectorFrame::SelectionOperation* mySelectionOperation = nullptr;
 
    GNESelectorFrame::SelectionHierarchy* mySelectionHierarchy = nullptr;
 
    GNESelectorFrame::Information* myInformation = nullptr;
 
    GNESelectorFrame(const GNESelectorFrame&) = delete;
 
    GNESelectorFrame& operator=(const GNESelectorFrame&) = delete;
};
class GNESelectorFrame : public GNEFrame {…};