GNEPythonToolDialogElements.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
/****************************************************************************/
// Elements used in GNEPythonToolDialog
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <utils/foxtools/fxheader.h>
 
// ===========================================================================
// class declaration
// ===========================================================================
 
class GNEApplicationWindow;
class GNEPythonTool;
class GNEPythonToolDialog;
class MFXButtonTooltip;
class MFXLabelTooltip;
class Option;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEPythonToolDialogElements {
 
public:
    class Category : public FXHorizontalFrame {
 
    public:
        Category(FXVerticalFrame* argumentFrame, const std::string& category);
 
        ~Category();
 
    private:
        Category(const Category&) = delete;
 
        Category& operator=(const Category&) = delete;
    };
 
    class Argument : public FXHorizontalFrame {
        FXDECLARE_ABSTRACT(GNEPythonToolDialogElements::Argument)
 
    public:
        Argument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                 GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                 const std::string& parameter, Option* option);
 
        ~Argument();
 
        virtual void reset() = 0;
 
        MFXLabelTooltip* getParameterLabel() const;
 
        const std::string getArgument() const;
 
        bool requiredAttributeSet() const;
 
 
        virtual long onCmdSetValue(FXObject*, FXSelector, void*) = 0;
 
        long onCmdResetValue(FXObject*, FXSelector, void*);
 
        long onUpdResetValue(FXObject*, FXSelector, void*);
 
 
    protected:
        Argument();
 
        virtual const std::string getValue() const = 0;
 
        GNEPythonToolDialog* myToolDialogParent;
 
        Option* myOption;
 
        const std::string myDefaultValue;
 
        FXHorizontalFrame* myElementsFrame = nullptr;
 
    private:
        MFXLabelTooltip* myParameterLabel = nullptr;
 
        FXButton* myResetButton = nullptr;
 
        Argument(const Argument&) = delete;
 
        Argument& operator=(const Argument&) = delete;
    };
 
 
    class EdgeVectorArgument : public Argument {
        FXDECLARE(GNEPythonToolDialogElements::EdgeVectorArgument)
 
    public:
        EdgeVectorArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                           GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                           const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrent(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrent(FXObject* sender, FXSelector, void*);
 
    protected:
        EdgeVectorArgument();
 
        const std::string getValue() const;
 
        FXTextField* myEdgeVectorTextField = nullptr;
 
    private:
        MFXButtonTooltip* myCurrentEdgesButton = nullptr;
 
        EdgeVectorArgument(const EdgeVectorArgument&) = delete;
 
        EdgeVectorArgument& operator=(const EdgeVectorArgument&) = delete;
    };
 
 
    class FileNameArgument : public Argument {
        FXDECLARE(GNEPythonToolDialogElements::FileNameArgument)
 
    public:
        FileNameArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                         GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                         const std::string name, Option* option);
 
        void reset();
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        FileNameArgument();
 
        FileNameArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                         GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                         const std::string name, Option* option, const std::string& useCurrent);
 
        const std::string getValue() const;
 
        FXTextField* myFilenameTextField = nullptr;
 
    private:
        MFXButtonTooltip* myCurrentButton = nullptr;
 
        MFXButtonTooltip* myOpenFilenameButton = nullptr;
 
        FileNameArgument(const FileNameArgument&) = delete;
 
        FileNameArgument& operator=(const FileNameArgument&) = delete;
    };
 
    class NetworkArgument : public FileNameArgument {
        FXDECLARE(GNEPythonToolDialogElements::NetworkArgument)
 
    public:
        NetworkArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                        GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                        const std::string name, Option* option);
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrentNetworkFile(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrentNetworkFile(FXObject* sender, FXSelector, void*);
 
    protected:
        NetworkArgument();
 
    private:
        NetworkArgument(const NetworkArgument&) = delete;
 
        NetworkArgument& operator=(const NetworkArgument&) = delete;
    };
 
    class AdditionalArgument : public FileNameArgument {
        FXDECLARE(GNEPythonToolDialogElements::AdditionalArgument)
 
    public:
        AdditionalArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                           GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                           const std::string name, Option* option);
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrentAdditionalFile(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrentAdditionalFile(FXObject* sender, FXSelector, void*);
 
    protected:
        AdditionalArgument();
 
    private:
        AdditionalArgument(const AdditionalArgument&) = delete;
 
        AdditionalArgument& operator=(const AdditionalArgument&) = delete;
    };
 
    class RouteArgument : public FileNameArgument {
        FXDECLARE(GNEPythonToolDialogElements::RouteArgument)
 
    public:
        RouteArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                      GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                      const std::string name, Option* option);
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrentRouteFile(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrentRouteFile(FXObject* sender, FXSelector, void*);
 
    protected:
        RouteArgument();
 
    private:
        RouteArgument(const RouteArgument&) = delete;
 
        RouteArgument& operator=(const RouteArgument&) = delete;
    };
 
    class DataArgument : public FileNameArgument {
        FXDECLARE(GNEPythonToolDialogElements::DataArgument)
 
    public:
        DataArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                     GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                     const std::string name, Option* option);
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrentDataFile(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrentDataFile(FXObject* sender, FXSelector, void*);
 
    protected:
        DataArgument();
 
    private:
        DataArgument(const DataArgument&) = delete;
 
        DataArgument& operator=(const DataArgument&) = delete;
    };
 
    class SumoConfigArgument : public FileNameArgument {
        FXDECLARE(GNEPythonToolDialogElements::SumoConfigArgument)
 
    public:
        SumoConfigArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                           GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                           const std::string name, Option* option);
 
        long onCmdOpenFilename(FXObject*, FXSelector, void*);
 
        long onCmdUseCurrentSumoConfigFile(FXObject*, FXSelector, void*);
 
        long onUpdUseCurrentSumoConfigFile(FXObject* sender, FXSelector, void*);
 
    protected:
        SumoConfigArgument();
 
    private:
        SumoConfigArgument(const SumoConfigArgument&) = delete;
 
        SumoConfigArgument& operator=(const SumoConfigArgument&) = delete;
    };
 
    class EdgeArgument : public Argument {
 
    public:
        EdgeArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                     GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                     const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        const std::string getValue() const;
 
        FXTextField* myEdgeTextField = nullptr;
 
    private:
        static const std::string INVALID_INT_STR;
 
        EdgeArgument(const EdgeArgument&) = delete;
 
        EdgeArgument& operator=(const EdgeArgument&) = delete;
    };
 
    class StringArgument : public Argument {
 
    public:
        StringArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                       GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                       const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        const std::string getValue() const;
 
        FXTextField* myStringTextField = nullptr;
 
    private:
        StringArgument(const StringArgument&) = delete;
 
        StringArgument& operator=(const StringArgument&) = delete;
    };
 
    class IntArgument : public Argument {
 
    public:
        IntArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                    GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                    const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        const std::string getValue() const;
 
        FXTextField* myIntTextField = nullptr;
 
    private:
        static const std::string INVALID_INT_STR;
 
        IntArgument(const IntArgument&) = delete;
 
        IntArgument& operator=(const IntArgument&) = delete;
    };
 
    class FloatArgument : public Argument {
 
    public:
        FloatArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                      GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                      const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        const std::string getValue() const;
 
        FXTextField* myFloatTextField = nullptr;
 
    private:
        static const std::string INVALID_DOUBLE_STR;
 
        FloatArgument(const IntArgument&) = delete;
 
        FloatArgument& operator=(const IntArgument&) = delete;
    };
 
 
    class BoolArgument : public Argument {
 
    public:
        BoolArgument(GNEPythonToolDialog* toolDialogParent, const GNEPythonTool* pythonTool,
                     GNEApplicationWindow* applicationWindow, FXVerticalFrame* argumentFrame,
                     const std::string name, Option* option);
 
        void reset();
 
        long onCmdSetValue(FXObject*, FXSelector, void*);
 
    protected:
        const std::string getValue() const;
 
        FXCheckButton* myCheckButton = nullptr;
 
    private:
        BoolArgument(const IntArgument&) = delete;
 
        BoolArgument& operator=(const IntArgument&) = delete;
    };
};