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-2023 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>
36#include <tool/tool_manager.h>
37#include <tool/action_toolbar.h>
39#include <tool/common_control.h>
40#include <tool/common_tools.h>
42#include <tool/zoom_tool.h>
48#include <trigo.h>
49#include <view/view.h>
50#include <base_screen.h>
51#include <gerbview_painter.h>
52#include <wx/wupdlock.h>
53
58#include <zoom_defines.h>
59
60
61GERBVIEW_FRAME::GERBVIEW_FRAME( KIWAY* aKiway, wxWindow* aParent )
62 : EDA_DRAW_FRAME( aKiway, aParent, FRAME_GERBER, wxT( "GerbView" ), wxDefaultPosition,
65 m_TextInfo( nullptr ),
67 ID_GERBVIEW_ZIP_FILE_LIST_CLEAR, _( "Clear Recent Zip Files" ) ),
69 ID_GERBVIEW_DRILL_FILE_LIST_CLEAR, _( "Clear Recent Drill Files" ) ),
71 ID_GERBVIEW_JOB_FILE_LIST_CLEAR, _( "Clear Recent Job Files" ) ),
72 m_activeLayer( 0 )
73{
75 m_gerberLayout = nullptr;
77 m_showBorderAndTitleBlock = false; // true for reference drawings.
78 m_SelLayerBox = nullptr;
79 m_DCodeSelector = nullptr;
80 m_SelComponentBox = nullptr;
81 m_SelNetnameBox = nullptr;
82 m_SelAperAttributesBox = nullptr;
83 m_cmpText = nullptr;
84 m_netText = nullptr;
85 m_apertText = nullptr;
86 m_dcodeText = nullptr;
87 m_displayMode = 0;
88 m_aboutTitle = _HKI( "KiCad Gerber Viewer" );
89
90 SHAPE_POLY_SET dummy; // A ugly trick to force the linker to include
91 // some methods in code and avoid link errors
92
93 int fileHistorySize = Pgm().GetCommonSettings()->m_System.file_history_size;
94 m_drillFileHistory.SetMaxFiles( fileHistorySize );
95 m_zipFileHistory.SetMaxFiles( fileHistorySize );
96 m_jobFileHistory.SetMaxFiles( fileHistorySize );
97
98 auto* galCanvas = new GERBVIEW_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_frameSize,
101
102 SetCanvas( galCanvas );
103
104 // GerbView requires draw priority for rendering negative objects
105 galCanvas->GetView()->UseDrawPriority( true );
106
107 // Give an icon
108 wxIcon icon;
109 wxIconBundle icon_bundle;
110
111 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview ) );
112 icon_bundle.AddIcon( icon );
113 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_32 ) );
114 icon_bundle.AddIcon( icon );
115 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_gerbview_16 ) );
116 icon_bundle.AddIcon( icon );
117
118 SetIcons( icon_bundle );
119
120 // Be sure a page info is set. this default value will be overwritten later.
121 PAGE_INFO pageInfo( wxT( "GERBER" ) );
122 SetLayout( new GBR_LAYOUT() );
123 SetPageSettings( pageInfo );
124
125 SetVisibleLayers( LSET::AllLayersMask() ); // All draw layers visible.
126
128
129 // Create the PCB_LAYER_WIDGET *after* SetLayout():
131
132 // Update the minimum string length in the layer panel with the length of the last default layer
133 wxString lyrName = GetImagesList()->GetDisplayName( GetImagesList()->ImagesMaxCount(),
134 false, true );
136
137 // LoadSettings() *after* creating m_LayersManager, because LoadSettings()
138 // initialize parameters in m_LayersManager
139 LoadSettings( config() );
140
141 setupTools();
147
148 m_auimgr.SetManagedWindow( this );
149
150 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" ).Top().Layer( 6 ) );
151 m_auimgr.AddPane( m_auxiliaryToolBar, EDA_PANE().HToolbar().Name( "AuxToolbar" ).Top()
152 .Layer(4) );
153 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" ).Bottom()
154 .Layer( 6 ) );
155 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" ).Left()
156 .Layer( 3 ) );
157 m_auimgr.AddPane( m_LayersManager, EDA_PANE().Palette().Name( "LayersManager" ).Right()
158 .Layer( 3 ).Caption( _( "Layers Manager" ) ).PaneBorder( false )
159 .MinSize( 80, -1 ).BestSize( m_LayersManager->GetBestSize() ) );
160
161 m_auimgr.AddPane( GetCanvas(), EDA_PANE().Canvas().Name( "DrawFrame" ).Center() );
162
163 ReFillLayerWidget(); // this is near end because contents establish size
164 m_auimgr.Update();
165
166 SetActiveLayer( 0, true );
168
170
172
173 setupUnits( config() );
174
175 // Enable the axes to match legacy draw style
176 auto& galOptions = GetGalDisplayOptions();
177 galOptions.m_axesEnabled = true;
178 galOptions.NotifyChanged();
179
181 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
182
183 // Drag and drop
184 // Note that all gerber files are aliased as GerberFileExtension
188 DragAcceptFiles( true );
189
191
192 // Ensure the window is on top
193 Raise();
194
195 // Register a call to update the toolbar sizes. It can't be done immediately because
196 // it seems to require some sizes calculated that aren't yet (at least on GTK).
197 CallAfter( [&]()
198 {
199 // Ensure the controls on the toolbars all are correctly sized
201 } );
202}
203
204
206{
207 // Ensure m_canvasType is up to date, to save it in config
209
210 // Shutdown all running tools
211 if( m_toolManager )
213
214 GetCanvas()->GetView()->Clear();
215
217 delete m_gerberLayout;
218}
219
220
222{
223 // No more vetos
224 m_isClosing = true;
226 GetCanvas()->GetView()->Clear();
227
228 if( m_toolManager )
230
231 // Be sure any OpenGL event cannot be fired after frame deletion:
232 GetCanvas()->SetEvtHandlerEnabled( false );
233
234 Destroy();
235}
236
237
238bool GERBVIEW_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
239{
240 // Ensure the frame is shown when opening the file(s), to avoid issues (crash) on GAL
241 // when trying to change the view if it is not fully initialized.
242 // It happens when starting GerbView with a gerber job file to load
243 if( !IsShown() )
244 Show();
245
246 // The current project path is also a valid command parameter. Check if a single path
247 // rather than a file name was passed to GerbView and use it as the initial MRU path.
248 if( aFileSet.size() > 0 )
249 {
250 wxString path = aFileSet[0];
251
252 // For some reason wxApp appears to leave the trailing double quote on quoted
253 // parameters which are required for paths with spaces. Maybe this should be
254 // pushed back into PGM_SINGLE_TOP::OnPgmInit() but that may cause other issues.
255 // We can't buy a break!
256 if( path.Last() == wxChar( '\"' ) )
257 path.RemoveLast();
258
259 if( !wxFileExists( path ) && wxDirExists( path ) )
260 {
261 m_mruPath = path;
262 return true;
263 }
264
265 const unsigned limit = std::min( unsigned( aFileSet.size() ),
266 unsigned( GERBER_DRAWLAYERS_COUNT ) );
267
268 for( unsigned i = 0; i < limit; ++i )
269 {
270 wxString ext = wxFileName( aFileSet[i] ).GetExt().Lower();
271
272 if( ext == ArchiveFileExtension )
273 LoadZipArchiveFile( aFileSet[i] );
274 else if( ext == GerberJobFileExtension )
275 LoadGerberJobFile( aFileSet[i] );
276 else
277 {
278 GERBER_ORDER_ENUM fnameLayer;
279 wxString fnameExtensionMatched;
280
282 fnameExtensionMatched );
283
284 switch( fnameLayer )
285 {
286 case GERBER_ORDER_ENUM::GERBER_DRILL:
287 LoadExcellonFiles( aFileSet[i] );
288 break;
289 case GERBER_ORDER_ENUM::GERBER_LAYER_UNKNOWN:
290 LoadAutodetectedFiles( aFileSet[i] );
291 break;
292 default:
293 LoadGerberFiles( aFileSet[i] );
294 }
295 }
296 }
297 }
298
299 Zoom_Automatique( true ); // Zoom fit in frame
300
301 return true;
302}
303
304
306{
307 return dynamic_cast<GERBVIEW_SETTINGS*>( config() );
308}
309
310
312{
314
315 if( aCfg->m_Window.grid.grids.empty() )
316 {
317 aCfg->m_Window.grid.grids = { GRID{ wxEmptyString, wxS( "100 mil" ), wxS( "100 mil" ) },
318 GRID{ wxEmptyString, wxS( "50 mil" ), wxS( "50 mil" ) },
319 GRID{ wxEmptyString, wxS( "25 mil" ), wxS( "25 mil" ) },
320 GRID{ wxEmptyString, wxS( "20 mil" ), wxS( "20 mil" ) },
321 GRID{ wxEmptyString, wxS( "10 mil" ), wxS( "10 mil" ) },
322 GRID{ wxEmptyString, wxS( "5 mil" ), wxS( "5 mil" ) },
323 GRID{ wxEmptyString, wxS( "2.5 mil" ), wxS( "2.5 mil" ) },
324 GRID{ wxEmptyString, wxS( "2 mil" ), wxS( "2 mil" ) },
325 GRID{ wxEmptyString, wxS( "1 mil" ), wxS( "1 mil" ) },
326 GRID{ wxEmptyString, wxS( "0.5 mil" ), wxS( "0.5 mil" ) },
327 GRID{ wxEmptyString, wxS( "0.2 mil" ), wxS( "0.2 mil" ) },
328 GRID{ wxEmptyString, wxS( "0.1 mil" ), wxS( "0.1 mil" ) },
329 GRID{ wxEmptyString, wxS( "5.0 mm" ), wxS( "5.0 mm" ) },
330 GRID{ wxEmptyString, wxS( "1.5 mm" ), wxS( "2.5 mm" ) },
331 GRID{ wxEmptyString, wxS( "1.0 mm" ), wxS( "1.0 mm" ) },
332 GRID{ wxEmptyString, wxS( "0.5 mm" ), wxS( "0.5 mm" ) },
333 GRID{ wxEmptyString, wxS( "0.25 mm" ), wxS( "0.25 mm" ) },
334 GRID{ wxEmptyString, wxS( "0.2 mm" ), wxS( "0.2 mm" ) },
335 GRID{ wxEmptyString, wxS( "0.1 mm" ), wxS( "0.1 mm" ) },
336 GRID{ wxEmptyString, wxS( "0.05 mm" ), wxS( "0.0 mm" ) },
337 GRID{ wxEmptyString, wxS( "0.025 mm" ), wxS( "0.0 mm" ) },
338 GRID{ wxEmptyString, wxS( "0.01 mm" ), wxS( "0.0 mm" ) } };
339 }
340
341 if( aCfg->m_Window.zoom_factors.empty() )
342 {
344 }
345
346 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
347 wxCHECK( cfg, /*void*/ );
348
353
354 PAGE_INFO pageInfo( wxT( "GERBER" ) );
355 pageInfo.SetType( cfg->m_Appearance.page_type );
356 SetPageSettings( pageInfo );
357
360
364}
365
366
368{
370
371 GERBVIEW_SETTINGS* cfg = dynamic_cast<GERBVIEW_SETTINGS*>( aCfg );
372 wxCHECK( cfg, /*void*/ );
373
375
379
380 COLOR_SETTINGS* cs = Pgm().GetSettingsManager().GetColorSettings();
381 Pgm().GetSettingsManager().SaveColorSettings( cs, "gerbview" );
382}
383
384
386{
387 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
389 wxString currentTheme = cfg->m_ColorTheme;
390 return mgr.GetColorSettings( currentTheme );
391}
392
393
395{
396 wxWindowUpdateLocker no_update( m_LayersManager );
397
401
402 wxAuiPaneInfo& lyrs = m_auimgr.GetPane( m_LayersManager );
403 wxSize bestz = m_LayersManager->GetBestSize();
404 bestz.x += 5; // gives a little margin
405
406 lyrs.MinSize( bestz );
407 lyrs.BestSize( bestz );
408 lyrs.FloatingSize( bestz );
409
410 if( lyrs.IsDocked() )
411 m_auimgr.Update();
412 else
413 m_LayersManager->SetSize( bestz );
414
416}
417
418
419void GERBVIEW_FRAME::SetElementVisibility( int aLayerID, bool aNewState )
420{
421 KIGFX::VIEW* view = GetCanvas()->GetView();
422
423 switch( aLayerID )
424 {
425 case LAYER_DCODES:
426 gvconfig()->m_Appearance.show_dcodes = aNewState;
427
428 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
429 {
430 int layer = GERBER_DRAW_LAYER( i );
431 int dcode_layer = GERBER_DCODE_LAYER( layer );
432 view->SetLayerVisible( dcode_layer, aNewState && view->IsLayerVisible( layer ) );
433 }
434
435 break;
436
438 {
440
442 []( KIGFX::VIEW_ITEM* aItem )
443 {
444 GERBER_DRAW_ITEM* item = dynamic_cast<GERBER_DRAW_ITEM*>( aItem );
445
446 // GetLayerPolarity() returns true for negative items
447 return ( item && item->GetLayerPolarity() );
448 } );
449
450 break;
451 }
452
455
457
458 // NOTE: LAYER_DRAWINGSHEET always used for visibility, but the layer manager passes
459 // LAYER_GERBVIEW_DRAWINGSHEET because of independent color control
461 break;
462
464 SetGridVisibility( aNewState );
465 break;
466
470 break;
471
472 default:
473 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::SetElementVisibility(): bad arg %d" ),
474 aLayerID ) );
475 }
476
478 m_LayersManager->SetRenderState( aLayerID, aNewState );
479}
480
481
483{
484 auto painter = static_cast<KIGFX::GERBVIEW_PAINTER*>( GetCanvas()->GetView()->GetPainter() );
485 KIGFX::GERBVIEW_RENDER_SETTINGS* settings = painter->GetSettings();
487 settings->LoadColors( GetColorSettings() );
488
490}
491
492
494{
495 for( int i = 0; i < (int) ImagesMaxCount(); ++i )
496 {
497 const GERBER_FILE_IMAGE* gerber = GetGbrImage( i );
498
499 if( gerber == nullptr ) // this graphic layer is available: use it
500 return i;
501 }
502
503 return NO_AVAILABLE_LAYERS;
504}
505
506
508{
510}
511
512
513void GERBVIEW_FRAME::syncLayerBox( bool aRebuildLayerBox )
514{
515 if( aRebuildLayerBox )
517
518 m_SelLayerBox->SetSelection( GetActiveLayer() );
519
520 int dcodeSelected = -1;
522
523 if( gerber )
524 dcodeSelected = gerber->m_Selected_Tool;
525
526 if( m_DCodeSelector )
527 {
529 m_DCodeSelector->SetDCodeSelection( dcodeSelected );
530 m_DCodeSelector->Enable( gerber != nullptr );
531 }
532}
533
534
536{
537 RemapLayers( GetImagesList()->SortImagesByFileExtension() );
538}
539
540
542{
543 RemapLayers( GetImagesList()->SortImagesByZOrder() );
544}
545
546
547void GERBVIEW_FRAME::RemapLayers( const std::unordered_map<int, int>& remapping )
548{
549 std::unordered_map<int, bool> oldVisibility;
550 LSET newVisibility;
551
552 for( const std::pair<const int, int>& entry : remapping )
553 oldVisibility[ entry.second ] = IsLayerVisible( entry.second );
554
555 for( const std::pair<const int, int>& entry : remapping )
556 newVisibility.set( entry.first, oldVisibility[ entry.second ] );
557
558 std::unordered_map<int, int> view_remapping;
559
560 for( const std::pair<const int, int>& entry : remapping )
561 {
562 view_remapping[ GERBER_DRAW_LAYER( entry.first ) ] = GERBER_DRAW_LAYER( entry.second );
563 view_remapping[ GERBER_DCODE_LAYER( entry.first ) ] = GERBER_DCODE_LAYER( entry.second );
564 }
565
566 GetCanvas()->GetView()->ReorderLayerData( view_remapping );
567
568 SetVisibleLayers( newVisibility );
570 syncLayerBox( true );
571 GetCanvas()->Refresh();
572}
573
574
576{
577 // Adjust draw params: draw offset and draw rotation for a gerber file image
579
580 if( !gerber )
581 return;
582
583 DIALOG_DRAW_LAYERS_SETTINGS dlg( this );
584
585 if( dlg.ShowModal() != wxID_OK )
586 return;
587
588 KIGFX::VIEW* view = GetCanvas()->GetView();
589
590 view->RecacheAllItems();
591 view->MarkDirty();
592 view->UpdateAllItems( KIGFX::ALL );
593
594 GetCanvas()->Refresh();
595}
596
597
599{
603 KIGFX::VIEW* view = GetCanvas()->GetView();
604
605 int lastVisibleLayer = -1;
606
607 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
608 {
609 view->SetLayerDiff( GERBER_DRAW_LAYER( i ), gvconfig()->m_Display.m_XORMode );
610
611 // Caching doesn't work with layered rendering of XOR'd layers
612 if( gvconfig()->m_Display.m_XORMode )
614 else
615 view->SetLayerTarget( GERBER_DRAW_LAYER( i ), target );
616
617 // We want the last visible layer, but deprioritize the active layer unless it's the
618 // only layer
619 if( ( lastVisibleLayer == -1 )
620 || ( view->IsLayerVisible( GERBER_DRAW_LAYER( i ) ) && i != GetActiveLayer() ) )
621 {
622 lastVisibleLayer = i;
623 }
624 }
625
626 //We don't want to diff the last visible layer onto the background, etc.
627 if( lastVisibleLayer != -1 )
628 {
629 view->SetLayerTarget( GERBER_DRAW_LAYER( lastVisibleLayer ), target );
630 view->SetLayerDiff( GERBER_DRAW_LAYER( lastVisibleLayer ), false );
631 }
632
633 view->RecacheAllItems();
634 view->MarkDirty();
635 view->UpdateAllItems( KIGFX::ALL );
636}
637
638
640{
642
643 // Display the gerber filename
644 if( gerber == nullptr )
645 {
646 SetTitle( _("Gerber Viewer") );
647
648 SetStatusText( wxEmptyString, 0 );
649
650 wxString info;
651 info.Printf( _( "Drawing layer not in use" ) );
652 m_TextInfo->SetValue( info );
653
654 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
655 m_auimgr.Update();
656
658 return;
659 }
660 else
661 {
662 wxString title;
663 wxFileName filename( gerber->m_FileName );
664
665 title = filename.GetFullName();
666
667 if( gerber->m_IsX2_file )
668 title += wxS( " " ) + _( "(with X2 attributes)" );
669
670 title += wxT( " \u2014 " ) + _( "Gerber Viewer" );
671 SetTitle( title );
672
673 gerber->DisplayImageInfo( this );
674
675 // Display Image Name and Layer Name (from the current gerber data):
676 wxString status;
677 status.Printf( _( "Image name: \"%s\" Layer name: \"%s\"" ),
678 gerber->m_ImageName,
679 gerber->GetLayerParams().m_LayerName );
680 SetStatusText( status, 0 );
681
682 // Display data format like fmt in X3.4Y3.4 no LZ or fmt mm X2.3 Y3.5 no TZ in main toolbar
683 wxString info;
684 info.Printf( wxT( "fmt: %s X%d.%d Y%d.%d no %cZ" ),
685 gerber->m_GerbMetric ? wxT( "mm" ) : wxT( "in" ),
686 gerber->m_FmtLen.x - gerber->m_FmtScale.x,
687 gerber->m_FmtScale.x,
688 gerber->m_FmtLen.y - gerber->m_FmtScale.y,
689 gerber->m_FmtScale.y,
690 gerber->m_NoTrailingZeros ? 'T' : 'L' );
691
692 if( gerber->m_IsX2_file )
693 info << wxT(" ") << _( "X2 attr" );
694
695 m_TextInfo->SetValue( info );
696
697 if( KIUI::EnsureTextCtrlWidth( m_TextInfo, &info ) ) // Resized
698 m_auimgr.Update();
699 }
700}
701
702
703bool GERBVIEW_FRAME::IsElementVisible( int aLayerID ) const
704{
705 switch( aLayerID )
706 {
709 case LAYER_GERBVIEW_GRID: return IsGridVisible();
712 case LAYER_GERBVIEW_BACKGROUND: return true;
713
714 default:
715 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::IsElementVisible(): bad arg %d" ),
716 aLayerID ) );
717 }
718
719 return true;
720}
721
722
724{
725 LSET visible = LSET::AllLayersMask();
726
727 if( GetCanvas() )
728 {
729 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
730 visible[i] = GetCanvas()->GetView()->IsLayerVisible( GERBER_DRAW_LAYER( i ) );
731 }
732
733 return visible;
734}
735
736
738{
739 if( GetCanvas() )
740 {
741 for( int i = 0; i < GERBER_DRAWLAYERS_COUNT; i++ )
742 {
743 bool v = aLayerMask[i];
744 int layer = GERBER_DRAW_LAYER( i );
745 GetCanvas()->GetView()->SetLayerVisible( layer, v );
747 gvconfig()->m_Appearance.show_dcodes && v );
748 }
749 }
750}
751
752
753bool GERBVIEW_FRAME::IsLayerVisible( int aLayer ) const
754{
755 return m_LayersManager->IsLayerVisible( aLayer );
756}
757
758
760{
761 COLOR4D color = COLOR4D::UNSPECIFIED;
762 COLOR_SETTINGS* settings = GetColorSettings();
763
764 switch( aLayerID )
765 {
767 case LAYER_DCODES:
771 color = settings->GetColor( aLayerID );
772 break;
773
776 break;
777
778 default:
779 wxFAIL_MSG( wxString::Format( wxT( "GERBVIEW_FRAME::GetVisibleElementColor(): bad arg %d" ),
780 aLayerID ) );
781 }
782
783 return color;
784}
785
786
788{
791}
792
793
794void GERBVIEW_FRAME::SetVisibleElementColor( int aLayerID, const COLOR4D& aColor )
795{
796 COLOR_SETTINGS* settings = GetColorSettings();
797
798 settings->SetColor( aLayerID, aColor );
799
800 switch( aLayerID )
801 {
805 break;
806
808 SetGridColor( aColor );
809 break;
810
812 SetDrawBgColor( aColor );
813 break;
814
815 default:
816 break;
817 }
818}
819
820
822{
823 return GetColorSettings()->GetColor( aLayer );
824}
825
826
827void GERBVIEW_FRAME::SetLayerColor( int aLayer, const COLOR4D& aColor )
828{
829 GetColorSettings()->SetColor( aLayer, aColor );
831}
832
833
834void GERBVIEW_FRAME::SetActiveLayer( int aLayer, bool doLayerWidgetUpdate )
835{
836 m_activeLayer = aLayer;
837
838 if( gvconfig()->m_Display.m_XORMode )
840
841 if( doLayerWidgetUpdate )
842 m_LayersManager->SelectLayer( aLayer );
843
845
847 GetCanvas()->SetFocus(); // otherwise hotkeys are stuck somewhere
848
850 GetCanvas()->Refresh();
851}
852
853
854void GERBVIEW_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
855{
856 m_paper = aPageSettings;
857
858 if( GetScreen() )
860
861 GERBVIEW_DRAW_PANEL_GAL* drawPanel = static_cast<GERBVIEW_DRAW_PANEL_GAL*>( GetCanvas() );
862
863 // Prepare drawing-sheet template
865 &Prj(), &GetTitleBlock(), nullptr );
866
867 if( GetScreen() )
868 {
869 drawingSheet->SetPageNumber( "1" );
870 drawingSheet->SetSheetCount( 1 );
871 }
872
875
876 // Draw panel takes ownership of the drawing-sheet
877 drawPanel->SetDrawingSheet( drawingSheet );
878}
879
880
882{
883 return m_paper;
884}
885
886
888{
889 // this function is only needed because EDA_DRAW_FRAME is not compiled
890 // with either -DPCBNEW or -DEESCHEMA, so the virtual is used to route
891 // into an application specific source file.
893}
894
895
897{
898 wxASSERT( m_gerberLayout );
900}
901
902
904{
905 wxASSERT( m_gerberLayout );
906 m_gerberLayout->SetTitleBlock( aTitleBlock );
907}
908
909
911{
913}
914
915
917{
919 GetCanvas()->GetGAL()->SetGridColor( aColor );
920 m_gridColor = aColor;
921}
922
923
925{
926 VECTOR2D gridSize = GetCanvas()->GetGAL()->GetGridSize();
927 wxString line;
928
929 line.Printf( wxT( "grid X %s Y %s" ),
930 MessageTextFromValue( gridSize.x, false ),
931 MessageTextFromValue( gridSize.y, false ) );
932
933 SetStatusText( line, 4 );
934 SetStatusText( line, 4 );
935}
936
937
939{
941
942 if( !GetScreen() )
943 return;
944
945 wxString line;
947
948 if( GetShowPolarCoords() ) // display relative polar coordinates
949 {
950 VECTOR2D v = cursorPos - GetScreen()->m_LocalOrigin;
951 EDA_ANGLE theta( VECTOR2D( v.x, -v.y ) );
952 double ro = hypot( v.x, v.y );
953
954 line.Printf( wxT( "r %s theta %s" ),
955 MessageTextFromValue( ro, false ),
956 MessageTextFromValue( theta, false ) );
957
958 SetStatusText( line, 3 );
959 }
960
961 // Display absolute coordinates:
962 line.Printf( wxT( "X %s Y %s" ),
963 MessageTextFromValue( cursorPos.x, false ),
964 MessageTextFromValue( cursorPos.y, false ) );
965 SetStatusText( line, 2 );
966
967 if( !GetShowPolarCoords() )
968 {
969 // Display relative cartesian coordinates:
970 double dXpos = cursorPos.x - GetScreen()->m_LocalOrigin.x;
971 double dYpos = cursorPos.y - GetScreen()->m_LocalOrigin.y;
972
973 line.Printf( wxT( "dx %s dy %s dist %s" ),
974 MessageTextFromValue( dXpos, false ),
975 MessageTextFromValue( dYpos,false ),
976 MessageTextFromValue( hypot( dXpos, dYpos ), false ) );
977 SetStatusText( line, 3 );
978 }
979
981}
982
983
985{
986 return m_gerberLayout->GetImagesList()->GetGbrImage( aIdx );
987}
988
989
991{
993}
994
995
997{
998 // Called on units change (see EDA_DRAW_FRAME)
1002}
1003
1004
1006{
1008
1009 EDA_DRAW_PANEL_GAL* galCanvas = GetCanvas();
1010
1011 if( m_toolManager )
1012 {
1014 GetCanvas()->GetViewControls(), config(), this );
1016 }
1017
1019
1021
1022 galCanvas->GetView()->RecacheAllItems();
1024 galCanvas->StartDrawing();
1025
1028
1031}
1032
1033
1035{
1036 // Create the manager and dispatcher & route draw panel events to the dispatcher
1039 GetCanvas()->GetViewControls(), config(), this );
1042
1043 // Register tools
1051
1052 // Run the selection tool, it is supposed to be always active
1053 m_toolManager->InvokeTool( "gerbview.InteractiveSelection" );
1054}
1055
1056
1058{
1060
1062 EDITOR_CONDITIONS cond( this );
1063
1064 wxASSERT( mgr );
1065
1066#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1067#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1068
1072
1076
1077 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
1078 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
1079 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
1080
1081 auto flashedDisplayOutlinesCond =
1082 [this] ( const SELECTION& )
1083 {
1085 };
1086
1087 auto linesFillCond =
1088 [this] ( const SELECTION& )
1089 {
1091 };
1092
1093 auto polygonsFilledCond =
1094 [this] ( const SELECTION& )
1095 {
1097 };
1098
1099 auto negativeObjectsCond =
1100 [this] ( const SELECTION& )
1101 {
1103 };
1104
1105 auto dcodeCond =
1106 [this] ( const SELECTION& )
1107 {
1109 };
1110
1111 auto diffModeCond =
1112 [this] ( const SELECTION& )
1113 {
1114 return gvconfig()->m_Display.m_DiffMode;
1115 };
1116
1117 auto xorModeCond =
1118 [this] ( const SELECTION& )
1119 {
1120 return gvconfig()->m_Display.m_XORMode;
1121 };
1122
1123 auto highContrastModeCond =
1124 [this] ( const SELECTION& )
1125 {
1127 };
1128
1129 auto flipGerberCond =
1130 [this] ( const SELECTION& )
1131 {
1133 };
1134
1135 auto layersManagerShownCondition =
1136 [this] ( const SELECTION& aSel )
1137 {
1139 };
1140
1141 mgr->SetConditions( GERBVIEW_ACTIONS::flashedDisplayOutlines, CHECK( flashedDisplayOutlinesCond ) );
1143 mgr->SetConditions( GERBVIEW_ACTIONS::polygonsDisplayOutlines, CHECK( polygonsFilledCond ) );
1144 mgr->SetConditions( GERBVIEW_ACTIONS::negativeObjectDisplay, CHECK( negativeObjectsCond ) );
1146 mgr->SetConditions( GERBVIEW_ACTIONS::toggleDiffMode, CHECK( diffModeCond ) );
1147 mgr->SetConditions( GERBVIEW_ACTIONS::toggleXORMode, CHECK( xorModeCond ) );
1148 mgr->SetConditions( GERBVIEW_ACTIONS::flipGerberView, CHECK( flipGerberCond ) );
1149 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastModeCond ) );
1150 mgr->SetConditions( GERBVIEW_ACTIONS::toggleLayerManager, CHECK( layersManagerShownCondition ) );
1151
1152#undef CHECK
1153#undef ENABLE
1154}
1155
1156
1157void GERBVIEW_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1158{
1159 EDA_DRAW_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1160
1161 // Update gal display options like cursor shape, grid options:
1162 GERBVIEW_SETTINGS* cfg = Pgm().GetSettingsManager().GetAppSettings<GERBVIEW_SETTINGS>();
1164
1165 SetPageSettings( PAGE_INFO( gvconfig()->m_Appearance.page_type ) );
1166
1168
1169 SetElementVisibility( LAYER_DCODES, gvconfig()->m_Appearance.show_dcodes );
1170
1174
1176 ReFillLayerWidget(); // Update the layers list
1177 m_LayersManager->ReFillRender(); // Update colors in Render after the config is read
1178
1179 Layout();
1180 SendSizeEvent();
1181}
1182
1183
1185{
1186 return m_toolManager->GetTool<GERBVIEW_SELECTION_TOOL>()->GetSelection();
1187}
1188
1189
1191{
1193
1194 // show/hide auxiliary Vertical layers and visibility manager toolbar
1195 m_auimgr.GetPane( "LayersManager" ).Show( m_show_layer_manager_tools );
1196 m_auimgr.Update();
1197}
int color
Definition: DXF_plotter.cpp:58
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE gerbIUScale
Definition: base_units.h:108
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:106
static TOOL_ACTION toggleGrid
Definition: actions.h:148
static TOOL_ACTION millimetersUnits
Definition: actions.h:156
static TOOL_ACTION togglePolarCoords
Definition: actions.h:159
static TOOL_ACTION milsUnits
Definition: actions.h:155
static TOOL_ACTION inchesUnits
Definition: actions.h:154
static TOOL_ACTION highContrastMode
Definition: actions.h:109
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:108
static TOOL_ACTION measureTool
Definition: actions.h:164
static TOOL_ACTION selectionTool
Definition: actions.h:163
static TOOL_ACTION zoomFitScreen
Definition: actions.h:100
static TOOL_ACTION zoomTool
Definition: actions.h:103
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:169
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:172
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
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.
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.
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_DiffMode
Display layers in diff mode.
bool m_XORMode
Display layers in exclusive-or mode.
bool m_FlipGerberView
Display as a mirror image.
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 ...
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 toggleDiffMode
static TOOL_ACTION flipGerberView
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:82
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:423
void SetLayerTarget(int aLayer, RENDER_TARGET aTarget)
Change the rendering target for a particular layer.
Definition: view.h:468
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition: view.h:392
void Clear()
Remove all items from the view.
Definition: view.cpp:1115
void RecacheAllItems()
Rebuild GAL display lists.
Definition: view.cpp:1400
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1500
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:640
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:409
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:212
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:616
void UpdateAllItemsConditionally(int aUpdateFlags, std::function< bool(VIEW_ITEM *)> aCondition)
Update items in the view according to the given flags and condition.
Definition: view.cpp:1510
void ReorderLayerData(std::unordered_map< int, int > aReorderMap)
Remap the data between layer ids without invalidating that data.
Definition: view.cpp:672
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: layer_ids.h:552
static LSET AllLayersMask()
Definition: lset.cpp:808
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:53
const VECTOR2I GetSizeIU(double aIUScale) const
Gets the page size in internal units.
Definition: page_info.h:161
const wxString & GetType() const
Definition: page_info.h:93
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
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.
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:165
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:167
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
ACTIONS * m_actions
Definition: tools_holder.h:166
@ GAL_SWITCH
Rendering engine changes.
Definition: tool_base.h:82
Master controller class:
Definition: tool_manager.h:57
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:145
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:289
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:230
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)
A lower-precision version of StringFromValue().
#define CHECK(x)
#define _HKI(x)
#define _(s)
#define KICAD_DEFAULT_DRAWFRAME_STYLE
@ FRAME_GERBER
Definition: frame_type.h:53
#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
const std::string GerberJobFileExtension
const std::string DrillFileExtension
const std::string GerberFileExtension
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:425
@ LAYER_GERBVIEW_BACKGROUND
Definition: layer_ids.h:424
@ LAYER_DCODES
Definition: layer_ids.h:420
@ LAYER_NEGATIVE_OBJECTS
Definition: layer_ids.h:421
@ LAYER_GERBVIEW_PAGE_LIMITS
Definition: layer_ids.h:426
@ LAYER_GERBVIEW_GRID
Definition: layer_ids.h:422
#define GERBER_DCODE_LAYER(x)
Definition: layer_ids.h:433
@ LAYER_DRAWINGSHEET
drawingsheet frame and titleblock
Definition: layer_ids.h:218
#define GERBER_DRAWLAYERS_COUNT
Definition: layer_ids.h:410
#define GERBER_DRAW_LAYER(x)
Definition: layer_ids.h:431
@ 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
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:172
see class PGM_BASE
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:115
std::vector< FAB_LAYER_COLOR > dummy
const double IU_PER_MILS
Definition: base_units.h:78
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:587
Definition of file extensions used in Kicad.
#define ZOOM_LIST_GERBVIEW
Definition: zoom_defines.h:29