KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_base_frame.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) 2018 Jean-Pierre Charras, [email protected]
5 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 2011 Wayne Stambaugh <[email protected]>
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 * Copyright (C) 2022 CERN
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
30#include <boost/version.hpp>
31
32#if BOOST_VERSION >= 106700
33#include <boost/uuid/entropy_error.hpp>
34#endif
35
36#include <3d_viewer/eda_3d_viewer_frame.h> // To include VIEWER3D_FRAMENAME
37#include <advanced_config.h>
38#include <base_units.h>
39#include <board.h>
40#include <cleanup_item.h>
41#include <collectors.h>
42#include <confirm.h>
43#include <footprint.h>
45#include <fp_lib_table.h>
46#include <lset.h>
47#include <kiface_base.h>
48#include <pcb_painter.h>
49#include <pcbnew_id.h>
50#include <pcbnew_settings.h>
51#include <pcb_base_frame.h>
52#include <pcb_draw_panel_gal.h>
53#include <pgm_base.h>
54#include <project_pcb.h>
56
57#include <math/vector2d.h>
58#include <math/vector2wx.h>
59#include <widgets/msgpanel.h>
60#include <wx/fswatcher.h>
61
64#include <tool/tool_manager.h>
66#include <tools/pcb_actions.h>
67#include <tool/grid_menu.h>
69
71
74
75wxDEFINE_EVENT( EDA_EVT_BOARD_CHANGED, wxCommandEvent );
76
77PCB_BASE_FRAME::PCB_BASE_FRAME( KIWAY* aKiway, wxWindow* aParent, FRAME_T aFrameType,
78 const wxString& aTitle, const wxPoint& aPos, const wxSize& aSize,
79 long aStyle, const wxString& aFrameName ) :
80 EDA_DRAW_FRAME( aKiway, aParent, aFrameType, aTitle, aPos, aSize, aStyle, aFrameName,
81 pcbIUScale ),
82 m_pcb( nullptr ),
83 m_originTransforms( *this ),
84 m_inFpChangeTimerEvent( false )
85{
87}
88
89
91{
92 // Ensure m_canvasType is up to date, to save it in config
93 if( GetCanvas() )
95
96 delete m_pcb;
97 m_pcb = nullptr;
98}
99
100
101bool PCB_BASE_FRAME::canCloseWindow( wxCloseEvent& aEvent )
102{
103 // Close modeless dialogs. They're trouble when they get destroyed after the frame and/or
104 // board.
105 wxWindow* viewer3D = Get3DViewerFrame();
106
107 if( viewer3D )
108 viewer3D->Close( true );
109
110 // Similarly, wxConvBrokenFileNames uses some statically allocated variables that make it
111 // crash when run later from a d'tor.
113
114 return true;
115}
116
117
118void PCB_BASE_FRAME::handleActivateEvent( wxActivateEvent& aEvent )
119{
121
122 if( m_spaceMouse )
123 m_spaceMouse->SetFocus( aEvent.GetActive() );
124}
125
126
127void PCB_BASE_FRAME::handleIconizeEvent( wxIconizeEvent& aEvent )
128{
130
131 if( m_spaceMouse && aEvent.IsIconized() )
132 m_spaceMouse->SetFocus( false );
133}
134
135
137{
138 wxWindow* frame = FindWindowByName( QUALIFIED_VIEWER3D_FRAMENAME( this ) );
139 return dynamic_cast<EDA_3D_VIEWER_FRAME*>( frame );
140}
141
142
143void PCB_BASE_FRAME::Update3DView( bool aMarkDirty, bool aRefresh, const wxString* aTitle )
144{
145 EDA_3D_VIEWER_FRAME* draw3DFrame = Get3DViewerFrame();
146
147 if( draw3DFrame )
148 {
149 if( aTitle )
150 draw3DFrame->SetTitle( *aTitle );
151
152 if( aMarkDirty )
153 draw3DFrame->ReloadRequest();
154
155 if( aRefresh )
156 draw3DFrame->Redraw();
157 }
158}
159
160
162{
163 if( m_pcb != aBoard )
164 {
165 delete m_pcb;
166 m_pcb = aBoard;
167
168 if( GetBoard() )
170
171 if( GetBoard() && GetCanvas() )
172 {
174
175 if( rs )
176 {
177 rs->SetDashLengthRatio( GetBoard()->GetPlotOptions().GetDashedLineDashRatio() );
178 rs->SetGapLengthRatio( GetBoard()->GetPlotOptions().GetDashedLineGapRatio() );
179 }
180 }
181
182 wxCommandEvent e( EDA_EVT_BOARD_CHANGED );
183 ProcessEventLocally( e );
184
185 for( wxEvtHandler* listener : m_boardChangeListeners )
186 {
187 wxCHECK2( listener, continue );
188
189 // Use the windows variant when handling event messages in case there is any special
190 // event handler pre and/or post processing specific to windows.
191 wxWindow* win = dynamic_cast<wxWindow*>( listener );
192
193 if( win )
194 win->HandleWindowEvent( e );
195 else
196 listener->SafelyProcessEvent( e );
197 }
198 }
199}
200
201
202void PCB_BASE_FRAME::AddBoardChangeListener( wxEvtHandler* aListener )
203{
204 auto it = std::find( m_boardChangeListeners.begin(), m_boardChangeListeners.end(), aListener );
205
206 // Don't add duplicate listeners.
207 if( it == m_boardChangeListeners.end() )
208 m_boardChangeListeners.push_back( aListener );
209}
210
211
212void PCB_BASE_FRAME::RemoveBoardChangeListener( wxEvtHandler* aListener )
213{
214 auto it = std::find( m_boardChangeListeners.begin(), m_boardChangeListeners.end(), aListener );
215
216 // Don't add duplicate listeners.
217 if( it != m_boardChangeListeners.end() )
218 m_boardChangeListeners.erase( it );
219}
220
221
223{
224 if( aFootprint )
225 {
226 GetBoard()->Add( aFootprint, ADD_MODE::APPEND );
227
228 aFootprint->SetFlags( IS_NEW );
229 aFootprint->SetPosition( VECTOR2I( 0, 0 ) ); // cursor in GAL may not be initialized yet
230
231 // Put it on FRONT layer (note that it might be stored flipped if the lib is an archive
232 // built from a board)
233 if( aFootprint->IsFlipped() )
234 aFootprint->Flip( aFootprint->GetPosition(), GetPcbNewSettings()->m_FlipDirection );
235
236 // Place it in orientation 0 even if it is not saved with orientation 0 in lib (note that
237 // it might be stored in another orientation if the lib is an archive built from a board)
238 aFootprint->SetOrientation( ANGLE_0 );
239
240 GetBoard()->UpdateUserUnits( aFootprint, GetCanvas()->GetView() );
241
243 }
244}
245
246
247EDA_ITEM* PCB_BASE_FRAME::ResolveItem( const KIID& aId, bool aAllowNullptrReturn ) const
248{
249 return GetBoard()->ResolveItem( aId, aAllowNullptrReturn );
250}
251
253{
254 // nullptr will clear the current focus
255 if( aItem != nullptr && !aItem->IsBOARD_ITEM() )
256 return;
257
258 FocusOnItem( static_cast<BOARD_ITEM*>( aItem ), UNDEFINED_LAYER );
259}
260
262{
263 std::vector<BOARD_ITEM*> items;
264
265 if( aItem )
266 items.push_back( aItem );
267
268 FocusOnItems( items, aLayer );
269}
270
271
272void PCB_BASE_FRAME::FocusOnItems( std::vector<BOARD_ITEM*> aItems, PCB_LAYER_ID aLayer )
273{
274 static std::vector<KIID> lastBrightenedItemIDs;
275
276 bool itemsUnbrightened = false;
277
278 for( KIID lastBrightenedItemID : lastBrightenedItemIDs )
279 {
280 if( BOARD_ITEM* lastItem = GetBoard()->ResolveItem( lastBrightenedItemID, true ) )
281 {
282 lastItem->ClearBrightened();
283 GetCanvas()->GetView()->Update( lastItem );
284 itemsUnbrightened = true;
285 }
286 }
287
288 if( itemsUnbrightened )
289 GetCanvas()->Refresh();
290
291 lastBrightenedItemIDs.clear();
292
293 if( aItems.empty() )
294 return;
295
296 VECTOR2I focusPt;
297 KIGFX::VIEW* view = GetCanvas()->GetView();
298 SHAPE_POLY_SET viewportPoly( view->GetViewport() );
299
300 for( wxWindow* dialog : findDialogs() )
301 {
302 wxPoint dialogPos = GetCanvas()->ScreenToClient( dialog->GetScreenPosition() );
303 SHAPE_POLY_SET dialogPoly( BOX2D( view->ToWorld( ToVECTOR2D( dialogPos ), true ),
304 view->ToWorld( ToVECTOR2D( dialog->GetSize() ), false ) ) );
305
306 try
307 {
308 viewportPoly.BooleanSubtract( dialogPoly );
309 }
310 catch( const std::exception& e )
311 {
312 wxFAIL_MSG( wxString::Format( wxT( "Clipper exception occurred: %s" ), e.what() ) );
313 }
314 }
315
316 SHAPE_POLY_SET itemPoly, clippedPoly;
317
318 for( BOARD_ITEM* item : aItems )
319 {
320 if( item && item != DELETED_BOARD_ITEM::GetInstance() )
321 {
322 item->SetBrightened();
323 lastBrightenedItemIDs.push_back( item->m_Uuid );
324
325 item->RunOnChildren(
326 [&]( BOARD_ITEM* child )
327 {
328 child->SetBrightened();
329 lastBrightenedItemIDs.push_back( child->m_Uuid );
330 },
331 RECURSE_MODE::RECURSE );
332
333 GetCanvas()->GetView()->Update( item );
334
335 // Focus on the object's location. Prefer a visible part of the object to its anchor
336 // in order to keep from scrolling around.
337
338 focusPt = item->GetPosition();
339
340 if( aLayer == UNDEFINED_LAYER && item->GetLayerSet().any() )
341 aLayer = item->GetLayerSet().Seq()[0];
342
343 switch( item->Type() )
344 {
345 case PCB_FOOTPRINT_T:
346 try
347 {
348 itemPoly = static_cast<FOOTPRINT*>( item )->GetBoundingHull();
349 }
350 catch( const std::exception& e )
351 {
352 wxFAIL_MSG( wxString::Format( wxT( "Clipper exception occurred: %s" ), e.what() ) );
353 }
354
355 break;
356
357 case PCB_PAD_T:
358 case PCB_MARKER_T:
359 case PCB_VIA_T:
360 FocusOnLocation( item->GetFocusPosition() );
361 GetCanvas()->Refresh();
362 return;
363
364 case PCB_SHAPE_T:
365 case PCB_FIELD_T:
366 case PCB_TEXT_T:
367 case PCB_TEXTBOX_T:
368 case PCB_TRACE_T:
369 case PCB_ARC_T:
371 case PCB_DIM_LEADER_T:
372 case PCB_DIM_CENTER_T:
373 case PCB_DIM_RADIAL_T:
375 item->TransformShapeToPolygon( itemPoly, aLayer, 0, pcbIUScale.mmToIU( 0.1 ), ERROR_INSIDE );
376 break;
377
378 case PCB_ZONE_T:
379 {
380 ZONE* zone = static_cast<ZONE*>( item );
381#if 0
382 // Using the filled area shapes to find a Focus point can give good results, but
383 // unfortunately the calculations are highly time consuming, even for not very
384 // large areas (can be easily a few minutes for large areas).
385 // so we used only the zone outline that usually do not have too many vertices.
386 zone->TransformShapeToPolygon( itemPoly, aLayer, 0, pcbIUScale.mmToIU( 0.1 ), ERROR_INSIDE );
387
388 if( itemPoly.IsEmpty() )
389 itemPoly = *zone->Outline();
390#else
391 // much faster calculation time when using only the zone outlines
392 itemPoly = *zone->Outline();
393#endif
394
395 break;
396 }
397
398 default:
399 {
400 BOX2I item_bbox = item->GetBoundingBox();
401 itemPoly.NewOutline();
402 itemPoly.Append( item_bbox.GetOrigin() );
403 itemPoly.Append( item_bbox.GetOrigin() + VECTOR2I( item_bbox.GetWidth(), 0 ) );
404 itemPoly.Append( item_bbox.GetOrigin() + VECTOR2I( 0, item_bbox.GetHeight() ) );
405 itemPoly.Append( item_bbox.GetOrigin() + VECTOR2I( item_bbox.GetWidth(),
406 item_bbox.GetHeight() ) );
407 break;
408 }
409 }
410
411 try
412 {
413 itemPoly.ClearArcs();
414 viewportPoly.ClearArcs();
415 clippedPoly.BooleanIntersection( itemPoly, viewportPoly );
416 }
417 catch( const std::exception& e )
418 {
419 wxFAIL_MSG( wxString::Format( wxT( "Clipper exception occurred: %s" ), e.what() ) );
420 }
421
422 if( !clippedPoly.IsEmpty() )
423 itemPoly = clippedPoly;
424 }
425 }
426
427 /*
428 * Perform a step-wise deflate to find the visual-center-of-mass
429 */
430
431 BOX2I bbox = itemPoly.BBox();
432 int step = std::min( bbox.GetWidth(), bbox.GetHeight() ) / 10;
433
434 while( !itemPoly.IsEmpty() )
435 {
436 focusPt = itemPoly.BBox().Centre();
437
438 try
439 {
440 itemPoly.Deflate( step, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, ARC_LOW_DEF );
441 }
442 catch( const std::exception& e )
443 {
444 wxFAIL_MSG( wxString::Format( wxT( "Clipper exception occurred: %s" ), e.what() ) );
445 }
446 }
447
448 FocusOnLocation( focusPt );
449
450 GetCanvas()->Refresh();
451}
452
453
455{
456 KIGFX::PCB_VIEW* view = GetCanvas()->GetView();
457
458 if( view && GetBoard()->m_SolderMaskBridges && view->HasItem( GetBoard()->m_SolderMaskBridges ) )
459 view->Remove( GetBoard()->m_SolderMaskBridges );
460}
461
462
464{
465 KIGFX::PCB_VIEW* view = GetCanvas()->GetView();
466
467 if( view && GetBoard()->m_SolderMaskBridges )
468 {
469 if( view->HasItem( GetBoard()->m_SolderMaskBridges ) )
470 view->Remove( GetBoard()->m_SolderMaskBridges );
471
472 view->Add( GetBoard()->m_SolderMaskBridges );
473 }
474}
475
476
477void PCB_BASE_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
478{
479 m_pcb->SetPageSettings( aPageSettings );
480
481 if( GetScreen() )
483}
484
485
487{
488 return m_pcb->GetPageSettings();
489}
490
491
493{
494 // this function is only needed because EDA_DRAW_FRAME is not compiled
495 // with either -DPCBNEW or -DEESCHEMA, so the virtual is used to route
496 // into an application specific source file.
498}
499
500
502{
504}
505
506
508{
510}
511
512
514{
516}
517
518
520{
521 VECTOR2I origin( 0, 0 );
522
523 switch( GetPcbNewSettings()->m_Display.m_DisplayOrigin )
524 {
525 case PCB_DISPLAY_ORIGIN::PCB_ORIGIN_PAGE: break;
526 case PCB_DISPLAY_ORIGIN::PCB_ORIGIN_AUX: origin = GetAuxOrigin(); break;
527 case PCB_DISPLAY_ORIGIN::PCB_ORIGIN_GRID: origin = GetGridOrigin(); break;
528 default: wxASSERT( false ); break;
529 }
530
531 return origin;
532}
533
535{
536 return m_originTransforms;
537}
538
539
541{
542 return m_pcb->GetTitleBlock();
543}
544
545
547{
548 m_pcb->SetTitleBlock( aTitleBlock );
549}
550
551
553{
554 return m_pcb->GetDesignSettings();
555}
556
557
559{
560 m_drawBgColor= aColor;
561 m_auimgr.Update();
562}
563
564
566{
567 return m_pcb->GetPlotOptions();
568}
569
570
572{
573 m_pcb->SetPlotOptions( aSettings );
574
575 // Plot Settings can also change the "tent vias" setting, which can affect the solder mask.
576 LSET visibleLayers = GetBoard()->GetVisibleLayers();
577
578 if( visibleLayers.test( F_Mask ) || visibleLayers.test( B_Mask ) )
579 {
581 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
582 {
583 BOARD_ITEM* item = nullptr;
584
585 if( aItem->IsBOARD_ITEM() )
586 item = static_cast<BOARD_ITEM*>( aItem );
587
588 // Note: KIGFX::REPAINT isn't enough for things that go from invisible to
589 // visible as they won't be found in the view layer's itemset for re-painting.
590 if( item && item->Type() == PCB_VIA_T )
591 return KIGFX::ALL;
592
593 return 0;
594 } );
595
596 GetCanvas()->Refresh();
597 }
598}
599
600
601BOX2I PCB_BASE_FRAME::GetBoardBoundingBox( bool aBoardEdgesOnly ) const
602{
603 BOX2I area = aBoardEdgesOnly ? m_pcb->GetBoardEdgesBoundingBox() : m_pcb->GetBoundingBox();
604
605 if( area.GetWidth() == 0 && area.GetHeight() == 0 )
606 {
607 VECTOR2I pageSize = GetPageSizeIU();
608
610 {
611 area.SetOrigin( 0, 0 );
612 area.SetEnd( pageSize.x, pageSize.y );
613 }
614 else
615 {
616 area.SetOrigin( -pageSize.x / 2, -pageSize.y / 2 );
617 area.SetEnd( pageSize.x / 2, pageSize.y / 2 );
618 }
619 }
620
621 return area;
622}
623
624
625const BOX2I PCB_BASE_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
626{
627 /* "Zoom to Fit" calls this with "aIncludeAllVisible" as true. Since that feature
628 * always ignored the page and border, this function returns a bbox without them
629 * as well when passed true. This technically is not all things visible, but it
630 * keeps behavior consistent.
631 *
632 * When passed false, this function returns a bbox of just the board edge. This
633 * allows things like fabrication text or anything else outside the board edge to
634 * be ignored, and just zooms up to the board itself.
635 *
636 * Calling "GetBoardBoundingBox(true)" when edge cuts are turned off will return
637 * the entire page and border, so we call "GetBoardBoundingBox(false)" instead.
638 */
639 if( aIncludeAllVisible || !m_pcb->IsLayerVisible( Edge_Cuts ) )
640 return GetBoardBoundingBox( false );
641 else
642 return GetBoardBoundingBox( true );
643}
644
645
646// Virtual function
648{
649}
650
651
653{
654 // call my base class
656
657 // tooltips in toolbars
659
661
662 if( viewer3D )
663 viewer3D->ShowChangedLanguage();
664}
665
666
668{
669 EDA_3D_VIEWER_FRAME* draw3DFrame = Get3DViewerFrame();
670
671 if( !draw3DFrame )
672 draw3DFrame = new EDA_3D_VIEWER_FRAME( &Kiway(), this, _( "3D Viewer" ) );
673
674 // Raising the window does not show the window on Windows if iconized. This should work
675 // on any platform.
676 if( draw3DFrame->IsIconized() )
677 draw3DFrame->Iconize( false );
678
679 draw3DFrame->Raise();
680 draw3DFrame->Show( true );
681
682 // Raising the window does not set the focus on Linux. This should work on any platform.
683 if( wxWindow::FindFocus() != draw3DFrame )
684 draw3DFrame->SetFocus();
685
686 // Allocate a slice of time to display the 3D frame
687 // a call to wxSafeYield() should be enough (and better), but on Linux we need
688 // to call wxYield()
689 // otherwise the activity messages are not displayed during the first board loading
690 wxYield();
691
692 // Note, the caller is responsible to load/update the board 3D view.
693 // after frame creation the board is not automatically created.
694
695 return draw3DFrame;
696}
697
698
700{
701 PCB_LAYER_ID preslayer = GetActiveLayer();
702 auto& displ_opts = GetDisplayOptions();
703
704 // Check if the specified layer matches the present layer
705 if( layer == preslayer )
706 return;
707
708 // Copper layers cannot be selected unconditionally; how many of those layers are
709 // currently enabled needs to be checked.
710 if( IsCopperLayer( layer ) )
711 {
712 if( layer > m_pcb->GetCopperLayerStackMaxId() )
713 return;
714 }
715
716 // Is yet more checking required? E.g. when the layer to be selected is a non-copper
717 // layer, or when switching between a copper layer and a non-copper layer, or vice-versa?
718 // ...
719
720 SetActiveLayer( layer );
721
722 if( displ_opts.m_ContrastModeDisplay != HIGH_CONTRAST_MODE::NORMAL )
723 GetCanvas()->Refresh();
724}
725
726
728{
730 GetCanvas()->GetView() );
731
732 // account for the globals
744
745 return guide;
746}
747
748
750{
752
753 BASE_SCREEN* screen = GetScreen();
754
755 if( !screen )
756 return;
757
758 wxString line;
760
761 if( GetShowPolarCoords() ) // display polar coordinates
762 {
763 double dx = cursorPos.x - screen->m_LocalOrigin.x;
764 double dy = cursorPos.y - screen->m_LocalOrigin.y;
765 double theta = RAD2DEG( atan2( -dy, dx ) );
766 double ro = hypot( dx, dy );
767
768 line.Printf( wxT( "r %s theta %.3f" ),
769 MessageTextFromValue( ro, false ),
770 theta );
771
772 SetStatusText( line, 3 );
773 }
774
775 // Transform absolute coordinates for user origin preferences
776 double userXpos = m_originTransforms.ToDisplayAbsX( static_cast<double>( cursorPos.x ) );
777 double userYpos = m_originTransforms.ToDisplayAbsY( static_cast<double>( cursorPos.y ) );
778
779 // Display absolute coordinates:
780 line.Printf( wxT( "X %s Y %s" ),
781 MessageTextFromValue( userXpos, false ),
782 MessageTextFromValue( userYpos, false ) );
783 SetStatusText( line, 2 );
784
785 if( !GetShowPolarCoords() ) // display relative cartesian coordinates
786 {
787 // Calculate relative coordinates
788 double relXpos = cursorPos.x - screen->m_LocalOrigin.x;
789 double relYpos = cursorPos.y - screen->m_LocalOrigin.y;
790
791 // Transform relative coordinates for user origin preferences
792 userXpos = m_originTransforms.ToDisplayRelX( relXpos );
793 userYpos = m_originTransforms.ToDisplayRelY( relYpos );
794
795 line.Printf( wxT( "dx %s dy %s dist %s" ),
796 MessageTextFromValue( userXpos, false ),
797 MessageTextFromValue( userYpos, false ),
798 MessageTextFromValue( hypot( userXpos, userYpos ), false ) );
799 SetStatusText( line, 3 );
800 }
801
803}
804
805
807{
808 EDA_DRAW_FRAME::unitsChangeRefresh(); // Update the status bar.
809
810 if( GetBoard() )
812
814}
815
816
818{
820
821 // Move legacy user grids to grid list
822 if( !aCfg->m_Window.grid.user_grid_x.empty() )
823 {
824 aCfg->m_Window.grid.grids.emplace_back( GRID{ "User Grid", aCfg->m_Window.grid.user_grid_x,
825 aCfg->m_Window.grid.user_grid_y } );
826 aCfg->m_Window.grid.user_grid_x = wxEmptyString;
827 aCfg->m_Window.grid.user_grid_y = wxEmptyString;
828 }
829
830 // Some, but not all, derived classes have a PCBNEW_SETTINGS.
831 if( PCBNEW_SETTINGS* pcbnew_cfg = dynamic_cast<PCBNEW_SETTINGS*>( aCfg ) )
832 m_polarCoords = pcbnew_cfg->m_PolarCoords;
833
834 wxASSERT( GetCanvas() );
835
836 if( GetCanvas() )
837 {
839
840 if( rs )
841 {
844 rs->SetDefaultFont( wxEmptyString ); // Always the KiCad font for PCBs
845 }
846 }
847}
848
849
851{
852 if( aErrorCode >= CLEANUP_FIRST )
853 return RPT_SEVERITY_ACTION;
854
856
857 return bds.m_DRCSeverities[ aErrorCode ];
858}
859
860
862{
864
865 // Some, but not all derived classes have a PCBNEW_SETTINGS.
866 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( aCfg );
867
868 if( cfg )
870}
871
872
874{
876}
877
878
880{
882}
883
884
886{
887 switch( GetFrameType() )
888 {
889 case FRAME_PCB_EDITOR:
891 default:
893
897
901 case FRAME_CVPCB:
904 }
905}
906
907
909{
910 static MAGNETIC_SETTINGS fallback;
911
913 return &cfg->m_MagneticItems;
914
915 return &fallback;
916}
917
918
920{
922
923 KIGFX::VIEW* view = GetCanvas()->GetView();
924 KIGFX::PCB_PAINTER* painter = static_cast<KIGFX::PCB_PAINTER*>( view->GetPainter() );
925 PCB_RENDER_SETTINGS* settings = painter->GetSettings();
926
927 settings->LoadColors( GetColorSettings( true ) );
930
931 if( aFlags & TEXTVARS_CHANGED )
933
934 // Note: KIGFX::REPAINT isn't enough for things that go from invisible to visible as
935 // they won't be found in the view layer's itemset for re-painting.
937 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
938 {
939 if( dynamic_cast<RATSNEST_VIEW_ITEM*>( aItem ) )
940 {
941 return KIGFX::ALL; // ratsnest display
942 }
943 else if( dynamic_cast<PCB_TRACK*>( aItem ) )
944 {
945 return KIGFX::REPAINT; // track, arc & via clearance display
946 }
947 else if( dynamic_cast<PAD*>( aItem ) )
948 {
949 return KIGFX::REPAINT; // pad clearance display
950 }
951 else if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem ) )
952 {
953 if( text->HasTextVars() )
954 {
955 text->ClearRenderCache();
956 text->ClearBoundingBoxCache();
957 return KIGFX::GEOMETRY | KIGFX::REPAINT;
958 }
959 }
960
961 return 0;
962 } );
963
965
967
968 // The 3D viewer isn't in the Kiway, so send its update manually
970
971 if( viewer )
972 viewer->CommonSettingsChanged( aFlags );
973}
974
975
977{
979
982
983 if( m_isClosing )
984 return;
985
988}
989
990
992{
996}
997
998
1000{
1001 return static_cast<PCB_DRAW_PANEL_GAL*>( EDA_DRAW_FRAME::GetCanvas() );
1002}
1003
1004
1006{
1008
1009 EDA_DRAW_PANEL_GAL* canvas = GetCanvas();
1010 KIGFX::VIEW* view = canvas->GetView();
1011
1012 if( m_toolManager )
1013 {
1014 m_toolManager->SetEnvironment( m_pcb, view, canvas->GetViewControls(), config(), this );
1015
1017 }
1018
1019 KIGFX::PCB_PAINTER* painter = static_cast<KIGFX::PCB_PAINTER*>( view->GetPainter() );
1020 KIGFX::PCB_RENDER_SETTINGS* settings = painter->GetSettings();
1021 const PCB_DISPLAY_OPTIONS& displ_opts = GetDisplayOptions();
1022
1023 settings->LoadDisplayOptions( displ_opts );
1024 settings->LoadColors( GetColorSettings() );
1026
1027 view->RecacheAllItems();
1029 canvas->StartDrawing();
1030
1031 try
1032
1033 {
1034 if( !m_spaceMouse )
1035 {
1036 m_spaceMouse = std::make_unique<NL_PCBNEW_PLUGIN>( GetCanvas() );
1037 }
1038 }
1039 catch( const std::system_error& e )
1040 {
1041 wxLogTrace( wxT( "KI_TRACE_NAVLIB" ), e.what() );
1042 }
1043}
1044
1045
1046void PCB_BASE_FRAME::SetDisplayOptions( const PCB_DISPLAY_OPTIONS& aOptions, bool aRefresh )
1047{
1049 bool hcVisChanged = m_displayOptions.m_ContrastModeDisplay == HIGH_CONTRAST_MODE::HIDDEN
1050 || aOptions.m_ContrastModeDisplay == HIGH_CONTRAST_MODE::HIDDEN;
1051 m_displayOptions = aOptions;
1052
1053 EDA_DRAW_PANEL_GAL* canvas = GetCanvas();
1054 KIGFX::PCB_VIEW* view = static_cast<KIGFX::PCB_VIEW*>( canvas->GetView() );
1055
1056 view->UpdateDisplayOptions( aOptions );
1059
1060 // Vias on a restricted layer set must be redrawn when high contrast mode is changed
1061 if( hcChanged )
1062 {
1063 bool showNetNames = false;
1064
1065 if( PCBNEW_SETTINGS* config = dynamic_cast<PCBNEW_SETTINGS*>( Kiface().KifaceSettings() ) )
1066 showNetNames = config->m_Display.m_NetNames > 0;
1067
1068 // Note: KIGFX::REPAINT isn't enough for things that go from invisible to visible as
1069 // they won't be found in the view layer's itemset for re-painting.
1071 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
1072 {
1073 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
1074 {
1075 if( via->GetViaType() != VIATYPE::THROUGH
1076 || via->GetRemoveUnconnected()
1077 || showNetNames )
1078 {
1079 return hcVisChanged ? KIGFX::ALL : KIGFX::REPAINT;
1080 }
1081 }
1082 else if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
1083 {
1084 if( pad->GetRemoveUnconnected()
1085 || showNetNames )
1086 {
1087 return hcVisChanged ? KIGFX::ALL : KIGFX::REPAINT;
1088 }
1089 }
1090
1091 return 0;
1092 } );
1093 }
1094
1095 if( aRefresh )
1096 canvas->Refresh();
1097}
1098
1099
1101{
1102 wxLogTrace( "KICAD_LIB_WATCH", "setFPWatcher" );
1103
1104 Unbind( wxEVT_FSWATCHER, &PCB_BASE_FRAME::OnFPChange, this );
1105
1106 if( m_watcher )
1107 {
1108 wxLogTrace( "KICAD_LIB_WATCH", "Remove watch" );
1109 m_watcher->RemoveAll();
1110 m_watcher->SetOwner( nullptr );
1111 m_watcher.reset();
1112 }
1113
1114 wxString libfullname;
1116
1117 if( !aFootprint || !tbl )
1118 return;
1119
1120 try
1121 {
1122 const FP_LIB_TABLE_ROW* row = tbl->FindRow( aFootprint->GetFPID().GetLibNickname() );
1123
1124 if( !row )
1125 return;
1126
1127 libfullname = row->GetFullURI( true );
1128 }
1129 catch( const std::exception& e )
1130 {
1131 DisplayInfoMessage( this, e.what() );
1132 return;
1133 }
1134 catch( const IO_ERROR& error )
1135 {
1136 wxLogTrace( "KICAD_LIB_WATCH", "Error: %s", error.What() );
1137 return;
1138 }
1139
1140 m_watcherFileName.Assign( libfullname, aFootprint->GetFPID().GetLibItemName(),
1142
1143 if( !m_watcherFileName.FileExists() )
1144 return;
1145
1146 m_watcherLastModified = m_watcherFileName.GetModificationTime();
1147
1148 Bind( wxEVT_FSWATCHER, &PCB_BASE_FRAME::OnFPChange, this );
1149 m_watcher = std::make_unique<wxFileSystemWatcher>();
1150 m_watcher->SetOwner( this );
1151
1152 wxFileName fn;
1153 fn.AssignDir( m_watcherFileName.GetPath() );
1154 fn.DontFollowLink();
1155
1156 wxLogTrace( "KICAD_LIB_WATCH", "Add watch: %s", fn.GetPath() );
1157
1158 {
1159 // Silence OS errors that come from the watcher
1160 wxLogNull silence;
1161 m_watcher->Add( fn );
1162 }
1163}
1164
1165
1166void PCB_BASE_FRAME::OnFPChange( wxFileSystemWatcherEvent& aEvent )
1167{
1168 if( aEvent.GetPath() != m_watcherFileName.GetFullPath() )
1169 return;
1170
1171 // Start the debounce timer (set to 1 second)
1172 if( !m_watcherDebounceTimer.StartOnce( 1000 ) )
1173 {
1174 wxLogTrace( "KICAD_LIB_WATCH", "Failed to start the debounce timer" );
1175 return;
1176 }
1177}
1178
1179
1181{
1182 if( aEvent.GetId() != m_watcherDebounceTimer.GetId() )
1183 {
1184 aEvent.Skip();
1185 return;
1186 }
1187
1189 {
1190 wxLogTrace( "KICAD_LIB_WATCH", "Restarting debounce timer" );
1191 m_watcherDebounceTimer.StartOnce( 3000 );
1192 }
1193
1194 wxLogTrace( "KICAD_LIB_WATCH", "OnFpChangeDebounceTimer" );
1195
1196 // Disable logging to avoid spurious messages and check if the file has changed
1197 wxLog::EnableLogging( false );
1198 wxDateTime lastModified = m_watcherFileName.GetModificationTime();
1199 wxLog::EnableLogging( true );
1200
1201 if( lastModified == m_watcherLastModified || !lastModified.IsValid() )
1202 return;
1203
1204 m_watcherLastModified = lastModified;
1205
1208
1209 // When loading a footprint from a library in the footprint editor
1210 // the items UUIDs must be keep and not reinitialized
1211 bool keepUUID = IsType( FRAME_FOOTPRINT_EDITOR );
1212
1213 if( !fp || !tbl )
1214 return;
1215
1217
1219 || IsOK( this, _( "The library containing the current footprint has changed.\n"
1220 "Do you want to reload the footprint?" ) ) )
1221 {
1222 wxString fpname = fp->GetFPID().GetLibItemName();
1223 wxString nickname = fp->GetFPID().GetLibNickname();
1224
1225 try
1226 {
1227 FOOTPRINT* newfp = tbl->FootprintLoad( nickname, fpname, keepUUID );
1228
1229 if( newfp )
1230 {
1231 std::vector<KIID> selectedItems;
1232
1233 for( const EDA_ITEM* item : GetCurrentSelection() )
1234 selectedItems.emplace_back( item->m_Uuid );
1235
1237
1238 ReloadFootprint( newfp );
1239
1240 newfp->ClearAllNets();
1244
1245 std::vector<EDA_ITEM*> sel;
1246
1247 for( const KIID& uuid : selectedItems )
1248 {
1249 if( BOARD_ITEM* item = GetBoard()->ResolveItem( uuid, true ) )
1250 sel.push_back( item );
1251 }
1252
1253 if( !sel.empty() )
1255 }
1256 }
1257 catch( const IO_ERROR& ioe )
1258 {
1259 DisplayError( this, ioe.What() );
1260 }
1261 }
1262
1263 m_inFpChangeTimerEvent = false;
1264}
@ ERROR_INSIDE
Definition: approximation.h:34
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:112
constexpr int ARC_LOW_DEF
Definition: base_units.h:128
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
BOX2< VECTOR2D > BOX2D
Definition: box2.h:923
static TOOL_ACTION selectItems
Select a list of items (specified as the event parameter)
Definition: actions.h:229
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Definition: app_settings.h:108
WINDOW_SETTINGS m_Window
Definition: app_settings.h:233
Handles how to draw a screen (a board, a schematic ...)
Definition: base_screen.h:41
VECTOR2D m_LocalOrigin
Relative Screen cursor coordinate (on grid) in user units.
Definition: base_screen.h:90
void SetContentModified(bool aModified=true)
Definition: base_screen.h:59
void InitDataPoints(const VECTOR2I &aPageSizeInternalUnits)
Definition: base_screen.cpp:46
Container for design settings for a BOARD object.
std::map< int, SEVERITY > m_DRCSeverities
void SetGridOrigin(const VECTOR2I &aOrigin)
const VECTOR2I & GetGridOrigin() const
const VECTOR2I & GetAuxOrigin() const
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:317
void SetPlotOptions(const PCB_PLOT_PARAMS &aOptions)
Definition: board.h:746
PCB_LAYER_ID GetCopperLayerStackMaxId() const
Definition: board.cpp:882
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: board.cpp:1147
const BOX2I GetBoardEdgesBoundingBox() const
Return the board bounding box calculated using exclusively the board edges (graphics on Edge....
Definition: board.h:1002
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: board.h:988
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition: board.cpp:973
const PAGE_INFO & GetPageSettings() const
Definition: board.h:742
void UpdateUserUnits(BOARD_ITEM *aItem, KIGFX::VIEW *aView)
Update any references within aItem (or its descendants) to the user units.
Definition: board.cpp:1504
const LSET & GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition: board.cpp:921
bool BuildConnectivity(PROGRESS_REPORTER *aReporter=nullptr)
Build or rebuild the board connectivity database for the board, especially the list of connected item...
Definition: board.cpp:186
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition: board.h:489
TITLE_BLOCK & GetTitleBlock()
Definition: board.h:748
void IncrementTimeStamp()
Definition: board.cpp:254
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: board.h:743
const PCB_PLOT_PARAMS & GetPlotOptions() const
Definition: board.h:745
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
Definition: board.cpp:913
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.cpp:1024
void SynchronizeProperties()
Copy the current project's text variables into the boards property cache.
Definition: board.cpp:2221
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition: board.h:750
BOARD_ITEM * ResolveItem(const KIID &aID, bool aAllowNullptrReturn=false) const
Definition: board.cpp:1583
void SetUserUnits(EDA_UNITS aUnits)
Definition: board.h:755
constexpr void SetOrigin(const Vec &pos)
Definition: box2.h:237
constexpr size_type GetWidth() const
Definition: box2.h:214
constexpr Vec Centre() const
Definition: box2.h:97
constexpr size_type GetHeight() const
Definition: box2.h:215
constexpr const Vec & GetOrigin() const
Definition: box2.h:210
constexpr void SetEnd(coord_type x, coord_type y)
Definition: box2.h:297
static DELETED_BOARD_ITEM * GetInstance()
Definition: board_item.h:490
Create and handle a window for the 3d viewer connected to a Kiway and a pcbboard.
void CommonSettingsChanged(int aFlags) override
Notification that common settings are updated.
void ShowChangedLanguage() override
void ReloadRequest()
Request reloading the 3D view.
FRAME_T GetFrameType() const
virtual APP_SETTINGS_BASE * config() const
Return the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
virtual void handleIconizeEvent(wxIconizeEvent &aEvent)
Handle a window iconize event.
virtual void OnModify()
Must be called after a model change in order to set the "modify" flag and do other frame-specific pro...
wxAuiManager m_auimgr
virtual bool IsContentModified() const
Get if the contents of the frame have been modified since the last save.
virtual void RecreateToolbars()
bool m_isClosing
Set by the close window event handler after frames are asked if they can close.
bool IsType(FRAME_T aType) const
The base class for create windows for drawing purpose.
virtual void ActivateGalCanvas()
Use to start up the GAL drawing canvas.
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
EDA_DRAW_PANEL_GAL::GAL_TYPE m_canvasType
The current canvas type.
void UpdateGridSelectBox()
Rebuild the grid combobox to respond to any changes in the GUI (units, user grid changes,...
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void FocusOnLocation(const VECTOR2I &aPos)
Useful to focus on a particular location, in find functions.
COLOR4D m_drawBgColor
virtual void handleActivateEvent(wxActivateEvent &aEvent)
Handle a window activation event.
virtual void UpdateMsgPanel()
Redraw the message panel.
void UpdateStatusBar() override
Update the status bar information.
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
virtual EDA_DRAW_PANEL_GAL * GetCanvas() const
Return a pointer to GAL-based canvas of given EDA draw frame.
void unitsChangeRefresh() override
Called when when the units setting has changed to allow for any derived classes to handle refreshing ...
std::vector< wxWindow * > findDialogs()
virtual void DisplayGridMsg()
Display current grid size in the status bar.
void CommonSettingsChanged(int aFlags) override
Notification event that some of the common (suite-wide) settings have changed.
bool m_showBorderAndTitleBlock
bool GetShowPolarCoords() const
For those frames that support polar coordinates.
GAL_TYPE GetBackend() const
Return the type of backend currently used by GAL canvas.
virtual void SetHighContrastLayer(int aLayer)
Take care of display settings for the given layer to be displayed in high contrast mode.
KIGFX::VIEW_CONTROLS * GetViewControls() const
Return a pointer to the #VIEW_CONTROLS instance used in the panel.
virtual KIGFX::VIEW * GetView() const
Return a pointer to the #VIEW instance used in the panel.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
void SetEventDispatcher(TOOL_DISPATCHER *aEventDispatcher)
Set a dispatcher that processes events and forwards them to tools.
void StartDrawing()
Begin drawing if it was stopped previously.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:98
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:142
const KIID m_Uuid
Definition: eda_item.h:516
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:110
void SetBrightened()
Definition: eda_item.h:135
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:79
static const TOOL_EVENT ConnectivityChangedEvent
Selected item had a property changed (except movement)
Definition: actions.h:346
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2513
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2595
bool IsFlipped() const
Definition: footprint.h:400
const LIB_ID & GetFPID() const
Definition: footprint.h:251
void ClearAllNets()
Clear (i.e.
Definition: footprint.cpp:1071
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
Definition: footprint.cpp:2454
VECTOR2I GetPosition() const override
Definition: footprint.h:227
Hold a record identifying a library accessed by the appropriate footprint library #PLUGIN object in t...
Definition: fp_lib_table.h:42
const FP_LIB_TABLE_ROW * FindRow(const wxString &aNickName, bool aCheckIfEnabled=false)
Return an FP_LIB_TABLE_ROW if aNickName is found in this table or in any chained fall back table frag...
FOOTPRINT * FootprintLoad(const wxString &aNickname, const wxString &aFootprintName, bool aKeepUUID=false)
Load a footprint having aFootprintName from the library given by aNickname.
A general implementation of a COLLECTORS_GUIDE.
Definition: collectors.h:324
void SetIgnoreBlindBuriedVias(bool ignore)
Definition: collectors.h:464
void SetIgnoreTracks(bool ignore)
Definition: collectors.h:470
void SetIgnoreFootprintsOnFront(bool ignore)
Definition: collectors.h:428
void SetIgnoreFPTextOnFront(bool ignore)
Definition: collectors.h:416
void SetIgnoreMicroVias(bool ignore)
Definition: collectors.h:467
void SetIgnoreFPTextOnBack(bool ignore)
Definition: collectors.h:410
void SetIgnoreThroughVias(bool ignore)
Definition: collectors.h:461
void SetIgnoreThroughHolePads(bool ignore)
Definition: collectors.h:446
void SetIgnoreFPReferences(bool ignore)
Definition: collectors.h:458
void SetIgnoreFPValues(bool ignore)
Definition: collectors.h:452
void SetIgnoreFootprintsOnBack(bool ignore)
Definition: collectors.h:422
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
Contains methods for drawing PCB-specific items.
Definition: pcb_painter.h:182
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
Definition: pcb_painter.h:187
PCB specific render settings.
Definition: pcb_painter.h:80
void LoadColors(const COLOR_SETTINGS *aSettings) override
void LoadDisplayOptions(const PCB_DISPLAY_OPTIONS &aOptions)
Load settings related to display options (high-contrast mode, full or outline modes for vias/pads/tra...
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: pcb_view.cpp:91
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
Definition: pcb_view.cpp:57
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Definition: pcb_view.cpp:74
void UpdateDisplayOptions(const PCB_DISPLAY_OPTIONS &aOptions)
Definition: pcb_view.cpp:149
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
void SetDefaultFont(const wxString &aFont)
void SetGapLengthRatio(double aRatio)
void SetDashLengthRatio(double aRatio)
void SetHighlightFactor(float aFactor)
void SetSelectFactor(float aFactor)
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
An abstract base class for deriving all objects that can be added to a VIEW.
Definition: view_item.h:86
bool IsBOARD_ITEM() const
Definition: view_item.h:102
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:66
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition: view.cpp:530
bool HasItem(const VIEW_ITEM *aItem) const
Indicates whether or not the given item has been added to the view.
Definition: view.cpp:1671
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:467
void RecacheAllItems()
Rebuild GAL display lists.
Definition: view.cpp:1451
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1561
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:220
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:1571
Definition: kiid.h:49
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:286
const UTF8 & GetLibItemName() const
Definition: lib_id.h:102
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition: lib_id.h:87
const wxString GetFullURI(bool aSubstituted=false) const
Return the full location specifying URI for the LIB, either in original UI form or in environment var...
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:37
A class to perform either relative or absolute display origin transforms for a single axis of a point...
Definition: pad.h:54
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:59
const VECTOR2D GetSizeIU(double aIUScale) const
Gets the page size in internal units.
Definition: page_info.h:171
DISPLAY_OPTIONS m_Display
static TOOL_ACTION rehatchShapes
Definition: pcb_actions.h:376
SEVERITY GetSeverity(int aErrorCode) const override
std::unique_ptr< wxFileSystemWatcher > m_watcher
virtual void ReloadFootprint(FOOTPRINT *aFootprint)
Reload the footprint from the library.
virtual void OnDisplayOptionsChanged()
void FocusOnItems(std::vector< BOARD_ITEM * > aItems, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)
void handleIconizeEvent(wxIconizeEvent &aEvent) override
Handle a window iconize event.
void FocusOnItem(EDA_ITEM *aItem) override
Focus on a particular canvas item.
ORIGIN_TRANSFORMS & GetOriginTransforms() override
Return a reference to the default ORIGIN_TRANSFORMS object.
virtual const PCB_PLOT_PARAMS & GetPlotSettings() const
Return the PCB_PLOT_PARAMS for the BOARD owned by this frame.
std::unique_ptr< NL_PCBNEW_PLUGIN > m_spaceMouse
wxDateTime m_watcherLastModified
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Display options control the way tracks, vias, outlines and other things are shown (for instance solid...
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void RemoveBoardChangeListener(wxEvtHandler *aListener)
Remove aListener to from the board changed listener list.
void handleActivateEvent(wxActivateEvent &aEvent) override
Handle a window activation event.
void setFPWatcher(FOOTPRINT *aFootprint)
Create or removes a watcher on the specified footprint.
virtual void unitsChangeRefresh() override
Called when when the units setting has changed to allow for any derived classes to handle refreshing ...
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Return bounding box of document with option to not include some items.
const VECTOR2I GetPageSizeIU() const override
Works off of GetPageSettings() to return the size of the paper page in the internal units of this par...
bool m_inFpChangeTimerEvent
PCBNEW_SETTINGS * GetPcbNewSettings() const
virtual void SwitchLayer(PCB_LAYER_ID aLayer)
Change the active layer in the frame.
virtual PCB_LAYER_ID GetActiveLayer() const
PCB_BASE_FRAME(KIWAY *aKiway, wxWindow *aParent, FRAME_T aFrameType, const wxString &aTitle, const wxPoint &aPos, const wxSize &aSize, long aStyle, const wxString &aFrameName)
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
const VECTOR2I & GetAuxOrigin() const
virtual PCB_VIEWERS_SETTINGS_BASE * GetViewerSettingsBase() const
const VECTOR2I GetUserOrigin() const
virtual MAGNETIC_SETTINGS * GetMagneticItemsSettings()
std::vector< wxEvtHandler * > m_boardChangeListeners
void OnFPChange(wxFileSystemWatcherEvent &aEvent)
Handler for FP change events.
bool canCloseWindow(wxCloseEvent &aCloseEvent) override
const VECTOR2I & GetGridOrigin() const override
Return the absolute coordinates of the origin of the snap grid.
void CommonSettingsChanged(int aFlags) override
Notification event that some of the common (suite-wide) settings have changed.
const TITLE_BLOCK & GetTitleBlock() const override
const PAGE_INFO & GetPageSettings() const override
BOX2I GetBoardBoundingBox(bool aBoardEdgesOnly=false) const
Calculate the bounding box containing all board items (or board edge segments).
EDA_ITEM * ResolveItem(const KIID &aId, bool aAllowNullptrReturn=false) const override
Fetch an item by KIID.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
virtual void ActivateGalCanvas() override
Use to start up the GAL drawing canvas.
void SetDrawBgColor(const COLOR4D &aColor) override
void OnFpChangeDebounceTimer(wxTimerEvent &aEvent)
Handler for the filesystem watcher debounce timer.
virtual void SetBoard(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr)
Set the #m_Pcb member in such as way as to ensure deleting any previous BOARD.
virtual void SetPageSettings(const PAGE_INFO &aPageSettings) override
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock) override
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
PCB_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
BOARD * GetBoard() const
virtual BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Return the BOARD_DESIGN_SETTINGS for the open project.
virtual void ShowChangedLanguage() override
Redraw the menus and what not in current language.
void AddBoardChangeListener(wxEvtHandler *aListener)
Add aListener to post #EDA_EVT_BOARD_CHANGED command events to.
virtual void AddFootprintToBoard(FOOTPRINT *aFootprint)
Add the given footprint to the board.
virtual void doReCreateMenuBar() override
void SetDisplayOptions(const PCB_DISPLAY_OPTIONS &aOptions, bool aRefresh=true)
Update the current display options.
GENERAL_COLLECTORS_GUIDE GetCollectorsGuide()
virtual void SetPlotSettings(const PCB_PLOT_PARAMS &aSettings)
PCB_DISPLAY_OPTIONS m_displayOptions
FOOTPRINT_EDITOR_SETTINGS * GetFootprintEditorSettings() const
void SetGridOrigin(const VECTOR2I &aPoint) override
PCB_ORIGIN_TRANSFORMS m_originTransforms
EDA_3D_VIEWER_FRAME * CreateAndShow3D_Frame()
Show the 3D view frame.
wxTimer m_watcherDebounceTimer
EDA_3D_VIEWER_FRAME * Get3DViewerFrame()
virtual void SetActiveLayer(PCB_LAYER_ID aLayer)
virtual COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Helper to retrieve the current color settings.
wxFileName m_watcherFileName
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
void rebuildConnectivity()
virtual void UpdateStatusBar() override
Update the status bar information.
HIGH_CONTRAST_MODE m_ContrastModeDisplay
How inactive layers are displayed.
void UpdateColors()
Update the color settings in the painter and GAL.
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
void DisplayBoard(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr)
Add all items from the current board to the VIEW, so they can be displayed by GAL.
void RedrawRatsnest()
Return the bounding box of the view that should be used if model is not valid.
T ToDisplayRelY(T aInternalValue) const
T ToDisplayAbsX(T aInternalValue) const
T ToDisplayRelX(T aInternalValue) const
Transform a 2-D coordinate point referenced to the internal origin to the equivalent point referenced...
T ToDisplayAbsY(T aInternalValue) const
Parameters and options when plotting/printing a board.
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:125
A progress reporter interface for use in multi-threaded environments.
static FP_LIB_TABLE * PcbFootprintLibs(PROJECT *aProject)
Return the table of footprint libraries without Kiway.
Definition: project_pcb.cpp:37
static void Cleanup3DCache(PROJECT *aProject)
T * GetAppSettings(const char *aFilename)
Return a handle to the a given settings by type.
Represent a set of closed polygons.
void ClearArcs()
Removes all arc references from all the outlines and holes in the polyset.
bool IsEmpty() const
Return true if the set is empty (no polygons at all)
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
int NewOutline()
Creates a new empty polygon in the set and returns its index.
void Deflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError)
void BooleanIntersection(const SHAPE_POLY_SET &b)
Perform boolean polyset intersection.
void BooleanSubtract(const SHAPE_POLY_SET &b)
Perform boolean polyset difference.
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.
Hold the information shown in the lower right corner of a plot, printout, or editing view.
Definition: title_block.h:41
TOOL_MANAGER * m_toolManager
Definition: tools_holder.h:171
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:173
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
virtual SELECTION & GetCurrentSelection()
Get the current selection from the canvas area.
Definition: tools_holder.h:98
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition: tool_base.h:80
@ GAL_SWITCH
Rendering engine changes.
Definition: tool_base.h:82
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:150
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
void SetEnvironment(EDA_ITEM *aModel, KIGFX::VIEW *aView, KIGFX::VIEW_CONTROLS *aViewControls, APP_SETTINGS_BASE *aSettings, TOOLS_HOLDER *aFrame)
Set the work environment (model, view, view controls and the parent window).
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
EDA_UNITS GetUserUnits() const
Handle a list of polygons defining a copper zone.
Definition: zone.h:74
SHAPE_POLY_SET * Outline()
Definition: zone.h:335
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=false) const override
Convert the zone shape to a closed polygon Used in filling zones calculations Circles and arcs are ap...
Definition: zone.cpp:1577
@ CLEANUP_FIRST
Definition: cleanup_item.h:33
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Display a yes/no dialog with aMessage and returns the user response.
Definition: confirm.cpp:251
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:222
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:169
This file is part of the common library.
#define _(s)
Declaration of the eda_3d_viewer class.
static constexpr EDA_ANGLE ANGLE_0
Definition: eda_angle.h:411
#define QUALIFIED_VIEWER3D_FRAMENAME(parent)
#define IS_NEW
New item, just created.
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:33
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
@ FRAME_CVPCB_DISPLAY
Definition: frame_type.h:53
@ FRAME_FOOTPRINT_VIEWER
Definition: frame_type.h:45
@ FRAME_FOOTPRINT_WIZARD
Definition: frame_type.h:46
@ FRAME_FOOTPRINT_PREVIEW
Definition: frame_type.h:48
@ FRAME_FOOTPRINT_CHOOSER
Definition: frame_type.h:44
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
@ FRAME_PCB_DISPLAY3D
Definition: frame_type.h:47
@ FRAME_CVPCB
Definition: frame_type.h:52
static const std::string KiCadFootprintFileExtension
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition: layer_ids.h:665
@ LAYER_FOOTPRINTS_FR
Show footprints on front.
Definition: layer_ids.h:258
@ LAYER_FP_REFERENCES
Show footprints references (when texts are visible).
Definition: layer_ids.h:265
@ LAYER_PADS
Meta control for all pads opacity/visibility (color ignored).
Definition: layer_ids.h:291
@ LAYER_TRACKS
Definition: layer_ids.h:266
@ LAYER_FP_TEXT
Definition: layer_ids.h:239
@ LAYER_FOOTPRINTS_BK
Show footprints on back.
Definition: layer_ids.h:259
@ LAYER_FP_VALUES
Show footprints values (when texts are visible).
Definition: layer_ids.h:262
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:232
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
@ Edge_Cuts
Definition: layer_ids.h:112
@ B_Mask
Definition: layer_ids.h:98
@ F_Mask
Definition: layer_ids.h:97
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
Message panel definition file.
@ COLOR
Color has changed.
Definition: view_item.h:54
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:58
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:59
Declaration of the NL_PCBNEW_PLUGIN class.
wxDEFINE_EVENT(EDA_EVT_BOARD_CHANGED, wxCommandEvent)
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:902
see class PGM_BASE
SEVERITY
@ RPT_SEVERITY_ACTION
KIWAY Kiway(KFCTL_STANDALONE)
float highlight_factor
How much to brighten highlighted objects by.
Definition: app_settings.h:139
float select_factor
How much to brighten selected objects by.
Definition: app_settings.h:140
const double IU_PER_MILS
Definition: base_units.h:77
constexpr int mmToIU(double mm) const
Definition: base_units.h:92
wxString user_grid_x
Definition: grid_settings.h:67
std::vector< GRID > grids
Definition: grid_settings.h:66
wxString user_grid_y
Definition: grid_settings.h:68
Common grid settings, available to every frame.
Definition: grid_settings.h:34
GRID_SETTINGS grid
Definition: app_settings.h:97
#define TEXTVARS_CHANGED
Definition: tools_holder.h:153
double RAD2DEG(double rad)
Definition: trigo.h:167
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:88
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:105
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:102
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:97
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:103
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition: typeinfo.h:93
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:107
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition: typeinfo.h:92
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition: typeinfo.h:90
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
Definition: typeinfo.h:99
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition: typeinfo.h:86
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:101
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:98
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:96
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition: typeinfo.h:104
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
VECTOR2D ToVECTOR2D(const wxPoint &aPoint)
Definition: vector2wx.h:40
Definition of file extensions used in Kicad.