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 EAGLE_PLUGIN::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};
238
239
241{
242 if( aItem->m_viewPrivData )
243 {
244 if( aItem->m_viewPrivData->m_view )
245 aItem->m_viewPrivData->m_view->VIEW::Remove( aItem );
246
247 delete aItem->m_viewPrivData;
248 aItem->m_viewPrivData = nullptr;
249 }
250}
251
252
253VIEW::VIEW( bool aIsDynamic ) :
254 m_enableOrderModifier( true ),
255 m_scale( 4.0 ),
256 m_minScale( 0.2 ), m_maxScale( 50000.0 ),
257 m_mirrorX( false ), m_mirrorY( false ),
258 m_painter( nullptr ),
259 m_gal( nullptr ),
260 m_dynamic( aIsDynamic ),
261 m_useDrawPriority( false ),
262 m_nextDrawPriority( 0 ),
263 m_reverseDrawOrder( false )
264{
265 // Set m_boundary to define the max area size. The default area size
266 // is defined here as the max value of a int.
267 // this is a default value acceptable for Pcbnew and Gerbview, but too large for Eeschema.
268 // So in eeschema a call to SetBoundary() with a smaller value will be needed.
269 typedef std::numeric_limits<int> coord_limits;
270 double pos = coord_limits::lowest() / 2 + coord_limits::epsilon();
271 double size = coord_limits::max() - coord_limits::epsilon();
272 m_boundary.SetOrigin( pos, pos );
273 m_boundary.SetSize( size, size );
274
275 m_allItems.reset( new std::vector<VIEW_ITEM*> );
276 m_allItems->reserve( 32768 );
277
278 // Redraw everything at the beginning
279 MarkDirty();
280
281 m_layers.reserve( VIEW_MAX_LAYERS );
282
283 // View uses layers to display EDA_ITEMs (item may be displayed on several layers, for example
284 // pad may be shown on pad, pad hole and solder paste layers). There are usual copper layers
285 // (eg. F.Cu, B.Cu, internal and so on) and layers for displaying objects such as texts,
286 // silkscreen, pads, vias, etc.
287 for( int ii = 0; ii < VIEW_MAX_LAYERS; ++ii )
288 {
289 m_layers.emplace_back();
290 m_layers[ii].items = std::make_shared<VIEW_RTREE>();
291 m_layers[ii].id = ii;
292 m_layers[ii].renderingOrder = ii;
293 m_layers[ii].visible = true;
294 m_layers[ii].displayOnly = false;
295 m_layers[ii].diffLayer = false;
296 m_layers[ii].hasNegatives = false;
297 m_layers[ii].target = TARGET_CACHED;
298 }
299
300 sortLayers();
301
302 m_preview.reset( new KIGFX::VIEW_GROUP() );
303 Add( m_preview.get() );
304}
305
306
308{
309 Remove( m_preview.get() );
310}
311
312
313void VIEW::Add( VIEW_ITEM* aItem, int aDrawPriority )
314{
315 int layers[VIEW_MAX_LAYERS], layers_count;
316
317 if( aDrawPriority < 0 )
318 aDrawPriority = m_nextDrawPriority++;
319
320 if( !aItem->m_viewPrivData )
321 aItem->m_viewPrivData = new VIEW_ITEM_DATA;
322
323 wxASSERT_MSG( aItem->m_viewPrivData->m_view == nullptr
324 || aItem->m_viewPrivData->m_view == this,
325 wxS( "Already in a different view!" ) );
326
327 aItem->m_viewPrivData->m_view = this;
328 aItem->m_viewPrivData->m_drawPriority = aDrawPriority;
329
330 aItem->ViewGetLayers( layers, layers_count );
331 aItem->viewPrivData()->saveLayers( layers, layers_count );
332
333 m_allItems->push_back( aItem );
334
335 for( int i = 0; i < layers_count; ++i )
336 {
337 wxCHECK2_MSG( layers[i] >= 0 && static_cast<unsigned>( layers[i] ) < m_layers.size(),
338 continue, wxS( "Invalid layer" ) );
339
340 VIEW_LAYER& l = m_layers[layers[i]];
341 l.items->Insert( aItem );
343 }
344
345 SetVisible( aItem, true );
346 Update( aItem, KIGFX::INITIAL_ADD );
347}
348
349
351{
352 if( aItem && aItem->m_viewPrivData )
353 {
354 wxCHECK( aItem->m_viewPrivData->m_view == this, /*void*/ );
355 auto item = std::find( m_allItems->begin(), m_allItems->end(), aItem );
356
357 if( item != m_allItems->end() )
358 {
359 m_allItems->erase( item );
361 }
362
363 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
364 aItem->m_viewPrivData->getLayers( layers, layers_count );
365
366 for( int i = 0; i < layers_count; ++i )
367 {
368 VIEW_LAYER& l = m_layers[layers[i]];
369 l.items->Remove( aItem );
371
372 // Clear the GAL cache
373 int prevGroup = aItem->m_viewPrivData->getGroup( layers[i] );
374
375 if( prevGroup >= 0 )
376 m_gal->DeleteGroup( prevGroup );
377 }
378
380 aItem->m_viewPrivData->m_view = nullptr;
381 }
382}
383
384
385void VIEW::SetRequired( int aLayerId, int aRequiredId, bool aRequired )
386{
387 wxCHECK( (unsigned) aLayerId < m_layers.size(), /*void*/ );
388 wxCHECK( (unsigned) aRequiredId < m_layers.size(), /*void*/ );
389
390 if( aRequired )
391 m_layers[aLayerId].requiredLayers.insert( aRequiredId );
392 else
393 m_layers[aLayerId].requiredLayers.erase( aRequired );
394}
395
396
397// stupid C++... python lambda would do this in one line
398template <class CONTAINER>
400{
401 typedef typename CONTAINER::value_type item_type;
402
403 QUERY_VISITOR( CONTAINER& aCont, int aLayer ) :
404 m_cont( aCont ), m_layer( aLayer )
405 {
406 }
407
408 bool operator()( VIEW_ITEM* aItem )
409 {
410 if( aItem->viewPrivData()->GetFlags() & VISIBLE )
411 m_cont.push_back( VIEW::LAYER_ITEM_PAIR( aItem, m_layer ) );
412
413 return true;
414 }
415
418};
419
420
421int VIEW::Query( const BOX2I& aRect, std::vector<LAYER_ITEM_PAIR>& aResult ) const
422{
423 if( m_orderedLayers.empty() )
424 return 0;
425
426 std::vector<VIEW_LAYER*>::const_reverse_iterator i;
427
428 // execute queries in reverse direction, so that items that are on the top of
429 // the rendering stack are returned first.
430 for( i = m_orderedLayers.rbegin(); i != m_orderedLayers.rend(); ++i )
431 {
432 // ignore layers that do not contain actual items (i.e. the selection box, menus, floats)
433 if( ( *i )->displayOnly || !( *i )->visible )
434 continue;
435
436 QUERY_VISITOR<std::vector<LAYER_ITEM_PAIR> > visitor( aResult, ( *i )->id );
437 ( *i )->items->Query( aRect, visitor );
438 }
439
440 return aResult.size();
441}
442
443
444VECTOR2D VIEW::ToWorld( const VECTOR2D& aCoord, bool aAbsolute ) const
445{
446 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
447
448 if( aAbsolute )
449 return VECTOR2D( matrix * aCoord );
450 else
451 return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
452}
453
454
455double VIEW::ToWorld( double aSize ) const
456{
457 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
458
459 return fabs( matrix.GetScale().x * aSize );
460}
461
462
463VECTOR2D VIEW::ToScreen( const VECTOR2D& aCoord, bool aAbsolute ) const
464{
465 const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
466
467 if( aAbsolute )
468 return VECTOR2D( matrix * aCoord );
469 else
470 return VECTOR2D( matrix.GetScale().x * aCoord.x, matrix.GetScale().y * aCoord.y );
471}
472
473
474double VIEW::ToScreen( double aSize ) const
475{
476 const MATRIX3x3D& matrix = m_gal->GetWorldScreenMatrix();
477
478 return matrix.GetScale().x * aSize;
479}
480
481
482void VIEW::CopySettings( const VIEW* aOtherView )
483{
484 wxASSERT_MSG( false, wxT( "This is not implemented" ) );
485}
486
487
488void VIEW::SetGAL( GAL* aGal )
489{
490 bool recacheGroups = ( m_gal != nullptr ); // recache groups only if GAL is reassigned
491 m_gal = aGal;
492
493 // clear group numbers, so everything is going to be recached
494 if( recacheGroups )
496
497 // every target has to be refreshed
498 MarkDirty();
499
500 // force the new GAL to display the current viewport.
502 SetScale( m_scale );
504}
505
506
508{
509 BOX2D rect;
510 VECTOR2D screenSize = m_gal->GetScreenPixelSize();
511
512 rect.SetOrigin( ToWorld( VECTOR2D( 0, 0 ) ) );
513 rect.SetEnd( ToWorld( screenSize ) );
514
515 return rect.Normalize();
516}
517
518
519void VIEW::SetViewport( const BOX2D& aViewport )
520{
521 VECTOR2D ssize = ToWorld( m_gal->GetScreenPixelSize(), false );
522
523 wxCHECK( fabs(ssize.x) > 0 && fabs(ssize.y) > 0, /*void*/ );
524
525 VECTOR2D centre = aViewport.Centre();
526 VECTOR2D vsize = aViewport.GetSize();
527 double zoom = 1.0 / std::max( fabs( vsize.x / ssize.x ), fabs( vsize.y / ssize.y ) );
528
529 SetCenter( centre );
530 SetScale( GetScale() * zoom );
531}
532
533
534void VIEW::SetMirror( bool aMirrorX, bool aMirrorY )
535{
536 wxASSERT_MSG( !aMirrorY, _( "Mirroring for Y axis is not supported yet" ) );
537
538 m_mirrorX = aMirrorX;
539 m_mirrorY = aMirrorY;
540 m_gal->SetFlip( aMirrorX, aMirrorY );
541
542 // Redraw everything
543 MarkDirty();
544}
545
546
547void VIEW::SetScale( double aScale, VECTOR2D aAnchor )
548{
549 if( aAnchor == VECTOR2D( 0, 0 ) )
550 aAnchor = m_center;
551
552 VECTOR2D a = ToScreen( aAnchor );
553
554 if( aScale < m_minScale )
556 else if( aScale > m_maxScale )
558 else
559 m_scale = aScale;
560
563
564 VECTOR2D delta = ToWorld( a ) - aAnchor;
565
567
568 // Redraw everything after the viewport has changed
569 MarkDirty();
570}
571
572
573void VIEW::SetCenter( const VECTOR2D& aCenter )
574{
575 m_center = aCenter;
576
577 if( !m_boundary.Contains( aCenter ) )
578 {
579 if( m_center.x < m_boundary.GetLeft() )
581 else if( aCenter.x > m_boundary.GetRight() )
583
584 if( m_center.y < m_boundary.GetTop() )
586 else if( m_center.y > m_boundary.GetBottom() )
588 }
589
592
593 // Redraw everything after the viewport has changed
594 MarkDirty();
595}
596
597
598void VIEW::SetCenter( const VECTOR2D& aCenter, const std::vector<BOX2D>& obscuringScreenRects )
599{
600 if( obscuringScreenRects.empty() )
601 return SetCenter( aCenter );
602
603 BOX2D screenRect( { 0, 0 }, m_gal->GetScreenPixelSize() );
604 SHAPE_POLY_SET unobscuredPoly( screenRect );
605 VECTOR2D unobscuredCenter = screenRect.Centre();
606
607 for( const BOX2D& obscuringScreenRect : obscuringScreenRects )
608 {
609 SHAPE_POLY_SET obscuringPoly( obscuringScreenRect );
610 unobscuredPoly.BooleanSubtract( obscuringPoly, SHAPE_POLY_SET::PM_FAST );
611 }
612
613 /*
614 * Perform a step-wise deflate to find the center of the largest unobscured area
615 */
616
617 BOX2I bbox = unobscuredPoly.BBox();
618 int step = std::min( bbox.GetWidth(), bbox.GetHeight() ) / 10;
619
620 while( !unobscuredPoly.IsEmpty() )
621 {
622 unobscuredCenter = unobscuredPoly.BBox().Centre();
623 unobscuredPoly.Deflate( step, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, ARC_LOW_DEF );
624 }
625
626 SetCenter( aCenter - ToWorld( unobscuredCenter - screenRect.Centre(), false ) );
627}
628
629
630void VIEW::SetLayerOrder( int aLayer, int aRenderingOrder )
631{
632 m_layers[aLayer].renderingOrder = aRenderingOrder;
633
634 sortLayers();
635}
636
637
638int VIEW::GetLayerOrder( int aLayer ) const
639{
640 return m_layers.at( aLayer ).renderingOrder;
641}
642
643
644void VIEW::SortLayers( int aLayers[], int& aCount ) const
645{
646 int maxLay, maxOrd, maxIdx;
647
648 for( int i = 0; i < aCount; ++i )
649 {
650 maxLay = aLayers[i];
651 maxOrd = GetLayerOrder( maxLay );
652 maxIdx = i;
653
654 // Look for the max element in the range (j..aCount)
655 for( int j = i; j < aCount; ++j )
656 {
657 if( maxOrd < GetLayerOrder( aLayers[j] ) )
658 {
659 maxLay = aLayers[j];
660 maxOrd = GetLayerOrder( maxLay );
661 maxIdx = j;
662 }
663 }
664
665 // Swap elements
666 aLayers[maxIdx] = aLayers[i];
667 aLayers[i] = maxLay;
668 }
669}
670
671
672void VIEW::ReorderLayerData( std::unordered_map<int, int> aReorderMap )
673{
674 std::vector<VIEW_LAYER> new_map;
675 new_map.reserve( m_layers.size() );
676
677 for( const VIEW_LAYER& layer : m_layers )
678 new_map.push_back( layer );
679
680 for( auto& pair : aReorderMap )
681 {
682 new_map[pair.second] = m_layers[pair.first];
683 new_map[pair.second].id = pair.second;
684 }
685
686 m_layers = new_map;
687
688 for( VIEW_ITEM* item : *m_allItems )
689 {
690 VIEW_ITEM_DATA* viewData = item->viewPrivData();
691
692 if( !viewData )
693 continue;
694
695 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
696
697 item->ViewGetLayers( layers, layers_count );
698 viewData->saveLayers( layers, layers_count );
699
700 viewData->reorderGroups( aReorderMap );
701
702 viewData->m_requiredUpdate |= COLOR;
703 }
704
705 UpdateItems();
706}
707
708
710{
711 UPDATE_COLOR_VISITOR( int aLayer, PAINTER* aPainter, GAL* aGal ) :
712 layer( aLayer ),
713 painter( aPainter ),
714 gal( aGal )
715 {
716 }
717
718 bool operator()( VIEW_ITEM* aItem )
719 {
720 // Obtain the color that should be used for coloring the item
721 const COLOR4D color = painter->GetSettings()->GetColor( aItem, layer );
722 int group = aItem->viewPrivData()->getGroup( layer );
723
724 if( group >= 0 )
726
727 return true;
728 }
729
730 int layer;
733};
734
735
736void VIEW::UpdateLayerColor( int aLayer )
737{
738 // There is no point in updating non-cached layers
739 if( !IsCached( aLayer ) )
740 return;
741
742 BOX2I r;
743
744 r.SetMaximum();
745
746 if( m_gal->IsVisible() )
747 {
749
750 UPDATE_COLOR_VISITOR visitor( aLayer, m_painter, m_gal );
751 m_layers[aLayer].items->Query( r, visitor );
752 MarkTargetDirty( m_layers[aLayer].target );
753 }
754}
755
756
758{
759 if( m_gal->IsVisible() )
760 {
762
763 for( VIEW_ITEM* item : *m_allItems )
764 {
765 VIEW_ITEM_DATA* viewData = item->viewPrivData();
766
767 if( !viewData )
768 continue;
769
770 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
771 viewData->getLayers( layers, layers_count );
772
773 for( int i = 0; i < layers_count; ++i )
774 {
775 const COLOR4D color = m_painter->GetSettings()->GetColor( item, layers[i] );
776 int group = viewData->getGroup( layers[i] );
777
778 if( group >= 0 )
780 }
781 }
782 }
783
784 MarkDirty();
785}
786
787
789{
790 UPDATE_DEPTH_VISITOR( int aLayer, int aDepth, GAL* aGal ) :
791 layer( aLayer ),
792 depth( aDepth ),
793 gal( aGal )
794 {
795 }
796
797 bool operator()( VIEW_ITEM* aItem )
798 {
799 int group = aItem->viewPrivData()->getGroup( layer );
800
801 if( group >= 0 )
803
804 return true;
805 }
806
809};
810
811
813{
814 if( m_topLayers.size() == 0 )
815 return 0;
816
817 return *m_topLayers.begin();
818}
819
820
821void VIEW::SetTopLayer( int aLayer, bool aEnabled )
822{
823 if( aEnabled )
824 {
825 if( m_topLayers.count( aLayer ) == 1 )
826 return;
827
828 m_topLayers.insert( aLayer );
829
830 // Move the layer closer to front
832 m_layers[aLayer].renderingOrder += TOP_LAYER_MODIFIER;
833 }
834 else
835 {
836 if( m_topLayers.count( aLayer ) == 0 )
837 return;
838
839 m_topLayers.erase( aLayer );
840
841 // Restore the previous rendering order
843 m_layers[aLayer].renderingOrder -= TOP_LAYER_MODIFIER;
844 }
845}
846
847
848void VIEW::EnableTopLayer( bool aEnable )
849{
850 if( aEnable == m_enableOrderModifier )
851 return;
852
853 m_enableOrderModifier = aEnable;
854
855 std::set<unsigned int>::iterator it;
856
857 if( aEnable )
858 {
859 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
860 m_layers[*it].renderingOrder += TOP_LAYER_MODIFIER;
861 }
862 else
863 {
864 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
865 m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
866 }
867
870}
871
872
874{
875 std::set<unsigned int>::iterator it;
876
878 {
879 // Restore the previous rendering order for layers that were marked as top
880 for( it = m_topLayers.begin(); it != m_topLayers.end(); ++it )
881 m_layers[*it].renderingOrder -= TOP_LAYER_MODIFIER;
882 }
883
884 m_topLayers.clear();
885}
886
887
889{
890 sortLayers();
891
892 if( m_gal->IsVisible() )
893 {
895
896 for( VIEW_ITEM* item : *m_allItems )
897 {
898 VIEW_ITEM_DATA* viewData = item->viewPrivData();
899
900 if( !viewData )
901 continue;
902
903 int layers[VIEW::VIEW_MAX_LAYERS], layers_count;
904 viewData->getLayers( layers, layers_count );
905
906 for( int i = 0; i < layers_count; ++i )
907 {
908 int group = viewData->getGroup( layers[i] );
909
910 if( group >= 0 )
911 m_gal->ChangeGroupDepth( group, m_layers[layers[i]].renderingOrder );
912 }
913 }
914 }
915
916 MarkDirty();
917}
918
919
921{
922 DRAW_ITEM_VISITOR( VIEW* aView, int aLayer, bool aUseDrawPriority, bool aReverseDrawOrder ) :
923 view( aView ),
924 layer( aLayer ),
925 useDrawPriority( aUseDrawPriority ),
926 reverseDrawOrder( aReverseDrawOrder ),
927 drawForcedTransparent( false ),
929 {
930 }
931
932 bool operator()( VIEW_ITEM* aItem )
933 {
934 wxCHECK( aItem->viewPrivData(), false );
935
937 {
939 return true;
940 }
941
942 // Conditions that have to be fulfilled for an item to be drawn
943 bool drawCondition = aItem->viewPrivData()->isRenderable()
944 && aItem->ViewGetLOD( layer, view ) < view->m_scale;
945 if( !drawCondition )
946 return true;
947
948 if( useDrawPriority )
949 drawItems.push_back( aItem );
950 else
951 view->draw( aItem, layer );
952
953 return true;
954 }
955
957 {
958 if( reverseDrawOrder )
959 {
960 std::sort( drawItems.begin(), drawItems.end(),
961 []( VIEW_ITEM* a, VIEW_ITEM* b ) -> bool
962 {
963 return b->viewPrivData()->m_drawPriority < a->viewPrivData()->m_drawPriority;
964 } );
965 }
966 else
967 {
968 std::sort( drawItems.begin(), drawItems.end(),
969 []( VIEW_ITEM* a, VIEW_ITEM* b ) -> bool
970 {
971 return a->viewPrivData()->m_drawPriority < b->viewPrivData()->m_drawPriority;
972 } );
973 }
974
975 for( VIEW_ITEM* item : drawItems )
976 view->draw( item, layer );
977 }
978
982 std::vector<VIEW_ITEM*> drawItems;
985};
986
987
988void VIEW::redrawRect( const BOX2I& aRect )
989{
990 for( VIEW_LAYER* l : m_orderedLayers )
991 {
992 if( l->visible && IsTargetDirty( l->target ) && areRequiredLayersEnabled( l->id ) )
993 {
995
996 m_gal->SetTarget( l->target );
997 m_gal->SetLayerDepth( l->renderingOrder );
998
999 // Differential layer also work for the negatives, since both special layer types
1000 // will composite on separate layers (at least in Cairo)
1001 if( l->diffLayer )
1003 else if( l->hasNegatives )
1005
1006 l->items->Query( aRect, drawFunc );
1007
1008 if( m_useDrawPriority )
1009 drawFunc.deferredDraw();
1010
1011 if( l->diffLayer )
1013 else if( l->hasNegatives )
1015
1016 if( drawFunc.foundForcedTransparent )
1017 {
1018 drawFunc.drawForcedTransparent = true;
1019
1021 m_gal->EnableDepthTest( true );
1022 m_gal->SetLayerDepth( l->renderingOrder );
1023
1024 l->items->Query( aRect, drawFunc );
1025 }
1026 }
1027 }
1028}
1029
1030
1031void VIEW::draw( VIEW_ITEM* aItem, int aLayer, bool aImmediate )
1032{
1033 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1034
1035 if( !viewData )
1036 return;
1037
1038 if( IsCached( aLayer ) && !aImmediate )
1039 {
1040 // Draw using cached information or create one
1041 int group = viewData->getGroup( aLayer );
1042
1043 if( group >= 0 )
1044 m_gal->DrawGroup( group );
1045 else
1046 Update( aItem );
1047 }
1048 else
1049 {
1050 // Immediate mode
1051 if( !m_painter->Draw( aItem, aLayer ) )
1052 aItem->ViewDraw( aLayer, this ); // Alternative drawing method
1053 }
1054}
1055
1056
1057void VIEW::draw( VIEW_ITEM* aItem, bool aImmediate )
1058{
1059 int layers[VIEW_MAX_LAYERS], layers_count;
1060
1061 aItem->ViewGetLayers( layers, layers_count );
1062
1063 // Sorting is needed for drawing order dependent GALs (like Cairo)
1064 SortLayers( layers, layers_count );
1065
1066 for( int i = 0; i < layers_count; ++i )
1067 {
1068 m_gal->SetLayerDepth( m_layers.at( layers[i] ).renderingOrder );
1069 draw( aItem, layers[i], aImmediate );
1070 }
1071}
1072
1073
1074void VIEW::draw( VIEW_GROUP* aGroup, bool aImmediate )
1075{
1076 for( unsigned int i = 0; i < aGroup->GetSize(); i++)
1077 draw( aGroup->GetItem(i), aImmediate );
1078}
1079
1080
1082{
1083 RECACHE_ITEM_VISITOR( VIEW* aView, GAL* aGal, int aLayer ) :
1084 view( aView ),
1085 gal( aGal ),
1086 layer( aLayer )
1087 {
1088 }
1089
1090 bool operator()( VIEW_ITEM* aItem )
1091 {
1092 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1093
1094 if( !viewData )
1095 return false;
1096
1097 // Remove previously cached group
1098 int group = viewData->getGroup( layer );
1099
1100 if( group >= 0 )
1101 gal->DeleteGroup( group );
1102
1103 viewData->setGroup( layer, -1 );
1104 view->Update( aItem );
1105
1106 return true;
1107 }
1108
1112};
1113
1114
1116{
1117 BOX2I r;
1118 r.SetMaximum();
1119 m_allItems->clear();
1120
1121 for( VIEW_LAYER& layer : m_layers )
1122 layer.items->RemoveAll();
1123
1125
1126 m_gal->ClearCache();
1127}
1128
1129
1131{
1133 {
1134 // TARGET_CACHED and TARGET_NONCACHED have to be redrawn together, as they contain
1135 // layers that rely on each other (eg. netnames are noncached, but tracks - are cached)
1138
1139 MarkDirty();
1140 }
1141
1143 {
1145 }
1146}
1147
1148
1150{
1151#ifdef KICAD_GAL_PROFILE
1152 PROF_TIMER totalRealTime;
1153#endif /* KICAD_GAL_PROFILE */
1154
1155 VECTOR2D screenSize = m_gal->GetScreenPixelSize();
1156 BOX2D rect( ToWorld( VECTOR2D( 0, 0 ) ),
1157 ToWorld( screenSize ) - ToWorld( VECTOR2D( 0, 0 ) ) );
1158
1159 rect.Normalize();
1160 BOX2I recti( rect.GetPosition(), rect.GetSize() );
1161
1162 // The view rtree uses integer positions. Large screens can overflow this size so in
1163 // this case, simply set the rectangle to the full rtree.
1164 if( rect.GetWidth() > std::numeric_limits<int>::max()
1165 || rect.GetHeight() > std::numeric_limits<int>::max() )
1166 {
1167 recti.SetMaximum();
1168 }
1169
1170 redrawRect( recti );
1171
1172 // All targets were redrawn, so nothing is dirty
1173 MarkClean();
1174
1175#ifdef KICAD_GAL_PROFILE
1176 totalRealTime.Stop();
1177 wxLogTrace( traceGalProfile, wxS( "VIEW::Redraw(): %.1f ms" ), totalRealTime.msecs() );
1178#endif /* KICAD_GAL_PROFILE */
1179}
1180
1181
1183{
1184 return m_gal->GetScreenPixelSize();
1185}
1186
1187
1189{
1191 view( aView )
1192 {
1193 }
1194
1195 bool operator()( VIEW_ITEM* aItem )
1196 {
1197 aItem->viewPrivData()->deleteGroups();
1198
1199 return true;
1200 }
1201
1203};
1204
1205
1207{
1208 BOX2I r;
1209
1210 r.SetMaximum();
1211 CLEAR_LAYER_CACHE_VISITOR visitor( this );
1212
1213 for( VIEW_LAYER& layer : m_layers )
1214 layer.items->Query( r, visitor );
1215}
1216
1217
1218void VIEW::invalidateItem( VIEW_ITEM* aItem, int aUpdateFlags )
1219{
1220 if( aUpdateFlags & INITIAL_ADD )
1221 {
1222 // Don't update layers or bbox, since it was done in VIEW::Add()
1223 // Now that we have initialized, set flags to ALL for the code below
1224 aUpdateFlags = ALL;
1225 }
1226 else
1227 {
1228 // updateLayers updates geometry too, so we do not have to update both of them at the
1229 // same time
1230 if( aUpdateFlags & LAYERS )
1231 updateLayers( aItem );
1232 else if( aUpdateFlags & GEOMETRY )
1233 updateBbox( aItem );
1234 }
1235
1236 int layers[VIEW_MAX_LAYERS], layers_count;
1237 aItem->ViewGetLayers( layers, layers_count );
1238
1239 // Iterate through layers used by the item and recache it immediately
1240 for( int i = 0; i < layers_count; ++i )
1241 {
1242 int layerId = layers[i];
1243
1244 if( IsCached( layerId ) )
1245 {
1246 if( aUpdateFlags & ( GEOMETRY | LAYERS | REPAINT ) )
1247 updateItemGeometry( aItem, layerId );
1248 else if( aUpdateFlags & COLOR )
1249 updateItemColor( aItem, layerId );
1250 }
1251
1252 // Mark those layers as dirty, so the VIEW will be refreshed
1253 MarkTargetDirty( m_layers[layerId].target );
1254 }
1255
1256 aItem->viewPrivData()->clearUpdateFlags();
1257}
1258
1259
1261{
1262 int n = 0;
1263
1264 m_orderedLayers.resize( m_layers.size() );
1265
1266 for( VIEW_LAYER& layer : m_layers )
1267 m_orderedLayers[n++] = &layer;
1268
1270
1271 MarkDirty();
1272}
1273
1274
1275void VIEW::updateItemColor( VIEW_ITEM* aItem, int aLayer )
1276{
1277 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1278 wxCHECK( (unsigned) aLayer < m_layers.size(), /*void*/ );
1279 wxCHECK( IsCached( aLayer ), /*void*/ );
1280
1281 if( !viewData )
1282 return;
1283
1284 // Obtain the color that should be used for coloring the item on the specific layerId
1285 const COLOR4D color = m_painter->GetSettings()->GetColor( aItem, aLayer );
1286 int group = viewData->getGroup( aLayer );
1287
1288 // Change the color, only if it has group assigned
1289 if( group >= 0 )
1291}
1292
1293
1294void VIEW::updateItemGeometry( VIEW_ITEM* aItem, int aLayer )
1295{
1296 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1297 wxCHECK( (unsigned) aLayer < m_layers.size(), /*void*/ );
1298 wxCHECK( IsCached( aLayer ), /*void*/ );
1299
1300 if( !viewData )
1301 return;
1302
1303 VIEW_LAYER& l = m_layers.at( aLayer );
1304
1305 m_gal->SetTarget( l.target );
1307
1308 // Redraw the item from scratch
1309 int group = viewData->getGroup( aLayer );
1310
1311 if( group >= 0 )
1313
1314 group = m_gal->BeginGroup();
1315 viewData->setGroup( aLayer, group );
1316
1317 if( !m_painter->Draw( aItem, aLayer ) )
1318 aItem->ViewDraw( aLayer, this ); // Alternative drawing method
1319
1320 m_gal->EndGroup();
1321}
1322
1323
1325{
1326 int layers[VIEW_MAX_LAYERS], layers_count;
1327
1328 aItem->ViewGetLayers( layers, layers_count );
1329
1330 for( int i = 0; i < layers_count; ++i )
1331 {
1332 VIEW_LAYER& l = m_layers[layers[i]];
1333 l.items->Remove( aItem );
1334 l.items->Insert( aItem );
1336 }
1337}
1338
1339
1341{
1342 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1343 int layers[VIEW_MAX_LAYERS], layers_count;
1344
1345 if( !viewData )
1346 return;
1347
1348 // Remove the item from previous layer set
1349 viewData->getLayers( layers, layers_count );
1350
1351 for( int i = 0; i < layers_count; ++i )
1352 {
1353 VIEW_LAYER& l = m_layers[layers[i]];
1354 l.items->Remove( aItem );
1356
1357 if( IsCached( l.id ) )
1358 {
1359 // Redraw the item from scratch
1360 int prevGroup = viewData->getGroup( layers[i] );
1361
1362 if( prevGroup >= 0 )
1363 {
1364 m_gal->DeleteGroup( prevGroup );
1365 viewData->setGroup( l.id, -1 );
1366 }
1367 }
1368 }
1369
1370 // Add the item to new layer set
1371 aItem->ViewGetLayers( layers, layers_count );
1372 viewData->saveLayers( layers, layers_count );
1373
1374 for( int i = 0; i < layers_count; i++ )
1375 {
1376 VIEW_LAYER& l = m_layers[layers[i]];
1377 l.items->Insert( aItem );
1379 }
1380}
1381
1382
1383bool VIEW::areRequiredLayersEnabled( int aLayerId ) const
1384{
1385 wxCHECK( (unsigned) aLayerId < m_layers.size(), false );
1386
1387 std::set<int>::const_iterator it, it_end;
1388
1389 for( int layer : m_layers.at( aLayerId ).requiredLayers )
1390 {
1391 // That is enough if just one layer is not enabled
1392 if( !m_layers.at( layer ).visible || !areRequiredLayersEnabled( layer ) )
1393 return false;
1394 }
1395
1396 return true;
1397}
1398
1399
1401{
1402 BOX2I r;
1403
1404 r.SetMaximum();
1405
1406 for( const VIEW_LAYER& l : m_layers )
1407 {
1408 if( IsCached( l.id ) )
1409 {
1410 RECACHE_ITEM_VISITOR visitor( this, m_gal, l.id );
1411 l.items->Query( r, visitor );
1412 }
1413 }
1414}
1415
1416
1418{
1419 if( !m_gal->IsVisible() || !m_gal->IsInitialized() )
1420 return;
1421
1422 unsigned int cntGeomUpdate = 0;
1423 bool anyUpdated = false;
1424
1425 for( VIEW_ITEM* item : *m_allItems )
1426 {
1427 auto vpd = item->viewPrivData();
1428
1429 if( !vpd )
1430 continue;
1431
1432 if( vpd->m_requiredUpdate != NONE )
1433 {
1434 anyUpdated = true;
1435
1436 if( vpd->m_requiredUpdate & ( GEOMETRY | LAYERS ) )
1437 {
1438 cntGeomUpdate++;
1439 }
1440 }
1441 }
1442
1443 unsigned int cntTotal = m_allItems->size();
1444
1445 double ratio = (double) cntGeomUpdate / (double) cntTotal;
1446
1447 // Optimization to improve view update time. If a lot of items (say, 30%) have their
1448 // bboxes/geometry changed it's way faster (around 10 times) to rebuild the R-Trees
1449 // from scratch rather than update the bbox of each changed item. Pcbnew does multiple
1450 // full geometry updates during file load, this can save a solid 30 seconds on load time
1451 // for larger designs...
1452
1453 if( ratio > 0.3 )
1454 {
1455 auto allItems = *m_allItems;
1456 int layers[VIEW_MAX_LAYERS], layers_count;
1457
1458 // kill all Rtrees
1459 for( VIEW_LAYER& layer : m_layers )
1460 layer.items->RemoveAll();
1461
1462 // and re-insert items from scratch
1463 for( VIEW_ITEM* item : allItems )
1464 {
1465 item->ViewGetLayers( layers, layers_count );
1466 item->viewPrivData()->saveLayers( layers, layers_count );
1467
1468 for( int i = 0; i < layers_count; ++i )
1469 {
1470 wxCHECK2_MSG( layers[i] >= 0 && static_cast<unsigned>( layers[i] ) < m_layers.size(),
1471 continue, wxS( "Invalid layer" ) );
1472 VIEW_LAYER& l = m_layers[layers[i]];
1473 l.items->Insert( item );
1475 }
1476
1477 item->viewPrivData()->m_requiredUpdate &= ~( LAYERS | GEOMETRY );
1478 }
1479 }
1480
1481 if( anyUpdated )
1482 {
1484
1485 for( VIEW_ITEM* item : *m_allItems.get() )
1486 {
1487 if( item->viewPrivData() && item->viewPrivData()->m_requiredUpdate != NONE )
1488 {
1489 invalidateItem( item, item->viewPrivData()->m_requiredUpdate );
1490 item->viewPrivData()->m_requiredUpdate = NONE;
1491 }
1492 }
1493 }
1494
1495 KI_TRACE( traceGalProfile, wxS( "View update: total items %u, geom %u anyUpdated %u\n" ), cntTotal,
1496 cntGeomUpdate, (unsigned) anyUpdated );
1497}
1498
1499
1500void VIEW::UpdateAllItems( int aUpdateFlags )
1501{
1502 for( VIEW_ITEM* item : *m_allItems )
1503 {
1504 if( item->viewPrivData() )
1505 item->viewPrivData()->m_requiredUpdate |= aUpdateFlags;
1506 }
1507}
1508
1509
1511 std::function<bool( VIEW_ITEM* )> aCondition )
1512{
1513 for( VIEW_ITEM* item : *m_allItems )
1514 {
1515 if( aCondition( item ) )
1516 {
1517 if( item->viewPrivData() )
1518 item->viewPrivData()->m_requiredUpdate |= aUpdateFlags;
1519 }
1520 }
1521}
1522
1523
1524void VIEW::UpdateAllItemsConditionally( std::function<int( VIEW_ITEM* )> aItemFlagsProvider )
1525{
1526 for( VIEW_ITEM* item : *m_allItems )
1527 {
1528 if( item->viewPrivData() )
1529 item->viewPrivData()->m_requiredUpdate |= aItemFlagsProvider( item );
1530 }
1531}
1532
1533
1534
1535std::unique_ptr<VIEW> VIEW::DataReference() const
1536{
1537 std::unique_ptr<VIEW> ret = std::make_unique<VIEW>();
1538 ret->m_allItems = m_allItems;
1539 ret->m_layers = m_layers;
1540 ret->sortLayers();
1541 return ret;
1542}
1543
1544
1545void VIEW::SetVisible( VIEW_ITEM* aItem, bool aIsVisible )
1546{
1547 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1548
1549 if( !viewData )
1550 return;
1551
1552 bool cur_visible = viewData->m_flags & VISIBLE;
1553
1554 if( cur_visible != aIsVisible )
1555 {
1556 if( aIsVisible )
1557 viewData->m_flags |= VISIBLE;
1558 else
1559 viewData->m_flags &= ~VISIBLE;
1560
1561 Update( aItem, APPEARANCE | COLOR );
1562 }
1563}
1564
1565
1566void VIEW::Hide( VIEW_ITEM* aItem, bool aHide, bool aHideOverlay )
1567{
1568 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1569
1570 if( !viewData )
1571 return;
1572
1573 if( !( viewData->m_flags & VISIBLE ) )
1574 return;
1575
1576 if( aHideOverlay )
1577 viewData->m_flags |= OVERLAY_HIDDEN;
1578
1579 if( aHide )
1580 viewData->m_flags |= HIDDEN;
1581 else
1582 viewData->m_flags &= ~( HIDDEN | OVERLAY_HIDDEN );
1583
1584 Update( aItem, APPEARANCE );
1585}
1586
1587
1588bool VIEW::IsVisible( const VIEW_ITEM* aItem ) const
1589{
1590 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1591
1592 return viewData && ( viewData->m_flags & VISIBLE );
1593}
1594
1595
1596bool VIEW::IsHiddenOnOverlay( const VIEW_ITEM* aItem ) const
1597{
1598 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1599
1600 return viewData && ( viewData->m_flags & OVERLAY_HIDDEN );
1601}
1602
1603
1604bool VIEW::HasItem( const VIEW_ITEM* aItem ) const
1605{
1606 const VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1607
1608 return viewData && viewData->m_view == this;
1609}
1610
1611
1612void VIEW::Update( const VIEW_ITEM* aItem ) const
1613{
1614 Update( aItem, ALL );
1615}
1616
1617
1618void VIEW::Update( const VIEW_ITEM* aItem, int aUpdateFlags ) const
1619{
1620 VIEW_ITEM_DATA* viewData = aItem->viewPrivData();
1621
1622 if( !viewData )
1623 return;
1624
1625 assert( aUpdateFlags != NONE );
1626
1627 viewData->m_requiredUpdate |= aUpdateFlags;
1628}
1629
1630
1631std::shared_ptr<VIEW_OVERLAY> VIEW::MakeOverlay()
1632{
1633 std::shared_ptr<VIEW_OVERLAY> overlay = std::make_shared<VIEW_OVERLAY>();
1634
1635 Add( overlay.get() );
1636 return overlay;
1637}
1638
1639
1641{
1642 if( !m_preview )
1643 return;
1644
1645 m_preview->Clear();
1646
1647 for( VIEW_ITEM* item : m_ownedItems )
1648 delete item;
1649
1650 m_ownedItems.clear();
1651 Update( m_preview.get() );
1652}
1653
1654
1656{
1657 m_preview.reset( new KIGFX::VIEW_GROUP() );
1658 Add( m_preview.get() );
1659}
1660
1661
1662void VIEW::AddToPreview( VIEW_ITEM* aItem, bool aTakeOwnership )
1663{
1664 Hide( aItem, false );
1665 m_preview->Add( aItem );
1666
1667 if( aTakeOwnership )
1668 m_ownedItems.push_back( aItem );
1669
1670 SetVisible( m_preview.get(), true );
1671 Hide( m_preview.get(), false );
1672 Update( m_preview.get() );
1673}
1674
1675
1676void VIEW::ShowPreview( bool aShow )
1677{
1678 SetVisible( m_preview.get(), aShow );
1679}
1680
1681
1682} // namespace KIGFX
int color
Definition: DXF_plotter.cpp:58
constexpr int ARC_LOW_DEF
Definition: base_units.h:120
void SetOrigin(const Vec &pos)
Definition: box2.h:203
BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
Definition: box2.h:120
const Vec & GetPosition() const
Definition: box2.h:185
void SetMaximum()
Definition: box2.h:64
coord_type GetTop() const
Definition: box2.h:195
coord_type GetHeight() const
Definition: box2.h:189
coord_type GetWidth() const
Definition: box2.h:188
void SetSize(const Vec &size)
Definition: box2.h:214
bool Contains(const Vec &aPoint) const
Definition: box2.h:142
Vec Centre() const
Definition: box2.h:71
coord_type GetRight() const
Definition: box2.h:190
coord_type GetLeft() const
Definition: box2.h:194
const Vec & GetSize() const
Definition: box2.h:180
coord_type GetBottom() const
Definition: box2.h:191
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:256
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
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
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:534
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:644
void ShowPreview(bool aShow=true)
Definition: view.cpp:1676
void sortLayers()
Clear cached GAL group numbers (ONLY numbers stored in VIEW_ITEMs, not group objects used by GAL)
Definition: view.cpp:1260
double m_maxScale
Definition: view.h:860
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition: view.cpp:507
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:482
virtual void SetScale(double aScale, VECTOR2D aAnchor={ 0, 0 })
Set the scaling factor, zooming around a given anchor point.
Definition: view.cpp:547
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:1031
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:888
void updateItemColor(VIEW_ITEM *aItem, int aLayer)
Update all information needed to draw an item.
Definition: view.cpp:1275
void SetViewport(const BOX2D &aViewport)
Set the visible area of the VIEW.
Definition: view.cpp:519
void SetRequired(int aLayerId, int aRequiredId, bool aRequired=true)
Mark the aRequiredId layer as required for the aLayerId layer.
Definition: view.cpp:385
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:463
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:638
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:313
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:350
void ClearTargets()
Clear targets that are marked as dirty.
Definition: view.cpp:1130
virtual void EnableTopLayer(bool aEnable)
Enable or disable display of the top layer.
Definition: view.cpp:848
bool m_mirrorX
Definition: view.h:862
void UpdateAllLayersColor()
Apply the new coloring scheme to all layers.
Definition: view.cpp:757
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:1631
void SetGAL(GAL *aGal)
Assign a rendering device for the VIEW.
Definition: view.cpp:488
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:421
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:1618
void invalidateItem(VIEW_ITEM *aItem, int aUpdateFlags)
Manage dirty flags & redraw queuing when updating an item.
Definition: view.cpp:1218
const VECTOR2I & GetScreenPixelSize() const
Return the size of the our rendering area in pixels.
Definition: view.cpp:1182
bool HasItem(const VIEW_ITEM *aItem) const
Indicates whether or not the given item has been added to the view.
Definition: view.cpp:1604
virtual int GetTopLayer() const
Definition: view.cpp:812
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:1149
void Clear()
Remove all items from the view.
Definition: view.cpp:1115
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:444
bool IsHiddenOnOverlay(const VIEW_ITEM *aItem) const
Definition: view.cpp:1596
void ClearTopLayers()
Remove all layers from the on-the-top set (they are no longer displayed over the rest of layers).
Definition: view.cpp:873
void InitPreview()
Definition: view.cpp:1655
void ClearPreview()
Definition: view.cpp:1640
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:1294
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:1340
void RecacheAllItems()
Rebuild GAL display lists.
Definition: view.cpp:1400
bool areRequiredLayersEnabled(int aLayerId) const
Definition: view.cpp:1383
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:253
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:1417
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:1500
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:240
virtual ~VIEW()
Definition: view.cpp:307
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:1535
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1566
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:821
void AddToPreview(VIEW_ITEM *aItem, bool aTakeOwnership=true)
Definition: view.cpp:1662
void UpdateLayerColor(int aLayer)
Apply the new coloring scheme held by RENDER_SETTINGS in case that it has changed.
Definition: view.cpp:736
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:573
std::vector< VIEW_LAYER * > m_orderedLayers
Flat list of all items.
Definition: view.h:846
void clearGroupCache()
Definition: view.cpp:1206
VECTOR2D m_center
Definition: view.h:855
void SetLayerOrder(int aLayer, int aRenderingOrder)
Set rendering order of a particular layer.
Definition: view.cpp:630
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:1324
bool IsVisible(const VIEW_ITEM *aItem) const
Return information if the item is visible (or not).
Definition: view.cpp:1588
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:1510
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Set the item visibility.
Definition: view.cpp:1545
void ReorderLayerData(std::unordered_map< int, int > aReorderMap)
Remap the data between layer ids without invalidating that data.
Definition: view.cpp:672
void redrawRect(const BOX2I &aRect)
Definition: view.cpp:988
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:295
A small class to help profiling.
Definition: profile.h:47
void Stop()
Save the time when this function was called, and set the counter stane to stop.
Definition: profile.h:86
double msecs(bool aSinceLast=false)
Definition: profile.h:147
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:36
CONTAINER::value_type item_type
Definition: view.cpp:401
QUERY_VISITOR(CONTAINER &aCont, int aLayer)
Definition: view.cpp:403
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:408
CONTAINER & m_cont
Definition: view.cpp:416
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:1195
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:932
DRAW_ITEM_VISITOR(VIEW *aView, int aLayer, bool aUseDrawPriority, bool aReverseDrawOrder)
Definition: view.cpp:922
int layers[VIEW_MAX_LAYERS]
Definition: view.cpp:980
std::vector< VIEW_ITEM * > drawItems
Definition: view.cpp:982
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:1090
RECACHE_ITEM_VISITOR(VIEW *aView, GAL *aGal, int aLayer)
Definition: view.cpp:1083
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:718
UPDATE_COLOR_VISITOR(int aLayer, PAINTER *aPainter, GAL *aGal)
Definition: view.cpp:711
UPDATE_DEPTH_VISITOR(int aLayer, int aDepth, GAL *aGal)
Definition: view.cpp:790
bool operator()(VIEW_ITEM *aItem)
Definition: view.cpp:797
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:587