view.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2016 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Tomasz Wlostowski <[email protected]>
 *
 * 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 <gal/gal.h>
#include <array>
#include <cstdint>
#include <functional>
#include <map>
#include <vector>
#include <set>
#include <unordered_map>
#include <memory>
#include <utility>
 
#include <math/box2.h>
#include <gal/definitions.h>
#include <base_set.h>
#include <view/view_overlay.h>
 
namespace KIGFX
{
class PAINTER;
class GAL;
struct RETAINED_GROUP_ORDER;
class VIEW_ITEM;
class VIEW_GROUP;
class VIEW_RTREE;

class GAL_API VIEW
{
public:
    friend class VIEW_ITEM;
 
    typedef std::pair<VIEW_ITEM*, int> LAYER_ITEM_PAIR;
 
    VIEW();
    virtual ~VIEW();
 
    // We own at least one list of raw pointers.  Don't let the compiler fill in copy c'tors that
    // will only land us in trouble.
    VIEW( const VIEW& ) = delete;
    VIEW& operator=( const VIEW& ) = delete;

    static void OnDestroy( VIEW_ITEM* aItem );

    virtual void Add( VIEW_ITEM* aItem, int aDrawPriority = -1 );

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

    virtual void Remove( VIEW_ITEM* aItem );
 

    int Query( const BOX2I& aRect, std::vector<LAYER_ITEM_PAIR>& aResult ) const;

    void Query( const BOX2I& aRect, const std::function<bool( VIEW_ITEM* )>& aFunc ) const;

    void SetVisible( VIEW_ITEM* aItem, bool aIsVisible = true );

    void Hide( VIEW_ITEM* aItem, bool aHide = true, bool aHideOverlay = false );

    bool IsVisible( const VIEW_ITEM* aItem ) const;
 
    bool IsHiddenOnOverlay( const VIEW_ITEM* aItem ) const;

    bool HasItem( const VIEW_ITEM* aItem ) const;

    void RepaintLayers( const BOX2I& aRect, const std::function<bool( int )>& aLayerFilter,
                        const std::function<bool( VIEW_ITEM*, int )>& aItemFilter );

    virtual void Update( const VIEW_ITEM* aItem, int aUpdateFlags ) const;
    virtual void Update( const VIEW_ITEM* aItem ) const;

    void SetRequired( int aLayerId, int aRequiredId, bool aRequired = true );

    void CopySettings( const VIEW* aOtherView );
 
    /*
     *  Convenience wrappers for adding multiple items
     *  template <class T> void AddItems( const T& aItems );
     *  template <class T> void RemoveItems( const T& aItems );
     */

    void SetGAL( GAL* aGal );

    inline GAL* GetGAL() const
    {
        return m_gal;
    }

    inline void SetPainter( PAINTER* aPainter )
    {
        m_painter = aPainter;
    }

    inline PAINTER* GetPainter() const
    {
        return m_painter;
    }

    void SetViewport( const BOX2D& aViewport );

    BOX2D GetViewport() const;

    void SetMirror( bool aMirrorX, bool aMirrorY );

    bool IsMirroredX() const
    {
        return m_mirrorX;
    }

    bool IsMirroredY() const
    {
        return m_mirrorY;
    }

    virtual void SetScale( double aScale, VECTOR2D aAnchor = { 0, 0 } );

    inline double GetScale() const
    {
        m_scaleRead = true;
        return m_scale;
    }

    bool IsShownAtScale( double aLod ) const;

    inline void SetBoundary( const BOX2D& aBoundary )
    {
        m_boundary = aBoundary;
    }

    inline void SetBoundary( const BOX2I& aBoundary )
    {
        m_boundary.SetOrigin( aBoundary.GetOrigin() );
        m_boundary.SetEnd( aBoundary.GetEnd() );
    }

    inline const BOX2D& GetBoundary() const
    {
        return m_boundary;
    }

    void SetScaleLimits( double aMaximum, double aMinimum )
    {
        wxASSERT_MSG( aMaximum > aMinimum, wxT( "I guess you passed parameters in wrong order" ) );
 
        m_minScale = aMinimum;
        m_maxScale = aMaximum;
    }

    void SetCenter( const VECTOR2D& aCenter );

    void SetCenter( const VECTOR2D& aCenter, const std::vector<BOX2D>& obscuringScreenRects );

    const VECTOR2D& GetCenter() const
    {
        return m_center;
    }

    VECTOR2D ToWorld( const VECTOR2D& aCoord, bool aAbsolute = true ) const;

    double ToWorld( double aSize ) const;

    VECTOR2D ToScreen( const VECTOR2D& aCoord, bool aAbsolute = true ) const;

    double ToScreen( double aSize ) const;

    const VECTOR2I& GetScreenPixelSize() const;

    void Clear();

    inline void SetLayerVisible( int aLayer, bool aVisible = true )
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return;
 
        VIEW_LAYER& layer = it->second;
 
        if( layer.visible != aVisible )
        {
            // Target has to be redrawn after changing its visibility
            MarkTargetDirty( layer.target );
 
            layerStateChanged( aLayer );
 
            layer.visible = aVisible;
            m_layerCachesStale = true;
        }
    }

    bool IsLayerVisible( int aLayer ) const
    {
        if( m_lodProbeLayer >= 0 )
            noteLodRead( aLayer );
 
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return false;
 
        return it->second.visible;
    }
 
    void SyncLayerVisibilityCache();
 
    bool IsLayerVisibleCached( int aLayer ) const
    {
        if( m_lodProbeLayer >= 0 )
            noteLodRead( aLayer );
 
        return m_layerVisibilityCache[ aLayer ];
    }

    inline void SetLayerDiff( int aLayer, bool aDiff = true )
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return;
 
        VIEW_LAYER& layer = it->second;
 
        if( layer.diffLayer != aDiff )
        {
            // Target has to be redrawn after changing its layers' diff status
            MarkTargetDirty( layer.target );
 
            if( IsCached( aLayer ) )
            {
                MarkGeometryDirty();
                MarkStaticDirty();
            }
 
            layer.diffLayer = aDiff;
        }
    }

    inline void SetLayerHasNegatives( int aLayer, bool aNegatives = true )
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return;
 
        VIEW_LAYER& layer = it->second;
 
        if( layer.hasNegatives != aNegatives )
        {
            // Target has to be redrawn after changing a layers' negatives
            MarkTargetDirty( layer.target );
 
            layerStateChanged( aLayer );
 
            layer.hasNegatives = aNegatives;
        }
    }

    inline void SetLayerDisplayOnly( int aLayer, bool aDisplayOnly = true )
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return;
 
        it->second.displayOnly = aDisplayOnly;
    }

    inline void SetLayerTarget( int aLayer, RENDER_TARGET aTarget )
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return;
 
        VIEW_LAYER& layer = it->second;
 
        if( layer.target != aTarget )
        {
            MarkTargetDirty( layer.target );
            MarkTargetDirty( aTarget );
            MarkGeometryDirty();
            MarkStaticDirty();
            layer.target = aTarget;
            m_layerCachesStale = true;
        }
    }

    void SetLayerOrder( int aLayer, int aRenderingOrder, bool aAutoSort = true );

    int GetLayerOrder( int aLayer ) const;

    void SortOrderedLayers();

    void SortLayers( std::vector<int>& aLayers ) const;

    void ReorderLayerData( std::unordered_map<int, int> aReorderMap );

    void UpdateLayerColor( int aLayer );

    void UpdateAllLayersColor();

    void UpdateAllLayersColorAndVisibility();

    void UpdateLayersColor( bool aVisibility, const std::function<bool( int )>& aLayers );

    virtual void SetTopLayer( int aLayer, bool aEnabled = true );

    virtual void EnableTopLayer( bool aEnable );
 
    virtual int GetTopLayer() const;

    void ClearTopLayers();

    void UpdateAllLayersOrder();

    void ClearTargets();

    virtual void Redraw();

    void RecacheAllItems();

    bool IsDirty() const
    {
        for( int i = 0; i < TARGETS_NUMBER; ++i )
        {
            if( IsTargetDirty( i ) )
                return true;
        }
 
        return false;
    }

    bool IsTargetDirty( int aTarget ) const
    {
        wxCHECK( aTarget < TARGETS_NUMBER, false );
        return m_dirtyTargets[aTarget];
    }

    inline void MarkTargetDirty( int aTarget )
    {
        wxCHECK( aTarget < TARGETS_NUMBER, /* void */ );
        m_dirtyTargets[aTarget] = true;
        m_targetEdited[aTarget] = true;
    }

    inline void MarkGeometryDirty()
    {
        m_cameraDirtyOnly = false;
        MarkStaticDirty();
    }

    void markSceneEdited();

    void MarkStaticDirty();

    void SyncRetainedScene();

    inline bool IsCached( int aLayer ) const
    {
        auto it = m_layers.find( aLayer );
 
        if( it == m_layers.end() )
            return false;
 
        return it->second.target == TARGET_CACHED;
    }

    void MarkDirty()
    {
        for( int i = 0; i < TARGETS_NUMBER; ++i )
        {
            m_dirtyTargets[i] = true;
            m_targetEdited[i] = true;
        }
 
        m_cameraDirtyOnly = false;
    }

    void MarkViewportDirty()
    {
        m_cameraDirtyOnly = m_cameraDirtyOnly || !IsDirty();
 
        for( int i = 0; i < TARGETS_NUMBER; ++i )
            m_dirtyTargets[i] = true;
    }

    void MarkClean()
    {
        for( int i = 0; i < TARGETS_NUMBER; ++i )
        {
            m_dirtyTargets[i] = false;
            m_targetEdited[i] = false;
        }
 
        m_cameraDirtyOnly = false;
    }
 
    bool IsCameraDirtyOnly() const
    {
        return IsDirty() && m_cameraDirtyOnly;
    }

    void UpdateItems();

    bool HasPendingItemUpdates() const
    {
        return m_hasPendingItemUpdates;
    }

    void UpdateAllItems( int aUpdateFlags );

    void UpdateAllItemsConditionally( int aUpdateFlags,
                                      std::function<bool( VIEW_ITEM* )> aCondition );

    void UpdateAllItemsConditionally( std::function<int( VIEW_ITEM* )> aItemFlagsProvider );

    bool IsUsingDrawPriority() const
    {
        return m_useDrawPriority;
    }

    void UseDrawPriority( bool aFlag )
    {
        m_useDrawPriority = aFlag;
    }

    void ReverseDrawOrder( bool aFlag )
    {
        m_reverseDrawOrder = aFlag;
    }
 
    std::shared_ptr<VIEW_OVERLAY> MakeOverlay();
 
    void InitPreview();
 
    void ClearPreview();
    void AddToPreview( VIEW_ITEM* aItem, bool aTakeOwnership = true );
 
    void ShowPreview( bool aShow = true );

    std::unique_ptr<VIEW> DataReference() const;

    static constexpr int VIEW_MAX_LAYERS = MAX_LAYERS_FOR_VIEW;

    static constexpr int TOP_LAYER_MODIFIER = -MAX_LAYERS_FOR_VIEW;
 
protected:
    struct VIEW_LAYER
    {
        bool                    visible;         
        bool                    displayOnly;     

        bool                    diffLayer;

        bool                    hasNegatives;
        std::shared_ptr<VIEW_RTREE> items;       
        int                     renderingOrder;  
        int                     id;              
        RENDER_TARGET           target;          

        std::set<int>           requiredLayers;
 
        bool operator< ( const VIEW_LAYER& aOther ) const
        {
            return id < aOther.id;
        }
    };

    void unlinkItem( VIEW_ITEM* aItem );

    void redrawRect( const BOX2I& aRect );

    void placeCachedGroup( VIEW_ITEM* aItem, int aLayer,
                           const RETAINED_GROUP_ORDER* aOrder = nullptr );
    double cachedGroupLOD( VIEW_ITEM* aItem, int aLayer );

    void placeRetainedInOrder( const std::vector<LAYER_ITEM_PAIR>& aItems, bool aReplacing );

    void layerStateChanged( int aLayer );

    void noteLodRead( int aLayer ) const;
 
    inline void markTargetClean( int aTarget )
    {
        wxCHECK( aTarget < TARGETS_NUMBER, /* void */ );
        m_dirtyTargets[aTarget] = false;
        m_targetEdited[aTarget] = false;
    }

    void draw( VIEW_ITEM* aItem, int aLayer, bool aImmediate = false );

    void draw( VIEW_ITEM* aItem, bool aImmediate = false );

    void draw( VIEW_GROUP* aGroup, bool aImmediate = false );

    void clearGroupCache();

    void invalidateItem( VIEW_ITEM* aItem, int aUpdateFlags );

    void recolorAllLayers( bool aReplace, const std::function<bool( int )>& aLayers = {} );

    void markDimExemption( const VIEW_ITEM* aItem, int aGroup );

    void updateItemColor( VIEW_ITEM* aItem, int aLayer );
 
    void recolorGroup( VIEW_ITEM* aItem, int aLayer, int aGroup );

    void releaseReplacedGroup( VIEW_ITEM* aItem, int aLayer );

    void releaseReplacedGroups();

    void updateItemGeometry( VIEW_ITEM* aItem, int aLayer, bool aPlace = true );

    void updateBbox( VIEW_ITEM* aItem );

    void updateLayers( VIEW_ITEM* aItem );

    static bool compareRenderingOrder( VIEW_LAYER* aI, VIEW_LAYER* aJ )
    {
        return aI->renderingOrder > aJ->renderingOrder;
    }

    bool areRequiredLayersEnabled( int aLayerId ) const;
 
    // Function objects that need to access VIEW/VIEW_ITEM private/protected members
    struct CLEAR_LAYER_CACHE_VISITOR;
    struct RECACHE_ITEM_VISITOR;
    struct DRAW_ITEM_VISITOR;
 
    std::unique_ptr<KIGFX::VIEW_GROUP> m_preview;
    std::vector<VIEW_ITEM*>            m_ownedItems;

    bool                               m_enableOrderModifier;

    std::map<int, VIEW_LAYER>          m_layers;

    std::vector<VIEW_LAYER*>           m_orderedLayers;

    std::shared_ptr<std::vector<VIEW_ITEM*>> m_allItems;

    std::set<unsigned int>             m_topLayers;

    VECTOR2D                           m_center;
 
    double                             m_scale;
    BOX2D                              m_boundary;
    double                             m_minScale;
    double                             m_maxScale;
 
    bool                               m_mirrorX;
    bool                               m_mirrorY;
    BASE_SET                           m_layerVisibilityCache;
    BASE_SET                           m_layerCachedFlagCache;

    bool                               m_layerCachesStale = true;

    PAINTER* m_painter;

    GAL* m_gal;

    bool m_dirtyTargets[TARGETS_NUMBER];

    bool m_targetEdited[TARGETS_NUMBER] = {};

    bool m_useDrawPriority;

    int m_nextDrawPriority;

    bool m_reverseDrawOrder;

    mutable bool m_hasPendingItemUpdates;

    mutable std::vector<VIEW_ITEM*> m_pendingItems;
    bool m_deferRetainedPlacement = false;
    std::vector<std::pair<VIEW_ITEM*, int>> m_deferredRetainedPlacements;

    std::map<std::pair<VIEW_ITEM*, int>, int> m_replacedRetainedGroups;

    mutable bool m_pendingListIncomplete = false;

    bool m_sceneLayersStale = true;

    struct SCALE_USE
    {
        bool   read = false;                                    
        double lodBelow = 0.0;                                  
        double lodAbove = std::numeric_limits<double>::max();   
    };
 
    SCALE_USE    m_scaleUse[TARGETS_NUMBER];
    mutable bool m_scaleRead = false;     

    SCALE_USE* m_keptScaleUse = nullptr;
 
    void noteKeptLod( double aLod ) const;

    void rescaleKeptTargets();

    std::vector<int> m_lodRefreshLayers;

    mutable int m_lodProbeLayer = -1;

    mutable std::unordered_map<int, std::vector<bool>> m_lodReads;

    void clearPendingItems();

    bool m_cameraDirtyOnly;
};
} // namespace KIGFX