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
62
63GERBVIEW_FRAME::GERBVIEW_FRAME( KIWAY* aKiway, wxWindow* aParent )
64 : EDA_DRAW_FRAME( aKiway, aParent, FRAME_GERBER, wxT( "GerbView" ), wxDefaultPosition,
67 m_TextInfo( nullptr ),
69 ID_GERBVIEW_ZIP_FILE_LIST_CLEAR, _( "Clear Recent Zip Files" ) ),
71 ID_GERBVIEW_DRILL_FILE_LIST_CLEAR, _( "Clear Recent Drill Files" ) ),
73 ID_GERBVIEW_JOB_FILE_LIST_CLEAR, _( "Clear Recent Job Files" ) ),
74 m_activeLayer( 0 )
75{
77 m_gerberLayout = nullptr;
79 m_showBorderAndTitleBlock = false; // true for reference drawings.
80 m_SelLayerBox = nullptr;
81 m_DCodeSelector = nullptr;
82 m_SelComponentBox = nullptr;
83 m_SelNetnameBox = nullptr;
84 m_SelAperAttributesBox = nullptr;
85 m_cmpText = nullptr;
86 m_netText = nullptr;
87 m_apertText = nullptr;
88 m_dcodeText = nullptr;
89 m_aboutTitle = _HKI( "KiCad Gerber Viewer" );
90
91 SHAPE_POLY_SET dummy; // A ugly trick to force the linker to include
92 // some methods in code and avoid link errors
93
94 int fileHistorySize = Pgm().GetCommonSettings()->m_System.file_history_size;
95 m_drillFileHistory.SetMaxFiles( fileHistorySize );
96 m_zipFileHistory.SetMaxFiles( fileHistorySize );
97 m_jobFileHistory.SetMaxFiles( fileHistorySize );
98
99 auto* galCanvas = new GERBVIEW_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_frameSize,
102
103 SetCanvas( galCanvas );
104
105 // GerbView requires draw priority for rendering negative objects
106 galCanvas->GetView()->UseDrawPriority( true );
107
108 // Give an icon
109 wxIcon icon;
110 wxIconBundle icon_bundle;
111
112 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 48 ) );
113 icon_bundle.AddIcon( icon );
114 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 128 ) );
115 icon_bundle.AddIcon( icon );
116 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview, 256 ) );
117 icon_bundle.AddIcon( icon );
118 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_32 ) );
119 icon_bundle.AddIcon( icon );
120 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_16 ) );
121 icon_bundle.AddIcon( icon );
122
123 SetIcons( icon_bundle );
124
125 // Be sure a page info is set. this default value will be overwritten later.
126 PAGE_INFO pageInfo( wxT( "GERBER" ) );
127 SetLayout( new GBR_LAYOUT() );
128 SetPageSettings( pageInfo );
129
130 SetVisibleLayers( LSET::AllLayersMask() ); // All draw layers visible.
131
133
134 // Create the PCB_LAYER_WIDGET *after* SetLayout():
136
137 // Update the minimum string length in the layer panel with the length of the last default layer
138 wxString lyrName = GetImagesList()->GetDisplayName( GetImagesList()->ImagesMaxCount(),
139 false, true );
141
142 // LoadSettings() *after* creating m_LayersManager, because LoadSettings()
143 // initialize parameters in m_LayersManager
144 LoadSettings( config() );
145
146 setupTools();
152
153 m_auimgr.SetManagedWindow( this );
154
155 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" ).Top().Layer( 6 ) );
156 m_auimgr.AddPane( m_auxiliaryToolBar, EDA_PANE().HToolbar().Name( "AuxToolbar" ).Top()
157 .Layer(4) );
158 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" ).Bottom()
159 .Layer( 6 ) );
160 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" ).Left()
161 .Layer( 3 ) );
162 m_auimgr.AddPane( m_LayersManager, EDA_PANE().Palette().Name( "LayersManager" ).Right()
163 .Layer( 3 ).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 GetCanvas()->GetView()->Clear();
232
233 if( m_toolManager )
235
236 // Be sure any OpenGL event cannot be fired after frame deletion:
237 GetCanvas()->SetEvtHandlerEnabled( false );
238
239 Destroy();
240}
241
242
243bool GERBVIEW_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
244{
245 // Ensure the frame is shown when opening the file(s), to avoid issues (crash) on GAL
246 // when trying to change the view if it is not fully initialized.
247 // It happens when starting GerbView with a gerber job file to load
248 if( !IsShownOnScreen() )
249 Show();
250
251 // The current project path is also a valid command parameter. Check if a single path
252 // rather than a file name was passed to GerbView and use it as the initial MRU path.
253 if( aFileSet.size() > 0 )
254 {
255 wxString path = aFileSet[0];
256
257 // For some reason wxApp appears to leave the trailing double quote on quoted
258 // parameters which are required for paths with spaces. Maybe this should be
259 // pushed back into PGM_SINGLE_TOP::OnPgmInit() but that may cause other issues.
260 // We can't buy a break!
261 if( path.Last() == wxChar( '\"' ) )
262 path.RemoveLast();
263
264 if( !wxFileExists( path ) && wxDirExists( path ) )
265 {
266 m_mruPath = path;
267 return true;
268 }
269
270 const unsigned limit = std::min( unsigned( aFileSet.size() ),
271 unsigned( GERBER_DRAWLAYERS_COUNT ) );
272
273 for( unsigned i = 0; i < limit; ++i )
274 {
275 wxString ext = wxFileName( aFileSet[i] ).GetExt().Lower();
276
278 LoadZipArchiveFile( aFileSet[i] );
279 else if( ext == FILEEXT::GerberJobFileExtension )
280 LoadGerberJobFile( aFileSet[i] );
281 else
282 {
283 GERBER_ORDER_ENUM fnameLayer;
284 wxString fnameExtensionMatched;
285
287 fnameExtensionMatched );
288
289 switch( fnameLayer )
290 {
291 case GERBER_ORDER_ENUM::GERBER_DRILL:
292 LoadExcellonFiles( aFileSet[i] );
293 break;
294 case GERBER_ORDER_ENUM::GERBER_LAYER_UNKNOWN:
295 LoadAutodetectedFiles( aFileSet[i] );
296 break;
297 default:
298 LoadGerberFiles( aFileSet[i] );
299 }
300 }
301 }
302 }
303
304 Zoom_Automatique( true ); // Zoom fit in frame
305
306 return true;
307}
308
309
311{
312 return dynamic_cast<GERBVIEW_SETTINGS*>( config() );
313}
314
315
317{
319
320 if( aCfg->m_Window.grid.grids.empty() )
321 {
322 aCfg->m_Window.grid.grids = { GRID{ wxEmptyString, wxS( "100 mil" ), wxS( "100 mil" ) },
323 GRID{ wxEmptyString, wxS( "50 mil" ), wxS( "50 mil" ) },
324 GRID{ wxEmptyString, wxS( "25 mil" ), wxS( "25 mil" ) },
325 GRID{ wxEmptyString, wxS( "20 mil" ), wxS( "20 mil" ) },
326 GRID{ wxEmptyString, wxS( "10 mil" ), wxS( "10 mil" ) },
327 GRID{ wxEmptyString, wxS( "5 mil" ), wxS( "5 mil" ) },
328 GRID{ wxEmptyString, wxS( "2.5 mil" ), wxS( "2.5 mil" ) },
329 GRID{ wxEmptyString, wxS( "2 mil" ), wxS( "2 mil" ) },
330 GRID{ wxEmptyString, wxS( "1 mil" ), wxS( "1 mil" ) },
331 GRID{ wxEmptyString, wxS( "0.5 mil" ), wxS( "0.5 mil" ) },
332 GRID{ wxEmptyString, wxS( "0.2 mil" ), wxS( "0.2 mil" ) },
333 GRID{ wxEmptyString, wxS( "0.1 mil" ), wxS( "0.1 mil" ) },
334 GRID{ wxEmptyString, wxS( "5.0 mm" ), wxS( "5.0 mm" ) },
335 GRID{ wxEmptyString, wxS( "1.5 mm" ), wxS( "2.5 mm" ) },
336 GRID{ wxEmptyString, wxS( "1.0 mm" ), wxS( "1.0 mm" ) },
337 GRID{ wxEmptyString, wxS( "0.5 mm" ), wxS( "0.5 mm" ) },
338 GRID{ wxEmptyString, wxS( "0.25 mm" ), wxS( "0.25 mm" ) },
339 GRID{ wxEmptyString, wxS( "0.2 mm" ), wxS( "0.2 mm" ) },
340 GRID{ wxEmptyString, wxS( "0.1 mm" ), wxS( "0.1 mm" ) },
341 GRID{ wxEmptyString, wxS( "0.05 mm" ), wxS( "0.0 mm" ) },
342 GRID{ wxEmptyString, wxS( "0.025 mm" ), wxS( "0.0 mm" ) },
343 GRID{ wxEmptyString, wxS( "0.01 mm" ), wxS( "0.0 mm" ) } };
344 }
345
346 if( aCfg->m_Window.zoom_factors.empty() )
347 {
349 }
350
351 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
352 wxCHECK( cfg, /*void*/ );
353
358
359 PAGE_INFO pageInfo( wxT( "GERBER" ) );
360 pageInfo.SetType( cfg->m_Appearance.page_type );
361 SetPageSettings( pageInfo );
362
365
369}
370
371
373{
375
376 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
377 wxCHECK( cfg, /*void*/ );
378
380
384
386 Pgm().GetSettingsManager().SaveColorSettings( cs, "gerbview" );
387}
388
389
391{
394 wxString currentTheme = cfg->m_ColorTheme;
395 return mgr.GetColorSettings( currentTheme );
396}
397
398
400{
401 wxWindowUpdateLocker no_update( m_LayersManager );
402
406
407 wxAuiPaneInfo& lyrs = m_auimgr.GetPane( m_LayersManager );
408 wxSize bestz = m_LayersManager->GetBestSize();
409 bestz.x += 5; // gives a little margin
410
411 lyrs.MinSize( bestz );
412 lyrs.BestSize( bestz );
413 lyrs.FloatingSize( bestz );
414
415 if( lyrs.IsDocked() )
416 m_auimgr.Update();
417 else
418 m_LayersManager->SetSize( bestz );
419
421}
422
423
424void GERBVIEW_FRAME::SetElementVisibility( int aLayerID, bool aNewState )
425{
426 KIGFX::VIEW* view = GetCanvas()->GetView();
427
428 switch( aLayerID )
429 {
430 case LAYER_DCODES:
431 gvconfig()->m_Appearance.show_dcodes = aNewState;
432
433 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
434 {
435 int layer = GERBER_DRAW_LAYER( i );
436 int dcode_layer = GERBER_DCODE_LAYER( layer );
437 view->SetLayerVisible( dcode_layer, aNewState && view->IsLayerVisible( layer ) );
438 }
439
440 break;
441
443 {
445
447 []( KIGFX::VIEW_ITEM* aItem )
448 {
449 GERBER_DRAW_ITEM* item = dynamic_cast<GERBER_DRAW_ITEM*>( aItem );
450
451 // GetLayerPolarity() returns true for negative items
452 return ( item && item->GetLayerPolarity() );
453 } );
454
455 break;
456 }
457
460
462
463 // NOTE: LAYER_DRAWINGSHEET always used for visibility, but the layer manager passes
464 // LAYER_GERBVIEW_DRAWINGSHEET because of independent color control
466 break;
467
469 SetGridVisibility( aNewState );
470 break;
471
475 break;
476
477 default:
478 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::SetElementVisibility(): bad arg %d" ),
479 aLayerID ) );
480 }
481
483 m_LayersManager->SetRenderState( aLayerID, aNewState );
484}
485
486
488{
489 auto painter = static_cast<KIGFX::GERBVIEW_PAINTER*>( GetCanvas()->GetView()->GetPainter() );
490 KIGFX::GERBVIEW_RENDER_SETTINGS* settings = painter->GetSettings();
492 settings->LoadColors( GetColorSettings() );
493
495}
496
497
499{
500 for( int i = 0; i < (int) ImagesMaxCount(); ++i )
501 {
502 const GERBER_FILE_IMAGE* gerber = GetGbrImage( i );
503
504 if( gerber == nullptr ) // this graphic layer is available: use it
505 return i;
506 }
507
508 return NO_AVAILABLE_LAYERS;
509}
510
511
513{
515}
516
517
518void GERBVIEW_FRAME::syncLayerBox( bool aRebuildLayerBox )
519{
520 if( aRebuildLayerBox )
522
523 m_SelLayerBox->SetSelection( GetActiveLayer() );
524
525 int dcodeSelected = -1;
527
528 if( gerber )
529 dcodeSelected = gerber->m_Selected_Tool;
530
531 if( m_DCodeSelector )
532 {
534 m_DCodeSelector->SetDCodeSelection( dcodeSelected );
535 m_DCodeSelector->Enable( gerber != nullptr );
536 }
537}
538
539
541{
542 RemapLayers( GetImagesList()->SortImagesByFileExtension() );
543}
544
545
547{
548 RemapLayers( GetImagesList()->SortImagesByZOrder() );
549}
550
551
552void GERBVIEW_FRAME::RemapLayers( const std::unordered_map<int, int>& remapping )
553{
554 // Save the visibility of each existing gerber layer, in order to be able
555 // to restore this visibility after layer reorder.
556 // Note: the visibility of other objects (D_CODE, negative objects ... )
557 // must be not modified
558 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
559 {
560 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
561
562 if( gerber )
563 {
564 if( IsLayerVisible( currlayer ) )
565 gerber->SetFlags( CANDIDATE );
566 else
567 gerber->ClearFlags( CANDIDATE );
568 }
569
570 }
571
572 std::unordered_map<int, int> view_remapping;
573
574 for( const std::pair<const int, int>& entry : remapping )
575 {
576 view_remapping[ GERBER_DRAW_LAYER( entry.first ) ] = GERBER_DRAW_LAYER( entry.second );
577 view_remapping[ GERBER_DCODE_LAYER( entry.first ) ] = GERBER_DCODE_LAYER( entry.second );
578 }
579
580 GetCanvas()->GetView()->ReorderLayerData( view_remapping );
581
582 // Restore visibility of gerber layers
583 LSET newVisibility = GetVisibleLayers();
584
585 for( int currlayer = GERBER_DRAWLAYERS_COUNT-1; currlayer >= 0; --currlayer )
586 {
587 GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( currlayer );
588
589 if( gerber )
590 {
591 if( gerber->HasFlag( CANDIDATE ) )
592 newVisibility.set( currlayer );
593 else
594 newVisibility.set( currlayer, false );
595
596 gerber->ClearFlags( CANDIDATE );
597 }
598 }
599
600 SetVisibleLayers( newVisibility );
601
603 syncLayerBox( true );
604
605 // Reordering draw layers need updating the view items
609
610 GetCanvas()->Refresh();
611}
612
613
615{
616 // Adjust draw params: draw offset and draw rotation for a gerber file image
618
619 if( !gerber )
620 return;
621
622 DIALOG_DRAW_LAYERS_SETTINGS dlg( this );
623
624 if( dlg.ShowModal() != wxID_OK )
625 return;
626
627 KIGFX::VIEW* view = GetCanvas()->GetView();
628
629 view->RecacheAllItems();
630 view->MarkDirty();
631 view->UpdateAllItems( KIGFX::ALL );
632
633 GetCanvas()->Refresh();
634}
635
636
638{
642 KIGFX::VIEW* view = GetCanvas()->GetView();
643
644 int lastVisibleLayer = -1;
645
646 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
647 {
648 view->SetLayerDiff( GERBER_DRAW_LAYER( i ), gvconfig()->m_Display.m_XORMode );
649
650 // Caching doesn't work with layered rendering of XOR'd layers
651 if( gvconfig()->m_Display.m_XORMode )
653 else
654 view->SetLayerTarget( GERBER_DRAW_LAYER( i ), target );
655
656 // We want the last visible layer, but deprioritize the active layer unless it's the
657 // only layer
658 if( ( lastVisibleLayer == -1 )
659 || ( view->IsLayerVisible( GERBER_DRAW_LAYER( i ) ) && i != GetActiveLayer() ) )
660 {
661 lastVisibleLayer = i;
662 }
663 }
664
665 //We don't want to diff the last visible layer onto the background, etc.
666 if( lastVisibleLayer != -1 )
667 {
668 view->SetLayerTarget( GERBER_DRAW_LAYER( lastVisibleLayer ), target );
669 view->SetLayerDiff( GERBER_DRAW_LAYER( lastVisibleLayer ), false );
670 }
671
672 view->RecacheAllItems();
673 view->MarkDirty();
674 view->UpdateAllItems( KIGFX::ALL );
675}
676
677
679{
681
682 // Display the gerber filename
683 if( gerber == nullptr )
684 {
685 SetTitle( _("Gerber Viewer") );
686
687 SetStatusText( wxEmptyString, 0 );
688
689 wxString info;
690 info.Printf( _( "Drawing layer not in use" ) );
691 m_TextInfo->SetValue( info );
692
693 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
694 m_auimgr.Update();
695
697 return;
698 }
699 else
700 {
701 wxString title;
702 wxFileName filename( gerber->m_FileName );
703
704 title = filename.GetFullName();
705
706 if( gerber->m_IsX2_file )
707 title += wxS( " " ) + _( "(with X2 attributes)" );
708
709 title += wxT( " \u2014 " ) + _( "Gerber Viewer" );
710 SetTitle( title );
711
712 gerber->DisplayImageInfo( this );
713
714 // Display Image Name and Layer Name (from the current gerber data):
715 wxString status;
716 status.Printf( _( "Image name: \"%s\" Layer name: \"%s\"" ),
717 gerber->m_ImageName,
718 gerber->GetLayerParams().m_LayerName );
719 SetStatusText( status, 0 );
720
721 // Display data format like fmt in X3.4Y3.4 no LZ or fmt mm X2.3 Y3.5 no TZ in main toolbar
722 wxString info;
723 info.Printf( wxT( "fmt: %s X%d.%d Y%d.%d no %cZ" ),
724 gerber->m_GerbMetric ? wxT( "mm" ) : wxT( "in" ),
725 gerber->m_FmtLen.x - gerber->m_FmtScale.x,
726 gerber->m_FmtScale.x,
727 gerber->m_FmtLen.y - gerber->m_FmtScale.y,
728 gerber->m_FmtScale.y,
729 gerber->m_NoTrailingZeros ? 'T' : 'L' );
730
731 if( gerber->m_IsX2_file )
732 info << wxT(" ") << _( "X2 attr" );
733
734 m_TextInfo->SetValue( info );
735
736 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
737 m_auimgr.Update();
738 }
739}
740
741
742bool GERBVIEW_FRAME::IsElementVisible( int aLayerID ) const
743{
744 switch( aLayerID )
745 {
748 case LAYER_GERBVIEW_GRID: return IsGridVisible();
751 case LAYER_GERBVIEW_BACKGROUND: return true;
752
753 default:
754 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::IsElementVisible(): bad arg %d" ),
755 aLayerID ) );
756 }
757
758 return true;
759}
760
761
763{
764 LSET visible = LSET::AllLayersMask();
765
766 if( GetCanvas() )
767 {
768 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
769 visible[i] = GetCanvas()->GetView()->IsLayerVisible( GERBER_DRAW_LAYER( i ) );
770 }
771
772 return visible;
773}
774
775
777{
778 if( GetCanvas() )
779 {
780 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
781 {
782 bool v = aLayerMask[i];
783 int layer = GERBER_DRAW_LAYER( i );
784 GetCanvas()->GetView()->SetLayerVisible( layer, v );
786 gvconfig()->m_Appearance.show_dcodes && v );
787 }
788 }
789}
790
791
792bool GERBVIEW_FRAME::IsLayerVisible( int aLayer ) const
793{
794 return m_LayersManager->IsLayerVisible( aLayer );
795}
796
797
799{
800 COLOR4D color = COLOR4D::UNSPECIFIED;
801 COLOR_SETTINGS* settings = GetColorSettings();
802
803 switch( aLayerID )
804 {
806 case LAYER_DCODES:
810 color = settings->GetColor( aLayerID );
811 break;
812
815 break;
816
817 default:
818 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::GetVisibleElementColor(): bad arg %d" ),
819 aLayerID ) );
820 }
821
822 return color;
823}
824
825
827{
830}
831
832
833void GERBVIEW_FRAME::SetVisibleElementColor( int aLayerID, const COLOR4D& aColor )
834{
835 COLOR_SETTINGS* settings = GetColorSettings();
836
837 settings->SetColor( aLayerID, aColor );
838
839 switch( aLayerID )
840 {
844 break;
845
847 SetGridColor( aColor );
848 break;
849
851 SetDrawBgColor( aColor );
852 break;
853
854 default:
855 break;
856 }
857}
858
859
861{
862 return GetColorSettings()->GetColor( aLayer );
863}
864
865
866void GERBVIEW_FRAME::SetLayerColor( int aLayer, const COLOR4D& aColor )
867{
868 GetColorSettings()->SetColor( aLayer, aColor );
870}
871
872
873void GERBVIEW_FRAME::SetActiveLayer( int aLayer, bool doLayerWidgetUpdate )
874{
875 m_activeLayer = aLayer;
876
877 if( gvconfig()->m_Display.m_XORMode )
879
880 if( doLayerWidgetUpdate )
881 {
882 m_LayersManager->SelectLayer( aLayer );
884 }
885
887
889 GetCanvas()->SetFocus(); // otherwise hotkeys are stuck somewhere
890
892 GetCanvas()->Refresh();
893}
894
895
896void GERBVIEW_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
897{
898 m_paper = aPageSettings;
899
900 if( GetScreen() )
902
903 GERBVIEW_DRAW_PANEL_GAL* drawPanel = static_cast<GERBVIEW_DRAW_PANEL_GAL*>( GetCanvas() );
904
905 // Prepare drawing-sheet template
907 &Prj(), &GetTitleBlock(), nullptr );
908
909 if( GetScreen() )
910 {
911 drawingSheet->SetPageNumber( "1" );
912 drawingSheet->SetSheetCount( 1 );
913 }
914
917
918 // Draw panel takes ownership of the drawing-sheet
919 drawPanel->SetDrawingSheet( drawingSheet );
920}
921
922
924{
925 return m_paper;
926}
927
928
930{
931 // this function is only needed because EDA_DRAW_FRAME is not compiled
932 // with either -DPCBNEW or -DEESCHEMA, so the virtual is used to route
933 // into an application specific source file.
935}
936
937
939{
940 wxASSERT( m_gerberLayout );
942}
943
944
946{
947 wxASSERT( m_gerberLayout );
948 m_gerberLayout->SetTitleBlock( aTitleBlock );
949}
950
951
953{
955}
956
957
959{
961 GetCanvas()->GetGAL()->SetGridColor( aColor );
962 m_gridColor = aColor;
963}
964
965
967{
968 VECTOR2D gridSize = GetCanvas()->GetGAL()->GetGridSize();
969 wxString line;
970
971 line.Printf( wxT( "grid X %s Y %s" ),
972 MessageTextFromValue( gridSize.x, false ),
973 MessageTextFromValue( gridSize.y, false ) );
974
975 SetStatusText( line, 4 );
976 SetStatusText( line, 4 );
977}
978
979
981{
983
984 if( !GetScreen() )
985 return;
986
987 wxString line;
989
990 if( GetShowPolarCoords() ) // display relative polar coordinates
991 {
992 VECTOR2D v = cursorPos - GetScreen()->m_LocalOrigin;
993 EDA_ANGLE theta( VECTOR2D( v.x, -v.y ) );
994 double ro = hypot( v.x, v.y );
995
996 line.Printf( wxT( "r %s theta %s" ),
997 MessageTextFromValue( ro, false ),
998 MessageTextFromValue( theta, false ) );
999
1000 SetStatusText( line, 3 );
1001 }
1002
1003 // Display absolute coordinates:
1004 line.Printf( wxT( "X %s Y %s" ),
1005 MessageTextFromValue( cursorPos.x, false ),
1006 MessageTextFromValue( cursorPos.y, false ) );
1007 SetStatusText( line, 2 );
1008
1009 if( !GetShowPolarCoords() )
1010 {
1011 // Display relative cartesian coordinates:
1012 double dXpos = cursorPos.x - GetScreen()->m_LocalOrigin.x;
1013 double dYpos = cursorPos.y - GetScreen()->m_LocalOrigin.y;
1014
1015 line.Printf( wxT( "dx %s dy %s dist %s" ),
1016 MessageTextFromValue( dXpos, false ),
1017 MessageTextFromValue( dYpos,false ),
1018 MessageTextFromValue( hypot( dXpos, dYpos ), false ) );
1019 SetStatusText( line, 3 );
1020 }
1021
1023}
1024
1025
1027{
1028 return m_gerberLayout->GetImagesList()->GetGbrImage( aIdx );
1029}
1030
1031
1033{
1035}
1036
1037
1039{
1040 // Called on units change (see EDA_DRAW_FRAME)
1044}
1045
1046
1048{
1050
1051 EDA_DRAW_PANEL_GAL* galCanvas = GetCanvas();
1052
1053 if( m_toolManager )
1054 {
1056 GetCanvas()->GetViewControls(), config(), this );
1058 }
1059
1061
1063
1064 galCanvas->GetView()->RecacheAllItems();
1066 galCanvas->StartDrawing();
1067
1070
1073}
1074
1075
1077{
1078 // Create the manager and dispatcher & route draw panel events to the dispatcher
1081 GetCanvas()->GetViewControls(), config(), this );
1084
1085 // Register tools
1093
1094 // Run the selection tool, it is supposed to be always active
1095 m_toolManager->InvokeTool( "gerbview.InteractiveSelection" );
1096}
1097
1098
1100{
1102
1104 EDITOR_CONDITIONS cond( this );
1105
1106 wxASSERT( mgr );
1107
1108#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1109#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1110
1114
1118
1119 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
1120 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
1121 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
1122
1123 auto flashedDisplayOutlinesCond =
1124 [this] ( const SELECTION& )
1125 {
1127 };
1128
1129 auto linesFillCond =
1130 [this] ( const SELECTION& )
1131 {
1133 };
1134
1135 auto polygonsFilledCond =
1136 [this] ( const SELECTION& )
1137 {
1139 };
1140
1141 auto negativeObjectsCond =
1142 [this] ( const SELECTION& )
1143 {
1145 };
1146
1147 auto dcodeCond =
1148 [this] ( const SELECTION& )
1149 {
1151 };
1152
1153 auto forceOpacityModeCond =
1154 [this] ( const SELECTION& )
1155 {
1157 };
1158
1159 auto xorModeCond =
1160 [this] ( const SELECTION& )
1161 {
1162 return gvconfig()->m_Display.m_XORMode;
1163 };
1164
1165 auto highContrastModeCond =
1166 [this] ( const SELECTION& )
1167 {
1169 };
1170
1171 auto flipGerberCond =
1172 [this] ( const SELECTION& )
1173 {
1175 };
1176
1177 auto layersManagerShownCondition =
1178 [this] ( const SELECTION& aSel )
1179 {
1181 };
1182
1183 mgr->SetConditions( GERBVIEW_ACTIONS::flashedDisplayOutlines, CHECK( flashedDisplayOutlinesCond ) );
1185 mgr->SetConditions( GERBVIEW_ACTIONS::polygonsDisplayOutlines, CHECK( polygonsFilledCond ) );
1186 mgr->SetConditions( GERBVIEW_ACTIONS::negativeObjectDisplay, CHECK( negativeObjectsCond ) );
1188 mgr->SetConditions( GERBVIEW_ACTIONS::toggleForceOpacityMode, CHECK( forceOpacityModeCond ) );
1189 mgr->SetConditions( GERBVIEW_ACTIONS::toggleXORMode, CHECK( xorModeCond ) );
1190 mgr->SetConditions( GERBVIEW_ACTIONS::flipGerberView, CHECK( flipGerberCond ) );
1191 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastModeCond ) );
1192 mgr->SetConditions( GERBVIEW_ACTIONS::toggleLayerManager, CHECK( layersManagerShownCondition ) );
1193
1194#undef CHECK
1195#undef ENABLE
1196}
1197
1198
1199void GERBVIEW_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1200{
1201 EDA_DRAW_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1202
1203 // Update gal display options like cursor shape, grid options:
1206
1207 SetPageSettings( PAGE_INFO( gvconfig()->m_Appearance.page_type ) );
1208
1210
1211 SetElementVisibility( LAYER_DCODES, gvconfig()->m_Appearance.show_dcodes );
1212
1216
1218 ReFillLayerWidget(); // Update the layers list
1219 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
1220
1221 Layout();
1222 SendSizeEvent();
1223}
1224
1225
1227{
1228 return m_toolManager->GetTool<GERBVIEW_SELECTION_TOOL>()->GetSelection();
1229}
1230
1231
1233{
1235
1236 // show/hide auxiliary Vertical layers and visibility manager toolbar
1237 m_auimgr.GetPane( "LayersManager" ).Show( m_show_layer_manager_tools );
1238 m_auimgr.Update();
1239}
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:177
static TOOL_ACTION millimetersUnits
Definition: actions.h:185
static TOOL_ACTION togglePolarCoords
Definition: actions.h:188
static TOOL_ACTION milsUnits
Definition: actions.h:184
static TOOL_ACTION inchesUnits
Definition: actions.h:183
static TOOL_ACTION highContrastMode
Definition: actions.h:135
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:134
static TOOL_ACTION measureTool
Definition: actions.h:193
static TOOL_ACTION selectionTool
Definition: actions.h:192
static TOOL_ACTION zoomFitScreen
Definition: actions.h:126
static TOOL_ACTION zoomTool
Definition: actions.h:129
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=std::numeric_limits< size_t >::max(), bool value=true)
Definition: base_set.h:61
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)
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 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 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
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 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.
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:279
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:35
static LSET AllLayersMask()
Definition: lset.cpp:767
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:678
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:435
@ LAYER_GERBVIEW_BACKGROUND
Definition: layer_ids.h:434
@ LAYER_DCODES
Definition: layer_ids.h:430
@ LAYER_NEGATIVE_OBJECTS
Definition: layer_ids.h:431
@ LAYER_GERBVIEW_PAGE_LIMITS
Definition: layer_ids.h:436
@ LAYER_GERBVIEW_GRID
Definition: layer_ids.h:432
#define GERBER_DCODE_LAYER(x)
Definition: layer_ids.h:443
@ LAYER_DRAWINGSHEET
drawingsheet frame and titleblock
Definition: layer_ids.h:221
#define GERBER_DRAWLAYERS_COUNT
Definition: layer_ids.h:420
#define GERBER_DRAW_LAYER(x)
Definition: layer_ids.h:441
@ 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
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
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:672
Definition of file extensions used in Kicad.
#define ZOOM_LIST_GERBVIEW
Definition: zoom_defines.h:29