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 <dick@softplc.com>
 * Copyright (C) 2010-2021 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( LAYER_NUM aLayer );

    LAYER_NUM GetSelectedLayer();

    void SetLayerVisible( LAYER_NUM aLayer, bool isVisible );

    bool IsLayerVisible( LAYER_NUM aLayer );

    void SetLayerColor( LAYER_NUM aLayer, const COLOR4D& aColor );

    COLOR4D GetLayerColor( LAYER_NUM aLayer ) 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( LAYER_NUM 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 LAYER_NUM 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( LAYER_NUM aLayer ) const;
    int findRenderRow( int aId ) const;

    void insertLayerRow( int aRow, const ROW& aSpec );

    void insertRenderRow( int aRow, const ROW& aSpec );

    void setLayerCheckbox( LAYER_NUM 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_