KiCad PCB EDA Suite
Loading...
Searching...
No Matches
view.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2013-2017 CERN
5 * Copyright (C) 2021 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * @author Tomasz Wlostowski <[email protected]>
8 * @author Maciej Suminski <[email protected]>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, you may find one here:
22 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
23 * or you may search the http://www.gnu.org website for the version 2 license,
24 * or you may write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28
29#include <layer_ids.h>
30#include <trace_helpers.h>
31
32#include <view/view.h>
33#include <view/view_group.h>
34#include <view/view_item.h>
35#include <view/view_rtree.h>
36#include <view/view_overlay.h>
37
38#include <gal/definitions.h>
40#include <gal/painter.h>
41
42#include <core/profile.h>
43
44#ifdef KICAD_GAL_PROFILE
45#include <wx/log.h>
46#endif
47
48namespace KIGFX {
49
50class VIEW;
51
53{
54public:
56 m_view( nullptr ),
59 m_drawPriority( 0 ),
60 m_groups( nullptr ),
61 m_groupsSize( 0 ) {}
62
64 {
66 }
67
68 int GetFlags() const
69 {
70 return m_flags;
71 }
72
73private:
74 friend class VIEW;
75
82 void getLayers( int* aLayers, int& aCount ) const
83 {
84 int* layersPtr = aLayers;
85
86 for( int layer : m_layers )
87 *layersPtr++ = layer;
88
89 aCount = m_layers.size();
90 }
91
98 int getGroup( int aLayer ) const
99 {
100 for( int i = 0; i < m_groupsSize; ++i )
101 {
102 if( m_groups[i].first == aLayer )
103 return m_groups[i].second;
104 }
105
106 return -1;
107 }
108
115 void setGroup( int aLayer, int aGroup )
116 {
117 // Look if there is already an entry for the layer
118 for( int i = 0; i < m_groupsSize; ++i )
119 {
120 if( m_groups[i].first == aLayer )
121 {
122 m_groups[i].second = aGroup;
123 return;
124 }
125 }
126
127 // If there was no entry for the given layer - create one
128 std::pair<int, int>* newGroups = new std::pair<int, int>[m_groupsSize + 1];
129
130 if( m_groupsSize > 0 )
131 {
132 std::copy( m_groups, m_groups + m_groupsSize, newGroups );
133 delete[] m_groups;
134 }
135
136 m_groups = newGroups;
137 newGroups[m_groupsSize++] = { aLayer, aGroup };
138 }
139
140
145 {
146 delete[] m_groups;
147 m_groups = nullptr;
148 m_groupsSize = 0;
149 }
150
151
157 inline bool storesGroups() const
158 {
159 return m_groupsSize > 0;
160 }
161
162
170 void reorderGroups( std::unordered_map<int, int> aReorderMap )
171 {
172 for( int i = 0; i < m_groupsSize; ++i )
173 {
174 int orig_layer = m_groups[i].first;
175 int new_layer = orig_layer;
176
177 if( aReorderMap.count( orig_layer ) )
178 new_layer = aReorderMap.at( orig_layer );
179
180 m_groups[i].first = new_layer;
181 }
182 }
183
190 void saveLayers( int* aLayers, int aCount )
191 {
192 m_layers.clear();
193
194 for( int i = 0; i < aCount; ++i )
195 {
196 // this fires on some eagle board after PCB_IO_EAGLE::Load()
197 wxASSERT( unsigned( aLayers[i] ) <= unsigned( VIEW::VIEW_MAX_LAYERS ) );
198
199 m_layers.push_back( aLayers[i] );
200 }
201 }
202
206 int requiredUpdate() const
207 {
208 return m_requiredUpdate;
209 }
210
215 {
217 }
218
222 bool isRenderable() const
223 {
224 return m_flags == VISIBLE;
225 }
226
231
232 std::pair<int, int>* m_groups;
235
236 std::vector<int> m_layers;
237
239};
240
241
243{
244 if( aItem->m_viewPrivData )
245 {
246 if( aItem->m_viewPrivData->m_view )
247 aItem->m_viewPrivData->m_view->VIEW::Remove( aItem );
248
249 delete aItem->m_viewPrivData;
250 aItem->m_viewPrivData = nullptr;
251 }
252}
253
254
255VIEW::VIEW( bool aIsDynamic ) :
256 m_enableOrderModifier( true ),
257 m_scale( 4.0 ),
258 m_minScale( 0.2 ), m_maxScale( 50000.0 ),
259 m_mirrorX( false ), m_mirrorY( false ),
260 m_painter( nullptr ),
261 m_gal( nullptr ),
262 m_dynamic( aIsDynamic ),
263 m_useDrawPriority( false ),
264 m_nextDrawPriority( 0 ),
265 m_reverseDrawOrder( false )
266{
267 // Set m_boundary to define the max area size. The default area size
268 // is defined here as the max value of a int.
269 // this is a default value acceptable for Pcbnew and Gerbview, but too large for Eeschema.
270 // So in eeschema a call to SetBoundary() with a smaller value will be needed.
271 typedef std::numeric_limits<int> coord_limits;
272 double pos = coord_limits::lowest() / 2 + coord_limits::epsilon();
273 double size = coord_limits::max() - coord_limits::epsilon();
274 m_boundary.SetOrigin( pos, pos );
275 m_boundary.SetSize( size, size );
276
277 m_allItems.reset( new std::vector<VIEW_ITEM*> );
278 m_allItems->reserve( 32768 );
279
280 // Redraw everything at the beginning
281 MarkDirty();
282
283 m_layers.reserve( VIEW_MAX_LAYERS );
284
285 // View uses layers to display EDA_ITEMs (item may be displayed on several layers, for example
286 // pad may be shown on pad, pad hole and solder paste layers). There are usual copper layers
287 // (eg. F.Cu, B.Cu, internal and so on) and layers for displaying objects such as texts,
288 // silkscreen, pads, vias, etc.
289 for( int ii = 0; ii < VIEW_MAX_LAYERS; ++ii )
290 {
291 m_layers.emplace_back();
292 m_layers[ii].items = std::make_shared<VIEW_RTREE>();
293 m_layers[ii].id = ii;
294 m_layers[ii].renderingOrder = ii;
295 m_layers[ii].visible = true;
296 m_layers[ii].displayOnly = false;
297 m_layers[ii].diffLayer = false;
298 m_layers[ii].hasNegatives = false;
299 m_layers[ii].target = TARGET_CACHED;
300 }
301
302 sortLayers();
303
304 m_preview.reset( new KIGFX::VIEW_GROUP() );
305 Add( m_preview.get() );
306}
307
308
310{
311 Remove( m_preview.get() );
312}
313
314
315void VIEW::Add( VIEW_ITEM* aItem, int aDrawPriority )
316{
317 int layers[VIEW_MAX_LAYERS], layers_count;
318
319 if( aDrawPriority < 0 )
320 aDrawPriority = m_nextDrawPriority++;
321
322 if( !aItem->m_viewPrivData )
323 aItem->m_viewPrivData = new VIEW_ITEM_DATA;
324
325 wxASSERT_MSG( aItem->m_viewPrivData->m_view == nullptr
326 || aItem->m_viewPrivData->m_view == this,
327 wxS( "Already in a different view!" ) );
328
329 aItem->m_viewPrivData->m_view = this;
330 aItem->m_viewPrivData->m_drawPriority = aDrawPriority;
331 const BOX2I bbox = aItem->ViewBBox();
332 aItem->m_viewPrivData->m_bbox = bbox;
333
334 aItem->ViewGetLayers( layers, layers_count );
335 aItem->viewPrivData()->saveLayers( layers, layers_count );
336
337 m_allItems->push_back( aItem );
338
339 for( int i = 0; i < layers_count; ++i )
340 {
341 wxCHECK2_MSG( layers[i] >= 0 && static_cast<unsigned>( layers[i] ) < m_layers.size(),
342 continue, wxS( "Invalid layer" ) );
343
344 VIEW_LAYER& l = m_layers[layers[i]];
345 l.items->Insert( aItem, bbox );
347 }
348
349 SetVisible( aItem, true );
350 Update( aItem, KIGFX::INITIAL_ADD );
351}
352
353
355{
356 if( aItem && aItem->m_viewPrivData )
357 {
358 wxCHECK( aItem->m_viewPrivData->m_view == this, /*void*/ );
359 auto item = std::find( m_allItems->begin(), m_allItems->end(), aItem );
360
361 if( item != m_allItems->end() )
362 {
363 m_allItems->erase( item );
365 }
366
367 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
368 aItem->m_viewPrivData->getLayers( layers, layers_count );
369 const BOX2I* bbox = &aItem->m_viewPrivData->m_bbox;
370
371 for( int i = 0; i < layers_count; ++i )
372 {
373 VIEW_LAYER& l = m_layers[layers[i]];
374 l.items->Remove( aItem, bbox );
376
377 // Clear the GAL cache
378 int prevGroup = aItem->m_viewPrivData->getGroup( layers[i] );
379
380 if( prevGroup >= 0 )
381 m_gal->DeleteGroup( prevGroup );
382 }
383
385 aItem->m_viewPrivData->m_view = nullptr;
386 }
387}
388
389
390void VIEW::SetRequired( int aLayerId, int aRequiredId, bool aRequired )
391{
392 wxCHECK( (unsigned) aLayerId < m_layers.size(), /*void*/ );
393 wxCHECK( (unsigned) aRequiredId < m_layers.size(), /*void*/ );
394
395 if( aRequired )
396 m_layers[aLayerId].requiredLayers.insert( aRequiredId );
397 else
398 m_layers[aLayerId].requiredLayers.erase( aRequired );
399}
400
401
402// stupid C++... python lambda would do this in one line
403template <class CONTAINER>
405{
406 typedef typename CONTAINER::value_type item_type;
407
408 QUERY_VISITOR( CONTAINER& aCont, int aLayer ) :
409 m_cont( aCont ), m_layer( aLayer )
410 {
411 }
412
413 bool operator()( VIEW_ITEM* aItem )
414 {
415 if( aItem->viewPrivData()->GetFlags() & VISIBLE )
416 m_cont.push_back( VIEW::LAYER_ITEM_PAIR( aItem, m_layer ) );
417
418 return true;
419 }
420
423};
424
425
426int VIEW::Query( const BOX2I& aRect, std::vector<LAYER_ITEM_PAIR>& aResult ) const
427{
428 if( m_orderedLayers.empty() )
429 return 0;
430
431 std::vector<VIEW_LAYER*>::const_reverse_iterator i;
432
433 // execute queries in reverse direction, so that items that are on the top of
434 // the rendering stack are returned first.
435 for( i = m_orderedLayers.rbegin(); i != m_orderedLayers.rend(); ++i )
436 {
437 // ignore layers that do not contain actual items (i.e. the selection box, menus, floats)
438 if( ( *i )->displayOnly || !( *i )->visible )
439 continue;
440
441 QUERY_VISITOR<std::vector<LAYER_ITEM_PAIR> > visitor( aResult, ( *i )->id );
442 ( *i )->items->Query( aRect, visitor );
443 }
444
445 return aResult.size();
446}
447
448
449VECTOR2D VIEW::ToWorld( const VECTOR2D& aCoord, bool aAbsolute ) const
450{
451 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
452
453 if( aAbsolute )
454 return VECTOR2D( matrix * aCoord );
455 else
456 return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
457}
458
459
460double VIEW::ToWorld( double aSize ) const
461{
462 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
463
464 return fabs( matrix.GetScale().x * aSize );
465}
466
467
468VECTOR2D VIEW::ToScreen( const VECTOR2D& aCoord, bool aAbsolute ) const
469{
470 const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
471
472 if( aAbsolute )
473 return VECTOR2D( matrix * aCoord );
474 else
475 return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
476}
477
478
479double VIEW::ToScreen( double aSize ) const
480{
481 const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
482
483 return matrix.GetScale().x * aSize;
484}
485
486
487void VIEW::CopySettings( const VIEW* aOtherView )
488{
489 wxASSERT_MSG( false, wxT( "This is not implemented" ) );
490}
491
492
493void VIEW::SetGAL( GAL* aGal )
494{
495 bool recacheGroups = ( m_gal != nullptr ); // recache groups only if GAL is reassigned
496 m_gal = aGal;
497
498 // clear group numbers, so everything is going to be recached
499 if( recacheGroups )
501
502 // every target has to be refreshed
503 MarkDirty();
504
505 // force the new GAL to display the current viewport.
507 SetScale( m_scale );
509}
510
511
513{
514 BOX2D rect;
515 VECTOR2D screenSize = m_gal->GetScreenPixelSize();
516
517 rect.SetOrigin( ToWorld( VECTOR2D( 0, 0 ) ) );
518 rect.SetEnd( ToWorld( screenSize ) );
519
520 return rect.Normalize();
521}
522
523
524void VIEW::SetViewport( const BOX2D& aViewport )
525{
526 VECTOR2D ssize = ToWorld( m_gal->GetScreenPixelSize(), false );
527
528 wxCHECK( fabs(ssize.x) > 0 && fabs(ssize.y) > 0, /*void*/ );
529
530 VECTOR2D centre = aViewport.Centre();
531 VECTOR2D vsize = aViewport.GetSize();
532 double zoom = 1.0 / std::max( fabs( vsize.x / ssize.x ), fabs( vsize.y / ssize.y ) );
533
534 SetCenter( centre );
535 SetScale( GetScale() * zoom );
536}
537
538
539void VIEW::SetMirror( bool aMirrorX, bool aMirrorY )
540{
541 wxASSERT_MSG( !aMirrorY, _( "Mirroring for Y axis is not supported yet" ) );
542
543 m_mirrorX = aMirrorX;
544 m_mirrorY = aMirrorY;
545 m_gal->SetFlip( aMirrorX, aMirrorY );
546
547 // Redraw everything
548 MarkDirty();
549}
550
551
552void VIEW::SetScale( double aScale, VECTOR2D aAnchor )
553{
554 if( aAnchor == VECTOR2D( 0, 0 ) )
555 aAnchor = m_center;
556
557 VECTOR2D a = ToScreen( aAnchor );
558
559 if( aScale < m_minScale )
561 else if( aScale > m_maxScale )
563 else
564 m_scale = aScale;
565
568
569 VECTOR2D delta = ToWorld( a ) - aAnchor;
570
572
573 // Redraw everything after the viewport has changed
574 MarkDirty();
575}
576
577
578void VIEW::SetCenter( const VECTOR2D& aCenter )
579{
580 m_center = aCenter;
581
582 if( !m_boundary.Contains( aCenter ) )
583 {
584 if( m_center.x < m_boundary.GetLeft() )
586 else if( aCenter.x > m_boundary.GetRight() )
588
589 if( m_center.y < m_boundary.GetTop() )
591 else if( m_center.y > m_boundary.GetBottom() )
593 }
594
597
598 // Redraw everything after the viewport has changed
599 MarkDirty();
600}
601
602
603void VIEW::SetCenter( const VECTOR2D& aCenter, const std::vector<BOX2D>& obscuringScreenRects )
604{
605 if( obscuringScreenRects.empty() )
606 return SetCenter( aCenter );
607
608 BOX2D screenRect( { 0, 0 }, m_gal->GetScreenPixelSize() );
609 SHAPE_POLY_SET unobscuredPoly( screenRect );
610 VECTOR2D unobscuredCenter = screenRect.Centre();
611
612 for( const BOX2D& obscuringScreenRect : obscuringScreenRects )
613 {
614 SHAPE_POLY_SET obscuringPoly( obscuringScreenRect );
615 unobscuredPoly.BooleanSubtract( obscuringPoly, SHAPE_POLY_SET::PM_FAST );
616 }
617
618 /*
619 * Perform a step-wise deflate to find the center of the largest unobscured area
620 */
621
622 BOX2I bbox = unobscuredPoly.BBox();
623 int step = std::min( bbox.GetWidth(), bbox.GetHeight() ) / 10;
624
625 if( step < 20 )
626 step = 20;
627
628 while( !unobscuredPoly.IsEmpty() )
629 {
630 unobscuredCenter = unobscuredPoly.BBox().Centre();
631 unobscuredPoly.Deflate( step, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, ARC_LOW_DEF );
632 }
633
634 SetCenter( aCenter - ToWorld( unobscuredCenter - screenRect.Centre(), false ) );
635}
636
637
638void VIEW::SetLayerOrder( int aLayer, int aRenderingOrder )
639{
640 m_layers[aLayer].renderingOrder = aRenderingOrder;
641
642 sortLayers();
643}
644
645
646int VIEW::GetLayerOrder( int aLayer ) const
647{
648 return m_layers.at( aLayer ).renderingOrder;
649}
650
651
652void VIEW::SortLayers( int aLayers[], int& aCount ) const
653{
654 int maxLay, maxOrd, maxIdx;
655
656 for( int i = 0; i < aCount; ++i )
657 {
658 maxLay = aLayers[i];
659 maxOrd = GetLayerOrder( maxLay );
660 maxIdx = i;
661
662 // Look for the max element in the range (j..aCount)
663 for( int j = i; j < aCount; ++j )
664 {
665 if( maxOrd < GetLayerOrder( aLayers[j] ) )
666 {
667 maxLay = aLayers[j];
668 maxOrd = GetLayerOrder( maxLay );
669 maxIdx = j;
670 }
671 }
672
673 // Swap elements
674 aLayers[maxIdx] = aLayers[i];
675 aLayers[i] = maxLay;
676 }
677}
678
679
680void VIEW::ReorderLayerData( std::unordered_map<int, int> aReorderMap )
681{
682 std::vector<VIEW_LAYER> new_map;
683 new_map.reserve( m_layers.size() );
684
685 for( const VIEW_LAYER& layer : m_layers )
686 new_map.push_back( layer );
687
688 for( auto& pair : aReorderMap )
689 {
690 new_map[pair.second] = m_layers[pair.first];
691 new_map[pair.second].id = pair.second;
692 }
693
694 // Transfer reordered data (using the copy assignment operator ):
695 m_layers = new_map;
696
697 for( VIEW_ITEM* item : *m_allItems )
698 {
699 VIEW_ITEM_DATA* viewData = item->viewPrivData();
700
701 if( !viewData )
702 continue;
703
704 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
705
706 item->ViewGetLayers( layers, layers_count );
707 viewData->saveLayers( layers, layers_count );
708
709 viewData->reorderGroups( aReorderMap );
710
711 viewData->m_requiredUpdate |= COLOR;
712 }
713
714 UpdateItems();
715}
716
717
719{
720 UPDATE_COLOR_VISITOR( int aLayer, PAINTER* aPainter, GAL* aGal ) :
721 layer( aLayer ),
722 painter( aPainter ),
723 gal( aGal )
724 {
725 }
726
727 bool operator()( VIEW_ITEM* aItem )
728 {
729 // Obtain the color that should be used for coloring the item
730 const COLOR4D color = painter->GetSettings()->GetColor( aItem, layer );
731 int group = aItem->viewPrivData()->getGroup( layer );
732
733 if( group >= 0 )
735
736 return true;
737 }
738
739 int layer;
742};
743
744
745void VIEW::UpdateLayerColor( int aLayer )
746{
747 // There is no point in updating non-cached layers
748 if( !IsCached( aLayer ) )
749 return;
750
751 BOX2I r;
752
753 r.SetMaximum();
754
755 if( m_gal->IsVisible() )
756 {
758
759 UPDATE_COLOR_VISITOR visitor( aLayer, m_painter, m_gal );
760 m_layers[aLayer].items->Query( r, visitor );
761 MarkTargetDirty( m_layers[aLayer].target );
762 }
763}
764
765
767{
768 if( m_gal->IsVisible() )
769 {
771
772 for( VIEW_ITEM* item : *m_allItems )
773 {
774 VIEW_ITEM_DATA* viewData = item->viewPrivData();
775
776 if( !viewData )
777 continue;
778
779 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
780 viewData->getLayers( layers, layers_count );
781
782 for( int i = 0; i < layers_count; ++i )
783 {
784 const COLOR4D color = m_painter->GetSettings()->GetColor( item, layers[i] );
785 int group = viewData->getGroup( layers[i] );
786
787 if( group >= 0 )
789 }
790 }
791 }
792
793 MarkDirty();
794}
795
796
798{
799 UPDATE_DEPTH_VISITOR( int aLayer, int aDepth, GAL* aGal ) :
800 layer( aLayer ),
801 depth( aDepth ),
802 gal( aGal )
803 {
804 }
805
806 bool operator()( VIEW_ITEM* aItem )
807 {
808 int group = aItem->viewPrivData()->getGroup( layer );
809
810 if( group >= 0 )
812
813 return true;
814 }
815
818};
819
820
822{
823 if( m_topLayers.size() == 0 )
824 return 0;
825
826 return *m_topLayers.begin();
827}
828
829
830void VIEW::SetTopLayer( int aLayer, bool aEnabled )
831{
832 if( aEnabled )
833 {
834 if( m_topLayers.count( aLayer ) == 1 )
835 return;
836
837 m_topLayers.insert( aLayer );
838
839 // Move the layer closer to front
841 m_layers[aLayer].renderingOrder += TOP_LAYER_MODIFIER;
842 }
843 else
844 {
845 if( m_topLayers.count( aLayer ) == 0 )
846 return;
847
848 m_topLayers.erase( aLayer );
849
850 // Restore the previous rendering order
852 m_layers[aLayer].renderingOrder -= TOP_LAYER_MODIFIER;
853 }
854}
855
856
857void VIEW::EnableTopLayer( bool aEnable )
858{
859 if( aEnable == m_enableOrderModifier )
860 return;
861
862 m_enableOrderModifier = aEnable;
863
864 std::set<unsigned int>::iterator it;
865
866 if( aEnable )
867 {
868 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
869 m_layers[*it].renderingOrder += TOP_LAYER_MODIFIER;
870 }
871 else
872 {
873 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
874 m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
875 }
876
879}
880
881
883{
884 std::set<unsigned int>::iterator it;
885
887 {
888 // Restore the previous rendering order for layers that were marked as top
889 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
890 m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
891 }
892
893 m_topLayers.clear();
894}
895
896
898{
899 sortLayers();
900
901 if( m_gal->IsVisible() )
902 {
904
905 for( VIEW_ITEM* item : *m_allItems )
906 {
907 VIEW_ITEM_DATA* viewData = item->viewPrivData();
908
909 if( !viewData )
910 continue;
911
912 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
913 viewData->getLayers( layers, layers_count );
914
915 for( int i = 0; i < layers_count; ++i )
916 {
917 int group = viewData->getGroup( layers[i] );
918
919 if( group >= 0 )
920 m_gal->ChangeGroupDepth( group, m_layers[layers[i]].renderingOrder );
921 }
922 }
923 }
924
925 MarkDirty();
926}
927
928
930{
931 DRAW_ITEM_VISITOR( VIEW* aView, int aLayer, bool aUseDrawPriority, bool aReverseDrawOrder ) :
932 view( aView ),
933 layer( aLayer ),
934 useDrawPriority( aUseDrawPriority ),
935 reverseDrawOrder( aReverseDrawOrder ),
936 drawForcedTransparent( false ),
938 {
939 }
940
941 bool operator()( VIEW_ITEM* aItem )
942 {
943 wxCHECK( aItem->viewPrivData(), false );
944
946 {
948 return true;
949 }
950
951 // Conditions that have to be fulfilled for an item to be drawn
952 bool drawCondition = aItem->viewPrivData()->isRenderable()
953 && aItem->ViewGetLOD( layer, view ) < view->m_scale;
954 if( !drawCondition )
955 return true;
956
957 if( useDrawPriority )
958 drawItems.push_back( aItem );
959 else
960 view->draw( aItem, layer );
961
962 return true;
963 }
964
966 {
967 if( reverseDrawOrder )
968 {
969 std::sort( drawItems.begin(), drawItems.end(),
970 []( VIEW_ITEM* a, VIEW_ITEM* b ) -> bool
971 {
972 return b->viewPrivData()->m_drawPriority < a->viewPrivData()->m_drawPriority;
973 } );
974 }
975 else
976 {
977 std::sort( drawItems.begin(), drawItems.end(),
978 []( VIEW_ITEM* a, VIEW_ITEM* b ) -> bool
979 {
980 return a->viewPrivData()->m_drawPriority < b->viewPrivData()->m_drawPriority;
981 } );
982 }
983
984 for( VIEW_ITEM* item : drawItems )
985 view->draw( item, layer );
986 }
987
991 std::vector<VIEW_ITEM*> drawItems;
994};
995
996
997void VIEW::redrawRect( const BOX2I& aRect )
998{
999 for( VIEW_LAYER* l : m_orderedLayers )
1000 {
1001 if( l->visible && IsTargetDirty( l->target ) && areRequiredLayersEnabled( l->id ) )
1002 {
1003 DRAW_ITEM_VISITOR drawFunc( this, l->id, m_useDrawPriority, m_reverseDrawOrder );
1004
1005 m_gal->SetTarget( l->target );
1006 m_gal->SetLayerDepth( l->renderingOrder );
1007
1008 // Differential layer also work for the negatives, since both special layer types
1009 // will composite on separate layers (at least in Cairo)
1010 if( l->diffLayer )
1012 else if( l->hasNegatives )
1014
1015 l->items->Query( aRect, drawFunc );
1016
1017 if( m_useDrawPriority )
1018 drawFunc.deferredDraw();
1019
1020 if( l->diffLayer )
1022 else if( l->hasNegatives )
1024
1025 if( drawFunc.foundForcedTransparent )
1026 {
1027 drawFunc.drawForcedTransparent = true;
1028
1030 m_gal->EnableDepthTest( true );
1031 m_gal->SetLayerDepth( l->renderingOrder );
1032
1033 l->items->Query( aRect, drawFunc );
1034 }
1035 }
1036 }
1037}
1038
1039
1040void VIEW::draw( VIEW_ITEM* aItem, int aLayer, bool aImmediate )
1041{
1042 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1043
1044 if( !viewData )
1045 return;
1046
1047 if( IsCached( aLayer ) && !aImmediate )
1048 {
1049 // Draw using cached information or create one
1050 int group = viewData->getGroup( aLayer );
1051
1052 if( group >= 0 )
1053 m_gal->DrawGroup( group );
1054 else
1055 Update( aItem );
1056 }
1057 else
1058 {
1059 // Immediate mode
1060 if( !m_painter->Draw( aItem, aLayer ) )
1061 aItem->ViewDraw( aLayer, this ); // Alternative drawing method
1062 }
1063}
1064
1065
1066void VIEW::draw( VIEW_ITEM* aItem, bool aImmediate )
1067{
1068 int layers[VIEW_MAX_LAYERS], layers_count;
1069
1070 aItem->ViewGetLayers( layers, layers_count );
1071
1072 // Sorting is needed for drawing order dependent GALs (like Cairo)
1073 SortLayers( layers, layers_count );
1074
1075 for( int i = 0; i < layers_count; ++i )
1076 {
1077 m_gal->SetLayerDepth( m_layers.at( layers[i] ).renderingOrder );
1078 draw( aItem, layers[i], aImmediate );
1079 }
1080}
1081
1082
1083void VIEW::draw( VIEW_GROUP* aGroup, bool aImmediate )
1084{
1085 for( unsigned int i = 0; i < aGroup->GetSize(); i++)
1086 draw( aGroup->GetItem(i), aImmediate );
1087}
1088
1089
1091{
1092 RECACHE_ITEM_VISITOR( VIEW* aView, GAL* aGal, int aLayer ) :
1093 view( aView ),
1094 gal( aGal ),
1095 layer( aLayer )
1096 {
1097 }
1098
1099 bool operator()( VIEW_ITEM* aItem )
1100 {
1101 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1102
1103 if( !viewData )
1104 return false;
1105
1106 // Remove previously cached group
1107 int group = viewData->getGroup( layer );
1108
1109 if( group >= 0 )
1110 gal->DeleteGroup( group );
1111
1112 viewData->setGroup( layer, -1 );
1113 view->Update( aItem );
1114
1115 return true;
1116 }
1117
1121};
1122
1123
1125{
1126 BOX2I r;
1127 r.SetMaximum();
1128 m_allItems->clear();
1129
1130 for( VIEW_LAYER& layer : m_layers )
1131 layer.items->RemoveAll();
1132
1134
1135 m_gal->ClearCache();
1136}
1137
1138
1140{
1142 {
1143 // TARGET_CACHED and TARGET_NONCACHED have to be redrawn together, as they contain
1144 // layers that rely on each other (eg. netnames are noncached, but tracks - are cached)
1147
1148 MarkDirty();
1149 }
1150
1152 {
1154 }
1155}
1156
1157
1159{
1160#ifdef KICAD_GAL_PROFILE
1161 PROF_TIMER totalRealTime;
1162#endif /* KICAD_GAL_PROFILE */
1163
1164 VECTOR2D screenSize = m_gal->GetScreenPixelSize();
1165 BOX2D rect( ToWorld( VECTOR2D( 0, 0 ) ),
1166 ToWorld( screenSize ) - ToWorld( VECTOR2D( 0, 0 ) ) );
1167
1168 rect.Normalize();
1169 BOX2I recti = BOX2ISafe( rect );
1170
1171 redrawRect( recti );
1172
1173 // All targets were redrawn, so nothing is dirty
1174 MarkClean();
1175
1176#ifdef KICAD_GAL_PROFILE
1177 totalRealTime.Stop();
1178 wxLogTrace( traceGalProfile, wxS( "VIEW::Redraw(): %.1f ms" ), totalRealTime.msecs() );
1179#endif /* KICAD_GAL_PROFILE */
1180}
1181
1182
1184{
1185 return m_gal->GetScreenPixelSize();
1186}
1187
1188
1190{
1192 view( aView )
1193 {
1194 }
1195
1196 bool operator()( VIEW_ITEM* aItem )
1197 {
1198 aItem->viewPrivData()->deleteGroups();
1199
1200 return true;
1201 }
1202
1204};
1205
1206
1208{
1209 BOX2I r;
1210
1211 r.SetMaximum();
1212 CLEAR_LAYER_CACHE_VISITOR visitor( this );
1213
1214 for( VIEW_LAYER& layer : m_layers )
1215 layer.items->Query( r, visitor );
1216}
1217
1218
1219void VIEW::invalidateItem( VIEW_ITEM* aItem, int aUpdateFlags )
1220{
1221 if( aUpdateFlags & INITIAL_ADD )
1222 {
1223 // Don't update layers or bbox, since it was done in VIEW::Add()
1224 // Now that we have initialized, set flags to ALL for the code below
1225 aUpdateFlags = ALL;
1226 }
1227 else
1228 {
1229 // updateLayers updates geometry too, so we do not have to update both of them at the
1230 // same time
1231 if( aUpdateFlags & LAYERS )
1232 updateLayers( aItem );
1233 else if( aUpdateFlags & GEOMETRY )
1234 updateBbox( aItem );
1235 }
1236
1237 int layers[VIEW_MAX_LAYERS], layers_count;
1238 aItem->ViewGetLayers( layers, layers_count );
1239
1240 // Iterate through layers used by the item and recache it immediately
1241 for( int i = 0; i < layers_count; ++i )
1242 {
1243 int layerId = layers[i];
1244
1245 if( IsCached( layerId ) )
1246 {
1247 if( aUpdateFlags & ( GEOMETRY | LAYERS | REPAINT ) )
1248 updateItemGeometry( aItem, layerId );
1249 else if( aUpdateFlags & COLOR )
1250 updateItemColor( aItem, layerId );
1251 }
1252
1253 // Mark those layers as dirty, so the VIEW will be refreshed
1254 MarkTargetDirty( m_layers[layerId].target );
1255 }
1256
1257 aItem->viewPrivData()->clearUpdateFlags();
1258}
1259
1260
1262{
1263 int n = 0;
1264
1265 m_orderedLayers.resize( m_layers.size() );
1266
1267 for( VIEW_LAYER& layer : m_layers )
1268 m_orderedLayers[n++] = &layer;
1269
1271
1272 MarkDirty();
1273}
1274
1275
1276void VIEW::updateItemColor( VIEW_ITEM* aItem, int aLayer )
1277{
1278 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1279 wxCHECK( (unsigned) aLayer < m_layers.size(), /*void*/ );
1280 wxCHECK( IsCached( aLayer ), /*void*/ );
1281
1282 if( !viewData )
1283 return;
1284
1285 // Obtain the color that should be used for coloring the item on the specific layerId
1286 const COLOR4D color = m_painter->GetSettings()->GetColor( aItem, aLayer );
1287 int group = viewData->getGroup( aLayer );
1288
1289 // Change the color, only if it has group assigned
1290 if( group >= 0 )
1292}
1293
1294
1295void VIEW::updateItemGeometry( VIEW_ITEM* aItem, int aLayer )
1296{
1297 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1298 wxCHECK( (unsigned) aLayer < m_layers.size(), /*void*/ );
1299 wxCHECK( IsCached( aLayer ), /*void*/ );
1300
1301 if( !viewData )
1302 return;
1303
1304 VIEW_LAYER& l = m_layers.at( aLayer );
1305
1306 m_gal->SetTarget( l.target );
1308
1309 // Redraw the item from scratch
1310 int group = viewData->getGroup( aLayer );
1311
1312 if( group >= 0 )
1314
1315 group = m_gal->BeginGroup();
1316 viewData->setGroup( aLayer, group );
1317
1318 if( !m_painter->Draw( aItem, aLayer ) )
1319 aItem->ViewDraw( aLayer, this ); // Alternative drawing method
1320
1321 m_gal->EndGroup();
1322}
1323
1324
1326{
1327 int layers[VIEW_MAX_LAYERS], layers_count;
1328
1329 aItem->ViewGetLayers( layers, layers_count );
1330 wxASSERT( aItem->m_viewPrivData ); //must have a viewPrivData
1331
1332 const BOX2I new_bbox = aItem->ViewBBox();
1333 const BOX2I* old_bbox = &aItem->m_viewPrivData->m_bbox;
1334 aItem->m_viewPrivData->m_bbox = new_bbox;
1335
1336 for( int i = 0; i < layers_count; ++i )
1337 {
1338 VIEW_LAYER& l = m_layers[layers[i]];
1339 l.items->Remove( aItem, old_bbox );
1340 l.items->Insert( aItem, new_bbox );
1342 }
1343}
1344
1345
1347{
1348 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1349 int layers[VIEW_MAX_LAYERS], layers_count;
1350
1351 if( !viewData )
1352 return;
1353
1354 // Remove the item from previous layer set
1355 viewData->getLayers( layers, layers_count );
1356 const BOX2I* old_bbox = &aItem->m_viewPrivData->m_bbox;
1357
1358 for( int i = 0; i < layers_count; ++i )
1359 {
1360 VIEW_LAYER& l = m_layers[layers[i]];
1361 l.items->Remove( aItem, old_bbox );
1363
1364 if( IsCached( l.id ) )
1365 {
1366 // Redraw the item from scratch
1367 int prevGroup = viewData->getGroup( layers[i] );
1368
1369 if( prevGroup >= 0 )
1370 {
1371 m_gal->DeleteGroup( prevGroup );
1372 viewData->setGroup( l.id, -1 );
1373 }
1374 }
1375 }
1376
1377 const BOX2I new_bbox = aItem->ViewBBox();
1378 aItem->m_viewPrivData->m_bbox = new_bbox;
1379
1380 // Add the item to new layer set
1381 aItem->ViewGetLayers( layers, layers_count );
1382 viewData->saveLayers( layers, layers_count );
1383
1384 for( int i = 0; i < layers_count; i++ )
1385 {
1386 VIEW_LAYER& l = m_layers[layers[i]];
1387 l.items->Insert( aItem, new_bbox );
1389 }
1390}
1391
1392
1393bool VIEW::areRequiredLayersEnabled( int aLayerId ) const
1394{
1395 wxCHECK( (unsigned) aLayerId < m_layers.size(), false );
1396
1397 std::set<int>::const_iterator it, it_end;
1398
1399 for( int layer : m_layers.at( aLayerId ).requiredLayers )
1400 {
1401 // That is enough if just one layer is not enabled
1402 if( !m_layers.at( layer ).visible || !areRequiredLayersEnabled( layer ) )
1403 return false;
1404 }
1405
1406 return true;
1407}
1408
1409
1411{
1412 BOX2I r;
1413
1414 r.SetMaximum();
1415
1416 for( const VIEW_LAYER& l : m_layers )
1417 {
1418 if( IsCached( l.id ) )
1419 {
1420 RECACHE_ITEM_VISITOR visitor( this, m_gal, l.id );
1421 l.items->Query( r, visitor );
1422 }
1423 }
1424}
1425
1426
1428{
1429 if( !m_gal->IsVisible() || !m_gal->IsInitialized() )
1430 return;
1431
1432 unsigned int cntGeomUpdate = 0;
1433 bool anyUpdated = false;
1434
1435 for( VIEW_ITEM* item : *m_allItems )
1436 {
1437 auto vpd = item->viewPrivData();
1438
1439 if( !vpd )
1440 continue;
1441
1442 if( vpd->m_requiredUpdate != NONE )
1443 {
1444 anyUpdated = true;
1445
1446 if( vpd->m_requiredUpdate & ( GEOMETRY | LAYERS ) )
1447 {
1448 cntGeomUpdate++;
1449 }
1450 }
1451 }
1452
1453 unsigned int cntTotal = m_allItems->size();
1454
1455 double ratio = (double) cntGeomUpdate / (double) cntTotal;
1456
1457 // Optimization to improve view update time. If a lot of items (say, 30%) have their
1458 // bboxes/geometry changed it's way faster (around 10 times) to rebuild the R-Trees
1459 // from scratch rather than update the bbox of each changed item. Pcbnew does multiple
1460 // full geometry updates during file load, this can save a solid 30 seconds on load time
1461 // for larger designs...
1462
1463 if( ratio > 0.3 )
1464 {
1465 auto allItems = *m_allItems;
1466 int layers[VIEW_MAX_LAYERS], layers_count;
1467
1468 // kill all Rtrees
1469 for( VIEW_LAYER& layer : m_layers )
1470 layer.items->RemoveAll();
1471
1472 // and re-insert items from scratch
1473 for( VIEW_ITEM* item : allItems )
1474 {
1475 const BOX2I bbox = item->ViewBBox();
1476 item->m_viewPrivData->m_bbox = bbox;
1477
1478 item->ViewGetLayers( layers, layers_count );
1479 item->viewPrivData()->saveLayers( layers, layers_count );
1480
1481 for( int i = 0; i < layers_count; ++i )
1482 {
1483 wxCHECK2_MSG( layers[i] >= 0 && static_cast<unsigned>( layers[i] ) < m_layers.size(),
1484 continue, wxS( "Invalid layer" ) );
1485 VIEW_LAYER& l = m_layers[layers[i]];
1486 l.items->Insert( item, bbox );
1488 }
1489
1490 item->viewPrivData()->m_requiredUpdate &= ~( LAYERS | GEOMETRY );
1491 }
1492 }
1493
1494 if( anyUpdated )
1495 {
1497
1498 for( VIEW_ITEM* item : *m_allItems.get() )
1499 {
1500 if( item->viewPrivData() && item->viewPrivData()->m_requiredUpdate != NONE )
1501 {
1502 invalidateItem( item, item->viewPrivData()->m_requiredUpdate );
1503 item->viewPrivData()->m_requiredUpdate = NONE;
1504 }
1505 }
1506 }
1507
1508 KI_TRACE( traceGalProfile, wxS( "View update: total items %u, geom %u anyUpdated %u\n" ), cntTotal,
1509 cntGeomUpdate, (unsigned) anyUpdated );
1510}
1511
1512
1513void VIEW::UpdateAllItems( int aUpdateFlags )
1514{
1515 for( VIEW_ITEM* item : *m_allItems )
1516 {
1517 if( item->viewPrivData() )
1518 item->viewPrivData()->m_requiredUpdate |= aUpdateFlags;
1519 }
1520}
1521
1522
1524 std::function<bool( VIEW_ITEM* )> aCondition )
1525{
1526 for( VIEW_ITEM* item : *m_allItems )
1527 {
1528 if( aCondition( item ) )
1529 {
1530 if( item->viewPrivData() )
1531 item->viewPrivData()->m_requiredUpdate |= aUpdateFlags;
1532 }
1533 }
1534}
1535
1536
1537void VIEW::UpdateAllItemsConditionally( std::function<int( VIEW_ITEM* )> aItemFlagsProvider )
1538{
1539 for( VIEW_ITEM* item : *m_allItems )
1540 {
1541 if( item->viewPrivData() )
1542 item->viewPrivData()->m_requiredUpdate |= aItemFlagsProvider( item );
1543 }
1544}
1545
1546
1547
1548std::unique_ptr<VIEW> VIEW::DataReference() const
1549{
1550 std::unique_ptr<VIEW> ret = std::make_unique<VIEW>();
1551 ret->m_allItems = m_allItems;
1552 ret->m_layers = m_layers;
1553 ret->sortLayers();
1554 return ret;
1555}
1556
1557
1558void VIEW::SetVisible( VIEW_ITEM* aItem, bool aIsVisible )
1559{
1560 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1561
1562 if( !viewData )
1563 return;
1564
1565 bool cur_visible = viewData->m_flags & VISIBLE;
1566
1567 if( cur_visible != aIsVisible )
1568 {
1569 if( aIsVisible )
1570 viewData->m_flags |= VISIBLE;
1571 else
1572 viewData->m_flags &= ~VISIBLE;
1573
1574 Update( aItem, APPEARANCE | COLOR );
1575 }
1576}
1577
1578
1579void VIEW::Hide( VIEW_ITEM* aItem, bool aHide, bool aHideOverlay )
1580{
1581 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1582
1583 if( !viewData )
1584 return;
1585
1586 if( !( viewData->m_flags & VISIBLE ) )
1587 return;
1588
1589 if( aHideOverlay )
1590 viewData->m_flags |= OVERLAY_HIDDEN;
1591
1592 if( aHide )
1593 viewData->m_flags |= HIDDEN;
1594 else
1595 viewData->m_flags &= ~( HIDDEN | OVERLAY_HIDDEN );
1596
1597 Update( aItem, APPEARANCE );
1598}
1599
1600
1601bool VIEW::IsVisible( const VIEW_ITEM* aItem ) const
1602{
1603 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1604
1605 return viewData && ( viewData->m_flags & VISIBLE );
1606}
1607
1608
1609bool VIEW::IsHiddenOnOverlay( const VIEW_ITEM* aItem ) const
1610{
1611 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1612
1613 return viewData && ( viewData->m_flags & OVERLAY_HIDDEN );
1614}
1615
1616
1617bool VIEW::HasItem( const VIEW_ITEM* aItem ) const
1618{
1619 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1620
1621 return viewData && viewData->m_view == this;
1622}
1623
1624
1625void VIEW::Update( const VIEW_ITEM* aItem ) const
1626{
1627 Update( aItem, ALL );
1628}
1629
1630
1631void VIEW::Update( const VIEW_ITEM* aItem, int aUpdateFlags ) const
1632{
1633 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1634
1635 if( !viewData )
1636 return;
1637
1638 assert( aUpdateFlags != NONE );
1639
1640 viewData->m_requiredUpdate |= aUpdateFlags;
1641}
1642
1643
1644std::shared_ptr<VIEW_OVERLAY> VIEW::MakeOverlay()
1645{
1646 std::shared_ptr<VIEW_OVERLAY> overlay = std::make_shared<VIEW_OVERLAY>();
1647
1648 Add( overlay.get() );
1649 return overlay;
1650}
1651
1652
1654{
1655 if( !m_preview )
1656 return;
1657
1658 m_preview->Clear();
1659
1660 for( VIEW_ITEM* item : m_ownedItems )
1661 delete item;
1662
1663 m_ownedItems.clear();
1664 Update( m_preview.get() );
1665}
1666
1667
1669{
1670 m_preview.reset( new KIGFX::VIEW_GROUP() );
1671 Add( m_preview.get() );
1672}
1673
1674
1675void VIEW::AddToPreview( VIEW_ITEM* aItem, bool aTakeOwnership )
1676{
1677 Hide( aItem, false );
1678 m_preview->Add( aItem );
1679
1680 if( aTakeOwnership )
1681 m_ownedItems.push_back( aItem );
1682
1683 SetVisible( m_preview.get(), true );
1684 Hide( m_preview.get(), false );
1685 Update( m_preview.get() );
1686}
1687
1688
1689void VIEW::ShowPreview( bool aShow )
1690{
1691 SetVisible( m_preview.get(), aShow );
1692}
1693
1694
1695} // namespace KIGFX
int color
Definition: DXF_plotter.cpp:58
constexpr int ARC_LOW_DEF
Definition: base_units.h:119
BOX2I BOX2ISafe(const BOX2D &aInput)
Definition: box2.h:883
void SetOrigin(const Vec &pos)
Definition: box2.h:227
BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
Definition: box2.h:136
void SetSize(const SizeVec &size)
Definition: box2.h:238
void SetMaximum()
Definition: box2.h:70
const SizeVec & GetSize() const
Definition: box2.h:196
size_type GetHeight() const
Definition: box2.h:205
coord_type GetTop() const
Definition: box2.h:219
size_type GetWidth() const
Definition: box2.h:204
bool Contains(const Vec &aPoint) const
Definition: box2.h:158
Vec Centre() const
Definition: box2.h:87
coord_type GetRight() const
Definition: box2.h:207
coord_type GetLeft() const
Definition: box2.h:218
coord_type GetBottom() const
Definition: box2.h:212
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:280
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
Abstract interface for drawing on a 2D-surface.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
virtual void StartDiffLayer()
Begins rendering of a differential layer.
virtual void EndDiffLayer()
Ends rendering of a differential layer.
void SetFlip(bool xAxis, bool yAxis)
Sets flipping of the screen.
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
virtual void ClearTarget(RENDER_TARGET aTarget)
Clear the target for rendering.
void SetZoomFactor(double aZoomFactor)
virtual int BeginGroup()
Begin a group.
virtual void ChangeGroupDepth(int aGroupNumber, int aDepth)
Change the depth (Z-axis position) of the group.
virtual void EndNegativesLayer()
Ends rendering of a negatives layer and draws it to the main layer.
virtual void StartNegativesLayer()
Begins rendering in a new layer that will be copied to the main layer in EndNegativesLayer().
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor)
Change the color used to draw the group.
virtual void DrawGroup(int aGroupNumber)
Draw the stored group.
void SetLookAtPoint(const VECTOR2D &aPoint)
Get/set the Point in world space to look at.
virtual bool IsInitialized() const
Return the initialization status for the canvas.
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
virtual void EndGroup()
End the group.
virtual void ClearCache()
Delete all data created during caching of graphic items.
virtual void SetTarget(RENDER_TARGET aTarget)
Set the target for rendering.
const VECTOR2I & GetScreenPixelSize() const
Return GAL canvas size in pixels.
virtual bool IsVisible() const
Return true if the GAL canvas is visible on the screen.
virtual void EnableDepthTest(bool aEnabled=false)
Contains all the knowledge about how to draw graphical object onto any particular output device.
Definition: painter.h:59
virtual bool Draw(const VIEW_ITEM *aItem, int aLayer)=0
Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
virtual COLOR4D GetColor(const VIEW_ITEM *aItem, int aLayer) const =0
Returns the color that should be used to draw the specific VIEW_ITEM on the specific layer using curr...
Extend VIEW_ITEM by possibility of grouping items into a single object.
Definition: view_group.h:48
virtual unsigned int GetSize() const
Return the number of stored items.
Definition: view_group.cpp:76
virtual VIEW_ITEM * GetItem(unsigned int aIdx) const
Definition: view_group.cpp:82
bool storesGroups() const
Return information if the item uses at least one group id (ie.
Definition: view.cpp:157
std::vector< int > m_layers
Definition: view.cpp:236
int requiredUpdate() const
Return current update flag for an item.
Definition: view.cpp:206
int m_requiredUpdate
Flag required for updating.
Definition: view.cpp:229
int m_flags
Visibility flags.
Definition: view.cpp:228
void reorderGroups(std::unordered_map< int, int > aReorderMap)
Reorder the stored groups (to facilitate reordering of layers).
Definition: view.cpp:170
void deleteGroups()
Remove all of the stored group ids.
Definition: view.cpp:144
bool isRenderable() const
Return if the item should be drawn or not.
Definition: view.cpp:222
int m_drawPriority
Order to draw this item in a layer, lowest first.
Definition: view.cpp:230
VIEW * m_view
Current dynamic view the item is assigned to.
Definition: view.cpp:227
std::pair< int, int > * m_groups
layer_number:group_id pairs for each layer the item occupies.
Definition: view.cpp:232
int getGroup(int aLayer) const
Return number of the group id for the given layer, or -1 in case it was not cached before.
Definition: view.cpp:98
BOX2I m_bbox
Stores layer numbers used by the item.
Definition: view.cpp:238
void getLayers(int *aLayers, int &aCount) const
Return layer numbers used by the item.
Definition: view.cpp:82
void saveLayers(int *aLayers, int aCount)
Save layers used by the item.
Definition: view.cpp:190
void setGroup(int aLayer, int aGroup)
Set a group id for the item and the layer combination.
Definition: view.cpp:115
int GetFlags() const
Definition: view.cpp:68
void clearUpdateFlags()
Mark an item as already updated, so it is not going to be redrawn.
Definition: view.cpp:214
An abstract base class for deriving all objects that can be added to a VIEW.
Definition: view_item.h:84
virtual const BOX2I ViewBBox() const =0
Return the bounding box of the item covering all its layers.
double m_forcedTransparency
Additional transparency for diff'ing items.
Definition: view_item.h:166
VIEW_ITEM_DATA * viewPrivData() const
Definition: view_item.h:147
virtual void ViewDraw(int aLayer, VIEW *aView) const
Draw the parts of the object belonging to layer aLayer.
Definition: view_item.h:115
virtual void ViewGetLayers(int aLayers[], int &aCount) const =0
Return the all the layers within the VIEW the object is painted on.
virtual double ViewGetLOD(int aLayer, VIEW *aView) const
Return the level of detail (LOD) of the item.
Definition: view_item.h:141
VIEW_ITEM_DATA * m_viewPrivData
Definition: view_item.h:165
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
double GetScale() const
Definition: view.h:271
void SetMirror(bool aMirrorX, bool aMirrorY)
Control the mirroring of the VIEW.
Definition: view.cpp:539
void SortLayers(int aLayers[], int &aCount) const
Change the order of given layer ids, so after sorting the order corresponds to layers rendering order...
Definition: view.cpp:652
void ShowPreview(bool aShow=true)
Definition: view.cpp:1689
void sortLayers()
Clear cached GAL group numbers (ONLY numbers stored in VIEW_ITEMs, not group objects used by GAL)
Definition: view.cpp:1261
double m_maxScale
Definition: view.h:860
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition: view.cpp:512
std::vector< VIEW_LAYER > m_layers
Sorted list of pointers to members of m_layers.
Definition: view.h:843
void CopySettings(const VIEW *aOtherView)
Copy layers and visibility settings from another view.
Definition: view.cpp:487
virtual void SetScale(double aScale, VECTOR2D aAnchor={ 0, 0 })
Set the scaling factor, zooming around a given anchor point.
Definition: view.cpp:552
static constexpr int TOP_LAYER_MODIFIER
Definition: view.h:732
void draw(VIEW_ITEM *aItem, int aLayer, bool aImmediate=false)
Draw an item, but on a specified layers.
Definition: view.cpp:1040
std::vector< VIEW_ITEM * > m_ownedItems
Whether to use rendering order modifier or not.
Definition: view.h:837
bool m_reverseDrawOrder
Definition: view.h:885
void UpdateAllLayersOrder()
Do everything that is needed to apply the rendering order of layers.
Definition: view.cpp:897
void updateItemColor(VIEW_ITEM *aItem, int aLayer)
Update all information needed to draw an item.
Definition: view.cpp:1276
void SetViewport(const BOX2D &aViewport)
Set the visible area of the VIEW.
Definition: view.cpp:524
void SetRequired(int aLayerId, int aRequiredId, bool aRequired=true)
Mark the aRequiredId layer as required for the aLayerId layer.
Definition: view.cpp:390
VECTOR2D ToScreen(const VECTOR2D &aCoord, bool aAbsolute=true) const
Convert a world space point/vector to a point/vector in screen space coordinates.
Definition: view.cpp:468
static bool compareRenderingOrder(VIEW_LAYER *aI, VIEW_LAYER *aJ)
Check if every layer required by the aLayerId layer is enabled.
Definition: view.h:821
int GetLayerOrder(int aLayer) const
Return rendering order of a particular layer.
Definition: view.cpp:646
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:315
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:354
void ClearTargets()
Clear targets that are marked as dirty.
Definition: view.cpp:1139
virtual void EnableTopLayer(bool aEnable)
Enable or disable display of the top layer.
Definition: view.cpp:857
bool m_mirrorX
Definition: view.h:862
void UpdateAllLayersColor()
Apply the new coloring scheme to all layers.
Definition: view.cpp:766
bool m_mirrorY
PAINTER contains information how do draw items.
Definition: view.h:863
std::shared_ptr< std::vector< VIEW_ITEM * > > m_allItems
The set of layers that are displayed on the top.
Definition: view.h:849
std::shared_ptr< VIEW_OVERLAY > MakeOverlay()
Definition: view.cpp:1644
void SetGAL(GAL *aGal)
Assign a rendering device for the VIEW.
Definition: view.cpp:493
virtual int Query(const BOX2I &aRect, std::vector< LAYER_ITEM_PAIR > &aResult) const
Find all visible items that touch or are within the rectangle aRect.
Definition: view.cpp:426
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1631
void invalidateItem(VIEW_ITEM *aItem, int aUpdateFlags)
Manage dirty flags & redraw queuing when updating an item.
Definition: view.cpp:1219
const VECTOR2I & GetScreenPixelSize() const
Return the size of the our rendering area in pixels.
Definition: view.cpp:1183
bool HasItem(const VIEW_ITEM *aItem) const
Indicates whether or not the given item has been added to the view.
Definition: view.cpp:1617
virtual int GetTopLayer() const
Definition: view.cpp:821
PAINTER * m_painter
Interface to #PAINTER that is used to draw items.
Definition: view.h:866
virtual void Redraw()
Immediately redraws the whole view.
Definition: view.cpp:1158
void Clear()
Remove all items from the view.
Definition: view.cpp:1124
std::set< unsigned int > m_topLayers
Center point of the VIEW (the point at which we are looking at).
Definition: view.h:852
bool m_enableOrderModifier
The set of possible displayed layers and its properties.
Definition: view.h:840
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Converts a screen space point/vector to a point/vector in world space coordinates.
Definition: view.cpp:449
bool IsHiddenOnOverlay(const VIEW_ITEM *aItem) const
Definition: view.cpp:1609
void ClearTopLayers()
Remove all layers from the on-the-top set (they are no longer displayed over the rest of layers).
Definition: view.cpp:882
void InitPreview()
Definition: view.cpp:1668
void ClearPreview()
Definition: view.cpp:1653
void MarkClean()
Force redraw of view on the next rendering.
Definition: view.h:652
void updateItemGeometry(VIEW_ITEM *aItem, int aLayer)
Update bounding box of an item.
Definition: view.cpp:1295
static constexpr int VIEW_MAX_LAYERS
Rendering order modifier for layers that are marked as top layers.
Definition: view.h:729
double m_minScale
Definition: view.h:859
double m_scale
Definition: view.h:857
void updateLayers(VIEW_ITEM *aItem)
Determine rendering order of layers. Used in display order sorting function.
Definition: view.cpp:1346
void RecacheAllItems()
Rebuild GAL display lists.
Definition: view.cpp:1410
bool areRequiredLayersEnabled(int aLayerId) const
Definition: view.cpp:1393
bool IsTargetDirty(int aTarget) const
Return true if any of layers belonging to the target or the target itself should be redrawn.
Definition: view.h:608
int m_nextDrawPriority
Flag to reverse the draw order when using draw priority.
Definition: view.h:882
VIEW(bool aIsDynamic=true)
Definition: view.cpp:255
bool m_useDrawPriority
The next sequential drawing priority.
Definition: view.h:879
void UpdateItems()
Iterate through the list of items that asked for updating and updates them.
Definition: view.cpp:1427
bool IsCached(int aLayer) const
Return true if the layer is cached.
Definition: view.h:626
std::pair< VIEW_ITEM *, int > LAYER_ITEM_PAIR
Definition: view.h:72
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1513
std::unique_ptr< KIGFX::VIEW_GROUP > m_preview
Definition: view.h:836
static void OnDestroy(VIEW_ITEM *aItem)
Nasty hack, invoked by the destructor of VIEW_ITEM to auto-remove the item from the owning VIEW if th...
Definition: view.cpp:242
virtual ~VIEW()
Definition: view.cpp:309
GAL * m_gal
Dynamic VIEW (eg.
Definition: view.h:869
std::unique_ptr< VIEW > DataReference() const
Return a new VIEW object that shares the same set of VIEW_ITEMs and LAYERs.
Definition: view.cpp:1548
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1579
virtual void SetTopLayer(int aLayer, bool aEnabled=true)
Set given layer to be displayed on the top or sets back the default order of layers.
Definition: view.cpp:830
void AddToPreview(VIEW_ITEM *aItem, bool aTakeOwnership=true)
Definition: view.cpp:1675
void UpdateLayerColor(int aLayer)
Apply the new coloring scheme held by RENDER_SETTINGS in case that it has changed.
Definition: view.cpp:745
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:643
BOX2D m_boundary
Definition: view.h:858
void SetCenter(const VECTOR2D &aCenter)
Set the center point of the VIEW (i.e.
Definition: view.cpp:578
std::vector< VIEW_LAYER * > m_orderedLayers
Flat list of all items.
Definition: view.h:846
void clearGroupCache()
Definition: view.cpp:1207
VECTOR2D m_center
Definition: view.h:855
void SetLayerOrder(int aLayer, int aRenderingOrder)
Set rendering order of a particular layer.
Definition: view.cpp:638
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:619
void updateBbox(VIEW_ITEM *aItem)
Update set of layers that an item occupies.
Definition: view.cpp:1325
bool IsVisible(const VIEW_ITEM *aItem) const
Return information if the item is visible (or not).
Definition: view.cpp:1601
void UpdateAllItemsConditionally(int aUpdateFlags, std::function< bool(VIEW_ITEM *)> aCondition)
Update items in the view according to the given flags and condition.
Definition: view.cpp:1523
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Set the item visibility.
Definition: view.cpp:1558
void ReorderLayerData(std::unordered_map< int, int > aReorderMap)
Remap the data between layer ids without invalidating that data.
Definition: view.cpp:680
void redrawRect(const BOX2I &aRect)
Definition: view.cpp:997
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:295
A small class to help profiling.
Definition: profile.h:49
void Stop()
Save the time when this function was called, and set the counter stane to stop.
Definition: profile.h:88
double msecs(bool aSinceLast=false)
Definition: profile.h:149
Represent a set of closed polygons.
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset difference For aFastMode meaning, see function booleanOp.
bool IsEmpty() const
Return true if the set is empty (no polygons at all)
void Deflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError)
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.
#define _(s)
const wxChar *const traceGalProfile
Flag to enable debug output of GAL performance profiling.
The Cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:247
@ COLOR
Color has changed.
Definition: view_item.h:53
@ INITIAL_ADD
Item is being added to the view.
Definition: view_item.h:56
@ NONE
No updates are required.
Definition: view_item.h:51
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:57
@ APPEARANCE
Visibility flag has changed.
Definition: view_item.h:52
@ GEOMETRY
Position or shape has changed.
Definition: view_item.h:54
@ LAYERS
Layers have changed.
Definition: view_item.h:55
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:58
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition: definitions.h:49
@ TARGET_CACHED
Main rendering target (cached)
Definition: definitions.h:48
@ TARGET_OVERLAY
Items that may change while the view stays the same (noncached)
Definition: definitions.h:50
@ HIDDEN
Item is temporarily hidden (usually in favor of a being drawn from an overlay, such as a SELECTION).
Definition: view_item.h:66
@ OVERLAY_HIDDEN
Item is temporarily hidden from being drawn on an overlay.
Definition: view_item.h:69
@ VISIBLE
Item is visible (in general)
Definition: view_item.h:65
std::shared_ptr< PNS_LOG_VIEWER_OVERLAY > overlay
Definition: playground.cpp:38
CONTAINER::value_type item_type
Definition: view.cpp:406
QUERY_VISITOR(CONTAINER &aCont, int aLayer)
Definition: view.cpp:408
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:413
CONTAINER & m_cont
Definition: view.cpp:421
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:1196
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:941
DRAW_ITEM_VISITOR(VIEW *aView, int aLayer, bool aUseDrawPriority, bool aReverseDrawOrder)
Definition: view.cpp:931
int layers[VIEW_MAX_LAYERS]
Definition: view.cpp:989
std::vector< VIEW_ITEM * > drawItems
Definition: view.cpp:991
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:1099
RECACHE_ITEM_VISITOR(VIEW *aView, GAL *aGal, int aLayer)
Definition: view.cpp:1092
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:727
UPDATE_COLOR_VISITOR(int aLayer, PAINTER *aPainter, GAL *aGal)
Definition: view.cpp:720
UPDATE_DEPTH_VISITOR(int aLayer, int aDepth, GAL *aGal)
Definition: view.cpp:799
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:806
int renderingOrder
Rendering order of this layer.
Definition: view.h:742
std::shared_ptr< VIEW_RTREE > items
R-tree indexing all items on this layer.
Definition: view.h:741
RENDER_TARGET target
Where the layer should be rendered.
Definition: view.h:744
int id
Layer ID.
Definition: view.h:743
constexpr int delta
wxLogTrace helper definitions.
#define KI_TRACE(aWhat,...)
VECTOR2< double > VECTOR2D
Definition: vector2d.h:601