KiCad PCB EDA Suite
KIGFX::VIEW Class Reference

Class VIEW. More...

#include <view.h>

Classes

struct  changeItemsDepth
 
struct  clearLayerCache
 
struct  drawItem
 
struct  extentsVisitor
 
struct  recacheItem
 
struct  updateItemsColor
 
struct  VIEW_LAYER
 

Public Types

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

Public Member Functions

 VIEW (bool aIsDynamic=true)
 Constructor. More...
 
 ~VIEW ()
 
void Add (VIEW_ITEM *aItem, int aDrawPriority=-1)
 Function Add() Adds a VIEW_ITEM to the view. More...
 
void Remove (VIEW_ITEM *aItem)
 Function Remove() Removes a VIEW_ITEM from the view. More...
 
int Query (const BOX2I &aRect, std::vector< LAYER_ITEM_PAIR > &aResult) const
 Function Query() Finds all visible items that touch or are within the rectangle aRect. More...
 
void SetVisible (VIEW_ITEM *aItem, bool aIsVisible=true)
 Sets the item visibility. More...
 
void Hide (VIEW_ITEM *aItem, bool aHide=true)
 Temporarily hides the item in the view (e.g. More...
 
bool IsVisible (const VIEW_ITEM *aItem) const
 Returns information if the item is visible (or not). More...
 
void Update (VIEW_ITEM *aItem, int aUpdateFlags)
 For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has changed. More...
 
void Update (VIEW_ITEM *aItem)
 
void SetRequired (int aLayerId, int aRequiredId, bool aRequired=true)
 Function SetRequired() Marks the aRequiredId layer as required for the aLayerId layer. More...
 
void CopySettings (const VIEW *aOtherView)
 Function CopySettings() Copies layers and visibility settings from another view. More...
 
void SetGAL (GAL *aGal)
 Function SetGAL() Assigns a rendering device for the VIEW. More...
 
GALGetGAL () const
 Function GetGAL() Returns the GAL this view is using to draw graphical primitives. More...
 
void SetPainter (PAINTER *aPainter)
 Function SetPainter() Sets the painter object used by the view for drawing VIEW_ITEMS. More...
 
PAINTERGetPainter () const
 Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS. More...
 
void SetViewport (const BOX2D &aViewport)
 Function SetViewport() Sets the visible area of the VIEW. More...
 
BOX2D GetViewport () const
 Function GetViewport() Returns the current viewport visible area rectangle. More...
 
void SetMirror (bool aMirrorX, bool aMirrorY)
 Function SetMirror() Controls the mirroring of the VIEW. More...
 
bool IsMirroredX () const
 Function IsMirroredX() Returns true if view is flipped across the X axis. More...
 
bool IsMirroredY () const
 Function IsMirroredX() Returns true if view is flipped across the Y axis. More...
 
void SetScale (double aScale)
 Function SetScale() Sets the scaling factor. More...
 
void SetScale (double aScale, const VECTOR2D &aAnchor)
 Function SetScale() Sets the scaling factor, zooming around a given anchor point. More...
 
double GetScale () const
 Function GetScale() More...
 
void SetBoundary (const BOX2I &aBoundary)
 Function SetBoundary() Sets limits for view area. More...
 
const BOX2IGetBoundary () const
 Function GetBoundary() More...
 
void SetScaleLimits (double aMaximum, double aMinimum)
 Function SetScaleLimits() Sets minimum and maximum values for scale. More...
 
void SetCenter (const VECTOR2D &aCenter)
 Function SetCenter() Sets the center point of the VIEW (i.e. More...
 
const VECTOR2DGetCenter () const
 Function GetCenter() Returns the center point of this VIEW (in world space coordinates) More...
 
VECTOR2D ToWorld (const VECTOR2D &aCoord, bool aAbsolute=true) const
 Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates. More...
 
double ToWorld (double aSize) const
 Function ToWorld() Converts a screen space one dimensional size to a one dimensional size in world space coordinates. More...
 
VECTOR2D ToScreen (const VECTOR2D &aCoord, bool aAbsolute=true) const
 Function ToScreen() Converts a world space point/vector to a point/vector in screen space coordinates. More...
 
double ToScreen (double aSize) const
 Function ToScreen() Converts a world space one dimensionsal size to a one dimensional size in screen space. More...
 
const VECTOR2IGetScreenPixelSize () const
 Function GetScreenPixelSize() Returns the size of the our rendering area, in pixels. More...
 
void AddLayer (int aLayer, bool aDisplayOnly=false)
 Function AddLayer() Adds a new layer to the view. More...
 
void ClearLayer (int aLayer)
 Function ClearLayer() Removes all items from a given layer. More...
 
void Clear ()
 Function Clear() Removes all items from the view. More...
 
void SetLayerVisible (int aLayer, bool aVisible=true)
 Function SetLayerVisible() Controls the visibility of a particular layer. More...
 
bool IsLayerVisible (int aLayer) const
 Function IsLayerVisible() Returns information about visibility of a particular layer. More...
 
void SetLayerDisplayOnly (int aLayer, bool aDisplayOnly=true)
 
void SetLayerTarget (int aLayer, RENDER_TARGET aTarget)
 Function SetLayerTarget() Changes the rendering target for a particular layer. More...
 
void SetLayerOrder (int aLayer, int aRenderingOrder)
 Function SetLayerOrder() Sets rendering order of a particular layer. More...
 
int GetLayerOrder (int aLayer) const
 Function GetLayerOrder() Returns rendering order of a particular layer. More...
 
void SortLayers (int aLayers[], int &aCount) const
 Function SortLayers() Changes the order of given layer ids, so after sorting the order corresponds to layers rendering order (descending, ie. More...
 
void UpdateLayerColor (int aLayer)
 Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it has changed. More...
 
void UpdateAllLayersColor ()
 Function UpdateAllLayersColor() Applies the new coloring scheme to all layers. More...
 
void SetTopLayer (int aLayer, bool aEnabled=true)
 Function SetTopLayer() Sets given layer to be displayed on the top or sets back the default order of layers. More...
 
void EnableTopLayer (bool aEnable)
 Function EnableTopLayer() Enables or disables display of the top layer. More...
 
int GetTopLayer () const
 
void ClearTopLayers ()
 Function ClearTopLayers() Removes all layers from the on-the-top set (they are no longer displayed over the rest of layers). More...
 
void UpdateAllLayersOrder ()
 Function UpdateLayerOrder() Does everything that is needed to apply the rendering order of layers. More...
 
void ClearTargets ()
 Function ClearTargets() Clears targets that are marked as dirty. More...
 
void Redraw ()
 Function Redraw() Immediately redraws the whole view. More...
 
void RecacheAllItems ()
 Function RecacheAllItems() Rebuilds GAL display lists. More...
 
bool IsDynamic () const
 Function IsDynamic() Tells if the VIEW is dynamic (ie. More...
 
bool IsDirty () const
 Function IsDirty() Returns true if any of the VIEW layers needs to be refreshened. More...
 
bool IsTargetDirty (int aTarget) const
 Function IsTargetDirty() Returns true if any of layers belonging to the target or the target itself should be redrawn. More...
 
void MarkTargetDirty (int aTarget)
 Function MarkTargetDirty() Sets or clears target 'dirty' flag. More...
 
bool IsCached (int aLayer) const
 Returns true if the layer is cached. More...
 
void MarkDirty ()
 Function MarkDirty() Forces redraw of view on the next rendering. More...
 
void MarkForUpdate (VIEW_ITEM *aItem)
 Function MarkForUpdate() Adds an item to a list of items that are going to be refreshed upon the next frame rendering. More...
 
void UpdateItems ()
 Function UpdateItems() Iterates through the list of items that asked for updating and updates them. More...
 
const BOX2I CalculateExtents ()
 
bool IsUsingDrawPriority () const
 Function IsUsingDrawPriority() More...
 
void UseDrawPriority (bool aFlag)
 Function UseDrawPriority() More...
 

Static Public Member Functions

static void OnDestroy (VIEW_ITEM *aItem)
 

Static Public Attributes

static const int VIEW_MAX_LAYERS = 512
 maximum number of layers that may be shown More...
 

Private Types

typedef std::unordered_map< int, VIEW_LAYERLAYER_MAP
 
typedef LAYER_MAP::iterator LAYER_MAP_ITER
 
typedef std::vector< VIEW_LAYER * > LAYER_ORDER
 
typedef std::vector< VIEW_LAYER * >::iterator LAYER_ORDER_ITER
 

Private Member Functions

void redrawRect (const BOX2I &aRect)
 
void markTargetClean (int aTarget)
 
void draw (VIEW_ITEM *aItem, int aLayer, bool aImmediate=false)
 Function draw() Draws an item, but on a specified layers. More...
 
void draw (VIEW_ITEM *aItem, bool aImmediate=false)
 Function draw() Draws an item on all layers that the item uses. More...
 
void draw (VIEW_GROUP *aGroup, bool aImmediate=false)
 Function draw() Draws a group of items on all layers that those items use. More...
 
void sortLayers ()
 
void clearGroupCache ()
 
void invalidateItem (VIEW_ITEM *aItem, int aUpdateFlags)
 Function invalidateItem() Manages dirty flags & redraw queueing when updating an item. More...
 
void updateItemColor (VIEW_ITEM *aItem, int aLayer)
 Updates colors that are used for an item to be drawn. More...
 
void updateItemGeometry (VIEW_ITEM *aItem, int aLayer)
 Updates all informations needed to draw an item. More...
 
void updateBbox (VIEW_ITEM *aItem)
 Updates bounding box of an item. More...
 
void updateLayers (VIEW_ITEM *aItem)
 Updates set of layers that an item occupies. More...
 
bool areRequiredLayersEnabled (int aLayerId) const
 Checks if every layer required by the aLayerId layer is enabled. More...
 

Static Private Member Functions

static bool compareRenderingOrder (VIEW_LAYER *aI, VIEW_LAYER *aJ)
 Determines rendering order of layers. Used in display order sorting function. More...
 

Private Attributes

bool m_enableOrderModifier
 
LAYER_MAP m_layers
 Contains set of possible displayed layers and its properties. More...
 
LAYER_ORDER m_orderedLayers
 Sorted list of pointers to members of m_layers. More...
 
std::set< unsigned int > m_topLayers
 Stores set of layers that are displayed on the top. More...
 
VECTOR2D m_center
 Center point of the VIEW (the point at which we are looking at) More...
 
double m_scale
 Scale of displayed VIEW_ITEMs. More...
 
BOX2I m_boundary
 View boundaries. More...
 
double m_minScale
 Scale lower limit. More...
 
double m_maxScale
 Scale upper limit. More...
 
bool m_mirrorX
 

Horizontal flip flag

More...
 
bool m_mirrorY
 

Vertical flip flag

More...
 
PAINTERm_painter
 PAINTER contains information how do draw items. More...
 
GALm_gal
 Gives interface to PAINTER, that is used to draw items. More...
 
bool m_dynamic
 Dynamic VIEW (eg. More...
 
bool m_dirtyTargets [TARGETS_NUMBER]
 Flags to mark targets as dirty, so they have to be redrawn on the next refresh event. More...
 
std::vector< VIEW_ITEM * > m_allItems
 Flat list of all items. More...
 
bool m_useDrawPriority
 Flag to respect draw priority when drawing items. More...
 
int m_nextDrawPriority
 The next sequential drawing priority. More...
 

Static Private Attributes

static const int TOP_LAYER_MODIFIER = -VIEW_MAX_LAYERS
 Rendering order modifier for layers that are marked as top layers. More...
 

Friends

class VIEW_ITEM
 

Detailed Description

Class VIEW.

Holds a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the GAL. VIEWs can exist in two flavors:

  • dynamic - where items can be added, removed or changed anytime, intended for the main editing panel. Each VIEW_ITEM can be added to a single dynamic view.
  • static - where items are added once at the startup and are not linked with the VIEW. Foreseen for preview windows and printing. Items in a view are grouped in layers (not to be confused with Kicad's PCB layers). Each layer is identified by an integer number. Visibility and rendering order can be set individually for each of the layers. Future versions of the VIEW will also allow to assign different layers to different rendering targets, which will be composited at the final stage by the GAL. The VIEW class also provides fast methods for finding all visible objects that are within a given rectangular area, useful for object selection/hit testing.

Definition at line 58 of file view.h.

Member Typedef Documentation

typedef std::pair<VIEW_ITEM*, int> KIGFX::VIEW::LAYER_ITEM_PAIR

Definition at line 63 of file view.h.

typedef std::unordered_map<int, VIEW_LAYER> KIGFX::VIEW::LAYER_MAP
private

Definition at line 649 of file view.h.

typedef LAYER_MAP::iterator KIGFX::VIEW::LAYER_MAP_ITER
private

Definition at line 650 of file view.h.

typedef std::vector<VIEW_LAYER*> KIGFX::VIEW::LAYER_ORDER
private

Definition at line 651 of file view.h.

typedef std::vector<VIEW_LAYER*>::iterator KIGFX::VIEW::LAYER_ORDER_ITER
private

Definition at line 652 of file view.h.

Constructor & Destructor Documentation

KIGFX::VIEW::VIEW ( bool  aIsDynamic = true)

Constructor.

Parameters
aIsDynamicdecides whether we are creating a static or a dynamic VIEW.

Definition at line 261 of file view.cpp.

References AddLayer(), m_allItems, m_boundary, MarkDirty(), BOX2< Vec >::SetMaximum(), and VIEW_MAX_LAYERS.

261  :
262  m_enableOrderModifier( true ),
263  m_scale( 4.0 ),
264  m_minScale( 4.0 ), m_maxScale( 15000 ),
265  m_mirrorX( false ), m_mirrorY( false ),
266  m_painter( NULL ),
267  m_gal( NULL ),
268  m_dynamic( aIsDynamic ),
269  m_useDrawPriority( false ),
270  m_nextDrawPriority( 0 )
271 {
273  m_allItems.reserve( 32768 );
274 
275  // Redraw everything at the beginning
276  MarkDirty();
277 
278  // View uses layers to display EDA_ITEMs (item may be displayed on several layers, for example
279  // pad may be shown on pad, pad hole and solder paste layers). There are usual copper layers
280  // (eg. F.Cu, B.Cu, internal and so on) and layers for displaying objects such as texts,
281  // silkscreen, pads, vias, etc.
282  for( int i = 0; i < VIEW_MAX_LAYERS; i++ )
283  AddLayer( i );
284 }
void AddLayer(int aLayer, bool aDisplayOnly=false)
Function AddLayer() Adds a new layer to the view.
Definition: view.cpp:294
bool m_useDrawPriority
Flag to respect draw priority when drawing items.
Definition: view.h:795
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
double m_minScale
Scale lower limit.
Definition: view.h:764
BOX2I m_boundary
View boundaries.
Definition: view.h:761
void SetMaximum()
Definition: box2.h:61
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
bool m_mirrorX
Horizontal flip flag
Definition: view.h:770
bool m_dynamic
Dynamic VIEW (eg.
Definition: view.h:783
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
int m_nextDrawPriority
The next sequential drawing priority.
Definition: view.h:798
double m_maxScale
Scale upper limit.
Definition: view.h:767
bool m_enableOrderModifier
Definition: view.h:743
std::vector< VIEW_ITEM * > m_allItems
Flat list of all items.
Definition: view.h:792
bool m_mirrorY
Vertical flip flag
Definition: view.h:773
double m_scale
Scale of displayed VIEW_ITEMs.
Definition: view.h:758
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
KIGFX::VIEW::~VIEW ( )

Definition at line 287 of file view.cpp.

References m_layers.

288 {
289  for( LAYER_MAP::value_type& l : m_layers )
290  delete l.second.items;
291 }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746

Member Function Documentation

void KIGFX::VIEW::Add ( VIEW_ITEM aItem,
int  aDrawPriority = -1 
)

Function Add() Adds a VIEW_ITEM to the view.

Set aDrawPriority to -1 to assign sequential priorities.

Parameters
aItemitem to be added. No ownership is given
aDrawPrioritypriority to draw this item on its layer, lowest first.

Definition at line 311 of file view.cpp.

References KIGFX::ALL, KIGFX::VIEW_RTREE::Insert(), KIGFX::VIEW::VIEW_LAYER::items, m_allItems, KIGFX::VIEW_ITEM_DATA::m_drawPriority, m_layers, m_nextDrawPriority, KIGFX::VIEW_ITEM_DATA::m_view, KIGFX::VIEW_ITEM::m_viewPrivData, MarkTargetDirty(), KIGFX::VIEW_ITEM_DATA::saveLayers(), SetVisible(), KIGFX::VIEW::VIEW_LAYER::target, Update(), VIEW_MAX_LAYERS, KIGFX::VIEW_ITEM::ViewGetLayers(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by SELECTION_TOOL::disambiguationMenu(), PCB_DRAW_PANEL_GAL::DisplayBoard(), PCB_TOOL::doInteractiveItemPlacement(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), GRID_HELPER::GRID_HELPER(), EDIT_TOOL::MeasureTool(), POINT_EDITOR::OnSelectionChange(), MODULE_EDITOR_TOOLS::PasteItems(), DRAWING_TOOL::PlaceDXF(), PCB_EDITOR_CONTROL::PlaceModule(), PCB_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), DIALOG_PAD_PROPERTIES::prepareCanvas(), BOARD_COMMIT::Push(), PCB_BASE_EDIT_FRAME::PutDataInPreviousState(), PCB_EDIT_FRAME::ReadPcbNetlist(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), PCB_EDITOR_CONTROL::Reset(), PCBNEW_CONTROL::Reset(), SELECTION_TOOL::Reset(), BOARD_COMMIT::Revert(), SELECTION_TOOL::selectMultiple(), PNS_KICAD_IFACE::SetView(), PNS_PCBNEW_DEBUG_DECORATOR::SetView(), PCB_DRAW_PANEL_GAL::SetWorksheet(), POINT_EDITOR::updatePoints(), ZONE_CREATE_HELPER::ZONE_CREATE_HELPER(), and SELECTION_TOOL::zoomFitSelection().

312 {
313  int layers[VIEW_MAX_LAYERS], layers_count;
314 
315  if( aDrawPriority < 0 )
316  aDrawPriority = m_nextDrawPriority++;
317 
318  if( !aItem->m_viewPrivData )
319  aItem->m_viewPrivData = new VIEW_ITEM_DATA;
320 
321  aItem->m_viewPrivData->m_view = this;
322  aItem->m_viewPrivData->m_drawPriority = aDrawPriority;
323 
324  aItem->ViewGetLayers( layers, layers_count );
325  aItem->viewPrivData()->saveLayers( layers, layers_count );
326 
327  m_allItems.push_back( aItem );
328 
329  for( int i = 0; i < layers_count; ++i )
330  {
331  VIEW_LAYER& l = m_layers[layers[i]];
332  l.items->Insert( aItem );
333  MarkTargetDirty( l.target );
334  }
335 
336  SetVisible( aItem, true );
337  Update( aItem, KIGFX::ALL );
338 }
Layers have changed.
Definition: view_item.h:59
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1377
int m_nextDrawPriority
The next sequential drawing priority.
Definition: view.h:798
std::vector< VIEW_ITEM * > m_allItems
Flat list of all items.
Definition: view.h:792
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Sets the item visibility.
Definition: view.cpp:1323
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::AddLayer ( int  aLayer,
bool  aDisplayOnly = false 
)

Function AddLayer() Adds a new layer to the view.

Parameters
aLayerunique ID of the layer to be added.
aDisplayOnlylayer is display-only (example: selection boxes, floating hints/menus). Objects belonging to this layer are not taken into account by Query() method.

Definition at line 294 of file view.cpp.

References m_layers, sortLayers(), and KIGFX::TARGET_CACHED.

Referenced by VIEW().

295 {
296  if( m_layers.find( aLayer ) == m_layers.end() )
297  {
298  m_layers[aLayer] = VIEW_LAYER();
299  m_layers[aLayer].id = aLayer;
300  m_layers[aLayer].items = new VIEW_RTREE();
301  m_layers[aLayer].renderingOrder = aLayer;
302  m_layers[aLayer].visible = true;
303  m_layers[aLayer].displayOnly = aDisplayOnly;
304  m_layers[aLayer].target = TARGET_CACHED;
305  }
306 
307  sortLayers();
308 }
void sortLayers()
Definition: view.cpp:1104
Main rendering target (cached)
Definition: definitions.h:41
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
bool KIGFX::VIEW::areRequiredLayersEnabled ( int  aLayerId) const
private

Checks if every layer required by the aLayerId layer is enabled.

Definition at line 1227 of file view.cpp.

References m_layers.

Referenced by redrawRect().

1228 {
1229  wxASSERT( (unsigned) aLayerId < m_layers.size() );
1230 
1231  std::set<int>::const_iterator it, it_end;
1232 
1233  for( it = m_layers.at( aLayerId ).requiredLayers.begin(),
1234  it_end = m_layers.at( aLayerId ).requiredLayers.end(); it != it_end; ++it )
1235  {
1236  // That is enough if just one layer is not enabled
1237  if( !m_layers.at( *it ).visible || !areRequiredLayersEnabled( *it ) )
1238  return false;
1239  }
1240 
1241  return true;
1242 }
bool areRequiredLayersEnabled(int aLayerId) const
Checks if every layer required by the aLayerId layer is enabled.
Definition: view.cpp:1227
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
const BOX2I KIGFX::VIEW::CalculateExtents ( )

Definition at line 1308 of file view.cpp.

References KIGFX::VIEW::extentsVisitor::extents, m_orderedLayers, and BOX2< Vec >::SetMaximum().

1309 {
1310  extentsVisitor v;
1311  BOX2I fullScene;
1312  fullScene.SetMaximum();
1313 
1314  for( VIEW_LAYER* l : m_orderedLayers )
1315  {
1316  l->items->Query( fullScene, v );
1317  }
1318 
1319  return v.extents;
1320 }
void SetMaximum()
Definition: box2.h:61
LAYER_ORDER m_orderedLayers
Sorted list of pointers to members of m_layers.
Definition: view.h:749
void KIGFX::VIEW::Clear ( )

Function Clear() Removes all items from the view.

Definition at line 970 of file view.cpp.

References KIGFX::GAL::ClearCache(), m_allItems, m_gal, m_layers, m_nextDrawPriority, and BOX2< Vec >::SetMaximum().

Referenced by PCB_DRAW_PANEL_GAL::DisplayBoard(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), and PCB_BASE_EDIT_FRAME::SetBoard().

971 {
972  BOX2I r;
973  r.SetMaximum();
974  m_allItems.clear();
975 
976  for( LAYER_MAP_ITER i = m_layers.begin(); i != m_layers.end(); ++i )
977  i->second.items->RemoveAll();
978 
979  m_nextDrawPriority = 0;
980 
981  m_gal->ClearCache();
982 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void SetMaximum()
Definition: box2.h:61
int m_nextDrawPriority
The next sequential drawing priority.
Definition: view.h:798
LAYER_MAP::iterator LAYER_MAP_ITER
Definition: view.h:650
std::vector< VIEW_ITEM * > m_allItems
Flat list of all items.
Definition: view.h:792
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
virtual void ClearCache()
Delete all data created during caching of graphic items.
void KIGFX::VIEW::clearGroupCache ( )
private

Definition at line 1053 of file view.cpp.

References KIGFX::VIEW::VIEW_LAYER::items, m_layers, KIGFX::VIEW_RTREE::Query(), and BOX2< Vec >::SetMaximum().

Referenced by SetGAL().

1054 {
1055  BOX2I r;
1056 
1057  r.SetMaximum();
1058  clearLayerCache visitor( this );
1059 
1060  for( LAYER_MAP_ITER i = m_layers.begin(); i != m_layers.end(); ++i )
1061  {
1062  VIEW_LAYER* l = &( ( *i ).second );
1063  l->items->Query( r, visitor );
1064  }
1065 }
void SetMaximum()
Definition: box2.h:61
LAYER_MAP::iterator LAYER_MAP_ITER
Definition: view.h:650
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::ClearLayer ( int  aLayer)

Function ClearLayer() Removes all items from a given layer.

Parameters
aLayerID of the layer to be cleared
void KIGFX::VIEW::ClearTargets ( )

Function ClearTargets() Clears targets that are marked as dirty.

Definition at line 985 of file view.cpp.

References KIGFX::GAL::ClearTarget(), IsTargetDirty(), m_gal, MarkDirty(), KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, and KIGFX::TARGET_OVERLAY.

Referenced by EDA_DRAW_PANEL_GAL::onPaint().

986 {
988  {
989  // TARGET_CACHED and TARGET_NONCACHED have to be redrawn together, as they contain
990  // layers that rely on each other (eg. netnames are noncached, but tracks - are cached)
993 
994  MarkDirty();
995  }
996 
998  {
1000  }
1001 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
Auxiliary rendering target (noncached)
Definition: definitions.h:42
virtual void ClearTarget(RENDER_TARGET aTarget)
Clears the target for rendering.
bool IsTargetDirty(int aTarget) const
Function IsTargetDirty() Returns true if any of layers belonging to the target or the target itself s...
Definition: view.h:556
Items that may change while the view stays the same (noncached)
Definition: definitions.h:43
Main rendering target (cached)
Definition: definitions.h:41
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::ClearTopLayers ( )

Function ClearTopLayers() Removes all layers from the on-the-top set (they are no longer displayed over the rest of layers).

Definition at line 781 of file view.cpp.

References m_enableOrderModifier, m_layers, m_topLayers, and TOP_LAYER_MODIFIER.

Referenced by PCB_DRAW_PANEL_GAL::SetTopLayer(), and EDA_DRAW_PANEL_GAL::SetTopLayer().

782 {
783  std::set<unsigned int>::iterator it;
784 
786  {
787  // Restore the previous rendering order for layers that were marked as top
788  for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
789  m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
790  }
791 
792  m_topLayers.clear();
793 }
static const int TOP_LAYER_MODIFIER
Rendering order modifier for layers that are marked as top layers.
Definition: view.h:789
std::set< unsigned int > m_topLayers
Stores set of layers that are displayed on the top.
Definition: view.h:752
bool m_enableOrderModifier
Definition: view.h:743
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
static bool KIGFX::VIEW::compareRenderingOrder ( VIEW_LAYER aI,
VIEW_LAYER aJ 
)
inlinestaticprivate

Determines rendering order of layers. Used in display order sorting function.

Definition at line 734 of file view.h.

References KIGFX::VIEW::VIEW_LAYER::renderingOrder.

Referenced by sortLayers().

735  {
736  return aI->renderingOrder > aJ->renderingOrder;
737  }
void KIGFX::VIEW::CopySettings ( const VIEW aOtherView)

Function CopySettings() Copies layers and visibility settings from another view.

Parameters
aOtherViewview from which settings will be copied.

Definition at line 478 of file view.cpp.

479 {
480  wxASSERT_MSG( false, wxT( "This is not implemented" ) );
481 }
void KIGFX::VIEW::draw ( VIEW_ITEM aItem,
int  aLayer,
bool  aImmediate = false 
)
private

Function draw() Draws an item, but on a specified layers.

It has to be marked that some of drawing settings are based on the layer on which an item is drawn.

Parameters
aItemis the item to be drawn.
aLayeris the layer which should be drawn.
aImmediatedictates the way of drawing - it allows to force immediate drawing mode for cached items.

Definition at line 878 of file view.cpp.

References KIGFX::GAL::BeginGroup(), KIGFX::PAINTER::Draw(), KIGFX::GAL::DrawGroup(), KIGFX::GAL::EndGroup(), KIGFX::VIEW_ITEM_DATA::getGroup(), IsCached(), m_gal, m_painter, KIGFX::VIEW_ITEM::ViewDraw(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by KIGFX::VIEW::drawItem::deferredDraw(), draw(), and KIGFX::VIEW::drawItem::operator()().

879 {
880  auto viewData = aItem->viewPrivData();
881 
882  if( !viewData )
883  return;
884 
885  if( IsCached( aLayer ) && !aImmediate )
886  {
887  // Draw using cached information or create one
888  int group = viewData->getGroup( aLayer );
889 
890  if( group >= 0 )
891  {
892  m_gal->DrawGroup( group );
893  }
894  else
895  {
896  group = m_gal->BeginGroup();
897  viewData->setGroup( aLayer, group );
898 
899  if( !m_painter->Draw( aItem, aLayer ) )
900  aItem->ViewDraw( aLayer, this ); // Alternative drawing method
901 
902  m_gal->EndGroup();
903  }
904  }
905  else
906  {
907  // Immediate mode
908  if( !m_painter->Draw( aItem, aLayer ) )
909  aItem->ViewDraw( aLayer, this ); // Alternative drawing method
910  }
911 }
virtual void DrawGroup(int aGroupNumber)
Draw the stored group.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual void EndGroup()
End the group.
virtual int BeginGroup()
Begin a group.
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
virtual bool Draw(const VIEW_ITEM *aItem, int aLayer)=0
Function Draw Takes an instance of VIEW_ITEM and passes it to a function that know how to draw the it...
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
void KIGFX::VIEW::draw ( VIEW_ITEM aItem,
bool  aImmediate = false 
)
private

Function draw() Draws an item on all layers that the item uses.

Parameters
aItemis the item to be drawn.
aImmediatedictates the way of drawing - it allows to force immediate drawing mode for cached items.

Definition at line 914 of file view.cpp.

References draw(), m_gal, m_layers, KIGFX::GAL::SetLayerDepth(), SortLayers(), VIEW_MAX_LAYERS, and KIGFX::VIEW_ITEM::ViewGetLayers().

915 {
916  int layers[VIEW_MAX_LAYERS], layers_count;
917 
918  aItem->ViewGetLayers( layers, layers_count );
919 
920  // Sorting is needed for drawing order dependent GALs (like Cairo)
921  SortLayers( layers, layers_count );
922 
923  for( int i = 0; i < layers_count; ++i )
924  {
925  m_gal->SetLayerDepth( m_layers.at( layers[i] ).renderingOrder );
926  draw( aItem, layers[i], aImmediate );
927  }
928 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
void SortLayers(int aLayers[], int &aCount) const
Function SortLayers() Changes the order of given layer ids, so after sorting the order corresponds to...
Definition: view.cpp:603
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
void draw(VIEW_ITEM *aItem, int aLayer, bool aImmediate=false)
Function draw() Draws an item, but on a specified layers.
Definition: view.cpp:878
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::draw ( VIEW_GROUP aGroup,
bool  aImmediate = false 
)
private

Function draw() Draws a group of items on all layers that those items use.

Parameters
aGroupis the group to be drawn.
aImmediatedictates the way of drawing - it allows to force immediate drawing mode for cached items.

Definition at line 931 of file view.cpp.

References draw(), KIGFX::VIEW_GROUP::GetItem(), and KIGFX::VIEW_GROUP::GetSize().

932 {
933  for( unsigned int i = 0; i < aGroup->GetSize(); i++)
934  draw( aGroup->GetItem(i), aImmediate );
935 }
void draw(VIEW_ITEM *aItem, int aLayer, bool aImmediate=false)
Function draw() Draws an item, but on a specified layers.
Definition: view.cpp:878
void KIGFX::VIEW::EnableTopLayer ( bool  aEnable)

Function EnableTopLayer() Enables or disables display of the top layer.

When disabled - layers are rendered as usual with no influence from SetTopLayer function. Otherwise on the top there is displayed the layer set previously with SetTopLayer function.

Parameters
aEnablewhether to enable or disable display of the top layer.

Definition at line 756 of file view.cpp.

References m_enableOrderModifier, m_layers, m_topLayers, TOP_LAYER_MODIFIER, UpdateAllLayersColor(), and UpdateAllLayersOrder().

757 {
758  if( aEnable == m_enableOrderModifier )
759  return;
760 
761  m_enableOrderModifier = aEnable;
762 
763  std::set<unsigned int>::iterator it;
764 
765  if( aEnable )
766  {
767  for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
768  m_layers[*it].renderingOrder += TOP_LAYER_MODIFIER;
769  }
770  else
771  {
772  for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
773  m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
774  }
775 
778 }
static const int TOP_LAYER_MODIFIER
Rendering order modifier for layers that are marked as top layers.
Definition: view.h:789
std::set< unsigned int > m_topLayers
Stores set of layers that are displayed on the top.
Definition: view.h:752
void UpdateAllLayersOrder()
Function UpdateLayerOrder() Does everything that is needed to apply the rendering order of layers...
Definition: view.cpp:796
bool m_enableOrderModifier
Definition: view.h:743
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void UpdateAllLayersColor()
Function UpdateAllLayersColor() Applies the new coloring scheme to all layers.
Definition: view.cpp:674
const BOX2I& KIGFX::VIEW::GetBoundary ( ) const
inline

Function GetBoundary()

Returns
Current view area boundary.

Definition at line 284 of file view.h.

References m_boundary.

Referenced by KIGFX::WX_VIEW_CONTROLS::onScroll(), and KIGFX::WX_VIEW_CONTROLS::UpdateScrollbars().

285  {
286  return m_boundary;
287  }
BOX2I m_boundary
View boundaries.
Definition: view.h:761
const VECTOR2D& KIGFX::VIEW::GetCenter ( ) const
inline

Function GetCenter() Returns the center point of this VIEW (in world space coordinates)

Returns
center point of the view

Definition at line 316 of file view.h.

References m_center.

Referenced by KIGFX::WX_VIEW_CONTROLS::onButton(), KIGFX::WX_VIEW_CONTROLS::onScroll(), KIGFX::WX_VIEW_CONTROLS::onTimer(), KIGFX::WX_VIEW_CONTROLS::onWheel(), EDA_DRAW_FRAME::UseGalCanvas(), and COMMON_TOOLS::ZoomFitScreen().

317  {
318  return m_center;
319  }
VECTOR2D m_center
Center point of the VIEW (the point at which we are looking at)
Definition: view.h:755
int KIGFX::VIEW::GetLayerOrder ( int  aLayer) const

Function GetLayerOrder() Returns rendering order of a particular layer.

Lower values are rendered first.

Parameters
aLayerthe layer
Returns
Rendering order of a particular layer.

Definition at line 597 of file view.cpp.

References m_layers.

Referenced by PCB_DRAW_PANEL_GAL::SetTopLayer(), and SortLayers().

598 {
599  return m_layers.at( aLayer ).renderingOrder;
600 }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
PAINTER* KIGFX::VIEW::GetPainter ( ) const
inline

Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS.

Returns
Pointer to the currently used Painter instance.

Definition at line 196 of file view.h.

References m_painter.

Referenced by drawArcWithHilight(), drawLineWithHilight(), KIGFX::PREVIEW::POLYGON_ITEM::drawPreviewShape(), KIGFX::PREVIEW::DrawTextNextToCursor(), drawTicksAlongLine(), ROUTER_PREVIEW_ITEM::getLayerColor(), PCBNEW_CONTROL::HighContrastMode(), PNS::TOOL_BASE::highlightNet(), PCB_EDITOR_CONTROL::HighlightNet(), highlightNet(), PCBNEW_CONTROL::LayerAlphaDec(), PCBNEW_CONTROL::LayerAlphaInc(), PCB_EDIT_FRAME::ListNetsAndSelect(), MODULE_EDITOR_TOOLS::ModuleEdgeOutlines(), MODULE_EDITOR_TOOLS::ModuleTextOutlines(), ZONE_CREATE_HELPER::OnFirstPoint(), PCB_LAYER_WIDGET::OnLayerColorChange(), PCB_LAYER_WIDGET::OnRenderColorChange(), PCB_DRAW_PANEL_GAL::OnShow(), PCBNEW_CONTROL::PadDisplayMode(), PCB_DRAW_PANEL_GAL::PCB_DRAW_PANEL_GAL(), SELECTION_TOOL::Reset(), SELECTION_TOOL::selectable(), PCB_DRAW_PANEL_GAL::SetHighContrastLayer(), EDA_DRAW_PANEL_GAL::SetHighContrastLayer(), PCBNEW_CONTROL::TrackDisplayMode(), DIALOG_DISPLAY_OPTIONS::TransferDataFromWindow(), PCB_DRAW_PANEL_GAL::UseColorScheme(), PCB_BASE_FRAME::UseGalCanvas(), PCBNEW_CONTROL::ViaDisplayMode(), KIGFX::PREVIEW::ARC_ASSISTANT::ViewDraw(), KIGFX::RATSNEST_VIEWITEM::ViewDraw(), KIGFX::PREVIEW::RULER_ITEM::ViewDraw(), KIGFX::PREVIEW::SELECTION_AREA::ViewDraw(), KIGFX::VIEW_GROUP::ViewDraw(), KIGFX::WORKSHEET_VIEWITEM::ViewDraw(), and PCBNEW_CONTROL::ZoneDisplayMode().

197  {
198  return m_painter;
199  }
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
double KIGFX::VIEW::GetScale ( ) const
inline
const VECTOR2I & KIGFX::VIEW::GetScreenPixelSize ( ) const

Function GetScreenPixelSize() Returns the size of the our rendering area, in pixels.

Returns
viewport screen size

Definition at line 1029 of file view.cpp.

References KIGFX::GAL::GetScreenPixelSize(), and m_gal.

Referenced by KIGFX::WX_VIEW_CONTROLS::handleAutoPanning(), KIGFX::WX_VIEW_CONTROLS::onScroll(), KIGFX::WX_VIEW_CONTROLS::onTimer(), and KIGFX::WX_VIEW_CONTROLS::onWheel().

1030 {
1031  return m_gal->GetScreenPixelSize();
1032 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
int KIGFX::VIEW::GetTopLayer ( ) const

Definition at line 720 of file view.cpp.

References m_topLayers.

Referenced by ROUTER_TOOL::getStartLayer(), PNS::TOOL_BASE::pickSingleItem(), and PNS::TOOL_BASE::updateStartItem().

721 {
722  if( m_topLayers.size() == 0 )
723  return 0;
724 
725  return *m_topLayers.begin();
726 }
std::set< unsigned int > m_topLayers
Stores set of layers that are displayed on the top.
Definition: view.h:752
BOX2D KIGFX::VIEW::GetViewport ( ) const

Function GetViewport() Returns the current viewport visible area rectangle.

Returns
Current viewport rectangle

Definition at line 501 of file view.cpp.

References KIGFX::GAL::GetScreenPixelSize(), m_gal, BOX2< Vec >::Normalize(), BOX2< Vec >::SetEnd(), BOX2< Vec >::SetOrigin(), and ToWorld().

Referenced by SELECTION_TOOL::guessSelectionCandidates(), and KIGFX::WX_VIEW_CONTROLS::UpdateScrollbars().

502 {
503  BOX2D rect;
504  VECTOR2D screenSize = m_gal->GetScreenPixelSize();
505 
506  rect.SetOrigin( ToWorld( VECTOR2D( 0, 0 ) ) );
507  rect.SetEnd( ToWorld( screenSize ) );
508 
509  return rect.Normalize();
510 }
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates...
Definition: view.cpp:440
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec.
Definition: box2.h:41
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:117
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:213
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
void SetOrigin(const Vec &pos)
Definition: box2.h:198
void KIGFX::VIEW::Hide ( VIEW_ITEM aItem,
bool  aHide = true 
)

Temporarily hides the item in the view (e.g.

for overlaying)

Parameters
aItemthe item to modify.
aHidewhether the item is hidden (on all layers), or not.

Definition at line 1344 of file view.cpp.

References KIGFX::APPEARANCE, KIGFX::HIDDEN, KIGFX::VIEW_ITEM_DATA::m_flags, Update(), KIGFX::VIEW_ITEM::viewPrivData(), and KIGFX::VISIBLE.

Referenced by SELECTION_TOOL::selectVisually(), and SELECTION_TOOL::unselectVisually().

1345 {
1346  auto viewData = aItem->viewPrivData();
1347 
1348  if( !viewData )
1349  return;
1350 
1351  if( !( viewData->m_flags & VISIBLE ) )
1352  return;
1353 
1354  if( aHide )
1355  viewData->m_flags |= HIDDEN;
1356  else
1357  viewData->m_flags &= ~HIDDEN;
1358 
1359  Update( aItem, APPEARANCE );
1360 }
Item is visible (in general)
Definition: view_item.h:68
No updates are required.
Definition: view_item.h:55
void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1377
void KIGFX::VIEW::invalidateItem ( VIEW_ITEM aItem,
int  aUpdateFlags 
)
private

Function invalidateItem() Manages dirty flags & redraw queueing when updating an item.

Parameters
aItemis the item to be updated.
aUpdateFlagsdetermines the way an item is refreshed.

Definition at line 1068 of file view.cpp.

References KIGFX::VIEW_ITEM_DATA::clearUpdateFlags(), KIGFX::COLOR, KIGFX::GEOMETRY, IsCached(), KIGFX::LAYERS, m_layers, MarkTargetDirty(), updateBbox(), updateItemColor(), updateItemGeometry(), updateLayers(), VIEW_MAX_LAYERS, KIGFX::VIEW_ITEM::ViewGetLayers(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by UpdateItems().

1069 {
1070  // updateLayers updates geometry too, so we do not have to update both of them at the same time
1071  if( aUpdateFlags & LAYERS )
1072  {
1073  updateLayers( aItem );
1074  }
1075  else if( aUpdateFlags & GEOMETRY )
1076  {
1077  updateBbox( aItem );
1078  }
1079 
1080  int layers[VIEW_MAX_LAYERS], layers_count;
1081  aItem->ViewGetLayers( layers, layers_count );
1082 
1083  // Iterate through layers used by the item and recache it immediately
1084  for( int i = 0; i < layers_count; ++i )
1085  {
1086  int layerId = layers[i];
1087 
1088  if( IsCached( layerId ) )
1089  {
1090  if( aUpdateFlags & ( GEOMETRY | LAYERS ) )
1091  updateItemGeometry( aItem, layerId );
1092  else if( aUpdateFlags & COLOR )
1093  updateItemColor( aItem, layerId );
1094  }
1095 
1096  // Mark those layers as dirty, so the VIEW will be refreshed
1097  MarkTargetDirty( m_layers[layerId].target );
1098  }
1099 
1100  aItem->viewPrivData()->clearUpdateFlags();
1101 }
void updateLayers(VIEW_ITEM *aItem)
Updates set of layers that an item occupies.
Definition: view.cpp:1184
void updateItemColor(VIEW_ITEM *aItem, int aLayer)
Updates colors that are used for an item to be drawn.
Definition: view.cpp:1119
Visibility flag has changed.
Definition: view_item.h:56
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
void updateBbox(VIEW_ITEM *aItem)
Updates bounding box of an item.
Definition: view.cpp:1168
void updateItemGeometry(VIEW_ITEM *aItem, int aLayer)
Updates all informations needed to draw an item.
Definition: view.cpp:1138
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
Position or shape has changed.
Definition: view_item.h:58
Color has changed.
Definition: view_item.h:57
bool KIGFX::VIEW::IsCached ( int  aLayer) const
inline

Returns true if the layer is cached.

Definition at line 576 of file view.h.

References m_layers, and KIGFX::TARGET_CACHED.

Referenced by draw(), invalidateItem(), RecacheAllItems(), UpdateAllLayersColor(), updateItemColor(), updateItemGeometry(), UpdateLayerColor(), and updateLayers().

577  {
578  wxASSERT( aLayer < (int) m_layers.size() );
579 
580  try
581  {
582  return m_layers.at( aLayer ).target == TARGET_CACHED;
583  }
584  catch( std::out_of_range )
585  {
586  return false;
587  }
588  }
Main rendering target (cached)
Definition: definitions.h:41
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
bool KIGFX::VIEW::IsDirty ( ) const
inline

Function IsDirty() Returns true if any of the VIEW layers needs to be refreshened.

Returns
True in case if any of layers is marked as dirty.

Definition at line 539 of file view.h.

References IsTargetDirty(), and KIGFX::TARGETS_NUMBER.

Referenced by EDA_DRAW_PANEL_GAL::onPaint(), and TOOL_MANAGER::ProcessEvent().

540  {
541  for( int i = 0; i < TARGETS_NUMBER; ++i )
542  {
543  if( IsTargetDirty( i ) )
544  return true;
545  }
546 
547  return false;
548  }
Number of available rendering targets.
Definition: definitions.h:44
bool IsTargetDirty(int aTarget) const
Function IsTargetDirty() Returns true if any of layers belonging to the target or the target itself s...
Definition: view.h:556
bool KIGFX::VIEW::IsDynamic ( ) const
inline

Function IsDynamic() Tells if the VIEW is dynamic (ie.

can be changed, for example displaying PCBs in a window) or static (that cannot be modified, eg. displaying image/PDF).

Definition at line 529 of file view.h.

References m_dynamic.

530  {
531  return m_dynamic;
532  }
bool m_dynamic
Dynamic VIEW (eg.
Definition: view.h:783
bool KIGFX::VIEW::IsLayerVisible ( int  aLayer) const
inline

Function IsLayerVisible() Returns information about visibility of a particular layer.

Parameters
aLayertrue if the layer is visible, false otherwise

Definition at line 404 of file view.h.

References m_layers.

Referenced by KIGFX::VIEW_GROUP::ViewDraw(), TEXTE_MODULE::ViewGetLOD(), and MODULE::ViewGetLOD().

405  {
406  wxASSERT( aLayer < (int) m_layers.size() );
407 
408  return m_layers.at( aLayer ).visible;
409  }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
bool KIGFX::VIEW::IsMirroredX ( ) const
inline

Function IsMirroredX() Returns true if view is flipped across the X axis.

Definition at line 227 of file view.h.

References m_mirrorX.

Referenced by PCBNEW_CONTROL::CursorControl().

228  {
229  return m_mirrorX;
230  }
bool m_mirrorX
Horizontal flip flag
Definition: view.h:770
bool KIGFX::VIEW::IsMirroredY ( ) const
inline

Function IsMirroredX() Returns true if view is flipped across the Y axis.

Definition at line 236 of file view.h.

References m_mirrorY.

237  {
238  return m_mirrorY;
239  }
bool m_mirrorY
Vertical flip flag
Definition: view.h:773
bool KIGFX::VIEW::IsTargetDirty ( int  aTarget) const
inline

Function IsTargetDirty() Returns true if any of layers belonging to the target or the target itself should be redrawn.

Returns
True if the above condition is fulfilled.

Definition at line 556 of file view.h.

References m_dirtyTargets, and KIGFX::TARGETS_NUMBER.

Referenced by ClearTargets(), IsDirty(), EDA_DRAW_PANEL_GAL::onPaint(), and redrawRect().

557  {
558  wxASSERT( aTarget < TARGETS_NUMBER );
559 
560  return m_dirtyTargets[aTarget];
561  }
Number of available rendering targets.
Definition: definitions.h:44
bool m_dirtyTargets[TARGETS_NUMBER]
Flags to mark targets as dirty, so they have to be redrawn on the next refresh event.
Definition: view.h:786
bool KIGFX::VIEW::IsUsingDrawPriority ( ) const
inline

Function IsUsingDrawPriority()

Returns
true if draw priority is being respected while redrawing.

Definition at line 619 of file view.h.

References m_useDrawPriority.

620  {
621  return m_useDrawPriority;
622  }
bool m_useDrawPriority
Flag to respect draw priority when drawing items.
Definition: view.h:795
bool KIGFX::VIEW::IsVisible ( const VIEW_ITEM aItem) const

Returns information if the item is visible (or not).

Parameters
aItemthe item to test.
Returns
when true, the item is visible (i.e. to be displayed, not visible in the current viewport)

Definition at line 1363 of file view.cpp.

References KIGFX::VIEW_ITEM_DATA::m_flags, KIGFX::VIEW_ITEM::viewPrivData(), and KIGFX::VISIBLE.

Referenced by PNS_KICAD_IFACE::HideItem(), and SELECTION_TOOL::selectable().

1364 {
1365  const auto viewData = aItem->viewPrivData();
1366 
1367  return viewData->m_flags & VISIBLE;
1368 }
void KIGFX::VIEW::MarkDirty ( )
inline

Function MarkDirty() Forces redraw of view on the next rendering.

Definition at line 594 of file view.h.

References m_dirtyTargets, and KIGFX::TARGETS_NUMBER.

Referenced by ClearTargets(), SetCenter(), setDrillOrigin(), SetGAL(), SetMirror(), setOrigin(), SetScale(), sortLayers(), UpdateAllLayersColor(), UpdateAllLayersOrder(), and VIEW().

595  {
596  for( int i = 0; i < TARGETS_NUMBER; ++i )
597  m_dirtyTargets[i] = true;
598  }
Number of available rendering targets.
Definition: definitions.h:44
bool m_dirtyTargets[TARGETS_NUMBER]
Flags to mark targets as dirty, so they have to be redrawn on the next refresh event.
Definition: view.h:786
void KIGFX::VIEW::MarkForUpdate ( VIEW_ITEM aItem)

Function MarkForUpdate() Adds an item to a list of items that are going to be refreshed upon the next frame rendering.

Parameters
aItemis the item to be refreshed.
void KIGFX::VIEW::markTargetClean ( int  aTarget)
inlineprivate

Definition at line 667 of file view.h.

References m_dirtyTargets, and KIGFX::TARGETS_NUMBER.

Referenced by Redraw().

668  {
669  wxASSERT( aTarget < TARGETS_NUMBER );
670 
671  m_dirtyTargets[aTarget] = false;
672  }
Number of available rendering targets.
Definition: definitions.h:44
bool m_dirtyTargets[TARGETS_NUMBER]
Flags to mark targets as dirty, so they have to be redrawn on the next refresh event.
Definition: view.h:786
void KIGFX::VIEW::MarkTargetDirty ( int  aTarget)
inline

Function MarkTargetDirty() Sets or clears target 'dirty' flag.

Parameters
aTargetis the target to set.

Definition at line 568 of file view.h.

References m_dirtyTargets, and KIGFX::TARGETS_NUMBER.

Referenced by Add(), SELECTION_TOOL::disambiguationMenu(), invalidateItem(), PCB_LAYER_WIDGET::OnRenderColorChange(), PCB_LAYER_WIDGET::OnRenderEnable(), EDA_DRAW_PANEL_GAL::onSize(), EDA_DRAW_FRAME::OnToggleGridState(), Remove(), SetLayerVisible(), DIALOG_DISPLAY_OPTIONS::TransferDataFromWindow(), DIALOG_MODEDIT_DISPLAY_OPTIONS::TransferDataFromWindow(), updateBbox(), COMMON_TOOLS::updateGrid(), PCBNEW_CONTROL::updateGrid(), UpdateLayerColor(), and updateLayers().

569  {
570  wxASSERT( aTarget < TARGETS_NUMBER );
571 
572  m_dirtyTargets[aTarget] = true;
573  }
Number of available rendering targets.
Definition: definitions.h:44
bool m_dirtyTargets[TARGETS_NUMBER]
Flags to mark targets as dirty, so they have to be redrawn on the next refresh event.
Definition: view.h:786
void KIGFX::VIEW::OnDestroy ( VIEW_ITEM aItem)
static

Definition at line 247 of file view.cpp.

References KIGFX::VIEW_ITEM_DATA::m_view, Remove(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by KIGFX::VIEW_ITEM::~VIEW_ITEM().

248 {
249  auto data = aItem->viewPrivData();
250 
251  if( !data )
252  return;
253 
254  if( data->m_view )
255  data->m_view->Remove( aItem );
256 
257  delete data;
258 }
int KIGFX::VIEW::Query ( const BOX2I aRect,
std::vector< LAYER_ITEM_PAIR > &  aResult 
) const

Function Query() Finds all visible items that touch or are within the rectangle aRect.

Parameters
aRectarea to search for items
aResultresult of the search, containing VIEW_ITEMs associated with their layers. Sorted according to the rendering order (items that are on top of the rendering stack as first).
Returns
Number of found items.

Definition at line 417 of file view.cpp.

References m_orderedLayers.

Referenced by GRID_HELPER::queryVisible(), and SELECTION_TOOL::selectMultiple().

418 {
419  if( m_orderedLayers.empty() )
420  return 0;
421 
422  std::vector<VIEW_LAYER*>::const_reverse_iterator i;
423 
424  // execute queries in reverse direction, so that items that are on the top of
425  // the rendering stack are returned first.
426  for( i = m_orderedLayers.rbegin(); i != m_orderedLayers.rend(); ++i )
427  {
428  // ignore layers that do not contain actual items (i.e. the selection box, menus, floats)
429  if( ( *i )->displayOnly )
430  continue;
431 
432  queryVisitor<std::vector<LAYER_ITEM_PAIR> > visitor( aResult, ( *i )->id );
433  ( *i )->items->Query( aRect, visitor );
434  }
435 
436  return aResult.size();
437 }
LAYER_ORDER m_orderedLayers
Sorted list of pointers to members of m_layers.
Definition: view.h:749
void KIGFX::VIEW::RecacheAllItems ( )

Function RecacheAllItems() Rebuilds GAL display lists.

Definition at line 1245 of file view.cpp.

References KIGFX::VIEW::VIEW_LAYER::id, IsCached(), KIGFX::VIEW::VIEW_LAYER::items, m_gal, m_layers, KIGFX::VIEW_RTREE::Query(), and BOX2< Vec >::SetMaximum().

Referenced by PCB_DRAW_PANEL_GAL::OnShow(), DIALOG_DISPLAY_OPTIONS::TransferDataFromWindow(), DIALOG_MODEDIT_DISPLAY_OPTIONS::TransferDataFromWindow(), and PCB_BASE_FRAME::UseGalCanvas().

1246 {
1247  BOX2I r;
1248 
1249  r.SetMaximum();
1250 
1251  for( LAYER_MAP_ITER i = m_layers.begin(); i != m_layers.end(); ++i )
1252  {
1253  VIEW_LAYER* l = &( ( *i ).second );
1254 
1255  if( IsCached( l->id ) )
1256  {
1257  recacheItem visitor( this, m_gal, l->id );
1258  l->items->Query( r, visitor );
1259  }
1260  }
1261 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void SetMaximum()
Definition: box2.h:61
LAYER_MAP::iterator LAYER_MAP_ITER
Definition: view.h:650
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::Redraw ( )

Function Redraw() Immediately redraws the whole view.

Definition at line 1004 of file view.cpp.

References KIGFX::GAL::GetScreenPixelSize(), m_gal, markTargetClean(), PROF_COUNTER::msecs(), BOX2< Vec >::Normalize(), redrawRect(), PROF_COUNTER::Stop(), KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, KIGFX::TARGET_OVERLAY, and ToWorld().

Referenced by EDA_DRAW_PANEL_GAL::onPaint().

1005 {
1006 #ifdef __WXDEBUG__
1007  PROF_COUNTER totalRealTime;
1008 #endif /* __WXDEBUG__ */
1009 
1010  VECTOR2D screenSize = m_gal->GetScreenPixelSize();
1011  BOX2I rect( ToWorld( VECTOR2D( 0, 0 ) ),
1012  ToWorld( screenSize ) - ToWorld( VECTOR2D( 0, 0 ) ) );
1013  rect.Normalize();
1014 
1015  redrawRect( rect );
1016 
1017  // All targets were redrawn, so nothing is dirty
1021 
1022 #ifdef __WXDEBUG__
1023  totalRealTime.Stop();
1024  wxLogTrace( "GAL_PROFILE", wxT( "VIEW::Redraw(): %.1f ms" ), totalRealTime.msecs() );
1025 #endif /* __WXDEBUG__ */
1026 }
void Stop()
save the time when this function was called, and set the counter stane to stop
Definition: profile.h:82
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates...
Definition: view.cpp:440
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
Auxiliary rendering target (noncached)
Definition: definitions.h:42
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
Items that may change while the view stays the same (noncached)
Definition: definitions.h:43
void markTargetClean(int aTarget)
Definition: view.h:667
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
double msecs() const
Definition: profile.h:124
void redrawRect(const BOX2I &aRect)
Definition: view.cpp:859
Main rendering target (cached)
Definition: definitions.h:41
void KIGFX::VIEW::redrawRect ( const BOX2I aRect)
private
  • Redraws contents within rect aRect

Definition at line 859 of file view.cpp.

References areRequiredLayersEnabled(), KIGFX::VIEW::drawItem::deferredDraw(), IsTargetDirty(), m_gal, m_orderedLayers, m_useDrawPriority, KIGFX::GAL::SetLayerDepth(), and KIGFX::GAL::SetTarget().

Referenced by Redraw().

860 {
861  for( VIEW_LAYER* l : m_orderedLayers )
862  {
863  if( l->visible && IsTargetDirty( l->target ) && areRequiredLayersEnabled( l->id ) )
864  {
865  drawItem drawFunc( this, l->id, m_useDrawPriority );
866 
867  m_gal->SetTarget( l->target );
868  m_gal->SetLayerDepth( l->renderingOrder );
869  l->items->Query( aRect, drawFunc );
870 
871  if( m_useDrawPriority )
872  drawFunc.deferredDraw();
873  }
874  }
875 }
bool m_useDrawPriority
Flag to respect draw priority when drawing items.
Definition: view.h:795
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
bool IsTargetDirty(int aTarget) const
Function IsTargetDirty() Returns true if any of layers belonging to the target or the target itself s...
Definition: view.h:556
LAYER_ORDER m_orderedLayers
Sorted list of pointers to members of m_layers.
Definition: view.h:749
bool areRequiredLayersEnabled(int aLayerId) const
Checks if every layer required by the aLayerId layer is enabled.
Definition: view.cpp:1227
virtual void SetTarget(RENDER_TARGET aTarget)
Sets the target for rendering.
void KIGFX::VIEW::Remove ( VIEW_ITEM aItem)

Function Remove() Removes a VIEW_ITEM from the view.

Parameters
aItemitem to be removed. Caller must dispose the removed item if necessary

Definition at line 341 of file view.cpp.

References KIGFX::GAL::DeleteGroup(), KIGFX::VIEW::VIEW_LAYER::items, m_allItems, m_gal, m_layers, MarkTargetDirty(), KIGFX::VIEW_RTREE::Remove(), KIGFX::VIEW::VIEW_LAYER::target, VIEW_MAX_LAYERS, and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by SELECTION_TOOL::disambiguationMenu(), PCB_TOOL::doInteractiveItemPlacement(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), EDIT_TOOL::MeasureTool(), OnDestroy(), POINT_EDITOR::OnSelectionChange(), MODULE_EDITOR_TOOLS::PasteItems(), DRAWING_TOOL::PlaceDXF(), PCB_EDITOR_CONTROL::PlaceModule(), PCB_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), BOARD_COMMIT::Push(), PCB_BASE_EDIT_FRAME::PutDataInPreviousState(), PCB_EDIT_FRAME::ReadPcbNetlist(), PCB_EDITOR_CONTROL::Reset(), PCBNEW_CONTROL::Reset(), SELECTION_TOOL::Reset(), BOARD_COMMIT::Revert(), SELECTION_TOOL::selectMultiple(), POINT_EDITOR::updatePoints(), SELECTION_TOOL::~SELECTION_TOOL(), and ZONE_CREATE_HELPER::~ZONE_CREATE_HELPER().

342 {
343  if( !aItem )
344  return;
345 
346  auto viewData = aItem->viewPrivData();
347 
348  if( !viewData )
349  return;
350 
351  wxASSERT( viewData->m_view == this );
352  auto item = std::find( m_allItems.begin(), m_allItems.end(), aItem );
353 
354  if( item != m_allItems.end() )
355  {
356  m_allItems.erase( item );
357  viewData->clearUpdateFlags();
358  }
359 
360  int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
361  viewData->getLayers( layers, layers_count );
362 
363  for( int i = 0; i < layers_count; ++i )
364  {
365  VIEW_LAYER& l = m_layers[layers[i]];
366  l.items->Remove( aItem );
367  MarkTargetDirty( l.target );
368 
369  // Clear the GAL cache
370  int prevGroup = viewData->getGroup( layers[i] );
371 
372  if( prevGroup >= 0 )
373  m_gal->DeleteGroup( prevGroup );
374  }
375 
376  viewData->deleteGroups();
377  viewData->m_view = nullptr;
378 }
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
std::vector< VIEW_ITEM * > m_allItems
Flat list of all items.
Definition: view.h:792
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetBoundary ( const BOX2I aBoundary)
inline

Function SetBoundary() Sets limits for view area.

Parameters
aBoundaryis the box that limits view area.

Definition at line 275 of file view.h.

References m_boundary.

276  {
277  m_boundary = aBoundary;
278  }
BOX2I m_boundary
View boundaries.
Definition: view.h:761
void KIGFX::VIEW::SetCenter ( const VECTOR2D aCenter)

Function SetCenter() Sets the center point of the VIEW (i.e.

the point in world space that will be drawn in the middle of the screen).

Parameters
aCenterthe new center point, in world space coordinates.

Definition at line 564 of file view.cpp.

References KIGFX::GAL::ComputeWorldScreenMatrix(), BOX2< Vec >::Contains(), BOX2< Vec >::GetBottom(), BOX2< Vec >::GetLeft(), BOX2< Vec >::GetRight(), BOX2< Vec >::GetTop(), m_boundary, m_center, m_gal, MarkDirty(), KIGFX::GAL::SetLookAtPoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by KIGFX::WX_VIEW_CONTROLS::CenterOnCursor(), PCB_EDITOR_CONTROL::CrossProbeSchToPcb(), DIALOG_DRC_CONTROL::OnLeftDClickClearance(), DIALOG_DRC_CONTROL::OnLeftDClickUnconnected(), DIALOG_DRC_CONTROL::OnMarkerSelectionEvent(), KIGFX::WX_VIEW_CONTROLS::onMotion(), DIALOG_DRC_CONTROL::OnPopupMenu(), KIGFX::WX_VIEW_CONTROLS::onScroll(), KIGFX::WX_VIEW_CONTROLS::onTimer(), DIALOG_DRC_CONTROL::OnUnconnectedSelectionEvent(), KIGFX::WX_VIEW_CONTROLS::onWheel(), SetGAL(), SetScale(), SetViewport(), EDA_DRAW_FRAME::UseGalCanvas(), KIGFX::WX_VIEW_CONTROLS::WarpCursor(), COMMON_TOOLS::ZoomFitScreen(), and SELECTION_TOOL::zoomFitSelection().

565 {
566  m_center = aCenter;
567 
568  if( !m_boundary.Contains( aCenter ) )
569  {
570  if( m_center.x < m_boundary.GetLeft() )
572  else if( aCenter.x > m_boundary.GetRight() )
574 
575  if( m_center.y < m_boundary.GetTop() )
577  else if( m_center.y > m_boundary.GetBottom() )
579  }
580 
583 
584  // Redraw everything after the viewport has changed
585  MarkDirty();
586 }
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:139
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
coord_type GetRight() const
Definition: box2.h:187
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
coord_type GetTop() const
Definition: box2.h:192
VECTOR2D m_center
Center point of the VIEW (the point at which we are looking at)
Definition: view.h:755
BOX2I m_boundary
View boundaries.
Definition: view.h:761
coord_type GetBottom() const
Definition: box2.h:188
void SetLookAtPoint(const VECTOR2D &aPoint)
Set the Point in world space to look at.
coord_type GetLeft() const
Definition: box2.h:191
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::SetGAL ( GAL aGal)

Function SetGAL() Assigns a rendering device for the VIEW.

Parameters
aGalpointer to the GAL output device

Definition at line 484 of file view.cpp.

References clearGroupCache(), m_center, m_gal, m_mirrorX, m_mirrorY, m_scale, MarkDirty(), SetCenter(), SetMirror(), and SetScale().

Referenced by EDA_DRAW_PANEL_GAL::EDA_DRAW_PANEL_GAL(), and EDA_DRAW_PANEL_GAL::SwitchBackend().

485 {
486  m_gal = aGal;
487 
488  // clear group numbers, so everything is going to be recached
489  clearGroupCache();
490 
491  // every target has to be refreshed
492  MarkDirty();
493 
494  // force the new GAL to display the current viewport.
495  SetCenter( m_center );
496  SetScale( m_scale );
498 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void SetMirror(bool aMirrorX, bool aMirrorY)
Function SetMirror() Controls the mirroring of the VIEW.
Definition: view.cpp:528
void SetScale(double aScale)
Function SetScale() Sets the scaling factor.
Definition: view.h:247
VECTOR2D m_center
Center point of the VIEW (the point at which we are looking at)
Definition: view.h:755
void SetCenter(const VECTOR2D &aCenter)
Function SetCenter() Sets the center point of the VIEW (i.e.
Definition: view.cpp:564
bool m_mirrorX
Horizontal flip flag
Definition: view.h:770
void clearGroupCache()
Definition: view.cpp:1053
bool m_mirrorY
Vertical flip flag
Definition: view.h:773
double m_scale
Scale of displayed VIEW_ITEMs.
Definition: view.h:758
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::SetLayerDisplayOnly ( int  aLayer,
bool  aDisplayOnly = true 
)
inline

Definition at line 411 of file view.h.

References m_layers.

Referenced by PCB_DRAW_PANEL_GAL::setDefaultLayerDeps().

412  {
413  wxASSERT( aLayer < (int) m_layers.size() );
414 
415  m_layers[aLayer].displayOnly = aDisplayOnly;
416  }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetLayerOrder ( int  aLayer,
int  aRenderingOrder 
)

Function SetLayerOrder() Sets rendering order of a particular layer.

Lower values are rendered first.

Parameters
aLayerthe layer
aRenderingOrderarbitrary number denoting the rendering order.

Definition at line 589 of file view.cpp.

References m_layers, and sortLayers().

Referenced by PCB_DRAW_PANEL_GAL::setDefaultLayerOrder(), and PCB_DRAW_PANEL_GAL::SetTopLayer().

590 {
591  m_layers[aLayer].renderingOrder = aRenderingOrder;
592 
593  sortLayers();
594 }
void sortLayers()
Definition: view.cpp:1104
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetLayerTarget ( int  aLayer,
RENDER_TARGET  aTarget 
)
inline

Function SetLayerTarget() Changes the rendering target for a particular layer.

Parameters
aLayeris the layer.
aTargetis the rendering target.

Definition at line 424 of file view.h.

References m_layers.

Referenced by PCB_DRAW_PANEL_GAL::setDefaultLayerDeps().

425  {
426  wxASSERT( aLayer < (int) m_layers.size() );
427 
428  m_layers[aLayer].target = aTarget;
429  }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetLayerVisible ( int  aLayer,
bool  aVisible = true 
)
inline

Function SetLayerVisible() Controls the visibility of a particular layer.

Parameters
aLayerthe layer to show/hide.
aVisiblethe obvious.

Definition at line 387 of file view.h.

References m_layers, and MarkTargetDirty().

Referenced by PCB_LAYER_WIDGET::OnLayerVisible(), PCB_LAYER_WIDGET::OnRenderEnable(), FOOTPRINT_EDIT_FRAME::SetElementVisibility(), and PCB_DRAW_PANEL_GAL::SyncLayersVisibility().

388  {
389  wxASSERT( aLayer < (int) m_layers.size() );
390 
391  if( m_layers[aLayer].visible != aVisible )
392  {
393  // Target has to be redrawn after changing its visibility
394  MarkTargetDirty( m_layers[aLayer].target );
395  m_layers[aLayer].visible = aVisible;
396  }
397  }
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetMirror ( bool  aMirrorX,
bool  aMirrorY 
)

Function SetMirror() Controls the mirroring of the VIEW.

Parameters
aMirrorXwhen true, the X axis is mirrored
aMirrorYwhen true, the Y axis is mirrored.

Definition at line 528 of file view.cpp.

References m_gal, m_mirrorX, m_mirrorY, MarkDirty(), and KIGFX::GAL::SetFlip().

Referenced by SetGAL().

529 {
530  wxASSERT_MSG( !aMirrorY, _( "Mirroring for Y axis is not supported yet" ) );
531 
532  m_mirrorX = aMirrorX;
533  m_mirrorY = aMirrorY;
534  m_gal->SetFlip( aMirrorX, aMirrorY );
535 
536  // Redraw everything
537  MarkDirty();
538 }
void SetFlip(bool xAxis, bool yAxis)
Sets flipping of the screen.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
bool m_mirrorX
Horizontal flip flag
Definition: view.h:770
bool m_mirrorY
Vertical flip flag
Definition: view.h:773
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::SetPainter ( PAINTER aPainter)
inline

Function SetPainter() Sets the painter object used by the view for drawing VIEW_ITEMS.

Definition at line 186 of file view.h.

References m_painter.

Referenced by PCB_DRAW_PANEL_GAL::PCB_DRAW_PANEL_GAL().

187  {
188  m_painter = aPainter;
189  }
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
void KIGFX::VIEW::SetRequired ( int  aLayerId,
int  aRequiredId,
bool  aRequired = true 
)

Function SetRequired() Marks the aRequiredId layer as required for the aLayerId layer.

In order to display the layer, all of its required layers have to be enabled.

Parameters
aLayerIdis the id of the layer for which we enable/disable the required layer.
aRequiredIdis the id of the required layer.
aRequiredtells if the required layer should be added or removed from the list.

Definition at line 381 of file view.cpp.

References m_layers.

Referenced by PCB_DRAW_PANEL_GAL::setDefaultLayerDeps().

382 {
383  wxASSERT( (unsigned) aLayerId < m_layers.size() );
384  wxASSERT( (unsigned) aRequiredId < m_layers.size() );
385 
386  if( aRequired )
387  m_layers[aLayerId].requiredLayers.insert( aRequiredId );
388  else
389  m_layers[aLayerId].requiredLayers.erase( aRequired );
390 }
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetScale ( double  aScale)
inline

Function SetScale() Sets the scaling factor.

Scale = 1 corresponds to the real world size of the objects (depending on correct GAL unit length & DPI settings).

Parameters
aScalethe scalefactor

Definition at line 247 of file view.h.

References m_center.

Referenced by KIGFX::WX_VIEW_CONTROLS::onWheel(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), SetGAL(), SetViewport(), EDA_DRAW_FRAME::UseGalCanvas(), COMMON_TOOLS::ZoomFitScreen(), SELECTION_TOOL::zoomFitSelection(), COMMON_TOOLS::ZoomInOut(), COMMON_TOOLS::ZoomInOutCenter(), and COMMON_TOOLS::ZoomPreset().

248  {
249  SetScale( aScale, m_center );
250  }
void SetScale(double aScale)
Function SetScale() Sets the scaling factor.
Definition: view.h:247
VECTOR2D m_center
Center point of the VIEW (the point at which we are looking at)
Definition: view.h:755
void KIGFX::VIEW::SetScale ( double  aScale,
const VECTOR2D aAnchor 
)

Function SetScale() Sets the scaling factor, zooming around a given anchor point.

(depending on correct GAL unit length & DPI settings).

Parameters
aAnchorthe zooming anchor point
aScalethe scale factor

Definition at line 541 of file view.cpp.

References KIGFX::GAL::ComputeWorldScreenMatrix(), delta, m_center, m_gal, m_maxScale, m_minScale, m_scale, MarkDirty(), SetCenter(), KIGFX::GAL::SetZoomFactor(), ToScreen(), and ToWorld().

542 {
543  VECTOR2D a = ToScreen( aAnchor );
544 
545  if( aScale < m_minScale )
547  else if( aScale > m_maxScale )
549  else
550  m_scale = aScale;
551 
554 
555  VECTOR2D delta = ToWorld( a ) - aAnchor;
556 
557  SetCenter( m_center - delta );
558 
559  // Redraw everything after the viewport has changed
560  MarkDirty();
561 }
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates...
Definition: view.cpp:440
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
static const int delta[8][2]
Definition: solve.cpp:112
VECTOR2D m_center
Center point of the VIEW (the point at which we are looking at)
Definition: view.h:755
double m_minScale
Scale lower limit.
Definition: view.h:764
void SetCenter(const VECTOR2D &aCenter)
Function SetCenter() Sets the center point of the VIEW (i.e.
Definition: view.cpp:564
double m_maxScale
Scale upper limit.
Definition: view.h:767
VECTOR2D ToScreen(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToScreen() Converts a world space point/vector to a point/vector in screen space coordinates...
Definition: view.cpp:459
void SetZoomFactor(double aZoomFactor)
Set the zoom factor of the scene.
double m_scale
Scale of displayed VIEW_ITEMs.
Definition: view.h:758
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::SetScaleLimits ( double  aMaximum,
double  aMinimum 
)
inline

Function SetScaleLimits() Sets minimum and maximum values for scale.

Parameters
aMaximumis the maximum value for scale.
aMinimumis the minimum value for scale.

Definition at line 295 of file view.h.

References m_maxScale, and m_minScale.

296  {
297  wxASSERT_MSG( aMaximum > aMinimum, wxT( "I guess you passed parameters in wrong order" ) );
298 
299  m_minScale = aMinimum;
300  m_maxScale = aMaximum;
301  }
double m_minScale
Scale lower limit.
Definition: view.h:764
double m_maxScale
Scale upper limit.
Definition: view.h:767
void KIGFX::VIEW::SetTopLayer ( int  aLayer,
bool  aEnabled = true 
)

Function SetTopLayer() Sets given layer to be displayed on the top or sets back the default order of layers.

Parameters
aEnabled= true to display aLayer on the top.
aLayerthe layer or -1 in case when no particular layer should be displayed on the top.

Definition at line 729 of file view.cpp.

References m_enableOrderModifier, m_layers, m_topLayers, and TOP_LAYER_MODIFIER.

Referenced by PCB_DRAW_PANEL_GAL::SetTopLayer(), and EDA_DRAW_PANEL_GAL::SetTopLayer().

730 {
731  if( aEnabled )
732  {
733  if( m_topLayers.count( aLayer ) == 1 )
734  return;
735 
736  m_topLayers.insert( aLayer );
737 
738  // Move the layer closer to front
740  m_layers[aLayer].renderingOrder += TOP_LAYER_MODIFIER;
741  }
742  else
743  {
744  if( m_topLayers.count( aLayer ) == 0 )
745  return;
746 
747  m_topLayers.erase( aLayer );
748 
749  // Restore the previous rendering order
751  m_layers[aLayer].renderingOrder -= TOP_LAYER_MODIFIER;
752  }
753 }
static const int TOP_LAYER_MODIFIER
Rendering order modifier for layers that are marked as top layers.
Definition: view.h:789
std::set< unsigned int > m_topLayers
Stores set of layers that are displayed on the top.
Definition: view.h:752
bool m_enableOrderModifier
Definition: view.h:743
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::SetViewport ( const BOX2D aViewport)

Function SetViewport() Sets the visible area of the VIEW.

Parameters
aViewportdesired visible area, in world space coordinates.

Definition at line 513 of file view.cpp.

References BOX2< Vec >::Centre(), GetScale(), KIGFX::GAL::GetScreenPixelSize(), BOX2< Vec >::GetSize(), m_gal, max, SetCenter(), SetScale(), ToWorld(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SELECTION_TOOL::findCallback(), and FOOTPRINT_PREVIEW_PANEL::renderFootprint().

514 {
515  VECTOR2D ssize = ToWorld( m_gal->GetScreenPixelSize(), false );
516 
517  wxASSERT( ssize.x > 0 && ssize.y > 0 );
518 
519  VECTOR2D centre = aViewport.Centre();
520  VECTOR2D vsize = aViewport.GetSize();
521  double zoom = 1.0 / std::max( fabs( vsize.x / ssize.x ), fabs( vsize.y / ssize.y ) );
522 
523  SetCenter( centre );
524  SetScale( GetScale() * zoom );
525 }
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates...
Definition: view.cpp:440
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
const Vec & GetSize() const
Definition: box2.h:177
void SetScale(double aScale)
Function SetScale() Sets the scaling factor.
Definition: view.h:247
void SetCenter(const VECTOR2D &aCenter)
Function SetCenter() Sets the center point of the VIEW (i.e.
Definition: view.cpp:564
Vec Centre() const
Definition: box2.h:67
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
#define max(a, b)
Definition: auxiliary.h:86
double GetScale() const
Function GetScale()
Definition: view.h:265
void KIGFX::VIEW::SetVisible ( VIEW_ITEM aItem,
bool  aIsVisible = true 
)

Sets the item visibility.

Parameters
aItemthe item to modify.
aIsVisiblewhether the item is visible (on all layers), or not.

Definition at line 1323 of file view.cpp.

References KIGFX::APPEARANCE, KIGFX::COLOR, KIGFX::VIEW_ITEM_DATA::m_flags, Update(), KIGFX::VIEW_ITEM::viewPrivData(), and KIGFX::VISIBLE.

Referenced by Add(), GRID_HELPER::BestSnapAnchor(), SELECTION_TOOL::disambiguationMenu(), MICROWAVE_TOOL::drawMicrowaveInductor(), PNS_KICAD_IFACE::EraseView(), GRID_HELPER::GRID_HELPER(), PNS_KICAD_IFACE::HideItem(), EDIT_TOOL::MeasureTool(), ZONE_CREATE_HELPER::OnComplete(), ZONE_CREATE_HELPER::OnFirstPoint(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), SELECTION_TOOL::selectMultiple(), GRID_HELPER::SetAuxAxes(), and ZONE_CREATE_HELPER::~ZONE_CREATE_HELPER().

1324 {
1325  auto viewData = aItem->viewPrivData();
1326 
1327  if( !viewData )
1328  return;
1329 
1330  bool cur_visible = viewData->m_flags & VISIBLE;
1331 
1332  if( cur_visible != aIsVisible )
1333  {
1334  if( aIsVisible )
1335  viewData->m_flags |= VISIBLE;
1336  else
1337  viewData->m_flags &= ~VISIBLE;
1338 
1339  Update( aItem, APPEARANCE | COLOR );
1340  }
1341 }
No updates are required.
Definition: view_item.h:55
Visibility flag has changed.
Definition: view_item.h:56
void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1377
void KIGFX::VIEW::SortLayers ( int  aLayers[],
int &  aCount 
) const

Function SortLayers() Changes the order of given layer ids, so after sorting the order corresponds to layers rendering order (descending, ie.

order in which layers should be drawn - from the bottom to the top).

Parameters
aLayersstores id of layers to be sorted.
aCountstores the number of layers.

Definition at line 603 of file view.cpp.

References GetLayerOrder().

Referenced by draw(), and KIGFX::VIEW_GROUP::ViewDraw().

604 {
605  int maxLay, maxOrd, maxIdx;
606 
607  for( int i = 0; i < aCount; ++i )
608  {
609  maxLay = aLayers[i];
610  maxOrd = GetLayerOrder( maxLay );
611  maxIdx = i;
612 
613  // Look for the max element in the range (j..aCount)
614  for( int j = i; j < aCount; ++j )
615  {
616  if( maxOrd < GetLayerOrder( aLayers[j] ) )
617  {
618  maxLay = aLayers[j];
619  maxOrd = GetLayerOrder( maxLay );
620  maxIdx = j;
621  }
622  }
623 
624  // Swap elements
625  aLayers[maxIdx] = aLayers[i];
626  aLayers[i] = maxLay;
627  }
628 }
int GetLayerOrder(int aLayer) const
Function GetLayerOrder() Returns rendering order of a particular layer.
Definition: view.cpp:597
void KIGFX::VIEW::sortLayers ( )
private
  • Sorts m_orderedLayers when layer rendering order has changed

Definition at line 1104 of file view.cpp.

References compareRenderingOrder(), m_layers, m_orderedLayers, and MarkDirty().

Referenced by AddLayer(), SetLayerOrder(), and UpdateAllLayersOrder().

1105 {
1106  int n = 0;
1107 
1108  m_orderedLayers.resize( m_layers.size() );
1109 
1110  for( LAYER_MAP_ITER i = m_layers.begin(); i != m_layers.end(); ++i )
1111  m_orderedLayers[n++] = &i->second;
1112 
1113  sort( m_orderedLayers.begin(), m_orderedLayers.end(), compareRenderingOrder );
1114 
1115  MarkDirty();
1116 }
LAYER_ORDER m_orderedLayers
Sorted list of pointers to members of m_layers.
Definition: view.h:749
LAYER_MAP::iterator LAYER_MAP_ITER
Definition: view.h:650
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
static bool compareRenderingOrder(VIEW_LAYER *aI, VIEW_LAYER *aJ)
Determines rendering order of layers. Used in display order sorting function.
Definition: view.h:734
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
VECTOR2D KIGFX::VIEW::ToScreen ( const VECTOR2D aCoord,
bool  aAbsolute = true 
) const

Function ToScreen() Converts a world space point/vector to a point/vector in screen space coordinates.

Parameters
aCoordthe point/vector to be converted
aAbsolutewhen true, aCoord is treated as a point, otherwise - as a direction (vector)

Definition at line 459 of file view.cpp.

References MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetWorldScreenMatrix(), m_gal, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by TOOL_DISPATCHER::handleMouseButton(), SetScale(), and KIGFX::WX_VIEW_CONTROLS::WarpCursor().

460 {
461  const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
462 
463  if( aAbsolute )
464  return VECTOR2D( matrix * aCoord );
465  else
466  return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
467 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:269
double KIGFX::VIEW::ToScreen ( double  aSize) const

Function ToScreen() Converts a world space one dimensionsal size to a one dimensional size in screen space.

Parameters
aSizethe size to be transformed.

Definition at line 470 of file view.cpp.

References MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetWorldScreenMatrix(), m_gal, and VECTOR2< T >::x.

471 {
472  const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
473 
474  return matrix.GetScale().x * aSize;
475 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:269
VECTOR2D KIGFX::VIEW::ToWorld ( const VECTOR2D aCoord,
bool  aAbsolute = true 
) const

Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates.

Parameters
aCoordthe point/vector to be converted
aAbsolutewhen true, aCoord is treated as a point, otherwise - as a direction (vector)

Definition at line 440 of file view.cpp.

References MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetScreenWorldMatrix(), m_gal, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by EDIT_POINTS::FindPoint(), KIGFX::WX_VIEW_CONTROLS::GetMousePosition(), GetViewport(), KIGFX::WX_VIEW_CONTROLS::onMotion(), KIGFX::WX_VIEW_CONTROLS::onScroll(), KIGFX::WX_VIEW_CONTROLS::onTimer(), KIGFX::WX_VIEW_CONTROLS::onWheel(), Redraw(), SELECTION_TOOL::selectionContains(), SetScale(), SetViewport(), KIGFX::ORIGIN_VIEWITEM::ViewDraw(), EDIT_POINTS::ViewDraw(), COMMON_TOOLS::ZoomFitScreen(), and SELECTION_TOOL::zoomFitSelection().

441 {
442  const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
443 
444  if( aAbsolute )
445  return VECTOR2D( matrix * aCoord );
446  else
447  return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
448 }
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:269
double KIGFX::VIEW::ToWorld ( double  aSize) const

Function ToWorld() Converts a screen space one dimensional size to a one dimensional size in world space coordinates.

Parameters
aSize: the size to be converted

Definition at line 451 of file view.cpp.

References MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetScreenWorldMatrix(), m_gal, and VECTOR2< T >::x.

452 {
453  const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
454 
455  return matrix.GetScale().x * aSize;
456 }
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:269
void KIGFX::VIEW::Update ( VIEW_ITEM aItem,
int  aUpdateFlags 
)

For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has changed.

For static views calling has no effect.

Parameters
aItemthe item to update.
aUpdateFlagshow much the object has changed.

Definition at line 1377 of file view.cpp.

References KIGFX::NONE, and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by Add(), PNS_PCBNEW_DEBUG_DECORATOR::AddLine(), PNS_PCBNEW_DEBUG_DECORATOR::Clear(), SELECTION_TOOL::disambiguationMenu(), PNS_KICAD_IFACE::DisplayItem(), PCB_TOOL::doInteractiveItemPlacement(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), PCB_EDIT_FRAME::Edit_Zone_Params(), MODULE_EDITOR_TOOLS::EnumeratePads(), PNS_KICAD_IFACE::EraseView(), Hide(), PNS_KICAD_IFACE::HideItem(), EDIT_TOOL::MeasureTool(), MODULE_EDITOR_TOOLS::ModuleEdgeOutlines(), MODULE_EDITOR_TOOLS::ModuleTextOutlines(), EDIT_TOOL::MoveExact(), ZONE_CREATE_HELPER::OnGeometryChange(), DIALOG_GLOBAL_EDIT_TRACKS_AND_VIAS::OnOkClick(), KIGFX::VIEW::recacheItem::operator()(), PCBNEW_CONTROL::PadDisplayMode(), MODULE_EDITOR_TOOLS::PasteItems(), DRAWING_TOOL::PlaceDXF(), PCB_EDITOR_CONTROL::PlaceModule(), PCB_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), PCB_EDIT_FRAME::Process_Config(), BOARD_COMMIT::Push(), PCB_BASE_EDIT_FRAME::PutDataInPreviousState(), PCB_DRAW_PANEL_GAL::RedrawRatsnest(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectVisually(), SetVisible(), PCBNEW_CONTROL::TrackDisplayMode(), SELECTION_TOOL::unselectVisually(), Update(), POINT_EDITOR::updatePoints(), SELECTION_TOOL::updateSelection(), PCBNEW_CONTROL::ViaDisplayMode(), and PCBNEW_CONTROL::ZoneDisplayMode().

1378 {
1379  auto viewData = aItem->viewPrivData();
1380 
1381  if( !viewData )
1382  return;
1383 
1384  assert( aUpdateFlags != NONE );
1385 
1386  viewData->m_requiredUpdate |= aUpdateFlags;
1387 
1388 }
void KIGFX::VIEW::Update ( VIEW_ITEM aItem)

Definition at line 1371 of file view.cpp.

References KIGFX::ALL, and Update().

1372 {
1373  Update( aItem, ALL );
1374 }
Layers have changed.
Definition: view_item.h:59
void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1377
void KIGFX::VIEW::UpdateAllLayersColor ( )

Function UpdateAllLayersColor() Applies the new coloring scheme to all layers.

The used scheme is held by RENDER_SETTINGS.

See also
RENDER_SETTINGS

Definition at line 674 of file view.cpp.

References KIGFX::GAL::BeginUpdate(), KIGFX::GAL::EndUpdate(), KIGFX::VIEW::VIEW_LAYER::id, IsCached(), KIGFX::VIEW::VIEW_LAYER::items, m_gal, m_layers, m_painter, MarkDirty(), KIGFX::VIEW_RTREE::Query(), and BOX2< Vec >::SetMaximum().

Referenced by EnableTopLayer(), PNS::TOOL_BASE::highlightNet(), PCB_EDITOR_CONTROL::HighlightNet(), highlightNet(), PCB_EDIT_FRAME::ListNetsAndSelect(), PCB_DRAW_PANEL_GAL::SetHighContrastLayer(), and EDA_DRAW_PANEL_GAL::SetHighContrastLayer().

675 {
676  BOX2I r;
677 
678  r.SetMaximum();
679  m_gal->BeginUpdate();
680 
681  for( LAYER_MAP_ITER i = m_layers.begin(); i != m_layers.end(); ++i )
682  {
683  VIEW_LAYER* l = &( ( *i ).second );
684 
685  // There is no point in updating non-cached layers
686  if( !IsCached( l->id ) )
687  continue;
688 
689  updateItemsColor visitor( l->id, m_painter, m_gal );
690  l->items->Query( r, visitor );
691  }
692 
693  m_gal->EndUpdate();
694  MarkDirty();
695 }
virtual void EndUpdate()
Disables item update mode.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void SetMaximum()
Definition: box2.h:61
virtual void BeginUpdate()
Enables item update mode.
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
LAYER_MAP::iterator LAYER_MAP_ITER
Definition: view.h:650
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::UpdateAllLayersOrder ( )

Function UpdateLayerOrder() Does everything that is needed to apply the rendering order of layers.

It has to be called after modification of renderingOrder field of LAYER.

Definition at line 796 of file view.cpp.

References KIGFX::GAL::BeginUpdate(), KIGFX::GAL::EndUpdate(), m_gal, m_layers, MarkDirty(), BOX2< Vec >::SetMaximum(), and sortLayers().

Referenced by EnableTopLayer(), PCB_DRAW_PANEL_GAL::SetTopLayer(), and EDA_DRAW_PANEL_GAL::SetTopLayer().

797 {
798  BOX2I r;
799  r.SetMaximum();
800 
801  sortLayers();
802  m_gal->BeginUpdate();
803 
804  for( LAYER_MAP::value_type& l : m_layers )
805  {
806  int layer = l.first;
807  changeItemsDepth visitor( layer, l.second.renderingOrder, m_gal );
808  m_layers[layer].items->Query( r, visitor );
809  }
810 
811  m_gal->EndUpdate();
812  MarkDirty();
813 }
void sortLayers()
Definition: view.cpp:1104
virtual void EndUpdate()
Disables item update mode.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void SetMaximum()
Definition: box2.h:61
virtual void BeginUpdate()
Enables item update mode.
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void MarkDirty()
Function MarkDirty() Forces redraw of view on the next rendering.
Definition: view.h:594
void KIGFX::VIEW::updateBbox ( VIEW_ITEM aItem)
private

Updates bounding box of an item.

Definition at line 1168 of file view.cpp.

References KIGFX::VIEW_RTREE::Insert(), KIGFX::VIEW::VIEW_LAYER::items, m_layers, MarkTargetDirty(), KIGFX::VIEW_RTREE::Remove(), KIGFX::VIEW::VIEW_LAYER::target, VIEW_MAX_LAYERS, and KIGFX::VIEW_ITEM::ViewGetLayers().

Referenced by invalidateItem().

1169 {
1170  int layers[VIEW_MAX_LAYERS], layers_count;
1171 
1172  aItem->ViewGetLayers( layers, layers_count );
1173 
1174  for( int i = 0; i < layers_count; ++i )
1175  {
1176  VIEW_LAYER& l = m_layers[layers[i]];
1177  l.items->Remove( aItem );
1178  l.items->Insert( aItem );
1179  MarkTargetDirty( l.target );
1180  }
1181 }
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::updateItemColor ( VIEW_ITEM aItem,
int  aLayer 
)
private

Updates colors that are used for an item to be drawn.

Definition at line 1119 of file view.cpp.

References KIGFX::GAL::ChangeGroupColor(), color, KIGFX::RENDER_SETTINGS::GetColor(), KIGFX::PAINTER::GetSettings(), IsCached(), m_gal, m_layers, m_painter, and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by invalidateItem().

1120 {
1121  auto viewData = aItem->viewPrivData();
1122  wxASSERT( (unsigned) aLayer < m_layers.size() );
1123  wxASSERT( IsCached( aLayer ) );
1124 
1125  if( !viewData )
1126  return;
1127 
1128  // Obtain the color that should be used for coloring the item on the specific layerId
1129  const COLOR4D color = m_painter->GetSettings()->GetColor( aItem, aLayer );
1130  int group = viewData->getGroup( aLayer );
1131 
1132  // Change the color, only if it has group assigned
1133  if( group >= 0 )
1134  m_gal->ChangeGroupColor( group, color );
1135 }
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual const COLOR4D & GetColor(const VIEW_ITEM *aItem, int aLayer) const =0
Function GetColor Returns the color that should be used to draw the specific VIEW_ITEM on the specifi...
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor)
Changes the color used to draw the group.
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
virtual RENDER_SETTINGS * GetSettings()=0
Function GetSettings Returns pointer to current settings that are going to be used when drawing items...
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void KIGFX::VIEW::updateItemGeometry ( VIEW_ITEM aItem,
int  aLayer 
)
private

Updates all informations needed to draw an item.

Definition at line 1138 of file view.cpp.

References KIGFX::GAL::BeginGroup(), KIGFX::GAL::DeleteGroup(), KIGFX::PAINTER::Draw(), KIGFX::GAL::EndGroup(), IsCached(), m_gal, m_layers, m_painter, KIGFX::VIEW::VIEW_LAYER::renderingOrder, KIGFX::GAL::SetLayerDepth(), KIGFX::GAL::SetTarget(), KIGFX::VIEW::VIEW_LAYER::target, KIGFX::VIEW_ITEM::ViewDraw(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by invalidateItem().

1139 {
1140  auto viewData = aItem->viewPrivData();
1141  wxASSERT( (unsigned) aLayer < m_layers.size() );
1142  wxASSERT( IsCached( aLayer ) );
1143 
1144  if( !viewData )
1145  return;
1146 
1147  VIEW_LAYER& l = m_layers.at( aLayer );
1148 
1149  m_gal->SetTarget( l.target );
1150  m_gal->SetLayerDepth( l.renderingOrder );
1151 
1152  // Redraw the item from scratch
1153  int group = viewData->getGroup( aLayer );
1154 
1155  if( group >= 0 )
1156  m_gal->DeleteGroup( group );
1157 
1158  group = m_gal->BeginGroup();
1159  viewData->setGroup( aLayer, group );
1160 
1161  if( !m_painter->Draw( static_cast<EDA_ITEM*>( aItem ), aLayer ) )
1162  aItem->ViewDraw( aLayer, this ); // Alternative drawing method
1163 
1164  m_gal->EndGroup();
1165 }
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
virtual void EndGroup()
End the group.
virtual int BeginGroup()
Begin a group.
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
virtual bool Draw(const VIEW_ITEM *aItem, int aLayer)=0
Function Draw Takes an instance of VIEW_ITEM and passes it to a function that know how to draw the it...
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
virtual void SetTarget(RENDER_TARGET aTarget)
Sets the target for rendering.
void KIGFX::VIEW::UpdateItems ( )

Function UpdateItems() Iterates through the list of items that asked for updating and updates them.

Definition at line 1264 of file view.cpp.

References KIGFX::GAL::BeginUpdate(), KIGFX::GAL::EndUpdate(), invalidateItem(), m_allItems, m_gal, and KIGFX::NONE.

Referenced by EDA_DRAW_PANEL_GAL::onPaint().

1265 {
1266  m_gal->BeginUpdate();
1267 
1268  for( VIEW_ITEM* item : m_allItems )
1269  {
1270  auto viewData = item->viewPrivData();
1271 
1272  if( !viewData )
1273  continue;
1274 
1275  if( viewData->m_requiredUpdate != NONE )
1276  {
1277  invalidateItem( item, viewData->m_requiredUpdate );
1278  viewData->m_requiredUpdate = NONE;
1279  }
1280  }
1281 
1282  m_gal->EndUpdate();
1283 }
friend class VIEW_ITEM
Definition: view.h:61
virtual void EndUpdate()
Disables item update mode.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void invalidateItem(VIEW_ITEM *aItem, int aUpdateFlags)
Function invalidateItem() Manages dirty flags & redraw queueing when updating an item.
Definition: view.cpp:1068
virtual void BeginUpdate()
Enables item update mode.
std::vector< VIEW_ITEM * > m_allItems
Flat list of all items.
Definition: view.h:792
void KIGFX::VIEW::UpdateLayerColor ( int  aLayer)

Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it has changed.

Parameters
aLayeris a number of the layer to be updated.
See also
RENDER_SETTINGS

Definition at line 656 of file view.cpp.

References KIGFX::GAL::BeginUpdate(), KIGFX::GAL::EndUpdate(), IsCached(), m_gal, m_layers, m_painter, MarkTargetDirty(), and BOX2< Vec >::SetMaximum().

Referenced by PCBNEW_CONTROL::LayerAlphaDec(), PCBNEW_CONTROL::LayerAlphaInc(), PCB_LAYER_WIDGET::OnLayerColorChange(), and PCB_LAYER_WIDGET::OnRenderColorChange().

657 {
658  // There is no point in updating non-cached layers
659  if( !IsCached( aLayer ) )
660  return;
661 
662  BOX2I r;
663 
664  r.SetMaximum();
665 
666  m_gal->BeginUpdate();
667  updateItemsColor visitor( aLayer, m_painter, m_gal );
668  m_layers[aLayer].items->Query( r, visitor );
669  MarkTargetDirty( m_layers[aLayer].target );
670  m_gal->EndUpdate();
671 }
virtual void EndUpdate()
Disables item update mode.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
void SetMaximum()
Definition: box2.h:61
virtual void BeginUpdate()
Enables item update mode.
PAINTER * m_painter
PAINTER contains information how do draw items.
Definition: view.h:776
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::updateLayers ( VIEW_ITEM aItem)
private

Updates set of layers that an item occupies.

Definition at line 1184 of file view.cpp.

References KIGFX::GAL::DeleteGroup(), KIGFX::VIEW_ITEM_DATA::getLayers(), KIGFX::VIEW::VIEW_LAYER::id, KIGFX::VIEW_RTREE::Insert(), IsCached(), KIGFX::VIEW::VIEW_LAYER::items, m_gal, m_layers, MarkTargetDirty(), KIGFX::VIEW_RTREE::Remove(), KIGFX::VIEW::VIEW_LAYER::target, VIEW_MAX_LAYERS, KIGFX::VIEW_ITEM::ViewGetLayers(), and KIGFX::VIEW_ITEM::viewPrivData().

Referenced by invalidateItem().

1185 {
1186  auto viewData = aItem->viewPrivData();
1187  int layers[VIEW_MAX_LAYERS], layers_count;
1188 
1189  if( !viewData )
1190  return;
1191 
1192  // Remove the item from previous layer set
1193  viewData->getLayers( layers, layers_count );
1194 
1195  for( int i = 0; i < layers_count; ++i )
1196  {
1197  VIEW_LAYER& l = m_layers[layers[i]];
1198  l.items->Remove( aItem );
1199  MarkTargetDirty( l.target );
1200 
1201  if( IsCached( l.id ) )
1202  {
1203  // Redraw the item from scratch
1204  int prevGroup = viewData->getGroup( layers[i] );
1205 
1206  if( prevGroup >= 0 )
1207  {
1208  m_gal->DeleteGroup( prevGroup );
1209  viewData->setGroup( l.id, -1 );
1210  }
1211  }
1212  }
1213 
1214  // Add the item to new layer set
1215  aItem->ViewGetLayers( layers, layers_count );
1216  viewData->saveLayers( layers, layers_count );
1217 
1218  for( int i = 0; i < layers_count; i++ )
1219  {
1220  VIEW_LAYER& l = m_layers[layers[i]];
1221  l.items->Insert( aItem );
1222  MarkTargetDirty( l.target );
1223  }
1224 }
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
GAL * m_gal
Gives interface to PAINTER, that is used to draw items.
Definition: view.h:779
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
static const int VIEW_MAX_LAYERS
maximum number of layers that may be shown
Definition: view.h:633
bool IsCached(int aLayer) const
Returns true if the layer is cached.
Definition: view.h:576
LAYER_MAP m_layers
Contains set of possible displayed layers and its properties.
Definition: view.h:746
void KIGFX::VIEW::UseDrawPriority ( bool  aFlag)
inline

Function UseDrawPriority()

Parameters
aFlagis true if draw priority should be respected while redrawing.

Definition at line 628 of file view.h.

References m_useDrawPriority.

629  {
630  m_useDrawPriority = aFlag;
631  }
bool m_useDrawPriority
Flag to respect draw priority when drawing items.
Definition: view.h:795

Friends And Related Function Documentation

friend class VIEW_ITEM
friend

Definition at line 61 of file view.h.

Member Data Documentation

std::vector<VIEW_ITEM*> KIGFX::VIEW::m_allItems
private

Flat list of all items.

Definition at line 792 of file view.h.

Referenced by Add(), Clear(), Remove(), UpdateItems(), and VIEW().

BOX2I KIGFX::VIEW::m_boundary
private

View boundaries.

Definition at line 761 of file view.h.

Referenced by GetBoundary(), SetBoundary(), SetCenter(), and VIEW().

VECTOR2D KIGFX::VIEW::m_center
private

Center point of the VIEW (the point at which we are looking at)

Definition at line 755 of file view.h.

Referenced by GetCenter(), SetCenter(), SetGAL(), and SetScale().

bool KIGFX::VIEW::m_dirtyTargets[TARGETS_NUMBER]
private

Flags to mark targets as dirty, so they have to be redrawn on the next refresh event.

Definition at line 786 of file view.h.

Referenced by IsTargetDirty(), MarkDirty(), markTargetClean(), and MarkTargetDirty().

bool KIGFX::VIEW::m_dynamic
private

Dynamic VIEW (eg.

display PCB in window) allows changes once it is built, static (eg. image/PDF) - does not.

Definition at line 783 of file view.h.

Referenced by IsDynamic().

bool KIGFX::VIEW::m_enableOrderModifier
private
  • Whether to use rendering order modifier or not

Definition at line 743 of file view.h.

Referenced by ClearTopLayers(), EnableTopLayer(), and SetTopLayer().

double KIGFX::VIEW::m_maxScale
private

Scale upper limit.

Definition at line 767 of file view.h.

Referenced by SetScale(), and SetScaleLimits().

double KIGFX::VIEW::m_minScale
private

Scale lower limit.

Definition at line 764 of file view.h.

Referenced by SetScale(), and SetScaleLimits().

bool KIGFX::VIEW::m_mirrorX
private

Horizontal flip flag

Definition at line 770 of file view.h.

Referenced by IsMirroredX(), SetGAL(), and SetMirror().

bool KIGFX::VIEW::m_mirrorY
private

Vertical flip flag

Definition at line 773 of file view.h.

Referenced by IsMirroredY(), SetGAL(), and SetMirror().

int KIGFX::VIEW::m_nextDrawPriority
private

The next sequential drawing priority.

Definition at line 798 of file view.h.

Referenced by Add(), and Clear().

LAYER_ORDER KIGFX::VIEW::m_orderedLayers
private

Sorted list of pointers to members of m_layers.

Definition at line 749 of file view.h.

Referenced by CalculateExtents(), Query(), redrawRect(), and sortLayers().

PAINTER* KIGFX::VIEW::m_painter
private

PAINTER contains information how do draw items.

Definition at line 776 of file view.h.

Referenced by draw(), GetPainter(), SetPainter(), UpdateAllLayersColor(), updateItemColor(), updateItemGeometry(), and UpdateLayerColor().

double KIGFX::VIEW::m_scale
private

Scale of displayed VIEW_ITEMs.

Definition at line 758 of file view.h.

Referenced by GetScale(), KIGFX::VIEW::drawItem::operator()(), SetGAL(), and SetScale().

std::set<unsigned int> KIGFX::VIEW::m_topLayers
private

Stores set of layers that are displayed on the top.

Definition at line 752 of file view.h.

Referenced by ClearTopLayers(), EnableTopLayer(), GetTopLayer(), and SetTopLayer().

bool KIGFX::VIEW::m_useDrawPriority
private

Flag to respect draw priority when drawing items.

Definition at line 795 of file view.h.

Referenced by IsUsingDrawPriority(), redrawRect(), and UseDrawPriority().

const int KIGFX::VIEW::TOP_LAYER_MODIFIER = -VIEW_MAX_LAYERS
staticprivate

Rendering order modifier for layers that are marked as top layers.

Definition at line 789 of file view.h.

Referenced by ClearTopLayers(), EnableTopLayer(), and SetTopLayer().

const int KIGFX::VIEW::VIEW_MAX_LAYERS = 512
static

The documentation for this class was generated from the following files: