constraint_overlay.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <vector>
 
#include <eda_item.h>
#include <kiid.h>
#include <layer_ids.h>
#include <math/box2.h>
#include <math/vector2d.h>
#include <geometry/seg.h>
#include <gal/color4d.h>
 
#include <tools/view_overlay_holder.h>
#include <constraints/board_constraint_adapter.h>
 
class BOARD;
class BITMAP_BASE;
 
namespace KIGFX
{
class VIEW;
}
 

struct CONSTRAINT_BADGE
{
    VECTOR2I            pos;
    KIID                constraint;
    PCB_CONSTRAINT_TYPE type;
    KIGFX::COLOR4D      color;
    std::vector<SEG>    avoid; // constrained geometry the badge stays clear of
};
 

class CONSTRAINT_BADGE_ITEM : public EDA_ITEM
{
public:
    CONSTRAINT_BADGE_ITEM();
 
    ~CONSTRAINT_BADGE_ITEM() override;
 
    void SetBadges( const std::vector<CONSTRAINT_BADGE>& aBadges, const KIID& aSelected )
    {
        m_badges = aBadges;
        m_selected = aSelected;
        m_layoutScale = -1.0;   // invalidate the cached layout; the badge set changed
    }

    void SetPreviewAnchor( const std::optional<VECTOR2I>& aAnchor ) { m_previewAnchor = aAnchor; }
 
    const BOX2I ViewBBox() const override
    {
        BOX2I bbox;
        bbox.SetMaximum(); // Always drawn, so the per-frame screen-constant sizing stays current.
        return bbox;
    }
 
    std::vector<int> ViewGetLayers() const override { return { LAYER_GP_OVERLAY }; }
 
    void ViewDraw( int aLayer, KIGFX::VIEW* aView ) const override;
 
    bool HitTest( const VECTOR2I&, int = 0 ) const override { return false; }
 
    wxString GetClass() const override { return wxT( "CONSTRAINT_BADGE_ITEM" ); }
 
#if defined( DEBUG )
    void Show( int, std::ostream& ) const override {}
#endif
 
private:
    BITMAP_BASE* icon( PCB_CONSTRAINT_TYPE aType ) const;

    BITMAP_BASE* disc( const KIGFX::COLOR4D& aColor ) const;
 
    std::vector<CONSTRAINT_BADGE> m_badges;
    KIID                          m_selected;
    std::optional<VECTOR2I>       m_previewAnchor;
 
    mutable std::map<PCB_CONSTRAINT_TYPE, std::unique_ptr<BITMAP_BASE>> m_icons;
    mutable std::map<uint32_t, std::unique_ptr<BITMAP_BASE>>            m_discs;
 
    // Screen-space layout cached per view scale, recomputed only when the zoom or badge set changes.
    mutable std::vector<VECTOR2D> m_layout;
    mutable double                m_layoutScale = -1.0;
};
 

enum class OVERLAY_MODE
{
    HOVER,
    ALWAYS
};
 
 
class CONSTRAINT_OVERLAY : public VIEW_OVERLAY_HOLDER
{
public:
    CONSTRAINT_OVERLAY( BOARD* aBoard, KIGFX::VIEW* aView );
    ~CONSTRAINT_OVERLAY() override;

    void Update( const BOARD_CONSTRAINT_DIAGNOSTICS& aDiag );

    void RefreshSelection();

    void Clear();

    bool SetSelected( const KIID& aConstraint );
 
    const KIID& GetSelected() const { return m_selected; }

    bool SetIsolated( const KIID& aConstraint );
 
    const KIID& GetIsolated() const { return m_isolated; }

    bool SetVisibilityMode( OVERLAY_MODE aMode );
 
    OVERLAY_MODE GetVisibilityMode() const { return m_mode; }

    bool SetHoverShape( const KIID& aShape );
 
    const KIID& GetHoverShape() const { return m_hoverShape; }

    bool SetPickPreview( const KIID& aElement, bool aWholeElement,
                         const std::optional<VECTOR2I>& aAnchor );

    void ClearPickPreview();

    const std::vector<CONSTRAINT_BADGE>& Badges() const { return m_badges; }

    static double BadgeHitRadius();

    static VECTOR2D BadgeScreenOffset();

    static double BadgeWorldPerPixel( double aWorldScale );

    static std::vector<VECTOR2D> LayoutBadges( const std::vector<CONSTRAINT_BADGE>& aBadges,
                                               double aWorldPerPx );
 
private:
    void render();
 
    BOARD*                        m_board;
    BOARD_CONSTRAINT_DIAGNOSTICS  m_lastDiag;
    std::vector<CONSTRAINT_BADGE> m_badges;
    KIID                          m_selected;
    KIID                          m_isolated;
    OVERLAY_MODE                  m_mode = OVERLAY_MODE::ALWAYS;
    KIID                          m_hoverShape = niluuid;
    CONSTRAINT_BADGE_ITEM         m_badgeItem;
 
    // Pick preview channel drawn on top of diagnostics tint while authoring a point based constraint
    // m_previewElement is outlined shape a point pick also marks m_previewAnchor
    KIID                          m_previewElement = niluuid;
    bool                          m_previewWhole = true;
    std::optional<VECTOR2I>       m_previewAnchor;
};