control.h

/*
 * Copyright 2007-2025, RTE (https://www.rte-france.com)
 * See AUTHORS.txt
 * SPDX-License-Identifier: MPL-2.0
 * This file is part of Antares-Simulator,
 * Adequacy and Performance assessment for interconnected energy networks.
 *
 * Antares_Simulator is free software: you can redistribute it and/or modify
 * it under the terms of the Mozilla Public Licence 2.0 as published by
 * the Mozilla Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * Antares_Simulator is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * Mozilla Public Licence 2.0 for more details.
 *
 * You should have received a copy of the Mozilla Public Licence 2.0
 * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
 */
#ifndef __ANTARES_TOOLBOX_MAP_CONTROL_H__
#define __ANTARES_TOOLBOX_MAP_CONTROL_H__
 
#include <wx/scrolwin.h>
#include "nodes/node.h"
#include "manager.h"
#include "tools/tool.h"
#include "settings.h"
#include "../notebook/notebook.h"
 
#define DEFAULT_MAP_WIDTH 1680
#define DEFAULT_MAP_HEIGHT 1050
 
namespace Antares::Map
{
// Forward declaration
class Component;
 
class Control final: public wxScrolledWindow
{
    friend class Component;
 
public:
    enum
    {
        gridSize = 75,
    };
 
public:
 
 
    Control(wxWindow* parent, Component& component);
 
 
 
    Control(wxWindow* parent, Component& component, size_t uID);
 
    virtual ~Control();
 
 
    const size_t& getUid() const
    {
        return this->uid;
    }
 
 
    double zoom() const
    {
        return pZoom;
    }
 
    void zoom(const double v);
 
 
    void forceReload()
    {
        pInvalidated = true;
    }
 
    const wxColour& getBackgroundColor()
    {
        return pBackgroundColor;
    }
 
    void setBackgroundColor(const wxColour& newColor)
    {
        pBackgroundColor = newColor;
    }
 
 
 
    void render(wxPaintEvent& evt);
 
    wxBitmap getRenderedMapImage(const MapRenderOptions& mapOptions);
 
 
 
    void paintGraph(wxDC& dc, bool inFile = false);
 
    void refresh()
    {
        this->Refresh();
    }
 
    void reset();
 
    void mouseMoved(wxMouseEvent& evt);
 
    void mouseLeftDown(wxMouseEvent& evt);
 
    void mouseWheelMoved(wxMouseEvent& evt);
 
    void mouseLeftUp(wxMouseEvent& evt);
 
    void rightClick(wxMouseEvent& evt);
 
    void mouseLeftWindow(wxMouseEvent& evt);
 
    void keyPressed(wxKeyEvent& evt);
 
    void keyReleased(wxKeyEvent& evt);
 
    void keyChar(wxKeyEvent& evt);
 
    void mouseDblClick(wxMouseEvent& evt);
 
    uint areasCount() const;
 
    void setpInfosAreaCount(wxStaticText* infosAreaCount)
    {
        pInfosAreaCount = infosAreaCount;
    }
 
    wxStaticText* getpInfosAreaCount()
    {
        return pInfosAreaCount;
    }
 
    uint connectionsCount() const;
 
    void setpInfosConnxCount(wxStaticText* infosConnxCount)
    {
        pInfosConnxCount = infosConnxCount;
    }
 
    wxStaticText* getpInfosConnxCount()
    {
        return pInfosConnxCount;
    }
 
    void setPointX(wxTextCtrl* textCtrl)
    {
        pointX = textCtrl;
    }
 
    wxTextCtrl* getPointX()
    {
        return pointX;
    }
 
    void setPointY(wxTextCtrl* textCtrl)
    {
        pointY = textCtrl;
    }
 
    wxTextCtrl* getPointY()
    {
        return pointY;
    }
 
    void addNewNode(uint count = 1);
    void addNewNodeWhereTheMouseIs();
    void addNewLoadNodeWhereTheMouseIs();
    void addNewThermalNodeWhereTheMouseIs();
    void addNewNuclearNodeWhereTheMouseIs();
    void addNewCCGTNodeWhereTheMouseIs();
    void addNewCoalNodeWhereTheMouseIs();
    void addNewOilNodeWhereTheMouseIs();
    void addNewHydroNodeWhereTheMouseIs();
    void addNewPSPPNodeWhereTheMouseIs();
    void addNewRENWNodeWhereTheMouseIs();
    void addNewWindNodeWhereTheMouseIs();
    void addNewSolarNodeWhereTheMouseIs();
    void addNewBioMNodeWhereTheMouseIs();
    void addNewVoidNodeWhereTheMouseIs();
    void addNewVirtualNodeWhereTheMouseIs();
 
    void recenter();
    void recenter(int x, int y);
 
    void computeBoundingBoxOfSelectedNodes();
 
public:
    Manager& nodes;
 
    Antares::Component::Button* pBtnSelectionArea;
    Antares::Component::Button* pBtnSelectionLink;
    // Antares::Component::Button* pBtnSelectionPlant;
    Antares::Component::Button* pBtnSelectionConstraint;
 
    Yuni::Event<void(int, int)> onPopupEvent;
 
    static size_t newUID;
 
private:
    void refreshCache();
 
    void updateMouseInfosFromEvent(wxMouseEvent& evt);
 
    void drawGrid(wxDC& dc);
    void drawSelectionBox(wxDC& dc);
    void drawTools(DrawingContext& drawingContext);
 
    void preDrawBoundingBoxOfSelectedNodes(wxDC& dc, const BoundingBox& bb);
 
    void drawSingleNode(wxDC& dc, Node* node);
 
    void removeTools();
    void removeTools(const Tool::LifeSpan filter);
    Tool::Tool* findTool(const int x, const int y);
 
    void performActionForSelectedTool();
 
    void addToolsForCurrentSelection();
 
    void onScroll(wxScrollWinEvent& evt);
 
    void onSize(wxSizeEvent& evt);
 
private:
    enum MouseAction
    {
        mouseActionNone,
        mouseActionSelectionBox,
        mouseActionMoveSelection,
        mouseActionTool,
    };
 
private:
    Component& pComponent;
    bool pInvalidated = true;
    bool pInvalidatedInnerCacheSize = true;
 
    wxTextCtrl* pointX = nullptr;
    wxTextCtrl* pointY = nullptr;
    wxStaticText* pInfosAreaCount = nullptr;
    wxStaticText* pInfosConnxCount = nullptr;
    double pZoom = 1.;
    wxColour pBackgroundColor = Settings::background;
 
    wxPoint pCachedRealSize;
    wxPoint pCachedBoxSize;
    wxPoint pCachedOrigin;
    wxPoint pOffsetForSelectedNodes;
    wxPoint pBottomRight;
 
    bool pKeyShift = false;
    bool pKeyCtrl = false;
    wxPoint pCurrentScroll;
    wxPoint pCurrentMousePosition;
    wxPoint pCurrentMousePositionGraph;
    wxPoint pCurrentClientSize;
    wxPoint pLastMousePosition;
    Tool::Tool* pLastSelectedTool = nullptr;
    Tool::Tool* pRemoverForSelection = nullptr;
 
    MouseAction pMouseAction = mouseActionNone;
    BoundingBox pSelectionBox;
 
    Tool::List pTools;
 
    int previousMaxSizeX = -1;
    int previousMaxSizeY = -1;
 
    const size_t uid;
 
    Antares::Component::Notebook::Page* pPage = nullptr;
 
    bool wasDrawn = false;
 
    // Event table
    DECLARE_EVENT_TABLE()
 
}; // class Control
 
} // namespace Antares::Map
 
#endif // __ANTARES_TOOLBOX_MAP_CONTROL_H__