haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/gerbview/layer_widget.cpp

982 lines
28 KiB
C++
Raw Blame History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2010-2020 KiCad Developers, see change_log.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/* This source module implements the layer visibility and selection widget
@todo make bitmap size dependent on the point size.
*/
//#define STAND_ALONE 1 // define to enable test program for LAYER_WIDGET
#include <layer_widget.h>
#include <macros.h>
#include <common.h>
#include <widgets/indicator_icon.h>
#include <algorithm>
#include <menus_helpers.h>
const wxEventType LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE = wxNewEventType();
/**
* Function shrinkFont
* reduces the size of the wxFont associated with \a aControl
*/
static void shrinkFont( wxWindow* aControl, int aPointSize )
{
wxFont font = aControl->GetFont();
font.SetPointSize( aPointSize );
aControl->SetFont( font ); // need this?
}
int LAYER_WIDGET::encodeId( int aColumn, int aId )
{
int id = aId * LYR_COLUMN_COUNT + aColumn;
return id;
}
LAYER_NUM LAYER_WIDGET::getDecodedId( int aControlId )
{
int id = aControlId / LYR_COLUMN_COUNT; // rounding is OK.
return id;
}
void LAYER_WIDGET::OnLeftDownLayers( wxMouseEvent& event )
{
int row;
LAYER_NUM layer;
wxWindow* eventSource = (wxWindow*) event.GetEventObject();
// if mouse event is coming from the m_LayerScrolledWindow and not one
// of its children, we have to find the row manually based on y coord.
if( eventSource == m_LayerScrolledWindow )
{
int y = event.GetY();
wxArrayInt heights = m_LayersFlexGridSizer->GetRowHeights();
int height = 0;
int rowCount = GetLayerRowCount();
for( row = 0; row<rowCount; ++row )
{
if( y < height + heights[row] )
break;
height += heights[row];
}
if( row >= rowCount )
row = rowCount - 1;
layer = getDecodedId( getLayerComp( row, 0 )->GetId() );
}
else
{
// all nested controls on a given row will have their ID encoded with
// encodeId(), and the corresponding decoding is getDecodedId()
int id = eventSource->GetId();
layer = getDecodedId( id );
row = findLayerRow( layer );
}
if( OnLayerSelect( layer ) ) // if client allows this change.
SelectLayerRow( row );
passOnFocus();
}
void LAYER_WIDGET::OnRightDownLayer( wxMouseEvent& aEvent, COLOR_SWATCH* aColorSwatch, const wxString& aLayerName )
{
wxMenu menu;
AddMenuItem( &menu, ID_CHANGE_LAYER_COLOR,
_( "Change Layer Color for" ) + wxS( " " ) + aLayerName,
KiBitmap( setcolor_copper_xpm ) );
menu.AppendSeparator();
OnLayerRightClick( menu );
menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [aColorSwatch]( wxCommandEvent& event ) {
if ( event.GetId() == ID_CHANGE_LAYER_COLOR ) {
aColorSwatch->GetNewSwatchColor();
} else {
event.Skip();
}
} );
PopupMenu( &menu );
passOnFocus();
}
void LAYER_WIDGET::OnLayerSwatchChanged( wxCommandEvent& aEvent )
{
COLOR_SWATCH* eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
COLOR4D newColor = eventSource->GetSwatchColor();
LAYER_NUM layer = getDecodedId( eventSource->GetId() );
// tell the client code.
OnLayerColorChange( layer, newColor );
// notify others
wxCommandEvent event( EVT_LAYER_COLOR_CHANGE );
wxPostEvent( this, event );
passOnFocus();
}
void LAYER_WIDGET::OnLayerCheckBox( wxCommandEvent& event )
{
wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
LAYER_NUM layer = getDecodedId( eventSource->GetId() );
OnLayerVisible( layer, eventSource->IsChecked() );
passOnFocus();
}
void LAYER_WIDGET::OnRightDownRender( wxMouseEvent& aEvent, COLOR_SWATCH* aColorSwatch, const wxString& aRenderName )
{
wxMenu menu;
AddMenuItem( &menu, ID_CHANGE_RENDER_COLOR,
_( "Change Render Color for" ) + wxS( " " )+ aRenderName,
KiBitmap( setcolor_board_body_xpm ) );
menu.Bind( wxEVT_COMMAND_MENU_SELECTED,
[aColorSwatch]( wxCommandEvent& event )
{
if( event.GetId() == ID_CHANGE_RENDER_COLOR )
aColorSwatch->GetNewSwatchColor();
else
event.Skip();
} );
PopupMenu( &menu );
passOnFocus();
}
void LAYER_WIDGET::OnRenderSwatchChanged( wxCommandEvent& aEvent )
{
auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
COLOR4D newColor = eventSource->GetSwatchColor();
LAYER_NUM id = getDecodedId( eventSource->GetId() );
if( id == LAYER_PCB_BACKGROUND )
{
// Update all swatch backgrounds
int count = GetLayerRowCount();
int row;
int col = 1; // bitmap button is column 1 in layers tab
for( row = 0; row < count; ++row )
{
COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
if( swatch )
swatch->SetSwatchBackground( newColor );
}
count = GetRenderRowCount();
col = 0; // bitmap button is column 0 in render tab
for( row = 0; row < count; ++row )
{
COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getRenderComp( row, col ) );
if( swatch )
swatch->SetSwatchBackground( newColor );
}
}
// tell the client code.
OnRenderColorChange( id, newColor );
passOnFocus();
}
void LAYER_WIDGET::OnRenderCheckBox( wxCommandEvent& event )
{
wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
LAYER_NUM id = getDecodedId( eventSource->GetId() );
OnRenderEnable( id, eventSource->IsChecked() );
passOnFocus();
}
void LAYER_WIDGET::OnTabChange( wxNotebookEvent& event )
{
// wxFocusEvent event( wxEVT_SET_FOCUS );
// m_FocusOwner->AddPendingEvent( event );
passOnFocus(); // does not work in this context, probably because we have receive control here too early.
}
wxWindow* LAYER_WIDGET::getLayerComp( int aRow, int aColumn ) const
{
unsigned ndx = aRow * LYR_COLUMN_COUNT + aColumn;
if( ndx < m_LayersFlexGridSizer->GetChildren().GetCount() )
return m_LayersFlexGridSizer->GetChildren()[ndx]->GetWindow();
return NULL;
}
int LAYER_WIDGET::findLayerRow( LAYER_NUM aLayer ) const
{
int count = GetLayerRowCount();
for( int row = 0; row < count; ++row )
{
// column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
wxWindow* w = getLayerComp( row, 0 );
wxASSERT( w );
if( aLayer == getDecodedId( w->GetId() ))
return row;
}
return -1;
}
wxWindow* LAYER_WIDGET::getRenderComp( int aRow, int aColumn ) const
{
int ndx = aRow * RND_COLUMN_COUNT + aColumn;
if( (unsigned) ndx < m_RenderFlexGridSizer->GetChildren().GetCount() )
return m_RenderFlexGridSizer->GetChildren()[ndx]->GetWindow();
return NULL;
}
int LAYER_WIDGET::findRenderRow( int aId ) const
{
int count = GetRenderRowCount();
for( int row = 0; row < count; ++row )
{
// column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
wxWindow* w = getRenderComp( row, 0 );
wxASSERT( w );
if( aId == getDecodedId( w->GetId() ))
return row;
}
return -1;
}
void LAYER_WIDGET::insertLayerRow( int aRow, const ROW& aSpec )
{
wxASSERT( aRow >= 0 );
int col;
int index = aRow * LYR_COLUMN_COUNT;
const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
// column 0
col = COLUMN_ICON_ACTIVE;
auto sbm = new INDICATOR_ICON( m_LayerScrolledWindow, *m_IconProvider,
ROW_ICON_PROVIDER::STATE::OFF, encodeId( col, aSpec.id ) );
sbm->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
// column 1 (COLUMN_COLORBM)
col = COLUMN_COLORBM;
auto bmb = new COLOR_SWATCH( m_LayerScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
getBackgroundLayerColor(), aSpec.defaultColor, SWATCH_SMALL );
bmb->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnLayerSwatchChanged, this );
bmb->SetToolTip( _("Left double click or middle click for color change, right click for menu" ) );
m_LayersFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
// column 2 (COLUMN_COLOR_LYR_CB)
col = COLUMN_COLOR_LYR_CB;
wxCheckBox* cb = new wxCheckBox( m_LayerScrolledWindow, encodeId( col, aSpec.id ), wxEmptyString );
cb->SetValue( aSpec.state );
cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnLayerCheckBox, this );
cb->SetToolTip( _( "Enable this for visibility" ) );
m_LayersFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
// column 3 (COLUMN_COLOR_LYRNAME)
col = COLUMN_COLOR_LYRNAME;
wxStaticText* st = new wxStaticText( m_LayerScrolledWindow, encodeId( col, aSpec.id ), aSpec.rowName );
shrinkFont( st, m_PointSize );
st->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
st->SetToolTip( aSpec.tooltip );
m_LayersFlexGridSizer->wxSizer::Insert( index+col, st, 0, flags );
// column 4 (COLUMN_ALPHA_INDICATOR)
col = COLUMN_ALPHA_INDICATOR;
sbm = new INDICATOR_ICON( m_LayerScrolledWindow, *m_IconProvider,
ROW_ICON_PROVIDER::STATE::OFF, wxID_ANY );
m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
// Bind right click eventhandler to all columns
wxString layerName( aSpec.rowName );
sbm->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt )
{
OnRightDownLayer( aEvt, bmb, layerName );
} );
bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt )
{
OnRightDownLayer( aEvt, bmb, layerName );
} );
cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt )
{
OnRightDownLayer( aEvt, bmb, layerName );
} );
st->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt )
{
OnRightDownLayer( aEvt, bmb, layerName );
} );
}
void LAYER_WIDGET::updateLayerRow( int aRow, const wxString& aName )
{
wxStaticText* label = dynamic_cast<wxStaticText*>( getLayerComp( aRow, COLUMN_COLOR_LYRNAME ) );
if( label )
label->SetLabel( aName );
INDICATOR_ICON* indicator = (INDICATOR_ICON*) getLayerComp( aRow, 0 );
if( indicator )
{
if( aRow == m_CurrentRow )
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::ON );
if( useAlternateBitmap( aRow ) )
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DIMMED );
else
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::OFF );
}
}
void LAYER_WIDGET::insertRenderRow( int aRow, const ROW& aSpec )
{
wxASSERT( aRow >= 0 );
int col;
int index = aRow * RND_COLUMN_COUNT;
const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
wxString renderName( aSpec.rowName );
wxCheckBox* cb = nullptr;
// column 1
if( !aSpec.spacer )
{
col = 1;
cb = new wxCheckBox( m_RenderScrolledWindow, encodeId( col, aSpec.id ),
aSpec.rowName, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
shrinkFont( cb, m_PointSize );
cb->SetValue( aSpec.state );
cb->Enable( aSpec.changeable );
cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnRenderCheckBox, this );
cb->SetToolTip( aSpec.tooltip );
}
// column 0
col = 0;
if( aSpec.color != COLOR4D::UNSPECIFIED )
{
auto bmb = new COLOR_SWATCH( m_RenderScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
getBackgroundLayerColor(), aSpec.defaultColor, SWATCH_SMALL );
bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnRenderSwatchChanged, this );
bmb->SetToolTip( _( "Left double click or middle click for color change" ) );
m_RenderFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
OnRightDownRender( aEvt, bmb, renderName );
} );
cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
OnRightDownRender( aEvt, bmb, renderName );
} );
// could add a left click handler on the color button that toggles checkbox.
}
else // == -1, no color selection wanted
{
// need a place holder within the sizer to keep grid full.
wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, encodeId( col, aSpec.id ) );
m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
}
// Items have to be inserted in order
col = 1;
if( aSpec.spacer )
{
wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, wxID_ANY );
m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
}
else
{
m_RenderFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
}
}
void LAYER_WIDGET::passOnFocus()
{
m_FocusOwner->SetFocus();
}
//-----<public>-------------------------------------------------------
LAYER_WIDGET::LAYER_WIDGET( wxWindow* aParent, wxWindow* aFocusOwner, wxWindowID id,
const wxPoint& pos, const wxSize& size, long style ) :
wxPanel( aParent, id, pos, size, style )
{
int indicatorSize = ConvertDialogToPixels( wxSize( 6, 6 ) ).x;
m_IconProvider = new ROW_ICON_PROVIDER( indicatorSize );
int pointSize = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ).GetPointSize();
int screenHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
if( screenHeight <= 900 && pointSize >= indicatorSize )
pointSize = pointSize * 8 / 10;
m_PointSize = pointSize;
wxBoxSizer* mainSizer = new wxBoxSizer( wxVERTICAL );
m_notebook = new wxAuiNotebook( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_NB_TOP );
wxFont font = m_notebook->GetFont();
// change the font size on the notebook's tabs to match aPointSize
font.SetPointSize( pointSize );
m_notebook->SetFont( font );
m_notebook->SetNormalFont( font );
m_notebook->SetSelectedFont( font );
m_notebook->SetMeasuringFont( font );
m_LayerPanel = new wxPanel( m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
wxBoxSizer* layerPanelSizer;
layerPanelSizer = new wxBoxSizer( wxVERTICAL );
m_LayerScrolledWindow = new wxScrolledWindow( m_LayerPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNO_BORDER );
m_LayerScrolledWindow->SetScrollRate( 5, 5 );
m_LayersFlexGridSizer = new wxFlexGridSizer( 0, LYR_COLUMN_COUNT, 0, 1 );
m_LayersFlexGridSizer->SetFlexibleDirection( wxHORIZONTAL );
m_LayersFlexGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_NONE );
m_LayerScrolledWindow->SetSizer( m_LayersFlexGridSizer );
m_LayerScrolledWindow->Layout();
m_LayersFlexGridSizer->Fit( m_LayerScrolledWindow );
layerPanelSizer->Add( m_LayerScrolledWindow, 1, wxBOTTOM|wxEXPAND|wxLEFT|wxTOP, 2 );
m_LayerPanel->SetSizer( layerPanelSizer );
m_LayerPanel->Layout();
layerPanelSizer->Fit( m_LayerPanel );
m_notebook->AddPage( m_LayerPanel, _( "Layers" ), true );
m_RenderingPanel = new wxPanel( m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
wxBoxSizer* renderPanelSizer;
renderPanelSizer = new wxBoxSizer( wxVERTICAL );
m_RenderScrolledWindow = new wxScrolledWindow( m_RenderingPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNO_BORDER );
m_RenderScrolledWindow->SetScrollRate( 5, 5 );
m_RenderFlexGridSizer = new wxFlexGridSizer( 0, RND_COLUMN_COUNT, 0, 1 );
m_RenderFlexGridSizer->SetFlexibleDirection( wxHORIZONTAL );
m_RenderFlexGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_NONE );
m_RenderScrolledWindow->SetSizer( m_RenderFlexGridSizer );
m_RenderScrolledWindow->Layout();
m_RenderFlexGridSizer->Fit( m_RenderScrolledWindow );
renderPanelSizer->Add( m_RenderScrolledWindow, 1, wxALL|wxEXPAND, 5 );
m_RenderingPanel->SetSizer( renderPanelSizer );
m_RenderingPanel->Layout();
renderPanelSizer->Fit( m_RenderingPanel );
m_notebook->AddPage( m_RenderingPanel, _( "Items" ), false );
mainSizer->Add( m_notebook, 1, wxEXPAND, 5 );
SetSizer( mainSizer );
m_FocusOwner = aFocusOwner;
m_CurrentRow = -1; // hide the arrow initially
// trap the tab changes so that we can call passOnFocus().
m_notebook->Bind( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, &LAYER_WIDGET::OnTabChange, this );
Layout();
}
LAYER_WIDGET::~LAYER_WIDGET()
{
delete m_IconProvider;
}
wxSize LAYER_WIDGET::GetBestSize() const
{
// size of m_LayerScrolledWindow --------------
wxArrayInt widths = m_LayersFlexGridSizer->GetColWidths();
int totWidth = 0;
if( widths.GetCount() )
{
for( int i = 0; i < LYR_COLUMN_COUNT; ++i )
{
totWidth += widths[i] + m_LayersFlexGridSizer->GetHGap();
}
}
// Account for the parent's frame:
totWidth += 15;
/* The minimum height is a small size to properly force computation
* of the panel's scrollbars (otherwise it will assume it *has* all
* this space) */
unsigned totHeight = 32;
wxSize layerz( totWidth, totHeight );
layerz += m_LayerPanel->GetWindowBorderSize();
// size of m_RenderScrolledWindow --------------
widths = m_RenderFlexGridSizer->GetColWidths();
totWidth = 0;
if( widths.GetCount() )
{
for( int i = 0; i < RND_COLUMN_COUNT; ++i )
{
totWidth += widths[i] + m_RenderFlexGridSizer->GetHGap();
}
}
// account for the parent's frame, this one has void space of 10 PLUS a border:
totWidth += 15;
// For totHeight re-use the previous small one
wxSize renderz( totWidth, totHeight );
renderz += m_RenderingPanel->GetWindowBorderSize();
wxSize clientz( std::max(renderz.x,layerz.x), std::max(renderz.y,layerz.y) );
return clientz;
}
int LAYER_WIDGET::GetLayerRowCount() const
{
int controlCount = m_LayersFlexGridSizer->GetChildren().GetCount();
return controlCount / LYR_COLUMN_COUNT;
}
int LAYER_WIDGET::GetRenderRowCount() const
{
int controlCount = m_RenderFlexGridSizer->GetChildren().GetCount();
return controlCount / RND_COLUMN_COUNT;
}
void LAYER_WIDGET::AppendLayerRow( const ROW& aRow )
{
int nextRow = GetLayerRowCount();
insertLayerRow( nextRow, aRow );
}
void LAYER_WIDGET::ClearLayerRows()
{
m_LayersFlexGridSizer->Clear( true );
}
void LAYER_WIDGET::AppendRenderRow( const ROW& aRow )
{
int nextRow = GetRenderRowCount();
insertRenderRow( nextRow, aRow );
}
void LAYER_WIDGET::ClearRenderRows()
{
m_RenderFlexGridSizer->Clear( true );
}
void LAYER_WIDGET::SelectLayerRow( int aRow )
{
// enable the layer tab at index 0
m_notebook->SetSelection( 0 );
INDICATOR_ICON* oldIndicator = (INDICATOR_ICON*) getLayerComp( m_CurrentRow, 0 );
if( oldIndicator )
{
if( useAlternateBitmap( m_CurrentRow ) )
oldIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DIMMED );
else
oldIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::OFF );
}
INDICATOR_ICON* newIndicator = (INDICATOR_ICON*) getLayerComp( aRow, 0 );
if( newIndicator )
{
newIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::ON );
// Make sure the desired layer row is visible.
// It seems that as of 2.8.2, setting the focus does this.
// I don't expect the scrolling to be needed at all because
// the minimum window size may end up being established so that the
// scroll bars will not be visible.
getLayerComp( aRow, 1 )->SetFocus();
}
m_CurrentRow = aRow;
// give the focus back to the app.
passOnFocus();
}
void LAYER_WIDGET::SelectLayer( LAYER_NUM aLayer )
{
int row = findLayerRow( aLayer );
SelectLayerRow( row );
}
LAYER_NUM LAYER_WIDGET::GetSelectedLayer()
{
wxWindow* w = getLayerComp( m_CurrentRow, 0 );
if( w )
return getDecodedId( w->GetId() );
return UNDEFINED_LAYER;
}
void LAYER_WIDGET::SetLayerVisible( LAYER_NUM aLayer, bool isVisible )
{
setLayerCheckbox( aLayer, isVisible );
OnLayerVisible( aLayer, isVisible );
}
void LAYER_WIDGET::setLayerCheckbox( LAYER_NUM aLayer, bool isVisible )
{
int row = findLayerRow( aLayer );
if( row >= 0 )
{
wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
wxASSERT( cb );
cb->SetValue( isVisible ); // does not fire an event
}
}
bool LAYER_WIDGET::IsLayerVisible( LAYER_NUM aLayer )
{
int row = findLayerRow( aLayer );
if( row >= 0 )
{
wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
wxASSERT( cb );
return cb->GetValue();
}
return false;
}
void LAYER_WIDGET::SetLayerColor( LAYER_NUM aLayer, COLOR4D aColor )
{
int row = findLayerRow( aLayer );
if( row >= 0 )
{
int col = 1; // bitmap button is column 1
auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
wxASSERT( swatch );
swatch->SetSwatchColor( aColor, false );
}
}
COLOR4D LAYER_WIDGET::GetLayerColor( LAYER_NUM aLayer ) const
{
int row = findLayerRow( aLayer );
if( row >= 0 )
{
int col = 1; // bitmap button is column 1
auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
wxASSERT( swatch );
return swatch->GetSwatchColor();
}
return COLOR4D::UNSPECIFIED; // it's caller fault, gave me a bad layer
}
void LAYER_WIDGET::SetRenderState( int aId, bool isSet )
{
int row = findRenderRow( aId );
if( row >= 0 )
{
int col = 1; // checkbox is column 1
wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
wxASSERT( cb );
cb->SetValue( isSet ); // does not fire an event
}
}
bool LAYER_WIDGET::GetRenderState( int aId )
{
int row = findRenderRow( aId );
if( row >= 0 )
{
int col = 1; // checkbox is column 1
wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
wxASSERT( cb );
return cb->GetValue();
}
return false; // the value of a non-existent row
}
void LAYER_WIDGET::UpdateLayouts()
{
m_LayersFlexGridSizer->Layout();
m_RenderFlexGridSizer->Layout();
m_LayerPanel->Layout();
m_RenderingPanel->Layout();
FitInside();
}
void LAYER_WIDGET::UpdateLayerIcons()
{
int rowCount = GetLayerRowCount();
for( int row = 0; row < rowCount ; row++ )
{
INDICATOR_ICON* indicator = (INDICATOR_ICON*) getLayerComp( row, COLUMN_ICON_ACTIVE );
if( indicator )
{
ROW_ICON_PROVIDER::STATE state;
if( row == m_CurrentRow )
state = ROW_ICON_PROVIDER::STATE::ON;
else if( useAlternateBitmap( row ) )
state = ROW_ICON_PROVIDER::STATE::DIMMED;
else
state = ROW_ICON_PROVIDER::STATE::OFF;
indicator->SetIndicatorState( state );
}
}
}
#if defined(STAND_ALONE)
#include <wx/aui/aui.h>
/**
* MYFRAME
* is a test class here to exercise the LAYER_WIDGET and explore use cases.
* @see http://www.kirix.com/labs/wxaui/screenshots.html
* for ideas.
*/
class MYFRAME : public wxFrame
{
// example of how to derive from LAYER_WIDGET in order to provide the
// abstract methods.
class MYLAYERS : public LAYER_WIDGET
{
public:
// your constructor could take a BOARD argument. here I leave it
// out because this source module wants to know nothing of BOARDs
// to maximize re-use.
MYLAYERS( wxWindow* aParent ) :
LAYER_WIDGET( aParent, aParent )
{
}
void OnLayerColorChange( int aLayer, COLOR4D aColor )
{
/* a test trigger only
if( aLayer == 2 )
{
ClearLayerRows();
}
*/
}
bool OnLayerSelect( LAYER_NUM aLayer )
{
return true;
}
void OnLayerVisible( LAYER_NUM aLayer, bool isVisible, bool isFinal )
{
}
void OnRenderColorChange( int aId, COLOR4D aColor )
{
}
void OnRenderEnable( int aId, bool isEnabled )
{
}
};
public:
MYFRAME( wxWindow * parent ) :
wxFrame( parent, -1, wxT( "wxAUI Test" ), wxDefaultPosition,
wxSize( 800, 600 ), wxDEFAULT_FRAME_STYLE )
{
// notify wxAUI which frame to use
m_mgr.SetManagedWindow( this );
MYLAYERS* lw = new MYLAYERS( this );
// add some layer rows
static const LAYER_WIDGET::ROW layerRows[] = {
LAYER_WIDGET::ROW( wxT("layer 1"), 0, RED, wxT("RED"), false ),
LAYER_WIDGET::ROW( wxT("layer 2"), 1, GREEN, wxT("GREEN"), true ),
LAYER_WIDGET::ROW( wxT("brown_layer"), 2, BROWN, wxT("BROWN"), true ),
LAYER_WIDGET::ROW( wxT("layer_4_you"), 3, BLUE, wxT("BLUE"), false ),
};
lw->AppendLayerRows( layerRows, arrayDim(layerRows) );
// add some render rows
static const LAYER_WIDGET::ROW renderRows[] = {
LAYER_WIDGET::ROW( wxT("With Very Large Ears"), 0, COLOR4D::UNSPECIFIED, wxT("Spock here") ),
LAYER_WIDGET::ROW( wxT("With Legs"), 1, YELLOW ),
LAYER_WIDGET::ROW( wxT("With Oval Eyes"), 1, BROWN, wxT("My eyes are upon you") ),
};
lw->AppendRenderRows( renderRows, arrayDim(renderRows) );
lw->SelectLayerRow( 1 );
wxAuiPaneInfo li;
li.MinSize( lw->GetBestSize() );
li.BestSize( lw->GetBestSize() );
li.Left();
// li.MaximizeButton( true );
// li.MinimizeButton( true );
li.CloseButton( false );
li.Caption( wxT( "Layers" ) );
m_mgr.AddPane( lw, li );
wxTextCtrl* text2 = new wxTextCtrl( this, -1, wxT( "Pane 2 - sample text" ),
wxDefaultPosition, wxSize( 200, 150 ),
wxNO_BORDER | wxTE_MULTILINE );
m_mgr.AddPane( text2, wxBOTTOM, wxT( "Pane Number Two" ) );
wxTextCtrl* text3 = new wxTextCtrl( this, -1, wxT( "Main content window" ),
wxDefaultPosition, wxSize( 200, 150 ),
wxNO_BORDER | wxTE_MULTILINE );
m_mgr.AddPane( text3, wxCENTER );
// tell the manager to "commit" all the changes just made
m_mgr.Update();
}
~MYFRAME()
{
// deinitialize the frame manager
m_mgr.UnInit();
}
private:
wxAuiManager m_mgr;
};
// our normal wxApp-derived class, as usual
class MyApp : public wxApp
{
public:
bool OnInit()
{
wxFrame* frame = new MYFRAME( NULL );
SetTopWindow( frame );
frame->Show();
return true;
}
};
DECLARE_APP( MyApp );
IMPLEMENT_APP( MyApp );
#endif // STAND_ALONE
Reference in New Issue View Git Blame Copy Permalink