widget_diff_canvas.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 3 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, you may find one here:
 * http://www.gnu.org/licenses/gpl-3.0.html
 * or you may search the http://www.gnu.org website for the version 3 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef KICAD_WIDGET_DIFF_CANVAS_H
#define KICAD_WIDGET_DIFF_CANVAS_H
 
#include <class_draw_panel_gal.h>
#include <diff_merge/diff_scene.h>
 
#include <array>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
class EDA_ITEM;
 
 
namespace KIGFX
{
class GAL_DISPLAY_OPTIONS;
class PAINTER;
class VIEW_ITEM;
class VIEW_GROUP;
}
 
 
namespace KIGFX
{
class VIEW_OVERLAY;
}
 

class WIDGET_DIFF_CANVAS : public EDA_DRAW_PANEL_GAL
{
public:
    WIDGET_DIFF_CANVAS( wxWindow* aParent, GAL_TYPE aBackend = GAL_FALLBACK, wxWindowID aId = wxID_ANY );
 
    ~WIDGET_DIFF_CANVAS() override;
 
private:
    WIDGET_DIFF_CANVAS( wxWindow* aParent, GAL_TYPE aBackend, wxWindowID aId,
                        std::unique_ptr<KIGFX::GAL_DISPLAY_OPTIONS> aGalOptions );
 
public:
    void SetScene( KICAD_DIFF::DIFF_SCENE aScene );
 
    void SetWorldUnitLength( double aWorldUnitLength );

    void SetContextPainter( std::unique_ptr<KIGFX::PAINTER> aPainter );

    void SetContextItems( const std::vector<KIGFX::VIEW_ITEM*>& aItems );

    void SetItemCategories( std::map<KIGFX::VIEW_ITEM*, KICAD_DIFF::CATEGORY> aMap );

    using ITEM_ID_GETTER = std::function<KIID( const EDA_ITEM& )>;
    void SetItemIdGetter( const ITEM_ID_GETTER& aGetter ) { m_itemIdGetter = aGetter; }

    using DIMMER = std::function<void( KIGFX::VIEW_ITEM*, bool aDim )>;
    void SetItemDimmer( DIMMER aDimmer ) { m_itemDimmer = std::move( aDimmer ); }

    void HighlightChange( std::optional<KIID_PATH> aChangeId );

    void SetCategoryVisible( KICAD_DIFF::CATEGORY aCategory, bool aVisible );
 
    bool IsCategoryVisible( KICAD_DIFF::CATEGORY aCategory ) const;

    void SetHiddenChanges( std::set<KIID_PATH> aHidden );
 
    bool IsChangeHidden( const KIID_PATH& aChangeId ) const;

    void SetLayerVisible( PCB_LAYER_ID aLayer, bool aVisible );
 
    bool IsLayerVisible( PCB_LAYER_ID aLayer ) const;

    void BeginUpdate();
    void EndUpdate();

    void ZoomToFit();

    void ZoomToBBox( const BOX2I& aBBox );

    void CenterOnHighlight();

    using PICK_HANDLER = std::function<void( const std::optional<KIID_PATH>& )>;
 
    void SetPickHandler( PICK_HANDLER aHandler ) { m_pickHandler = std::move( aHandler ); }
 
    using ITEM_HANDLER = std::function<void( KIGFX::VIEW_ITEM* )>;
    void SetDoubleClickHandler( ITEM_HANDLER aHandler ) { m_dclickHandler = std::move( aHandler ); }
 
private:
    void rebuildOverlay( bool aOverlayOnly = false );

    void buildRenderScene();

    void refreshItemDimming();
 
    KIID getItemId( const EDA_ITEM& aItem ) const;

    const KICAD_DIFF::SCENE_SHAPE* shapeAt( const wxPoint& aScreenPoint ) const;

    std::optional<BOX2I> highlightedBBox() const;
 
    void onLeftDown( wxMouseEvent& aEvent );
    void onDoubleClick( wxMouseEvent& aEvent );
    void onMotion( wxMouseEvent& aEvent );
    void onLeave( wxMouseEvent& aEvent );
    void onChar( wxKeyEvent& aEvent );
    void onSize( wxSizeEvent& aEvent );
 
    struct HIGHLIGHT_BOX_ITEM;
 
    KICAD_DIFF::DIFF_SCENE   m_scene;
    KICAD_DIFF::DIFF_SCENE              m_renderScene;
    std::optional<KIID_PATH> m_highlight;
    std::optional<KIID_PATH>            m_hover;
    PICK_HANDLER             m_pickHandler;
    ITEM_HANDLER                        m_dclickHandler;
    DIMMER                              m_itemDimmer;
    ITEM_ID_GETTER                      m_itemIdGetter;
    std::unique_ptr<HIGHLIGHT_BOX_ITEM> m_highlightBox;
    std::unique_ptr<HIGHLIGHT_BOX_ITEM> m_hoverBox;
 
    std::array<bool, KICAD_DIFF::CATEGORY_COUNT> m_categoryVisible{ { true, true, true, true } };
 
    std::set<KIID_PATH> m_hiddenChanges;

    bool m_holdRebuild = false;
 
    LSET m_layerVisible;
 
    bool m_hasNativeContext = false;
    std::unique_ptr<KIGFX::VIEW_GROUP> m_contextGroup;
    std::vector<KIGFX::VIEW_ITEM*>                    m_contextGroupItems;
    std::map<KIGFX::VIEW_ITEM*, KICAD_DIFF::CATEGORY> m_itemCategories;
    std::shared_ptr<KIGFX::VIEW_OVERLAY> m_overlay;

    std::unique_ptr<KIGFX::GAL_DISPLAY_OPTIONS> m_galOptions;

    bool m_zoomToFitPending = false;
};
 
#endif // KICAD_WIDGET_DIFF_CANVAS_H