GNEFixElementsDialog.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
/****************************************************************************/
// template used to fix elements during saving
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netedit/dialogs/basic/GNEErrorBasicDialog.h>
#include <netedit/dialogs/basic/GNEInformationBasicDialog.h>
#include <utils/foxtools/MFXGroupBoxModule.h>
#include <utils/gui/div/GUIDesigns.h>
#include <utils/gui/windows/GUIAppEnum.h>
 
// ===========================================================================
// class definitions
// ===========================================================================
 
template <typename T>
class GNEFixElementsDialog : public GNEDialog {
 
public:
    class ConflictElement {
 
    public:
        ConflictElement(T element, const std::string& id, FXIcon* icon, const std::string& description) :
            myElement(element),
            myID(id),
            myIcon(icon),
            myDescription(description) {}
 
        ~ConflictElement() {}
 
        T getElement() const {
            return myElement;
        }
 
        const std::string& getID() const {
            return myID;
        }
 
        FXIcon* getIcon() const {
            return myIcon;
        }
 
        const std::string& getDescription() const {
            return myDescription;
        }
 
    private:
        T myElement;
 
        std::string myID;
 
        FXIcon* myIcon = nullptr;
 
        std::string myDescription;
 
        ConflictElement() = delete;
    };
 
    class FixOptions : public MFXGroupBoxModule {
 
    public:
        FixOptions(GNEFixElementsDialog<T>* fixElementDialog, FXVerticalFrame* frameParent, const std::string& title) :
            MFXGroupBoxModule(frameParent, title, MFXGroupBoxModule::Options::SAVE),
            myFixElementDialogParent(fixElementDialog) {
            // register this fix option to list of fix options
            fixElementDialog->registerFixOptions(this);
            // Create table
            myTable = new FXTable(getCollapsableFrame(), this, MID_TABLE, GUIDesignTableFixElements);
            // create frames for options
            FXHorizontalFrame* optionsFrame = new FXHorizontalFrame(getCollapsableFrame(), GUIDesignAuxiliarHorizontalFrame);
            myLeftFrameOptions = new FXVerticalFrame(optionsFrame, GUIDesignAuxiliarFrameFixedWidth(int(myTable->getWidth() * 0.5)));
            myRightFrameOptions = new FXVerticalFrame(optionsFrame, GUIDesignAuxiliarFrameFixedWidth(int(myTable->getWidth() * 0.5)));
        }
 
        virtual void selectInternalTestSolution(const std::string& solution) = 0;
 
        virtual bool applyFixOption() = 0;
 
 
        virtual long onCmdSelectOption(FXObject*, FXSelector, void*) = 0;
 
 
        void setInvalidElements(const std::vector<ConflictElement>& conflictedElements) {
            // parse invalid elements
            myConflictedElements = conflictedElements;
            // configure table
            myTable->setTableSize((int)(myConflictedElements.size()), 3);
            myTable->setSelBackColor(FXRGBA(255, 255, 255, 255));
            myTable->setSelTextColor(FXRGBA(0, 0, 0, 255));
            myTable->setEditable(false);
            // configure header
            myTable->setVisibleColumns(4);
            myTable->setColumnHeaderHeight(GUIDesignHeight);
            myTable->getRowHeader()->setWidth(0);
            // icon
            myTable->setColumnWidth(0, GUIDesignHeight);
            myTable->setColumnText(0, "");
            // ID
            myTable->setColumnWidth(1, 110);
            myTable->setColumnText(1, toString(SUMO_ATTR_ID).c_str());
            // description
            myTable->setColumnWidth(2, myTable->getWidth() - GUIDesignHeight - 110 - 15);
            myTable->setColumnText(2, TL("Conflict"));
            // Declare pointer to FXTableItem
            FXTableItem* item = nullptr;
            // iterate over invalid edges
            for (int i = 0; i < (int)myConflictedElements.size(); i++) {
                // Set icon
                item = new FXTableItem("", myConflictedElements.at(i).getIcon());
                item->setIconPosition(FXTableItem::CENTER_X);
                myTable->setItem(i, 0, item);
                // Set ID
                item = new FXTableItem(myConflictedElements.at(i).getID().c_str());
                item->setJustify(FXTableItem::LEFT | FXTableItem::CENTER_Y);
                myTable->setItem(i, 1, item);
                // Set conflict
                item = new FXTableItem(myConflictedElements.at(i).getDescription().c_str());
                item->setJustify(FXTableItem::LEFT | FXTableItem::CENTER_Y);
                myTable->setItem(i, 2, item);
                // set row height
                myTable->setRowHeight(i, GUIDesignHeight);
            }
            // check if enable or disable options
            if (myConflictedElements.size() > 0) {
                enableOptions();
            } else {
                disableOptions();
            }
        }
 
    protected:
        GNEFixElementsDialog* myFixElementDialogParent = nullptr;
 
        FXTable* myTable = nullptr;
 
        FXVerticalFrame* myLeftFrameOptions = nullptr;
 
        FXVerticalFrame* myRightFrameOptions = nullptr;
 
        std::vector<ConflictElement> myConflictedElements;
 
        FixOptions() :
            MFXGroupBoxModule() {
        }
 
        void registerOption(FXWindow* option) {
            myOptions.push_back(option);
            // adjust width
            option->setWidth(int(myTable->getWidth() * 0.5));
        }
 
    private:
        std::vector<FXWindow*> myOptions;
 
        void enableOptions() {
            // enable each option
            for (auto option : myOptions) {
                option->enable();
            }
        }
 
        void disableOptions() {
            // disable each option
            for (auto option : myOptions) {
                option->disable();
            }
        }
 
        bool saveContents() const {
            // open file dialog to save list of conflicted items
            const FXString file = MFXUtils::getFilename2Write(myTable,
                                  TL("Save list of conflicted items"),
                                  SUMOXMLDefinitions::TXTFileExtensions.getMultilineString().c_str(),
                                  GUIIconSubSys::getIcon(GUIIcon::SAVE), gCurrentFolder);
            // continue if file is not empty
            if (file == "") {
                return false;
            } else {
                try {
                    // open output device
                    OutputDevice& device = OutputDevice::getDevice(file.text());
                    // get invalid element ID and problem
                    for (const auto& conflictedElement : myConflictedElements) {
                        device << conflictedElement.getID() << ":" << conflictedElement.getDescription() << "\n";
                    }
                    // close output device
                    device.close();
                    // open information message box
                    GNEInformationBasicDialog(myFixElementDialogParent->myApplicationWindow,
                                              TL("Saving successfully"),
                                              TL("List of conflicted items was successfully saved"));
                    return true;
                } catch (IOError& e) {
                    // open message box error
                    GNEErrorBasicDialog(myFixElementDialogParent->myApplicationWindow,
                                        TL("Saving list of conflicted items failed"), e.what());
                    return false;
                }
            }
        }
 
        FixOptions(const FixOptions&) = delete;
 
        FixOptions& operator=(const FixOptions&) = delete;
    };
 
    GNEFixElementsDialog(GNEApplicationWindow* mainWindow, const std::string title, GUIIcon icon):
        GNEDialog(mainWindow, title.c_str(), icon, GNEDialog::Buttons::ACCEPT_CANCEL,
                  GNEDialog::OpenType::MODAL, ResizeMode::STATIC) {
        // create left and right frames
        FXHorizontalFrame* columnFrame = new FXHorizontalFrame(myContentFrame, GUIDesignAuxiliarHorizontalFrame);
        myLeftFrame = new FXVerticalFrame(columnFrame, GUIDesignAuxiliarVerticalFrame);
        myRightFrame = new FXVerticalFrame(columnFrame, GUIDesignAuxiliarVerticalFrame);
    }
 
    ~GNEFixElementsDialog() {}
 
    GNEApplicationWindow* getApplicationWindow() {
        return myApplicationWindow;
    }
 
    void registerFixOptions(FixOptions* fixOptions) {
        myFixOptions.push_back(fixOptions);
    }
 
    void runInternalTest(const InternalTestStep::DialogArgument* dialogArgument) {
        // run internal test for each fix option
        for (auto fixOption : myFixOptions) {
            fixOption->selectInternalTestSolution(dialogArgument->getCustomAction());
        }
    }
 
 
    long onCmdAccept(FXObject*, FXSelector, void*) {
        bool abortSaving = false;
        // apply each fix option in their correspond fixOption
        for (auto fixOption : myFixOptions) {
            // if applyFixOption returns false, abort saving (usually for selecting invalid elements)
            if (fixOption->applyFixOption() == false) {
                abortSaving = true;
            }
        }
        // continue depending of abortSaving
        if (abortSaving == false) {
            return closeDialogAccepting();
        } else {
            return closeDialogCanceling();
        }
    }
 
 
protected:
    std::vector<GNEFixElementsDialog::FixOptions*> myFixOptions;
 
    FXVerticalFrame* myLeftFrame = nullptr;
 
    FXVerticalFrame* myRightFrame = nullptr;
 
private:
    GNEFixElementsDialog(const GNEFixElementsDialog&) = delete;
 
    GNEFixElementsDialog& operator=(const GNEFixElementsDialog&) = delete;
};