item.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_ITEM_H__
#define __ANTARES_TOOLBOX_MAP_ITEM_H__
 
#include <vector>
#include <set>
#include <map>
#include <wx/gdicmn.h>
#include <wx/colour.h>
#include <wx/dc.h>
 
namespace Antares::Map
{
class DrawingContext;
class Manager;
class Connection;
class BindingConstraint;
 
class Item
{
public:
    struct SetCompare
    {
        bool operator()(const Item* s1, const Item* s2) const
        {
            return s1 < s2;
        }
    };
 
    using Vector = std::vector<Item*>;
 
    using Set = std::set<Item*, SetCompare>;
 
    using Links = std::map<Item*, bool>;
 
    enum Type
    {
        tyUnknown,
        tyNode,
        tyConnection,
        tyBindingConstraint,
    };
 
public:
 
 
    Item(Manager& manager, const int zPos = 0);
    virtual ~Item();
 
 
    virtual Type type() const
    {
        return tyUnknown;
    }
 
 
 
    Manager& manager()
    {
        return pManager;
    }
 
    const Manager& manager() const
    {
        return pManager;
    }
 
 
 
 
    virtual bool isVisibleOnLayer(const size_t& /* layerID */) const
    {
        return false;
    }
 
 
 
    const wxString& caption() const
    {
        return pCaption;
    }
 
    void caption(const wxString& v)
    {
        pCaption = v;
        forceReload();
        captionHasChanged();
    }
 
 
 
    int x() const
    {
        return pX;
    }
 
    void x(const int v)
    {
        pX = v;
        forceReload();
        positionHasChanged();
    }
 
 
 
    int y() const
    {
        return pY;
    }
 
    void y(const int v)
    {
        pY = v;
        forceReload();
        positionHasChanged();
    }
 
 
    virtual wxPoint absolutePosition(DrawingContext& dc) const;
 
 
    const wxColour& color() const
    {
        return pColor;
    }
 
    void color(const wxColour& c);
    void color(const wxString& s);
    void color(const int r, const int g, const int b);
    void color(const int r, const int g, const int b, const int alpha);
 
 
 
    virtual bool selected() const
    {
        return pSelected;
    }
 
    virtual void selected(bool v);
 
 
 
    int zPosition() const
    {
        return pZPosition;
    }
 
 
 
 
    virtual void refreshCache(wxDC& dc) = 0;
 
    void forceReload();
 
    bool isInvalidated() const
    {
        return pInvalidated;
    }
 
 
 
 
    virtual bool contains(const int x, const int y, double& distance) = 0;
 
    virtual bool isContained(const int x1, const int y1, const int x2, const int y2) const = 0;
 
    virtual void draw(DrawingContext& dc) = 0;
 
    virtual void drawExternalDrawer(DrawingContext&)
    {
    }
 
 
    virtual void move(const int x, const int y);
 
    virtual void extendBoundingBox(wxPoint& topLeft, wxPoint& bottomRight) = 0;
 
 
 
    virtual void mouseDblClick()
    {
    }
 
 
protected:
    void internalClearAllLinks();
 
    virtual void captionHasChanged()
    {
    }
 
    virtual void positionHasChanged()
    {
    }
 
    virtual void colorHasChanged()
    {
    }
 
protected:
    Manager& pManager;
    wxColour pColor;
    bool pSelected;
    bool pInvalidated;
 
    int pX;
    int pY;
    wxString pCaption;
 
    Links* pLinks;
 
    int pZPosition;
 
    // Friends
    friend class ::Antares::Map::Manager;
    friend class ::Antares::Map::Connection;
    friend class ::Antares::Map::BindingConstraint;
}; // class Item
 
} // namespace Antares::Map
 
#include "../drawingcontext.h"
#include "../manager.h"
#include "connection.h"
 
#endif // __ANTARES_TOOLBOX_MAP_ITEM_H__