layer_widget.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2010-2022 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
 */
 
#ifndef LAYERWIDGET_H_
#define LAYERWIDGET_H_
 
#include <wx/intl.h>
#include <wx/statbmp.h>
#include <wx/string.h>
#include <wx/aui/auibook.h>
#include <wx/notebook.h>
#include <wx/sizer.h>
#include <wx/gdicmn.h>
#include <wx/scrolwin.h>
#include <wx/font.h>
#include <wx/colour.h>
#include <wx/settings.h>
#include <wx/panel.h>
#include <wx/bitmap.h>
#include <wx/image.h>
#include <wx/icon.h>
#include <layer_ids.h>
#include <gal/color4d.h>
#include <widgets/color_swatch.h>
#include <widgets/indicator_icon.h>
 
#define LYR_COLUMN_COUNT 5 
#define RND_COLUMN_COUNT 2 
 
#define COLUMN_ICON_ACTIVE 0
#define COLUMN_COLORBM 1
#define COLUMN_COLOR_LYR_CB 2
#define COLUMN_COLOR_LYRNAME 3
#define COLUMN_ALPHA_INDICATOR 4
 
using KIGFX::COLOR4D;
 
class LAYER_WIDGET : public wxPanel
{
public:
 struct ROW
 {
 wxString rowName; 
 int id; 
 COLOR4D color; 
 bool state; 
 wxString tooltip; 
 bool changeable; 
 bool spacer; 
 COLOR4D defaultColor; 
 
 ROW( const wxString& aRowName, int aId, const COLOR4D& aColor = COLOR4D::UNSPECIFIED,
 const wxString& aTooltip = wxEmptyString, bool aState = true,
 bool aChangeable = true, const COLOR4D& aDefaultColor = COLOR4D::UNSPECIFIED )
 {
 rowName = aRowName;
 id = aId;
 color = aColor;
 state = aState;
 tooltip = aTooltip;
 changeable = aChangeable;
 spacer = false;
 defaultColor = aDefaultColor;
 }
 
 ROW()
 {
 id = 0;
 color = COLOR4D::UNSPECIFIED;
 state = true;
 changeable = true;
 spacer = true;
 defaultColor = COLOR4D::UNSPECIFIED;
 }
 };
 
 static const wxEventType EVT_LAYER_COLOR_CHANGE;
 
public:
 
 LAYER_WIDGET( wxWindow* aParent, wxWindow* aFocusOwner, wxWindowID id = wxID_ANY,
 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 long style = wxTAB_TRAVERSAL );
 
 virtual ~LAYER_WIDGET();
 
 void SetSmallestLayerString( const wxString& aString )
 {
 m_smallestLayerString = aString;
 }
 
 wxSize GetBestSize() const;
 
 int GetLayerRowCount() const;
 
 int GetRenderRowCount() const;
 
 void AppendLayerRow( const ROW& aRow );
 
 void AppendLayerRows( const ROW* aRowsArray, int aRowCount )
 {
 for( int row=0; row<aRowCount; ++row )
 AppendLayerRow( aRowsArray[row] );
 
 UpdateLayouts();
 }
 
 void ClearLayerRows();
 
 void AppendRenderRow( const ROW& aRow );
 
 void AppendRenderRows( const ROW* aRowsArray, int aRowCount )
 {
 for( int row=0; row<aRowCount; ++row )
 AppendRenderRow( aRowsArray[row] );
 
 UpdateLayouts();
 }
 
 void ClearRenderRows();
 
 void SelectLayerRow( int aRow );
 
 void SelectLayer( int aLayer );
 
 int GetSelectedLayer();
 
 void SetLayerVisible( int aLayer, bool isVisible );
 
 bool IsLayerVisible( int aLayer );
 
 void SetLayerColor( int aLayer, const COLOR4D& aColor );
 
 COLOR4D GetLayerColor( int aLayer ) const;
 
 COLOR4D GetRenderColor( int aRow ) const;
 
 void SetRenderState( int aId, bool isSet );
 
 bool GetRenderState( int aId );
 
 void UpdateLayouts();
 
 void UpdateLayerIcons();
 
/* did not help:
 void Freeze()
 {
 LAYER_PANEL_BASE::Freeze();
 m_LayerScrolledWindow->Freeze();
 m_RenderScrolledWindow->Freeze();
 }
 
 void Thaw()
 {
 m_RenderScrolledWindow->Thaw();
 m_LayerScrolledWindow->Thaw();
 LAYER_PANEL_BASE::Thaw();
 }
*/
 
 //-----<abstract functions>-------------------------------------------
 
 virtual void OnLayerColorChange( int aLayer, const COLOR4D& aColor ) = 0;
 
 virtual bool OnLayerSelect( int aLayer ) = 0;
 
 virtual void OnLayerVisible( int aLayer, bool isVisible, bool isFinal = true ) = 0;
 
 virtual void OnLayerRightClick( wxMenu& aMenu ) = 0;
 
 virtual void OnRenderColorChange( int aId, const COLOR4D& aColor ) = 0;
 
 virtual void OnRenderEnable( int aId, bool isEnabled ) = 0;
 
protected:
 virtual bool useAlternateBitmap(int aRow) { return false; }
 
 virtual COLOR4D getBackgroundLayerColor() { return COLOR4D::BLACK; }
 
 static int encodeId( int aColumn, int aId );
 
 static int getDecodedId( int aControlId );
 
 void OnLeftDownLayers( wxMouseEvent& event );
 
 void OnRightDownLayer( wxMouseEvent& event, COLOR_SWATCH* aColorSwatch,
 const wxString& aLayerName );
 
 void OnLayerSwatchChanged( wxCommandEvent& aEvent );
 
 void OnLayerCheckBox( wxCommandEvent& event );
 
 void OnRightDownRender( wxMouseEvent& aEvent, COLOR_SWATCH* aColorSwatch,
 const wxString& aRenderName );
 
 void OnRenderSwatchChanged( wxCommandEvent& aEvent );
 
 void OnRenderCheckBox( wxCommandEvent& event );
 
 void OnTabChange( wxNotebookEvent& event );
 
 
 wxWindow* getLayerComp( int aRow, int aColumn ) const;
 wxWindow* getRenderComp( int aRow, int aColumn ) const;
 
 int findLayerRow( int aLayer ) const;
 int findRenderRow( int aId ) const;
 
 void insertLayerRow( int aRow, const ROW& aSpec );
 
 void insertRenderRow( int aRow, const ROW& aSpec );
 
 void setLayerCheckbox( int aLayer, bool isVisible );
 
 void updateLayerRow( int aRow, const wxString& aName );
 
 void passOnFocus();
 
 // popup menu ids.
 enum POPUP_ID
 {
 ID_CHANGE_LAYER_COLOR = wxID_HIGHEST,
 ID_CHANGE_RENDER_COLOR,
 ID_LAST_VALUE
 };
 
 wxNotebook* m_notebook;
 wxPanel* m_LayerPanel;
 wxScrolledWindow* m_LayerScrolledWindow;
 wxFlexGridSizer* m_LayersFlexGridSizer;
 wxPanel* m_RenderingPanel;
 wxScrolledWindow* m_RenderScrolledWindow;
 wxFlexGridSizer* m_RenderFlexGridSizer;
 
 wxWindow* m_FocusOwner;
 int m_CurrentRow; 
 int m_PointSize;
 
 ROW_ICON_PROVIDER* m_IconProvider;
 
 wxString m_smallestLayerString;
};
 
#endif // LAYERWIDGET_H_