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 The 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 <toolbars_gerber.h>
38#include <tool/tool_manager.h>
39#include <tool/action_toolbar.h>
41#include <tool/common_control.h>
42#include <tool/common_tools.h>
44#include <tool/zoom_tool.h>
50#include <trigo.h>
51#include <view/view.h>
52#include <view/view_controls.h>
53#include <base_screen.h>
54#include <gerbview_painter.h>
55#include <wx/wupdlock.h>
56
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();
151
152 m_toolbarSettings = GetToolbarSettings<GERBVIEW_TOOLBAR_SETTINGS>( "gerbview-toolbars" );
155
156 m_auimgr.SetManagedWindow( this );
157
158 m_auimgr.AddPane( m_tbTopMain, EDA_PANE().HToolbar().Name( "TopMainToolbar" ).Top().Layer( 6 ) );
159 m_auimgr.AddPane( m_tbTopAux, EDA_PANE().HToolbar().Name( "TopAuxToolbar" ).Top().Layer(4) );
160 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" ).Bottom().Layer( 6 ) );
161 m_auimgr.AddPane( m_tbLeft, EDA_PANE().VToolbar().Name( "LeftToolbar" ).Left().Layer( 3 ) );
162 m_auimgr.AddPane( m_LayersManager, EDA_PANE().Palette().Name( "LayersManager" ).Right().Layer( 3 )
163 .Caption( _( "Layers Manager" ) ).PaneBorder( false )
164 .MinSize( 80, -1 ).BestSize( m_LayersManager->GetBestSize() ) );
165
166 m_auimgr.AddPane( GetCanvas(), EDA_PANE().Canvas().Name( "DrawFrame" ).Center() );
167
168 ReFillLayerWidget(); // this is near end because contents establish size
169 m_auimgr.Update();
170
171 SetActiveLayer( 0, true );
173
175
177
178 setupUnits( config() );
179
180 // Enable the axes to match legacy draw style
181 auto& galOptions = GetGalDisplayOptions();
182 galOptions.m_axesEnabled = true;
183 galOptions.NotifyChanged();
184
186 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
187
188 // Drag and drop
189 // Note that all gerber files are aliased as GerberFileExtension
193 DragAcceptFiles( true );
194
196
197 // Ensure the window is on top
198 Raise();
199
200 // Register a call to update the toolbar sizes. It can't be done immediately because
201 // it seems to require some sizes calculated that aren't yet (at least on GTK).
202 CallAfter( [this]()
203 {
204 // Ensure the controls on the toolbars all are correctly sized
206 } );
207}
208
209
211{
212 // Ensure m_canvasType is up to date, to save it in config
214
215 // Shutdown all running tools
216 if( m_toolManager )
218
219 GetCanvas()->GetView()->Clear();
220
222 delete m_gerberLayout;
223}
224
225
227{
228 // No more vetos
229 m_isClosing = true;
231
232 if( m_toolManager )
234
235 // Be sure any OpenGL event cannot be fired after frame deletion:
236 GetCanvas()->SetEvtHandlerEnabled( false );
237
238 Destroy();
239}
240
241
242bool GERBVIEW_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
243{
244 // Ensure the frame is shown when opening the file(s), to avoid issues (crash) on GAL
245 // when trying to change the view if it is not fully initialized.
246 // It happens when starting GerbView with a gerber job file to load
247 if( !IsShownOnScreen() )
248 Show();
249
250 // The current project path is also a valid command parameter. Check if a single path
251 // rather than a file name was passed to GerbView and use it as the initial MRU path.
252 if( aFileSet.size() > 0 )
253 {
254 wxString path = aFileSet[0];
255
256 // For some reason wxApp appears to leave the trailing double quote on quoted
257 // parameters which are required for paths with spaces. Maybe this should be
258 // pushed back into PGM_SINGLE_TOP::OnPgmInit() but that may cause other issues.
259 // We can't buy a break!
260 if( path.Last() == wxChar( '\"' ) )
261 path.RemoveLast();
262
263 if( !wxFileExists( path ) && wxDirExists( path ) )
264 {
265 m_mruPath = path;
266 return true;
267 }
268
269 const unsigned limit = std::min( unsigned( aFileSet.size() ),
270 unsigned( GERBER_DRAWLAYERS_COUNT ) );
271
272 for( unsigned i = 0; i < limit; ++i )
273 {
274 wxString ext = wxFileName( aFileSet[i] ).GetExt().Lower();
275
277 LoadZipArchiveFile( aFileSet[i] );
278 else if( ext == FILEEXT::GerberJobFileExtension )
279 LoadGerberJobFile( aFileSet[i] );
280 else
281 {
282 GERBER_ORDER_ENUM fnameLayer;
283 wxString fnameExtensionMatched;
284
286 fnameExtensionMatched );
287
288 switch( fnameLayer )
289 {
290 case GERBER_ORDER_ENUM::GERBER_DRILL:
291 LoadExcellonFiles( aFileSet[i] );
292 break;
293 case GERBER_ORDER_ENUM::GERBER_LAYER_UNKNOWN:
294 LoadAutodetectedFiles( aFileSet[i] );
295 break;
296 default:
297 LoadGerberFiles( aFileSet[i] );
298 }
299 }
300 }
301 }
302
303 Zoom_Automatique( true ); // Zoom fit in frame
304
305 return true;
306}
307
308
310{
311 return dynamic_cast<GERBVIEW_SETTINGS*>( config() );
312}
313
314
316{
318
319 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
320 wxCHECK( cfg, /*void*/ );
321
324
325 PAGE_INFO pageInfo( wxT( "GERBER" ) );
326 pageInfo.SetType( cfg->m_Appearance.page_type );
327 SetPageSettings( pageInfo );
328
331
335}
336
337
339{
341
342 if( GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg ) )
343 {
344 cfg->m_Appearance.page_type = GetPageSettings().GetType();
345
346 m_drillFileHistory.Save( &cfg->m_DrillFileHistory );
347 m_zipFileHistory.Save( &cfg->m_ZipFileHistory );
348 m_jobFileHistory.Save( &cfg->m_JobFileHistory );
349 }
350
352}
353
354
356{
357 GERBVIEW_SETTINGS* cfg = GetAppSettings<GERBVIEW_SETTINGS>( "gerbview" );
358 return ::GetColorSettings( cfg ? cfg->m_ColorTheme : DEFAULT_THEME );
359}
360
361
363{
364 wxWindowUpdateLocker no_update( m_LayersManager );
365
368
369 // Re-build the various boxes in the toolbars
370 // TODO: Could this be made more precise instead of just blowing away all the toolbars?
372
373 wxAuiPaneInfo& lyrs = m_auimgr.GetPane( m_LayersManager );
374 wxSize bestz = m_LayersManager->GetBestSize();
375 bestz.x += 5; // gives a little margin
376
377 lyrs.MinSize( bestz );
378 lyrs.BestSize( bestz );
379 lyrs.FloatingSize( bestz );
380
381 if( lyrs.IsDocked() )
382 m_auimgr.Update();
383 else
384 m_LayersManager->SetSize( bestz );
385
387}
388
389
390void GERBVIEW_FRAME::SetElementVisibility( int aLayerID, bool aNewState )
391{
392 KIGFX::VIEW* view = GetCanvas()->GetView();
393
394 switch( aLayerID )
395 {
396 case LAYER_DCODES:
397 gvconfig()->m_Appearance.show_dcodes = aNewState;
398
399 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
400 {
401 int layer = GERBER_DRAW_LAYER( i );
402 int dcode_layer = GERBER_DCODE_LAYER( layer );
403 view->SetLayerVisible( dcode_layer, aNewState && view->IsLayerVisible( layer ) );
404 }
405
406 break;
407
409 {
411
413 []( KIGFX::VIEW_ITEM* aItem )
414 {
415 GERBER_DRAW_ITEM* item = dynamic_cast<GERBER_DRAW_ITEM*>( aItem );
416
417 // GetLayerPolarity() returns true for negative items
418 return ( item && item->GetLayerPolarity() );
419 } );
420
421 break;
422 }
423
426
428
429 // NOTE: LAYER_DRAWINGSHEET always used for visibility, but the layer manager passes
430 // LAYER_GERBVIEW_DRAWINGSHEET because of independent color control
432 break;
433
435 SetGridVisibility( aNewState );
436 break;
437
441 break;
442
443 default:
444 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::SetElementVisibility(): bad arg %d" ),
445 aLayerID ) );
446 }
447
449 m_LayersManager->SetRenderState( aLayerID, aNewState );
450}
451
452
454{
455 auto painter = static_cast<KIGFX::GERBVIEW_PAINTER*>( GetCanvas()->GetView()->GetPainter() );
456 KIGFX::GERBVIEW_RENDER_SETTINGS* settings = painter->GetSettings();
458 settings->LoadColors( GetColorSettings() );
459
461}
462
463
465{
466 for( int i = 0; i < (int) ImagesMaxCount(); ++i )
467 {
468 const GERBER_FILE_IMAGE* gerber = GetGbrImage( i );
469
470 if( gerber == nullptr ) // this graphic layer is available: use it
471 return i;
472 }
473
474 return NO_AVAILABLE_LAYERS;
475}
476
477
479{
481}
482
483
484void GERBVIEW_FRAME::syncLayerBox( bool aRebuildLayerBox )
485{
486 if( aRebuildLayerBox )
488
489 m_SelLayerBox->SetSelection( GetActiveLayer() );
490
491 int dcodeSelected = -1;
493
494 if( gerber )
495 dcodeSelected = gerber->m_Selected_Tool;
496
497 if( m_DCodeSelector )
498 {
500 m_DCodeSelector->SetDCodeSelection( dcodeSelected );
501 m_DCodeSelector->Enable( gerber != nullptr );
502 }
503}
504
505
507{
508 RemapLayers( GetImagesList()->SortImagesByFileExtension() );
509}
510
511
513{
514 RemapLayers( GetImagesList()->SortImagesByZOrder() );
515}
516
517
518void GERBVIEW_FRAME::RemapLayers( const std::unordered_map<int, int>& remapping )
519{
520 // Save the visibility of each existing gerber layer, in order to be able
521 // to restore this visibility after layer reorder.
522 // Note: the visibility of other objects (D_CODE, negative objects ... )
523 // must be not modified
524 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
525 {
526 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
527
528 if( gerber )
529 {
530 if( IsLayerVisible( currlayer ) )
531 gerber->SetFlags( CANDIDATE );
532 else
533 gerber->ClearFlags( CANDIDATE );
534 }
535
536 }
537
538 std::unordered_map<int, int> view_remapping;
539
540 for( const std::pair<const int, int>& entry : remapping )
541 {
542 view_remapping[ GERBER_DRAW_LAYER( entry.first ) ] = GERBER_DRAW_LAYER( entry.second );
543 view_remapping[ GERBER_DCODE_LAYER( entry.first ) ] = GERBER_DCODE_LAYER( entry.second );
544 }
545
546 GetCanvas()->GetView()->ReorderLayerData( view_remapping );
547
548 // Restore visibility of gerber layers
549 LSET newVisibility = GetVisibleLayers();
550
551 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
552 {
553 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
554
555 if( gerber )
556 {
557 if( gerber->HasFlag( CANDIDATE ) )
558 newVisibility.set( currlayer );
559 else
560 newVisibility.set( currlayer, false );
561
562 gerber->ClearFlags( CANDIDATE );
563 }
564 }
565
566 SetVisibleLayers( newVisibility );
567
569 syncLayerBox( true );
570
571 // Reordering draw layers need updating the view items
575
576 GetCanvas()->Refresh();
577}
578
579
581{
582 // Adjust draw params: draw offset and draw rotation for a gerber file image
584
585 if( !gerber )
586 return;
587
588 DIALOG_DRAW_LAYERS_SETTINGS dlg( this );
589
590 if( dlg.ShowModal() != wxID_OK )
591 return;
592
593 KIGFX::VIEW* view = GetCanvas()->GetView();
594
595 view->RecacheAllItems();
596 view->MarkDirty();
597 view->UpdateAllItems( KIGFX::ALL );
598
599 GetCanvas()->Refresh();
600}
601
602
604{
608 KIGFX::VIEW* view = GetCanvas()->GetView();
609
610 int lastVisibleLayer = -1;
611
612 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
613 {
614 view->SetLayerDiff( GERBER_DRAW_LAYER( i ), gvconfig()->m_Display.m_XORMode );
615
616 // Caching doesn't work with layered rendering of XOR'd layers
617 if( gvconfig()->m_Display.m_XORMode )
619 else
620 view->SetLayerTarget( GERBER_DRAW_LAYER( i ), target );
621
622 // We want the last visible layer, but deprioritize the active layer unless it's the
623 // only layer
624 if( ( lastVisibleLayer == -1 )
625 || ( view->IsLayerVisible( GERBER_DRAW_LAYER( i ) ) && i != GetActiveLayer() ) )
626 {
627 lastVisibleLayer = i;
628 }
629 }
630
631 //We don't want to diff the last visible layer onto the background, etc.
632 if( lastVisibleLayer != -1 )
633 {
634 view->SetLayerTarget( GERBER_DRAW_LAYER( lastVisibleLayer ), target );
635 view->SetLayerDiff( GERBER_DRAW_LAYER( lastVisibleLayer ), false );
636 }
637
638 view->RecacheAllItems();
639 view->MarkDirty();
640 view->UpdateAllItems( KIGFX::ALL );
641}
642
643
645{
647
648 // Display the gerber filename
649 if( gerber == nullptr )
650 {
651 SetTitle( _("Gerber Viewer") );
652
653 SetStatusText( wxEmptyString, 0 );
654
655 wxString info = _( "Drawing layer not in use" );
656 m_TextInfo->SetValue( info );
657
658 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
659 m_auimgr.Update();
660
662 return;
663 }
664 else
665 {
666 wxString title;
667 wxFileName filename( gerber->m_FileName );
668
669 title = filename.GetFullName();
670
671 if( gerber->m_IsX2_file )
672 title += wxS( " " ) + _( "(with X2 attributes)" );
673
674 title += wxT( " \u2014 " ) + _( "Gerber Viewer" );
675 SetTitle( title );
676
677 gerber->DisplayImageInfo( this );
678
679 // Display Image Name and Layer Name (from the current gerber data):
680 wxString status;
681 status.Printf( _( "Image name: '%s' Layer name: '%s'" ),
682 gerber->m_ImageName,
683 gerber->GetLayerParams().m_LayerName );
684 SetStatusText( status, 0 );
685
686 // Display data format like fmt in X3.4Y3.4 no LZ or fmt mm X2.3 Y3.5 no TZ in main toolbar
687 wxString info;
688 info.Printf( wxT( "fmt: %s X%d.%d Y%d.%d no %cZ" ),
689 gerber->m_GerbMetric ? wxT( "mm" ) : wxT( "in" ),
690 gerber->m_FmtLen.x - gerber->m_FmtScale.x,
691 gerber->m_FmtScale.x,
692 gerber->m_FmtLen.y - gerber->m_FmtScale.y,
693 gerber->m_FmtScale.y,
694 gerber->m_NoTrailingZeros ? 'T' : 'L' );
695
696 if( gerber->m_IsX2_file )
697 info << wxT(" ") << _( "X2 attr" );
698
699 m_TextInfo->SetValue( info );
700
701 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
702 m_auimgr.Update();
703 }
704}
705
706
707bool GERBVIEW_FRAME::IsElementVisible( int aLayerID ) const
708{
709 switch( aLayerID )
710 {
713 case LAYER_GERBVIEW_GRID: return IsGridVisible();
716 case LAYER_GERBVIEW_BACKGROUND: return true;
717
718 default:
719 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::IsElementVisible(): bad arg %d" ),
720 aLayerID ) );
721 }
722
723 return true;
724}
725
726
728{
729 LSET visible = LSET::AllLayersMask();
730
731 if( GetCanvas() )
732 {
733 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
734 visible[i] = GetCanvas()->GetView()->IsLayerVisible( GERBER_DRAW_LAYER( i ) );
735 }
736
737 return visible;
738}
739
740
741void GERBVIEW_FRAME::SetVisibleLayers( const LSET& aLayerMask )
742{
743 if( GetCanvas() )
744 {
745 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
746 {
747 bool v = aLayerMask[i];
748 int layer = GERBER_DRAW_LAYER( i );
749 GetCanvas()->GetView()->SetLayerVisible( layer, v );
751 gvconfig()->m_Appearance.show_dcodes && v );
752 }
753 }
754}
755
756
757bool GERBVIEW_FRAME::IsLayerVisible( int aLayer ) const
758{
759 return m_LayersManager->IsLayerVisible( aLayer );
760}
761
762
764{
765 COLOR4D color = COLOR4D::UNSPECIFIED;
766 COLOR_SETTINGS* settings = GetColorSettings();
767
768 switch( aLayerID )
769 {
771 case LAYER_DCODES:
775 color = settings->GetColor( aLayerID );
776 break;
777
780 break;
781
782 default:
783 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::GetVisibleElementColor(): bad arg %d" ),
784 aLayerID ) );
785 }
786
787 return color;
788}
789
790
792{
795}
796
797
798void GERBVIEW_FRAME::SetVisibleElementColor( int aLayerID, const COLOR4D& aColor )
799{
800 COLOR_SETTINGS* settings = GetColorSettings();
801
802 settings->SetColor( aLayerID, aColor );
803
804 switch( aLayerID )
805 {
809 break;
810
812 SetGridColor( aColor );
813 break;
814
816 SetDrawBgColor( aColor );
817 break;
818
819 default:
820 break;
821 }
822}
823
824
826{
827 return GetColorSettings()->GetColor( aLayer );
828}
829
830
831void GERBVIEW_FRAME::SetLayerColor( int aLayer, const COLOR4D& aColor )
832{
833 GetColorSettings()->SetColor( aLayer, aColor );
835}
836
837
838void GERBVIEW_FRAME::SetActiveLayer( int aLayer, bool doLayerWidgetUpdate )
839{
840 m_activeLayer = aLayer;
841
842 if( gvconfig()->m_Display.m_XORMode )
844
845 if( doLayerWidgetUpdate )
846 {
847 m_LayersManager->SelectLayer( aLayer );
849 }
850
852
854 GetCanvas()->SetFocus(); // otherwise hotkeys are stuck somewhere
855
857 GetCanvas()->Refresh();
858}
859
860
861void GERBVIEW_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
862{
863 m_paper = aPageSettings;
864
865 if( GetScreen() )
867
868 GERBVIEW_DRAW_PANEL_GAL* drawPanel = static_cast<GERBVIEW_DRAW_PANEL_GAL*>( GetCanvas() );
869
870 // Prepare drawing-sheet template
872 &Prj(), &GetTitleBlock(), nullptr );
873
874 if( GetScreen() )
875 {
876 drawingSheet->SetPageNumber( "1" );
877 drawingSheet->SetSheetCount( 1 );
878 }
879
882
883 // Draw panel takes ownership of the drawing-sheet
884 drawPanel->SetDrawingSheet( drawingSheet );
885}
886
887
889{
890 return m_paper;
891}
892
893
895{
896 // this function is only needed because EDA_DRAW_FRAME is not compiled
897 // with either -DPCBNEW or -DEESCHEMA, so the virtual is used to route
898 // into an application specific source file.
900}
901
902
904{
905 wxASSERT( m_gerberLayout );
907}
908
909
911{
912 wxASSERT( m_gerberLayout );
913 m_gerberLayout->SetTitleBlock( aTitleBlock );
914}
915
916
918{
920}
921
922
924{
926 GetCanvas()->GetGAL()->SetGridColor( aColor );
927 m_gridColor = aColor;
928}
929
930
932{
933 VECTOR2D gridSize = GetCanvas()->GetGAL()->GetGridSize();
934 wxString line;
935
936 line.Printf( wxT( "grid X %s Y %s" ),
937 MessageTextFromValue( gridSize.x, false ),
938 MessageTextFromValue( gridSize.y, false ) );
939
940 SetStatusText( line, 4 );
941 SetStatusText( line, 4 );
942}
943
944
946{
948
949 if( !GetScreen() )
950 return;
951
952 wxString line;
954
955 if( GetShowPolarCoords() ) // display relative polar coordinates
956 {
957 VECTOR2D v = cursorPos - GetScreen()->m_LocalOrigin;
958 EDA_ANGLE theta( VECTOR2D( v.x, -v.y ) );
959 double ro = hypot( v.x, v.y );
960
961 line.Printf( wxT( "r %s theta %s" ),
962 MessageTextFromValue( ro, false ),
963 MessageTextFromValue( theta, false ) );
964
965 SetStatusText( line, 3 );
966 }
967
968 // Display absolute coordinates:
969 line.Printf( wxT( "X %s Y %s" ),
970 MessageTextFromValue( cursorPos.x, false ),
971 MessageTextFromValue( cursorPos.y, false ) );
972 SetStatusText( line, 2 );
973
974 if( !GetShowPolarCoords() )
975 {
976 // Display relative cartesian coordinates:
977 double dXpos = cursorPos.x - GetScreen()->m_LocalOrigin.x;
978 double dYpos = cursorPos.y - GetScreen()->m_LocalOrigin.y;
979
980 line.Printf( wxT( "dx %s dy %s dist %s" ),
981 MessageTextFromValue( dXpos, false ),
982 MessageTextFromValue( dYpos,false ),
983 MessageTextFromValue( hypot( dXpos, dYpos ), false ) );
984 SetStatusText( line, 3 );
985 }
986
988}
989
990
992{
993 return m_gerberLayout->GetImagesList()->GetGbrImage( aIdx );
994}
995
996
998{
1000}
1001
1002
1004{
1005 // Called on units change (see EDA_DRAW_FRAME)
1009}
1010
1011
1013{
1015
1016 EDA_DRAW_PANEL_GAL* galCanvas = GetCanvas();
1017
1018 if( m_toolManager )
1019 {
1021 GetCanvas()->GetViewControls(), config(), this );
1023 }
1024
1026
1028
1029 galCanvas->GetView()->RecacheAllItems();
1031 galCanvas->StartDrawing();
1032
1035
1038
1039 try
1040 {
1041 if( !m_spaceMouse )
1042 m_spaceMouse = std::make_unique<NL_GERBVIEW_PLUGIN>();
1043
1044 m_spaceMouse->SetCanvas( galCanvas );
1045 }
1046 catch( const std::system_error& e )
1047 {
1048 wxLogTrace( wxT( "KI_TRACE_NAVLIB" ), e.what() );
1049 }
1050}
1051
1052
1054{
1055 // Create the manager and dispatcher & route draw panel events to the dispatcher
1058 GetCanvas()->GetViewControls(), config(), this );
1061
1062 // Register tools
1070
1071 // Run the selection tool, it is supposed to be always active
1072 m_toolManager->InvokeTool( "common.InteractiveSelection" );
1073}
1074
1075
1077{
1079
1081 EDITOR_CONDITIONS cond( this );
1082
1083 wxASSERT( mgr );
1084
1085#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1086#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1087
1091
1095
1096 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MM ) ) );
1097 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCH ) ) );
1098 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
1099
1100 auto flashedDisplayOutlinesCond =
1101 [this] ( const SELECTION& )
1102 {
1104 };
1105
1106 auto linesFillCond =
1107 [this] ( const SELECTION& )
1108 {
1110 };
1111
1112 auto polygonsFilledCond =
1113 [this] ( const SELECTION& )
1114 {
1116 };
1117
1118 auto negativeObjectsCond =
1119 [this] ( const SELECTION& )
1120 {
1122 };
1123
1124 auto dcodeCond =
1125 [this] ( const SELECTION& )
1126 {
1128 };
1129
1130 auto forceOpacityModeCond =
1131 [this] ( const SELECTION& )
1132 {
1134 };
1135
1136 auto xorModeCond =
1137 [this] ( const SELECTION& )
1138 {
1139 return gvconfig()->m_Display.m_XORMode;
1140 };
1141
1142 auto highContrastModeCond =
1143 [this] ( const SELECTION& )
1144 {
1146 };
1147
1148 auto flipGerberCond =
1149 [this] ( const SELECTION& )
1150 {
1152 };
1153
1154 auto layersManagerShownCondition =
1155 [this] ( const SELECTION& aSel )
1156 {
1158 };
1159
1160 mgr->SetConditions( GERBVIEW_ACTIONS::flashedDisplayOutlines, CHECK( flashedDisplayOutlinesCond ) );
1162 mgr->SetConditions( GERBVIEW_ACTIONS::polygonsDisplayOutlines, CHECK( polygonsFilledCond ) );
1163 mgr->SetConditions( GERBVIEW_ACTIONS::negativeObjectDisplay, CHECK( negativeObjectsCond ) );
1165 mgr->SetConditions( GERBVIEW_ACTIONS::toggleForceOpacityMode, CHECK( forceOpacityModeCond ) );
1166 mgr->SetConditions( GERBVIEW_ACTIONS::toggleXORMode, CHECK( xorModeCond ) );
1167 mgr->SetConditions( GERBVIEW_ACTIONS::flipGerberView, CHECK( flipGerberCond ) );
1168 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastModeCond ) );
1169 mgr->SetConditions( GERBVIEW_ACTIONS::toggleLayerManager, CHECK( layersManagerShownCondition ) );
1170
1171#undef CHECK
1172#undef ENABLE
1173}
1174
1175
1177{
1179
1180 // Update gal display options like cursor shape, grid options:
1181 if( GERBVIEW_SETTINGS* cfg = GetAppSettings<GERBVIEW_SETTINGS>( "gerbview" ) )
1182 {
1183 GetGalDisplayOptions().ReadWindowSettings( cfg->m_Window );
1184
1185 SetPageSettings( PAGE_INFO( cfg->m_Appearance.page_type ) );
1186 SetElementVisibility( LAYER_DCODES, cfg->m_Appearance.show_dcodes );
1187 }
1188
1190
1194
1196 ReFillLayerWidget(); // Update the layers list
1197 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
1198
1199 Layout();
1200 SendSizeEvent();
1201}
1202
1203
1205{
1206 return m_toolManager->GetTool<GERBVIEW_SELECTION_TOOL>()->GetSelection();
1207}
1208
1209
1211{
1213
1214 // show/hide auxiliary Vertical layers and visibility manager toolbar
1215 m_auimgr.GetPane( "LayersManager" ).Show( m_show_layer_manager_tools );
1216 m_auimgr.Update();
1217}
1218
1219void GERBVIEW_FRAME::handleActivateEvent( wxActivateEvent& aEvent )
1220{
1222
1223 if( m_spaceMouse )
1224 m_spaceMouse->SetFocus( aEvent.GetActive() );
1225}
1226
1227void GERBVIEW_FRAME::handleIconizeEvent( wxIconizeEvent& aEvent )
1228{
1230
1231 if( m_spaceMouse )
1232 m_spaceMouse->SetFocus( false );
1233}
int color
Definition: DXF_plotter.cpp:63
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE gerbIUScale
Definition: base_units.h:111
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:195
static TOOL_ACTION millimetersUnits
Definition: actions.h:203
static TOOL_ACTION togglePolarCoords
Definition: actions.h:206
static TOOL_ACTION milsUnits
Definition: actions.h:202
static TOOL_ACTION inchesUnits
Definition: actions.h:201
static TOOL_ACTION highContrastMode
Definition: actions.h:152
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:151
static TOOL_ACTION measureTool
Definition: actions.h:249
static TOOL_ACTION selectionTool
Definition: actions.h:248
static TOOL_ACTION zoomFitScreen
Definition: actions.h:141
static TOOL_ACTION zoomTool
Definition: actions.h:145
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:108
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:236
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:116
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)
Change the sheet-count number displayed in the title block.
void SetPageNumber(const std::string &aPageNumber)
Change the page number displayed in the title block.
void SetPageBorderColorLayer(int aLayerId)
Override 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
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 setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
virtual void UpdateToolbarControlSizes()
Update the sizes of any controls in the toolbars of the frame.
TOOLBAR_SETTINGS * m_toolbarSettings
wxAuiManager m_auimgr
virtual void RecreateToolbars()
ACTION_TOOLBAR * m_tbLeft
ACTION_TOOLBAR * m_tbTopAux
std::map< const wxString, TOOL_ACTION * > m_acceptedExts
Associate file extensions with action to execute.
ACTION_TOOLBAR * m_tbTopMain
wxString m_aboutTitle
bool m_isClosing
Set by the close window event handler after frames are asked if they can close.
wxString m_mruPath
void ReCreateMenuBar()
Recreate 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
The current canvas type.
virtual BASE_SCREEN * GetScreen() const
Return a pointer to a BASE_SCREEN or one of its derivatives.
void setupUnits(APP_SETTINGS_BASE *aCfg)
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)
Change 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()
Determine 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)
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 ...
bool IsGridVisible() const
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.
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:142
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:144
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition: eda_item.h:146
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)
wxStaticText * m_dcodeText
wxChoice * m_SelAperAttributesBox
void UpdateXORLayers()
Update each layers' differential option.
void UpdateStatusBar() override
Update the status bar information.
void configureToolbars() override
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.
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
GBR_LAYER_BOX_SELECTOR * m_SelLayerBox
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 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 SetVisibleLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
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.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
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
void CommonSettingsChanged(int aFlags) override
Called after the preferences dialog is run.
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:86
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:66
void SetLayerDiff(int aLayer, bool aDiff=true)
Set the whether the layer should drawn differentially.
Definition: view.h:438
void SetLayerTarget(int aLayer, RENDER_TARGET aTarget)
Change the rendering target for a particular layer.
Definition: view.h:497
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition: view.h:400
void Clear()
Remove all items from the view.
Definition: view.cpp:1143
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
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:659
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:422
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:220
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:639
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
void ReorderLayerData(std::unordered_map< int, int > aReorderMap)
Remap the data between layer ids without invalidating that data.
Definition: view.cpp:680
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:286
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:37
static const LSET & AllLayersMask()
Definition: lset.cpp:624
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:565
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:125
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely save 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:171
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:173
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
ACTIONS * m_actions
Definition: tools_holder.h:172
@ 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:306
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()
Initialize 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:60
@ ID_GERBVIEW_DRILL_FILE1
Definition: gerbview_id.h:52
@ ID_GERBVIEW_ZIP_FILE_LIST_CLEAR
Definition: gerbview_id.h:66
@ ID_GERBVIEW_JOB_FILE1
Definition: gerbview_id.h:58
@ ID_GERBVIEW_ZIP_FILE1
Definition: gerbview_id.h:64
@ ID_GERBVIEW_DRILL_FILE_LIST_CLEAR
Definition: gerbview_id.h:54
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:49
@ LAYER_GERBVIEW_DRAWINGSHEET
Definition: layer_ids.h:522
@ LAYER_GERBVIEW_BACKGROUND
Definition: layer_ids.h:521
@ LAYER_DCODES
Definition: layer_ids.h:517
@ LAYER_NEGATIVE_OBJECTS
Definition: layer_ids.h:518
@ LAYER_GERBVIEW_PAGE_LIMITS
Definition: layer_ids.h:523
@ LAYER_GERBVIEW_GRID
Definition: layer_ids.h:519
#define GERBER_DCODE_LAYER(x)
Definition: layer_ids.h:530
@ LAYER_DRAWINGSHEET
Sheet frame and title block.
Definition: layer_ids.h:277
#define GERBER_DRAWLAYERS_COUNT
Number of draw layers in Gerbview.
Definition: layer_ids.h:507
#define GERBER_DRAW_LAYER(x)
Definition: layer_ids.h:528
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:58
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:59
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition: definitions.h:38
@ TARGET_CACHED
Main rendering target (cached)
Definition: definitions.h:37
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:174
Declaration of the NL_GERBVIEW_PLUGIN class.
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:902
see class PGM_BASE
#define DEFAULT_THEME
std::vector< FAB_LAYER_COLOR > dummy
const double IU_PER_MILS
Definition: base_units.h:77
VECTOR2< double > VECTOR2D
Definition: vector2d.h:694
Definition of file extensions used in Kicad.