KiCad PCB EDA Suite
Loading...
Searching...
No Matches
gerbview_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, jp.charras at wanadoo.fr
5 * Copyright (C) 1992-2024 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include <kiface_base.h>
22#include <base_units.h>
23#include <pgm_base.h>
24#include <bitmaps.h>
27#include <gerbview_frame.h>
28#include <gerbview_id.h>
29#include <gerber_file_image.h>
31#include <excellon_image.h>
33#include <gerbview_settings.h>
35#include <lset.h>
37#include <tool/tool_manager.h>
38#include <tool/action_toolbar.h>
40#include <tool/common_control.h>
41#include <tool/common_tools.h>
43#include <tool/zoom_tool.h>
49#include <trigo.h>
50#include <view/view.h>
51#include <view/view_controls.h>
52#include <base_screen.h>
53#include <gerbview_painter.h>
54#include <wx/wupdlock.h>
55
60#include <zoom_defines.h>
61
63#include <wx/log.h>
64
65GERBVIEW_FRAME::GERBVIEW_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
66 EDA_DRAW_FRAME( aKiway, aParent, FRAME_GERBER, wxT( "GerbView" ), wxDefaultPosition,
69 m_TextInfo( nullptr ),
71 ID_GERBVIEW_ZIP_FILE_LIST_CLEAR, _( "Clear Recent Zip Files" ) ),
73 ID_GERBVIEW_DRILL_FILE_LIST_CLEAR, _( "Clear Recent Drill Files" ) ),
75 ID_GERBVIEW_JOB_FILE_LIST_CLEAR, _( "Clear Recent Job Files" ) ),
76 m_activeLayer( 0 )
77{
79 m_gerberLayout = nullptr;
81 m_showBorderAndTitleBlock = false; // true for reference drawings.
82 m_SelLayerBox = nullptr;
83 m_DCodeSelector = nullptr;
84 m_SelComponentBox = nullptr;
85 m_SelNetnameBox = nullptr;
86 m_SelAperAttributesBox = nullptr;
87 m_cmpText = nullptr;
88 m_netText = nullptr;
89 m_apertText = nullptr;
90 m_dcodeText = nullptr;
91 m_aboutTitle = _HKI( "KiCad Gerber Viewer" );
92
93 SHAPE_POLY_SET dummy; // A ugly trick to force the linker to include
94 // some methods in code and avoid link errors
95
96 int fileHistorySize = Pgm().GetCommonSettings()->m_System.file_history_size;
97 m_drillFileHistory.SetMaxFiles( fileHistorySize );
98 m_zipFileHistory.SetMaxFiles( fileHistorySize );
99 m_jobFileHistory.SetMaxFiles( fileHistorySize );
100
101 auto* galCanvas = new GERBVIEW_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_frameSize,
104
105 SetCanvas( galCanvas );
106
107 // GerbView requires draw priority for rendering negative objects
108 galCanvas->GetView()->UseDrawPriority( true );
109
110 // Give an icon
111 wxIcon icon;
112 wxIconBundle icon_bundle;
113
114 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 48 ) );
115 icon_bundle.AddIcon( icon );
116 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 128 ) );
117 icon_bundle.AddIcon( icon );
118 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 256 ) );
119 icon_bundle.AddIcon( icon );
120 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_32 ) );
121 icon_bundle.AddIcon( icon );
122 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_16 ) );
123 icon_bundle.AddIcon( icon );
124
125 SetIcons( icon_bundle );
126
127 // Be sure a page info is set. this default value will be overwritten later.
128 PAGE_INFO pageInfo( wxT( "GERBER" ) );
129 SetLayout( new GBR_LAYOUT() );
130 SetPageSettings( pageInfo );
131
132 SetVisibleLayers( LSET::AllLayersMask() ); // All draw layers visible.
133
135
136 // Create the PCB_LAYER_WIDGET *after* SetLayout():
138
139 // Update the minimum string length in the layer panel with the length of the last default layer
140 wxString lyrName = GetImagesList()->GetDisplayName( GetImagesList()->ImagesMaxCount(),
141 false, true );
143
144 // LoadSettings() *after* creating m_LayersManager, because LoadSettings()
145 // initialize parameters in m_LayersManager
146 LoadSettings( config() );
147
148 setupTools();
154
155 m_auimgr.SetManagedWindow( this );
156
157 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" ).Top().Layer( 6 ) );
158 m_auimgr.AddPane( m_auxiliaryToolBar, EDA_PANE().HToolbar().Name( "AuxToolbar" ).Top()
159 .Layer(4) );
160 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" ).Bottom()
161 .Layer( 6 ) );
162 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" ).Left()
163 .Layer( 3 ) );
164 m_auimgr.AddPane( m_LayersManager, EDA_PANE().Palette().Name( "LayersManager" ).Right()
165 .Layer( 3 ).Caption( _( "Layers Manager" ) ).PaneBorder( false )
166 .MinSize( 80, -1 ).BestSize( m_LayersManager->GetBestSize() ) );
167
168 m_auimgr.AddPane( GetCanvas(), EDA_PANE().Canvas().Name( "DrawFrame" ).Center() );
169
170 ReFillLayerWidget(); // this is near end because contents establish size
171 m_auimgr.Update();
172
173 SetActiveLayer( 0, true );
175
177
179
180 setupUnits( config() );
181
182 // Enable the axes to match legacy draw style
183 auto& galOptions = GetGalDisplayOptions();
184 galOptions.m_axesEnabled = true;
185 galOptions.NotifyChanged();
186
188 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
189
190 // Drag and drop
191 // Note that all gerber files are aliased as GerberFileExtension
195 DragAcceptFiles( true );
196
198
199 // Ensure the window is on top
200 Raise();
201
202 // Register a call to update the toolbar sizes. It can't be done immediately because
203 // it seems to require some sizes calculated that aren't yet (at least on GTK).
204 CallAfter( [this]()
205 {
206 // Ensure the controls on the toolbars all are correctly sized
208 } );
209}
210
211
213{
214 // Ensure m_canvasType is up to date, to save it in config
216
217 // Shutdown all running tools
218 if( m_toolManager )
220
221 GetCanvas()->GetView()->Clear();
222
224 delete m_gerberLayout;
225}
226
227
229{
230 // No more vetos
231 m_isClosing = true;
233 GetCanvas()->GetView()->Clear();
234
235 if( m_toolManager )
237
238 // Be sure any OpenGL event cannot be fired after frame deletion:
239 GetCanvas()->SetEvtHandlerEnabled( false );
240
241 Destroy();
242}
243
244
245bool GERBVIEW_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
246{
247 // Ensure the frame is shown when opening the file(s), to avoid issues (crash) on GAL
248 // when trying to change the view if it is not fully initialized.
249 // It happens when starting GerbView with a gerber job file to load
250 if( !IsShownOnScreen() )
251 Show();
252
253 // The current project path is also a valid command parameter. Check if a single path
254 // rather than a file name was passed to GerbView and use it as the initial MRU path.
255 if( aFileSet.size() > 0 )
256 {
257 wxString path = aFileSet[0];
258
259 // For some reason wxApp appears to leave the trailing double quote on quoted
260 // parameters which are required for paths with spaces. Maybe this should be
261 // pushed back into PGM_SINGLE_TOP::OnPgmInit() but that may cause other issues.
262 // We can't buy a break!
263 if( path.Last() == wxChar( '\"' ) )
264 path.RemoveLast();
265
266 if( !wxFileExists( path ) && wxDirExists( path ) )
267 {
268 m_mruPath = path;
269 return true;
270 }
271
272 const unsigned limit = std::min( unsigned( aFileSet.size() ),
273 unsigned( GERBER_DRAWLAYERS_COUNT ) );
274
275 for( unsigned i = 0; i < limit; ++i )
276 {
277 wxString ext = wxFileName( aFileSet[i] ).GetExt().Lower();
278
280 LoadZipArchiveFile( aFileSet[i] );
281 else if( ext == FILEEXT::GerberJobFileExtension )
282 LoadGerberJobFile( aFileSet[i] );
283 else
284 {
285 GERBER_ORDER_ENUM fnameLayer;
286 wxString fnameExtensionMatched;
287
289 fnameExtensionMatched );
290
291 switch( fnameLayer )
292 {
293 case GERBER_ORDER_ENUM::GERBER_DRILL:
294 LoadExcellonFiles( aFileSet[i] );
295 break;
296 case GERBER_ORDER_ENUM::GERBER_LAYER_UNKNOWN:
297 LoadAutodetectedFiles( aFileSet[i] );
298 break;
299 default:
300 LoadGerberFiles( aFileSet[i] );
301 }
302 }
303 }
304 }
305
306 Zoom_Automatique( true ); // Zoom fit in frame
307
308 return true;
309}
310
311
313{
314 return dynamic_cast<GERBVIEW_SETTINGS*>( config() );
315}
316
317
319{
321
322 if( aCfg->m_Window.grid.grids.empty() )
323 {
324 aCfg->m_Window.grid.grids = { GRID{ wxEmptyString, wxS( "100 mil" ), wxS( "100 mil" ) },
325 GRID{ wxEmptyString, wxS( "50 mil" ), wxS( "50 mil" ) },
326 GRID{ wxEmptyString, wxS( "25 mil" ), wxS( "25 mil" ) },
327 GRID{ wxEmptyString, wxS( "20 mil" ), wxS( "20 mil" ) },
328 GRID{ wxEmptyString, wxS( "10 mil" ), wxS( "10 mil" ) },
329 GRID{ wxEmptyString, wxS( "5 mil" ), wxS( "5 mil" ) },
330 GRID{ wxEmptyString, wxS( "2.5 mil" ), wxS( "2.5 mil" ) },
331 GRID{ wxEmptyString, wxS( "2 mil" ), wxS( "2 mil" ) },
332 GRID{ wxEmptyString, wxS( "1 mil" ), wxS( "1 mil" ) },
333 GRID{ wxEmptyString, wxS( "0.5 mil" ), wxS( "0.5 mil" ) },
334 GRID{ wxEmptyString, wxS( "0.2 mil" ), wxS( "0.2 mil" ) },
335 GRID{ wxEmptyString, wxS( "0.1 mil" ), wxS( "0.1 mil" ) },
336 GRID{ wxEmptyString, wxS( "5.0 mm" ), wxS( "5.0 mm" ) },
337 GRID{ wxEmptyString, wxS( "1.5 mm" ), wxS( "2.5 mm" ) },
338 GRID{ wxEmptyString, wxS( "1.0 mm" ), wxS( "1.0 mm" ) },
339 GRID{ wxEmptyString, wxS( "0.5 mm" ), wxS( "0.5 mm" ) },
340 GRID{ wxEmptyString, wxS( "0.25 mm" ), wxS( "0.25 mm" ) },
341 GRID{ wxEmptyString, wxS( "0.2 mm" ), wxS( "0.2 mm" ) },
342 GRID{ wxEmptyString, wxS( "0.1 mm" ), wxS( "0.1 mm" ) },
343 GRID{ wxEmptyString, wxS( "0.05 mm" ), wxS( "0.0 mm" ) },
344 GRID{ wxEmptyString, wxS( "0.025 mm" ), wxS( "0.0 mm" ) },
345 GRID{ wxEmptyString, wxS( "0.01 mm" ), wxS( "0.0 mm" ) } };
346 }
347
348 if( aCfg->m_Window.zoom_factors.empty() )
349 {
351 }
352
353 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
354 wxCHECK( cfg, /*void*/ );
355
360
361 PAGE_INFO pageInfo( wxT( "GERBER" ) );
362 pageInfo.SetType( cfg->m_Appearance.page_type );
363 SetPageSettings( pageInfo );
364
367
371}
372
373
375{
377
378 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
379 wxCHECK( cfg, /*void*/ );
380
382
386
388 Pgm().GetSettingsManager().SaveColorSettings( cs, "gerbview" );
389}
390
391
393{
396 wxString currentTheme = cfg->m_ColorTheme;
397 return mgr.GetColorSettings( currentTheme );
398}
399
400
402{
403 wxWindowUpdateLocker no_update( m_LayersManager );
404
408
409 wxAuiPaneInfo& lyrs = m_auimgr.GetPane( m_LayersManager );
410 wxSize bestz = m_LayersManager->GetBestSize();
411 bestz.x += 5; // gives a little margin
412
413 lyrs.MinSize( bestz );
414 lyrs.BestSize( bestz );
415 lyrs.FloatingSize( bestz );
416
417 if( lyrs.IsDocked() )
418 m_auimgr.Update();
419 else
420 m_LayersManager->SetSize( bestz );
421
423}
424
425
426void GERBVIEW_FRAME::SetElementVisibility( int aLayerID, bool aNewState )
427{
428 KIGFX::VIEW* view = GetCanvas()->GetView();
429
430 switch( aLayerID )
431 {
432 case LAYER_DCODES:
433 gvconfig()->m_Appearance.show_dcodes = aNewState;
434
435 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
436 {
437 int layer = GERBER_DRAW_LAYER( i );
438 int dcode_layer = GERBER_DCODE_LAYER( layer );
439 view->SetLayerVisible( dcode_layer, aNewState && view->IsLayerVisible( layer ) );
440 }
441
442 break;
443
445 {
447
449 []( KIGFX::VIEW_ITEM* aItem )
450 {
451 GERBER_DRAW_ITEM* item = dynamic_cast<GERBER_DRAW_ITEM*>( aItem );
452
453 // GetLayerPolarity() returns true for negative items
454 return ( item && item->GetLayerPolarity() );
455 } );
456
457 break;
458 }
459
462
464
465 // NOTE: LAYER_DRAWINGSHEET always used for visibility, but the layer manager passes
466 // LAYER_GERBVIEW_DRAWINGSHEET because of independent color control
468 break;
469
471 SetGridVisibility( aNewState );
472 break;
473
477 break;
478
479 default:
480 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::SetElementVisibility(): bad arg %d" ),
481 aLayerID ) );
482 }
483
485 m_LayersManager->SetRenderState( aLayerID, aNewState );
486}
487
488
490{
491 auto painter = static_cast<KIGFX::GERBVIEW_PAINTER*>( GetCanvas()->GetView()->GetPainter() );
492 KIGFX::GERBVIEW_RENDER_SETTINGS* settings = painter->GetSettings();
494 settings->LoadColors( GetColorSettings() );
495
497}
498
499
501{
502 for( int i = 0; i < (int) ImagesMaxCount(); ++i )
503 {
504 const GERBER_FILE_IMAGE* gerber = GetGbrImage( i );
505
506 if( gerber == nullptr ) // this graphic layer is available: use it
507 return i;
508 }
509
510 return NO_AVAILABLE_LAYERS;
511}
512
513
515{
517}
518
519
520void GERBVIEW_FRAME::syncLayerBox( bool aRebuildLayerBox )
521{
522 if( aRebuildLayerBox )
524
525 m_SelLayerBox->SetSelection( GetActiveLayer() );
526
527 int dcodeSelected = -1;
529
530 if( gerber )
531 dcodeSelected = gerber->m_Selected_Tool;
532
533 if( m_DCodeSelector )
534 {
536 m_DCodeSelector->SetDCodeSelection( dcodeSelected );
537 m_DCodeSelector->Enable( gerber != nullptr );
538 }
539}
540
541
543{
544 RemapLayers( GetImagesList()->SortImagesByFileExtension() );
545}
546
547
549{
550 RemapLayers( GetImagesList()->SortImagesByZOrder() );
551}
552
553
554void GERBVIEW_FRAME::RemapLayers( const std::unordered_map<int, int>& remapping )
555{
556 // Save the visibility of each existing gerber layer, in order to be able
557 // to restore this visibility after layer reorder.
558 // Note: the visibility of other objects (D_CODE, negative objects ... )
559 // must be not modified
560 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
561 {
562 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
563
564 if( gerber )
565 {
566 if( IsLayerVisible( currlayer ) )
567 gerber->SetFlags( CANDIDATE );
568 else
569 gerber->ClearFlags( CANDIDATE );
570 }
571
572 }
573
574 std::unordered_map<int, int> view_remapping;
575
576 for( const std::pair<const int, int>& entry : remapping )
577 {
578 view_remapping[ GERBER_DRAW_LAYER( entry.first ) ] = GERBER_DRAW_LAYER( entry.second );
579 view_remapping[ GERBER_DCODE_LAYER( entry.first ) ] = GERBER_DCODE_LAYER( entry.second );
580 }
581
582 GetCanvas()->GetView()->ReorderLayerData( view_remapping );
583
584 // Restore visibility of gerber layers
585 LSET newVisibility = GetVisibleLayers();
586
587 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
588 {
589 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
590
591 if( gerber )
592 {
593 if( gerber->HasFlag( CANDIDATE ) )
594 newVisibility.set( currlayer );
595 else
596 newVisibility.set( currlayer, false );
597
598 gerber->ClearFlags( CANDIDATE );
599 }
600 }
601
602 SetVisibleLayers( newVisibility );
603
605 syncLayerBox( true );
606
607 // Reordering draw layers need updating the view items
611
612 GetCanvas()->Refresh();
613}
614
615
617{
618 // Adjust draw params: draw offset and draw rotation for a gerber file image
620
621 if( !gerber )
622 return;
623
624 DIALOG_DRAW_LAYERS_SETTINGS dlg( this );
625
626 if( dlg.ShowModal() != wxID_OK )
627 return;
628
629 KIGFX::VIEW* view = GetCanvas()->GetView();
630
631 view->RecacheAllItems();
632 view->MarkDirty();
633 view->UpdateAllItems( KIGFX::ALL );
634
635 GetCanvas()->Refresh();
636}
637
638
640{
644 KIGFX::VIEW* view = GetCanvas()->GetView();
645
646 int lastVisibleLayer = -1;
647
648 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
649 {
650 view->SetLayerDiff( GERBER_DRAW_LAYER( i ), gvconfig()->m_Display.m_XORMode );
651
652 // Caching doesn't work with layered rendering of XOR'd layers
653 if( gvconfig()->m_Display.m_XORMode )
655 else
656 view->SetLayerTarget( GERBER_DRAW_LAYER( i ), target );
657
658 // We want the last visible layer, but deprioritize the active layer unless it's the
659 // only layer
660 if( ( lastVisibleLayer == -1 )
661 || ( view->IsLayerVisible( GERBER_DRAW_LAYER( i ) ) && i != GetActiveLayer() ) )
662 {
663 lastVisibleLayer = i;
664 }
665 }
666
667 //We don't want to diff the last visible layer onto the background, etc.
668 if( lastVisibleLayer != -1 )
669 {
670 view->SetLayerTarget( GERBER_DRAW_LAYER( lastVisibleLayer ), target );
671 view->SetLayerDiff( GERBER_DRAW_LAYER( lastVisibleLayer ), false );
672 }
673
674 view->RecacheAllItems();
675 view->MarkDirty();
676 view->UpdateAllItems( KIGFX::ALL );
677}
678
679
681{
683
684 // Display the gerber filename
685 if( gerber == nullptr )
686 {
687 SetTitle( _("Gerber Viewer") );
688
689 SetStatusText( wxEmptyString, 0 );
690
691 wxString info;
692 info.Printf( _( "Drawing layer not in use" ) );
693 m_TextInfo->SetValue( info );
694
695 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
696 m_auimgr.Update();
697
699 return;
700 }
701 else
702 {
703 wxString title;
704 wxFileName filename( gerber->m_FileName );
705
706 title = filename.GetFullName();
707
708 if( gerber->m_IsX2_file )
709 title += wxS( " " ) + _( "(with X2 attributes)" );
710
711 title += wxT( " \u2014 " ) + _( "Gerber Viewer" );
712 SetTitle( title );
713
714 gerber->DisplayImageInfo( this );
715
716 // Display Image Name and Layer Name (from the current gerber data):
717 wxString status;
718 status.Printf( _( "Image name: \"%s\" Layer name: \"%s\"" ),
719 gerber->m_ImageName,
720 gerber->GetLayerParams().m_LayerName );
721 SetStatusText( status, 0 );
722
723 // Display data format like fmt in X3.4Y3.4 no LZ or fmt mm X2.3 Y3.5 no TZ in main toolbar
724 wxString info;
725 info.Printf( wxT( "fmt: %s X%d.%d Y%d.%d no %cZ" ),
726 gerber->m_GerbMetric ? wxT( "mm" ) : wxT( "in" ),
727 gerber->m_FmtLen.x - gerber->m_FmtScale.x,
728 gerber->m_FmtScale.x,
729 gerber->m_FmtLen.y - gerber->m_FmtScale.y,
730 gerber->m_FmtScale.y,
731 gerber->m_NoTrailingZeros ? 'T' : 'L' );
732
733 if( gerber->m_IsX2_file )
734 info << wxT(" ") << _( "X2 attr" );
735
736 m_TextInfo->SetValue( info );
737
738 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
739 m_auimgr.Update();
740 }
741}
742
743
744bool GERBVIEW_FRAME::IsElementVisible( int aLayerID ) const
745{
746 switch( aLayerID )
747 {
750 case LAYER_GERBVIEW_GRID: return IsGridVisible();
753 case LAYER_GERBVIEW_BACKGROUND: return true;
754
755 default:
756 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::IsElementVisible(): bad arg %d" ),
757 aLayerID ) );
758 }
759
760 return true;
761}
762
763
765{
766 LSET visible = LSET::AllLayersMask();
767
768 if( GetCanvas() )
769 {
770 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
771 visible[i] = GetCanvas()->GetView()->IsLayerVisible( GERBER_DRAW_LAYER( i ) );
772 }
773
774 return visible;
775}
776
777
779{
780 if( GetCanvas() )
781 {
782 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
783 {
784 bool v = aLayerMask[i];
785 int layer = GERBER_DRAW_LAYER( i );
786 GetCanvas()->GetView()->SetLayerVisible( layer, v );
788 gvconfig()->m_Appearance.show_dcodes && v );
789 }
790 }
791}
792
793
794bool GERBVIEW_FRAME::IsLayerVisible( int aLayer ) const
795{
796 return m_LayersManager->IsLayerVisible( aLayer );
797}
798
799
801{
802 COLOR4D color = COLOR4D::UNSPECIFIED;
803 COLOR_SETTINGS* settings = GetColorSettings();
804
805 switch( aLayerID )
806 {
808 case LAYER_DCODES:
812 color = settings->GetColor( aLayerID );
813 break;
814
817 break;
818
819 default:
820 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::GetVisibleElementColor(): bad arg %d" ),
821 aLayerID ) );
822 }
823
824 return color;
825}
826
827
829{
832}
833
834
835void GERBVIEW_FRAME::SetVisibleElementColor( int aLayerID, const COLOR4D& aColor )
836{
837 COLOR_SETTINGS* settings = GetColorSettings();
838
839 settings->SetColor( aLayerID, aColor );
840
841 switch( aLayerID )
842 {
846 break;
847
849 SetGridColor( aColor );
850 break;
851
853 SetDrawBgColor( aColor );
854 break;
855
856 default:
857 break;
858 }
859}
860
861
863{
864 return GetColorSettings()->GetColor( aLayer );
865}
866
867
868void GERBVIEW_FRAME::SetLayerColor( int aLayer, const COLOR4D& aColor )
869{
870 GetColorSettings()->SetColor( aLayer, aColor );
872}
873
874
875void GERBVIEW_FRAME::SetActiveLayer( int aLayer, bool doLayerWidgetUpdate )
876{
877 m_activeLayer = aLayer;
878
879 if( gvconfig()->m_Display.m_XORMode )
881
882 if( doLayerWidgetUpdate )
883 {
884 m_LayersManager->SelectLayer( aLayer );
886 }
887
889
891 GetCanvas()->SetFocus(); // otherwise hotkeys are stuck somewhere
892
894 GetCanvas()->Refresh();
895}
896
897
898void GERBVIEW_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
899{
900 m_paper = aPageSettings;
901
902 if( GetScreen() )
904
905 GERBVIEW_DRAW_PANEL_GAL* drawPanel = static_cast<GERBVIEW_DRAW_PANEL_GAL*>( GetCanvas() );
906
907 // Prepare drawing-sheet template
909 &Prj(), &GetTitleBlock(), nullptr );
910
911 if( GetScreen() )
912 {
913 drawingSheet->SetPageNumber( "1" );
914 drawingSheet->SetSheetCount( 1 );
915 }
916
919
920 // Draw panel takes ownership of the drawing-sheet
921 drawPanel->SetDrawingSheet( drawingSheet );
922}
923
924
926{
927 return m_paper;
928}
929
930
932{
933 // this function is only needed because EDA_DRAW_FRAME is not compiled
934 // with either -DPCBNEW or -DEESCHEMA, so the virtual is used to route
935 // into an application specific source file.
937}
938
939
941{
942 wxASSERT( m_gerberLayout );
944}
945
946
948{
949 wxASSERT( m_gerberLayout );
950 m_gerberLayout->SetTitleBlock( aTitleBlock );
951}
952
953
955{
957}
958
959
961{
963 GetCanvas()->GetGAL()->SetGridColor( aColor );
964 m_gridColor = aColor;
965}
966
967
969{
970 VECTOR2D gridSize = GetCanvas()->GetGAL()->GetGridSize();
971 wxString line;
972
973 line.Printf( wxT( "grid X %s Y %s" ),
974 MessageTextFromValue( gridSize.x, false ),
975 MessageTextFromValue( gridSize.y, false ) );
976
977 SetStatusText( line, 4 );
978 SetStatusText( line, 4 );
979}
980
981
983{
985
986 if( !GetScreen() )
987 return;
988
989 wxString line;
991
992 if( GetShowPolarCoords() ) // display relative polar coordinates
993 {
994 VECTOR2D v = cursorPos - GetScreen()->m_LocalOrigin;
995 EDA_ANGLE theta( VECTOR2D( v.x, -v.y ) );
996 double ro = hypot( v.x, v.y );
997
998 line.Printf( wxT( "r %s theta %s" ),
999 MessageTextFromValue( ro, false ),
1000 MessageTextFromValue( theta, false ) );
1001
1002 SetStatusText( line, 3 );
1003 }
1004
1005 // Display absolute coordinates:
1006 line.Printf( wxT( "X %s Y %s" ),
1007 MessageTextFromValue( cursorPos.x, false ),
1008 MessageTextFromValue( cursorPos.y, false ) );
1009 SetStatusText( line, 2 );
1010
1011 if( !GetShowPolarCoords() )
1012 {
1013 // Display relative cartesian coordinates:
1014 double dXpos = cursorPos.x - GetScreen()->m_LocalOrigin.x;
1015 double dYpos = cursorPos.y - GetScreen()->m_LocalOrigin.y;
1016
1017 line.Printf( wxT( "dx %s dy %s dist %s" ),
1018 MessageTextFromValue( dXpos, false ),
1019 MessageTextFromValue( dYpos,false ),
1020 MessageTextFromValue( hypot( dXpos, dYpos ), false ) );
1021 SetStatusText( line, 3 );
1022 }
1023
1025}
1026
1027
1029{
1030 return m_gerberLayout->GetImagesList()->GetGbrImage( aIdx );
1031}
1032
1033
1035{
1037}
1038
1039
1041{
1042 // Called on units change (see EDA_DRAW_FRAME)
1046}
1047
1048
1050{
1052
1053 EDA_DRAW_PANEL_GAL* galCanvas = GetCanvas();
1054
1055 if( m_toolManager )
1056 {
1058 GetCanvas()->GetViewControls(), config(), this );
1060 }
1061
1063
1065
1066 galCanvas->GetView()->RecacheAllItems();
1068 galCanvas->StartDrawing();
1069
1072
1075
1076 try
1077 {
1078 if( !m_spaceMouse )
1079 m_spaceMouse = std::make_unique<NL_GERBVIEW_PLUGIN>();
1080
1081 m_spaceMouse->SetCanvas( galCanvas );
1082 }
1083 catch( const std::system_error& e )
1084 {
1085 wxLogTrace( wxT( "KI_TRACE_NAVLIB" ), e.what() );
1086 }
1087}
1088
1089
1091{
1092 // Create the manager and dispatcher & route draw panel events to the dispatcher
1095 GetCanvas()->GetViewControls(), config(), this );
1098
1099 // Register tools
1107
1108 // Run the selection tool, it is supposed to be always active
1109 m_toolManager->InvokeTool( "gerbview.InteractiveSelection" );
1110}
1111
1112
1114{
1116
1118 EDITOR_CONDITIONS cond( this );
1119
1120 wxASSERT( mgr );
1121
1122#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1123#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1124
1128
1132
1133 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
1134 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
1135 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
1136
1137 auto flashedDisplayOutlinesCond =
1138 [this] ( const SELECTION& )
1139 {
1141 };
1142
1143 auto linesFillCond =
1144 [this] ( const SELECTION& )
1145 {
1147 };
1148
1149 auto polygonsFilledCond =
1150 [this] ( const SELECTION& )
1151 {
1153 };
1154
1155 auto negativeObjectsCond =
1156 [this] ( const SELECTION& )
1157 {
1159 };
1160
1161 auto dcodeCond =
1162 [this] ( const SELECTION& )
1163 {
1165 };
1166
1167 auto forceOpacityModeCond =
1168 [this] ( const SELECTION& )
1169 {
1171 };
1172
1173 auto xorModeCond =
1174 [this] ( const SELECTION& )
1175 {
1176 return gvconfig()->m_Display.m_XORMode;
1177 };
1178
1179 auto highContrastModeCond =
1180 [this] ( const SELECTION& )
1181 {
1183 };
1184
1185 auto flipGerberCond =
1186 [this] ( const SELECTION& )
1187 {
1189 };
1190
1191 auto layersManagerShownCondition =
1192 [this] ( const SELECTION& aSel )
1193 {
1195 };
1196
1197 mgr->SetConditions( GERBVIEW_ACTIONS::flashedDisplayOutlines, CHECK( flashedDisplayOutlinesCond ) );
1199 mgr->SetConditions( GERBVIEW_ACTIONS::polygonsDisplayOutlines, CHECK( polygonsFilledCond ) );
1200 mgr->SetConditions( GERBVIEW_ACTIONS::negativeObjectDisplay, CHECK( negativeObjectsCond ) );
1202 mgr->SetConditions( GERBVIEW_ACTIONS::toggleForceOpacityMode, CHECK( forceOpacityModeCond ) );
1203 mgr->SetConditions( GERBVIEW_ACTIONS::toggleXORMode, CHECK( xorModeCond ) );
1204 mgr->SetConditions( GERBVIEW_ACTIONS::flipGerberView, CHECK( flipGerberCond ) );
1205 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastModeCond ) );
1206 mgr->SetConditions( GERBVIEW_ACTIONS::toggleLayerManager, CHECK( layersManagerShownCondition ) );
1207
1208#undef CHECK
1209#undef ENABLE
1210}
1211
1212
1213void GERBVIEW_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1214{
1215 EDA_DRAW_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1216
1217 // Update gal display options like cursor shape, grid options:
1220
1221 SetPageSettings( PAGE_INFO( gvconfig()->m_Appearance.page_type ) );
1222
1224
1225 SetElementVisibility( LAYER_DCODES, gvconfig()->m_Appearance.show_dcodes );
1226
1230
1232 ReFillLayerWidget(); // Update the layers list
1233 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
1234
1235 Layout();
1236 SendSizeEvent();
1237}
1238
1239
1241{
1242 return m_toolManager->GetTool<GERBVIEW_SELECTION_TOOL>()->GetSelection();
1243}
1244
1245
1247{
1249
1250 // show/hide auxiliary Vertical layers and visibility manager toolbar
1251 m_auimgr.GetPane( "LayersManager" ).Show( m_show_layer_manager_tools );
1252 m_auimgr.Update();
1253}
1254
1255void GERBVIEW_FRAME::handleActivateEvent( wxActivateEvent& aEvent )
1256{
1258
1259 if( m_spaceMouse )
1260 m_spaceMouse->SetFocus( aEvent.GetActive() );
1261}
1262
1263void GERBVIEW_FRAME::handleIconizeEvent( wxIconizeEvent& aEvent )
1264{
1266
1267 if( m_spaceMouse )
1268 m_spaceMouse->SetFocus( false );
1269}
int color
Definition: DXF_plotter.cpp:58
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE gerbIUScale
Definition: base_units.h:107
wxBitmap KiBitmap(BITMAPS aBitmap, int aHeightTag)
Construct a wxBitmap from an image identifier Returns the image from the active theme if the image ha...
Definition: bitmap.cpp:104
static TOOL_ACTION toggleGrid
Definition: actions.h:185
static TOOL_ACTION millimetersUnits
Definition: actions.h:193
static TOOL_ACTION togglePolarCoords
Definition: actions.h:196
static TOOL_ACTION milsUnits
Definition: actions.h:192
static TOOL_ACTION inchesUnits
Definition: actions.h:191
static TOOL_ACTION highContrastMode
Definition: actions.h:143
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:142
static TOOL_ACTION measureTool
Definition: actions.h:201
static TOOL_ACTION selectionTool
Definition: actions.h:200
static TOOL_ACTION zoomFitScreen
Definition: actions.h:134
static TOOL_ACTION zoomTool
Definition: actions.h:137
Manage TOOL_ACTION objects.
void SetConditions(const TOOL_ACTION &aAction, const ACTION_CONDITIONS &aConditions)
Set the conditions the UI elements for activating a specific tool action should use for determining t...
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Definition: app_settings.h:92
WINDOW_SETTINGS m_Window
Definition: app_settings.h:172
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:175
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 InitDataPoints(const VECTOR2I &aPageSizeInternalUnits)
Definition: base_screen.cpp:46
BASE_SET & set(size_t pos)
Definition: base_set.h:115
Color settings are a bit different than most of the settings objects in that there can be more than o...
void SetColor(int aLayer, const COLOR4D &aColor)
COLOR4D GetColor(int aLayer) const
Handle actions that are shared between different applications.
Handles action that are shared between different applications.
Definition: common_tools.h:38
void SetDCodeSelection(int aDCodeId)
int ShowModal() override
void SetSheetCount(int aSheetCount)
Changes the sheet-count number displayed in the title block.
void SetPageNumber(const std::string &aPageNumber)
Changes the page number displayed in the title block.
void SetPageBorderColorLayer(int aLayerId)
Overrides the layer used to pick the color of the page border (normally LAYER_GRID)
void SetColorLayer(int aLayerId)
Can be used to override which layer ID is used for drawing sheet item colors.
virtual APP_SETTINGS_BASE * config() const
Returns 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 setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
wxAuiManager m_auimgr
std::map< const wxString, TOOL_ACTION * > m_acceptedExts
Associates files extensions with action to execute.
wxString m_aboutTitle
bool m_isClosing
Set by NonUserClose() to indicate that the user did not request the current close.
wxString m_mruPath
void ReCreateMenuBar()
Recreates the menu bar.
The base class for create windows for drawing purpose.
virtual void ClearMsgPanel()
Clear all messages from the message panel.
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
virtual BASE_SCREEN * GetScreen() const
Return a pointer to a BASE_SCREEN or one of its derivatives.
void setupUnits(APP_SETTINGS_BASE *aCfg)
ACTION_TOOLBAR * m_optionsToolBar
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.
virtual void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType)
Changes the current rendering backend.
GAL_DISPLAY_OPTIONS_IMPL & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
virtual void resolveCanvasType()
Determines the Canvas type to load (with prompt if required) and initializes m_canvasType.
EDA_MSG_PANEL * m_messagePanel
void SetCanvas(EDA_DRAW_PANEL_GAL *aPanel)
virtual void SetScreen(BASE_SCREEN *aScreen)
void RecreateToolbars()
Rebuild all toolbars, and update the checked state of check tools.
ACTION_TOOLBAR * m_mainToolBar
virtual void Zoom_Automatique(bool aWarpPointer)
Redraw the screen with best zoom level and the best centering that shows all the page or the board.
virtual void SetGridVisibility(bool aVisible)
virtual void handleActivateEvent(wxActivateEvent &aEvent)
Handle a window activation event.
virtual void SetDrawBgColor(const COLOR4D &aColor)
void UpdateStatusBar() override
Update the status bar information.
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 ...
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Notification event that some of the common (suite-wide) settings have changed.
bool IsGridVisible() const
bool m_showBorderAndTitleBlock
ACTION_TOOLBAR * m_auxiliaryToolBar
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.
void StopDrawing()
Prevent the GAL canvas from further drawing until it is recreated or StartDrawing() is called.
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.
void ForceRefresh()
Force a redraw.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
@ GAL_TYPE_OPENGL
OpenGL implementation.
@ GAL_TYPE_NONE
GAL not used (the legacy wxDC engine is used)
KIGFX::GAL * GetGAL() const
Return a pointer to the GAL instance used in the panel.
void SetFocus() 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.
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:127
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:129
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition: eda_item.h:131
Specialization of the wxAuiPaneInfo class for KiCad panels.
Class that groups generic conditions for editor states.
SELECTION_CONDITION CurrentTool(const TOOL_ACTION &aTool)
Create a functor testing if the specified tool is the current active tool in the frame.
SELECTION_CONDITION Units(EDA_UNITS aUnit)
Create a functor that tests if the frame has the specified units.
SELECTION_CONDITION GridVisible()
Create a functor testing if the grid is visible in a frame.
SELECTION_CONDITION PolarCoordinates()
Create a functor testing if polar coordinates are current being used.
SELECTION_CONDITION FullscreenCursor()
Create a functor testing if the cursor is full screen in a frame.
void Save(APP_SETTINGS_BASE &aSettings)
Saves history into a JSON settings object.
void SetMaxFiles(size_t aMaxFiles)
Update the number of files that will be contained inside the file history.
void Load(const APP_SETTINGS_BASE &aSettings)
Loads history from a JSON settings object.
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
bool m_DisplayFlashedItemsFill
Option to draw flashed items (filled/sketch)
bool m_HighContrastMode
High contrast mode (dim un-highlighted objects)
bool m_XORMode
Display layers in exclusive-or mode.
bool m_FlipGerberView
Display as a mirror image.
bool m_ForceOpacityMode
Display layers in transparency (alpha channel) forced mode.
bool m_DisplayPolygonsFill
Option to draw polygons (filled/sketch)
bool m_DisplayLinesFill
Option to draw line items (filled/sketch)
A list of GERBER_DRAW_ITEM objects currently loaded.
Definition: gbr_layout.h:46
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition: gbr_layout.h:64
GERBER_FILE_IMAGE_LIST * GetImagesList() const
Definition: gbr_layout.cpp:41
TITLE_BLOCK & GetTitleBlock()
Definition: gbr_layout.h:63
bool GetLayerPolarity() const
static void GetGerberLayerFromFilename(const wxString &filename, enum GERBER_ORDER_ENUM &order, wxString &matchedExtension)
Utility function to guess which PCB layer of a gerber/drill file corresponds to based on its file ext...
const wxString GetDisplayName(int aIdx, bool aNameOnly=false, bool aFullName=false)
Get the display name for the layer at aIdx.
void DeleteAllImages()
Remove all loaded data in list, and delete all images, freeing the memory.
GERBER_FILE_IMAGE * GetGbrImage(int aIdx)
Hold the image data and parameters for one gerber file and layer parameters.
wxSize m_FmtScale
Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4.
wxString m_FileName
Full File Name for this layer.
wxString m_ImageName
Image name, from IN <name>* command.
bool m_IsX2_file
True if a X2 gerber attribute was found in file.
wxSize m_FmtLen
Nb chars per coord. ex fmt 2.3, m_FmtLen = 5.
bool m_GerbMetric
false = Inches, true = metric
bool m_NoTrailingZeros
true: remove tailing zeros.
GERBER_LAYER & GetLayerParams()
void DisplayImageInfo(GERBVIEW_FRAME *aMainFrame)
Display information about image parameters in the status bar.
Abstract functions of LAYER_WIDGET so they may be tied into the GERBVIEW_FRAME's data and we can add ...
bool OnLayerSelected()
Ensure the active layer is visible, and other layers not visible when m_alwaysShowActiveLayer is true...
void ReFillRender()
Rebuild Render for instance after the config is read.
void ReFill()
Rebuild Render for instance after the config is read.
wxString m_LayerName
Gather all the actions that are shared by tools.
static TOOL_ACTION dcodeDisplay
static TOOL_ACTION negativeObjectDisplay
static TOOL_ACTION flashedDisplayOutlines
static TOOL_ACTION toggleXORMode
static TOOL_ACTION loadZipFile
static TOOL_ACTION toggleLayerManager
static TOOL_ACTION flipGerberView
static TOOL_ACTION toggleForceOpacityMode
static TOOL_ACTION linesDisplayOutlines
static TOOL_ACTION polygonsDisplayOutlines
static TOOL_ACTION layerChanged
static TOOL_ACTION loadGerbFiles
Handle actions that are shared between different frames in Pcbnew.
void SetDrawingSheet(DS_PROXY_VIEW_ITEM *aDrawingSheet)
Set or update the drawing-sheet (borders and title block) used by the draw panel.
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Returns a pointer to the active color theme settings.
void SetLayerColor(int aLayer, const COLOR4D &aColor)
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Called after the preferences dialog is run.
wxStaticText * m_dcodeText
wxChoice * m_SelAperAttributesBox
void UpdateXORLayers()
Update each layers' differential option.
void UpdateStatusBar() override
Update the status bar information.
COLOR4D GetVisibleElementColor(int aLayerID)
Return the color of a gerber visible element.
GERBVIEW_SETTINGS * gvconfig() const
const PAGE_INFO & GetPageSettings() const override
bool IsLayerVisible(int aLayer) const
Test whether a given layer is visible.
void DisplayGridMsg() override
Display the current grid pane on the status bar.
void SortLayersByX2Attributes()
void SetLayout(GBR_LAYOUT *aLayout)
Set the m_gerberLayout member in such as way as to ensure deleting any previous GBR_LAYOUT.
void ReCreateHToolbar() override
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
GBR_LAYER_BOX_SELECTOR * m_SelLayerBox
void UpdateToolbarControlSizes() override
Update the sizes of any controls in the toolbars of the frame.
bool m_show_layer_manager_tools
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
GBR_LAYOUT * m_gerberLayout
void SetPageSettings(const PAGE_INFO &aPageSettings) override
void ApplyDisplaySettingsToGAL()
Updates the GAL with display settings changes.
PAGE_INFO m_paper
bool LoadGerberJobFile(const wxString &aFileName)
Load a Gerber job file, and load gerber files found in job files.
wxStaticText * m_cmpText
GERBER_FILE_IMAGE_LIST * GetImagesList() const
Accessors to GERBER_FILE_IMAGE_LIST and GERBER_FILE_IMAGE data.
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
void syncLayerBox(bool aRebuildLayerBox=false)
Update the currently "selected" layer within m_SelLayerBox.
GBR_LAYOUT * GetGerberLayout() const
bool LoadGerberFiles(const wxString &aFileName)
Load a given Gerber file or selected file(s), if the filename is empty.
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock) override
void ReCreateAuxiliaryToolbar() override
void doCloseWindow() override
wxChoice * m_SelComponentBox
FILE_HISTORY m_jobFileHistory
std::unique_ptr< NL_GERBVIEW_PLUGIN > m_spaceMouse
wxChoice * m_SelNetnameBox
int GetActiveLayer() const
Return the active layer.
wxTextCtrl * m_TextInfo
bool IsElementVisible(int aLayerID) const
Test whether a given element category is visible.
DCODE_SELECTION_BOX * m_DCodeSelector
GERBER_LAYER_WIDGET * m_LayersManager
void SetActiveLayer(int aLayer, bool doLayerWidgetUpdate=true)
change the currently active layer to aLayer and update the GERBER_LAYER_WIDGET.
wxStaticText * m_netText
void syncLayerWidget()
Update the currently "selected" layer within the GERBER_LAYER_WIDGET.
void SetVisibleElementColor(int aLayerID, const COLOR4D &aColor)
GERBVIEW_FRAME(KIWAY *aKiway, wxWindow *aParent)
unsigned ImagesMaxCount() const
The max number of file images.
void ReCreateOptToolbar() override
Create or update the left vertical toolbar (option toolbar)
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
void SetVisibleLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
wxStaticText * m_apertText
COLOR4D GetLayerColor(int aLayer) const
void SortLayersByFileExtension()
GERBER_FILE_IMAGE * GetGbrImage(int aIdx) const
void handleActivateEvent(wxActivateEvent &aEvent) override
Handle a window activation event.
void SetGridVisibility(bool aVisible) override
const TITLE_BLOCK & GetTitleBlock() const override
bool LoadAutodetectedFiles(const wxString &aFileName)
Load a given file or selected file(s), if the filename is empty.
void RemapLayers(const std::unordered_map< int, int > &remapping)
Takes a layer remapping and reorders the layers.
void ReFillLayerWidget()
Change out all the layers in m_Layers; called upon loading new gerber files.
FILE_HISTORY m_zipFileHistory
bool OpenProjectFiles(const std::vector< wxString > &aFileSet, int aCtl) override
Open a project or set of files given by aFileList.
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
int getNextAvailableLayer() const
Find the next empty layer.
bool LoadZipArchiveFile(const wxString &aFileName)
Load a zipped archive file.
void UpdateTitleAndInfo()
Display the short filename (if exists) of the selected layer on the caption of the main GerbView wind...
void SetElementVisibility(int aLayerID, bool aNewState)
Change the visibility of an element category.
virtual void SetGridColor(const COLOR4D &aColor) override
void unitsChangeRefresh() override
Called when when the units setting has changed to allow for any derived classes to handle refreshing ...
const VECTOR2I GetPageSizeIU() const override
Works off of GetPageSettings() to return the size of the paper page in the internal units of this par...
void ActivateGalCanvas() override
Use to start up the GAL drawing canvas.
void handleIconizeEvent(wxIconizeEvent &aEvent) override
Handle a window iconize event.
FILE_HISTORY m_drillFileHistory
bool LoadExcellonFiles(const wxString &aFileName)
Load a drill (EXCELLON) file or many files.
COLOR4D GetGridColor() override
Selection tool for GerbView, based on the one in Pcbnew.
std::vector< wxString > m_JobFileHistory
std::vector< wxString > m_DrillFileHistory
GBR_DISPLAY_OPTIONS m_Display
std::vector< wxString > m_ZipFileHistory
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
const VECTOR2D & GetGridSize() const
Return the grid size.
Methods for drawing GerbView specific items.
Store GerbView specific render settings.
void LoadColors(const COLOR_SETTINGS *aSettings) override
void SetHighContrast(bool aEnabled)
Turns on/off high contrast display mode.
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:84
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
void SetLayerDiff(int aLayer, bool aDiff=true)
Set the whether the layer should drawn differentially.
Definition: view.h:432
void SetLayerTarget(int aLayer, RENDER_TARGET aTarget)
Change the rendering target for a particular layer.
Definition: view.h:477
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition: view.h:401
void Clear()
Remove all items from the view.
Definition: view.cpp:1168
void RecacheAllItems()
Rebuild GAL display lists.
Definition: view.cpp:1454
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1563
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:649
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:418
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:221
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:625
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:1573
void ReorderLayerData(std::unordered_map< int, int > aReorderMap)
Remap the data between layer ids without invalidating that data.
Definition: view.cpp:715
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
bool Destroy() override
Our version of Destroy() which is virtual from wxWidgets.
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:284
void SetRenderState(int aId, bool isSet)
Set the state of the checkbox associated with aId within the Render tab group of the widget.
void SelectLayer(int aLayer)
Change the row selection in the layer list to aLayer provided.
bool IsLayerVisible(int aLayer)
Return the visible state of the layer ROW associated with aLayer id.
wxSize GetBestSize() const
Return the preferred minimum size, taking into consideration the dynamic content.
void SetSmallestLayerString(const wxString &aString)
Set the string that is used for determining the smallest string displayed in the layer's tab.
Definition: layer_widget.h:141
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:36
static LSET AllLayersMask()
Definition: lset.cpp:701
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
const wxString & GetType() const
Definition: page_info.h:99
bool SetType(const wxString &aStandardPageDescriptionName, bool aIsPortrait=false)
Set the name of the page type and also the sizes and margins commonly associated with that type name.
Definition: page_info.cpp:122
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:679
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:142
T * GetAppSettings()
Returns a handle to the a given settings by type If the settings have already been loaded,...
COLOR_SETTINGS * GetColorSettings(const wxString &aName="user")
Retrieves a color settings object that applications can read colors from.
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely saves a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.
Represent a set of closed polygons.
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:167
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:169
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
ACTIONS * m_actions
Definition: tools_holder.h:168
@ GAL_SWITCH
Rendering engine changes.
Definition: tool_base.h:82
Master controller class:
Definition: tool_manager.h:62
void DeactivateTool()
Deactivate the currently active tool.
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
bool InvokeTool(TOOL_ID aToolId)
Call a tool by sending a tool activation event to tool of given ID.
ACTION_MANAGER * GetActionManager() const
Definition: tool_manager.h:302
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:235
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
void RegisterTool(TOOL_BASE *aTool)
Add a tool to the manager set and sets it up.
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).
void InitTools()
Initializes all registered tools.
void ShutdownAllTools()
Shutdown all tools with a currently registered event loop in this tool manager by waking them up with...
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
#define CHECK(x)
#define _HKI(x)
#define _(s)
#define KICAD_DEFAULT_DRAWFRAME_STYLE
#define CANDIDATE
flag indicating that the structure is connected
@ FRAME_GERBER
Definition: frame_type.h:57
#define NO_AVAILABLE_LAYERS
#define GERBVIEW_FRAME_NAME
The main window used in GerbView.
@ ID_GERBVIEW_JOB_FILE_LIST_CLEAR
Definition: gerbview_id.h:62
@ ID_GERBVIEW_DRILL_FILE1
Definition: gerbview_id.h:54
@ ID_GERBVIEW_ZIP_FILE_LIST_CLEAR
Definition: gerbview_id.h:68
@ ID_GERBVIEW_JOB_FILE1
Definition: gerbview_id.h:60
@ ID_GERBVIEW_ZIP_FILE1
Definition: gerbview_id.h:66
@ ID_GERBVIEW_DRILL_FILE_LIST_CLEAR
Definition: gerbview_id.h:56
static const std::string GerberJobFileExtension
static const std::string GerberFileExtension
static const std::string DrillFileExtension
static const std::string ArchiveFileExtension
#define DEFAULT_FILE_HISTORY_SIZE
IDs range for menuitems file history: The default range file history size is 9 (compatible with defau...
Definition: id.h:69
@ LAYER_GERBVIEW_DRAWINGSHEET
Definition: layer_ids.h:436
@ LAYER_GERBVIEW_BACKGROUND
Definition: layer_ids.h:435
@ LAYER_DCODES
Definition: layer_ids.h:431
@ LAYER_NEGATIVE_OBJECTS
Definition: layer_ids.h:432
@ LAYER_GERBVIEW_PAGE_LIMITS
Definition: layer_ids.h:437
@ LAYER_GERBVIEW_GRID
Definition: layer_ids.h:433
#define GERBER_DCODE_LAYER(x)
Definition: layer_ids.h:444
@ LAYER_DRAWINGSHEET
drawingsheet frame and titleblock
Definition: layer_ids.h:219
#define GERBER_DRAWLAYERS_COUNT
Definition: layer_ids.h:421
#define GERBER_DRAW_LAYER(x)
Definition: layer_ids.h:442
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:57
@ 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
KICOMMON_API bool EnsureTextCtrlWidth(wxTextCtrl *aCtrl, const wxString *aString=nullptr)
Set the minimum pixel width on a text control in order to make a text string be fully visible within ...
Definition: ui_common.cpp:166
Declaration of the NL_GERBVIEW_PLUGIN class.
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1060
see class PGM_BASE
std::vector< FAB_LAYER_COLOR > dummy
const double IU_PER_MILS
Definition: base_units.h:77
std::vector< GRID > grids
Definition: grid_settings.h:66
Common grid settings, available to every frame.
Definition: grid_settings.h:34
GRID_SETTINGS grid
Definition: app_settings.h:81
std::vector< double > zoom_factors
Definition: app_settings.h:78
VECTOR2< double > VECTOR2D
Definition: vector2d.h:690
Definition of file extensions used in Kicad.
#define ZOOM_LIST_GERBVIEW
Definition: zoom_defines.h:29