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 (C) 2020 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef __VIEW_H
#define __VIEW_H

#include <vector>
#include <set>
#include <unordered_map>
#include <memory>

#include <math/box2.h>
#include <gal/definitions.h>

#include <view/view_overlay.h>
#include <view/view.h>

class EDA_ITEM;

namespace KIGFX
{
class PAINTER;
class GAL;
class VIEW_ITEM;
class VIEW_GROUP;
class VIEW_RTREE;

class VIEW
{
public:
 friend class VIEW_ITEM;

 typedef std::pair<VIEW_ITEM*, int> LAYER_ITEM_PAIR;

 VIEW( bool aIsDynamic = true );

 virtual ~VIEW();

 static void OnDestroy( VIEW_ITEM* aItem );

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

 virtual void Remove( VIEW_ITEM* aItem );


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

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

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

 bool IsVisible( const VIEW_ITEM* aItem ) const;

 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
 {
 return m_scale;
 }

 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 )
 {
 wxCHECK( aLayer < (int) m_layers.size(), /*void*/ );

 if( m_layers[aLayer].visible != aVisible )
 {
 // Target has to be redrawn after changing its visibility
 MarkTargetDirty( m_layers[aLayer].target );
 m_layers[aLayer].visible = aVisible;
 }
 }

 inline bool IsLayerVisible( int aLayer ) const
 {
 wxCHECK( aLayer >= 0, false);
 wxCHECK( aLayer < (int) m_layers.size(), false );

 return m_layers.at( aLayer ).visible;
 }

 inline void SetLayerDiff( int aLayer, bool aDiff = true )
 {
 wxCHECK( aLayer < (int) m_layers.size(), /*void*/ );

 if( m_layers[aLayer].diffLayer != aDiff )
 {
 // Target has to be redrawn after changing its layers' diff status
 MarkTargetDirty( m_layers[aLayer].target );
 m_layers[aLayer].diffLayer = aDiff;
 }
 }

 inline void SetLayerHasNegatives( int aLayer, bool aNegatives = true )
 {
 wxCHECK( aLayer < (int) m_layers.size(), /*void*/ );

 if( m_layers[aLayer].hasNegatives != aNegatives )
 {
 // Target has to be redrawn after changing a layers' negatives
 MarkTargetDirty( m_layers[aLayer].target );
 m_layers[aLayer].hasNegatives = aNegatives;
 }
 }

 inline void SetLayerDisplayOnly( int aLayer, bool aDisplayOnly = true )
 {
 wxCHECK( aLayer < (int) m_layers.size(), /*void*/ );
 m_layers[aLayer].displayOnly = aDisplayOnly;
 }

 inline void SetLayerTarget( int aLayer, RENDER_TARGET aTarget )
 {
 wxCHECK( aLayer < (int) m_layers.size(), /*void*/ );
 m_layers[aLayer].target = aTarget;
 }

 void SetLayerOrder( int aLayer, int aRenderingOrder );

 int GetLayerOrder( int aLayer ) const;

 void SortLayers( int aLayers[], int& aCount ) const;

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

 void UpdateLayerColor( int aLayer );

 void UpdateAllLayersColor();

 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 IsDynamic() const
 {
 return m_dynamic;
 }

 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;
 }

 inline bool IsCached( int aLayer ) const
 {
 wxCHECK( aLayer < (int) m_layers.size(), false );

 try
 {
 return m_layers.at( aLayer ).target == TARGET_CACHED;
 }
 catch( const std::out_of_range& )
 {
 return false;
 }
 }

 void MarkDirty()
 {
 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;
 }

 void UpdateItems();

 void UpdateAllItems( int aUpdateFlags );

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

 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( EDA_ITEM* aItem, bool aTakeOwnership = true );

 void ShowPreview( bool aShow = true );

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

 static constexpr int VIEW_MAX_LAYERS = 512; 

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; 
 };



 VIEW( const VIEW& ) = delete;

 void redrawRect( const BOX2I& aRect );

 inline void markTargetClean( int aTarget )
 {
 wxCHECK( aTarget < TARGETS_NUMBER, /* void */ );
 m_dirtyTargets[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 sortLayers();

 void clearGroupCache();

 void invalidateItem( VIEW_ITEM* aItem, int aUpdateFlags );

 void updateItemColor( VIEW_ITEM* aItem, int aLayer );

 void updateItemGeometry( VIEW_ITEM* aItem, int aLayer );

 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;
 struct UPDATE_COLOR_VISITOR;
 struct UPDATE_DEPTH_VISITOR;

 std::unique_ptr<KIGFX::VIEW_GROUP> m_preview;
 std::vector<EDA_ITEM *> m_ownedItems;

 bool m_enableOrderModifier;

 std::vector<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;

 PAINTER* m_painter;

 GAL* m_gal;

 bool m_dynamic;

 bool m_dirtyTargets[TARGETS_NUMBER];

 static const int TOP_LAYER_MODIFIER;

 bool m_useDrawPriority;

 int m_nextDrawPriority;

 bool m_reverseDrawOrder;
};
} // namespace KIGFX

#endif