wx_collapsible_pane.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.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 3 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, see <https://www.gnu.org/licenses/>.
 */
 
#include <kiplatform/ui.h>
#include <widgets/ui_common.h>
#include <widgets/wx_collapsible_pane.h>
 
#include <wx/dc.h>
#include <wx/dcclient.h>
#include <wx/panel.h>
#include <wx/renderer.h>
#include <wx/settings.h>
#include <wx/sizer.h>
#include <wx/toplevel.h>
#include <wx/window.h>
 
#ifdef _WIN32
#include <windows.h>
#endif
 
#include <algorithm>
 
 
wxDEFINE_EVENT( WX_COLLAPSIBLE_PANE_HEADER_CHANGED, wxCommandEvent );
wxDEFINE_EVENT( WX_COLLAPSIBLE_PANE_CHANGED, wxCommandEvent );
 
 
bool WX_COLLAPSIBLE_PANE::Create( wxWindow* aParent, wxWindowID aId, const wxString& aLabel )
{
    if( !wxControl::Create( aParent, aId, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE, wxDefaultValidator,
                            wxT( "COLLAPSIBLE_PANE_HEADER" ) ) )
    {
        return false;
    }
 
    m_sizer = new wxBoxSizer( wxVERTICAL );
 
    m_header = new WX_COLLAPSIBLE_PANE_HEADER( this, wxID_ANY, aLabel );
 
    m_sizer->Add( m_header );
 
    m_pane = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER,
                          wxT( "COLLAPSIBLE_PANE_PANEL" ) );
 
    m_pane->Hide();
 
    Bind( wxEVT_SIZE, &WX_COLLAPSIBLE_PANE::onSize, this );
    Bind( WX_COLLAPSIBLE_PANE_HEADER_CHANGED, &WX_COLLAPSIBLE_PANE::onHeaderClicked, this );
 
    return true;
}
 
 
void WX_COLLAPSIBLE_PANE::init()
{
    m_pane   = nullptr;
    m_sizer  = nullptr;
    m_header = nullptr;
}
 
 
WX_COLLAPSIBLE_PANE::~WX_COLLAPSIBLE_PANE()
{
    if( m_sizer )
        m_sizer->SetContainingWindow( nullptr );
 
    // Not owned by wxWindow
    delete m_sizer;
}
 
 
void WX_COLLAPSIBLE_PANE::Collapse( bool aCollapse )
{
    if( IsCollapsed() == aCollapse )
        return;
 
    InvalidateBestSize();
 
    m_pane->Show( !aCollapse );
    m_header->SetCollapsed( aCollapse );
 
    SetSize( GetBestSize() );
}
 
 
bool WX_COLLAPSIBLE_PANE::IsCollapsed() const
{
    return !m_pane || !m_pane->IsShown();
}
 
 
void WX_COLLAPSIBLE_PANE::SetLabel( const wxString& aLabel )
{
    m_header->SetLabel( aLabel );
    m_header->SetInitialSize();
 
    Layout();
}
 
 
bool WX_COLLAPSIBLE_PANE::SetBackgroundColour( const wxColour& aColor )
{
    m_header->SetBackgroundColour( aColor );
    return wxWindow::SetBackgroundColour( aColor );
}
 
 
bool WX_COLLAPSIBLE_PANE::InformFirstDirection( int aDirection, int aSize, int aAvailableOtherDir )
{
    wxWindow* const pane = GetPane();
 
    if( !pane )
        return false;
 
    if( !pane->InformFirstDirection( aDirection, aSize, aAvailableOtherDir ) )
        return false;
 
    InvalidateBestSize();
 
    return true;
}
 
 
wxSize WX_COLLAPSIBLE_PANE::DoGetBestClientSize() const
{
    wxSize size = m_sizer->GetMinSize();
 
    if( IsExpanded() )
    {
        wxSize paneSize = m_pane->GetBestSize();
 
        size.SetWidth( std::max( size.GetWidth(), paneSize.x ) );
        size.SetHeight( size.y + GetMargin() + GetMargin() + paneSize.y );
    }
 
    return size;
}
 
 
bool WX_COLLAPSIBLE_PANE::Layout()
{
    if( !m_sizer || !m_pane || !m_header )
        return false;
 
    wxSize size( GetSize() );
 
    m_sizer->SetDimension( 0, 0, size.x, m_sizer->GetMinSize().y );
    m_sizer->Layout();
 
    if( IsExpanded() )
    {
        int yoffset = m_sizer->GetSize().y + GetMargin();
        m_pane->SetSize( GetMargin(), yoffset, size.x - ( GetMargin() * 2 ), size.y - ( GetMargin() + yoffset ) );
        m_pane->Layout();
    }
 
    return true;
}
 
 
int WX_COLLAPSIBLE_PANE::GetMargin() const
{
#if defined( __WXMSW__ )
    wxASSERT( m_header );
    return m_header->ConvertDialogToPixels( wxSize( 2, 0 ) ).x;
#else
    return 3;
#endif
}
 
 
void WX_COLLAPSIBLE_PANE::onSize( wxSizeEvent& aEvent )
{
    Layout();
    aEvent.Skip();
}
 
 
void WX_COLLAPSIBLE_PANE::onHeaderClicked( wxCommandEvent& aEvent )
{
    if( aEvent.GetEventObject() != m_header )
    {
        aEvent.Skip();
        return;
    }
 
    Collapse( !IsCollapsed() );
 
    wxCommandEvent evt( WX_COLLAPSIBLE_PANE_CHANGED, GetId() );
    evt.SetEventObject( this );
    ProcessEvent( evt );
}
 
 
// WX_COLLAPSIBLE_PANE_HEADER implementation
 
 
WX_COLLAPSIBLE_PANE_HEADER::WX_COLLAPSIBLE_PANE_HEADER( WX_COLLAPSIBLE_PANE* aParent, wxWindowID aId,
                                                        const wxString& aLabel ) :
        m_parent( aParent )
{
    init();
 
    Create( aParent, aId, aLabel );
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::init()
{
    m_collapsed = true;
    m_inWindow  = false;
}
 
 
bool WX_COLLAPSIBLE_PANE_HEADER::Create( wxWindow* aParent, wxWindowID aId, const wxString& aLabel )
{
    if( !wxControl::Create( aParent, aId, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE, wxDefaultValidator,
                            wxT( "COLLAPSIBLE_PANE_HEADER" ) ) )
    {
        return false;
    }
 
    SetLabel( aLabel );
 
    Bind( wxEVT_PAINT, &WX_COLLAPSIBLE_PANE_HEADER::onPaint, this );
    Bind( wxEVT_SET_FOCUS, &WX_COLLAPSIBLE_PANE_HEADER::onFocus, this );
    Bind( wxEVT_KILL_FOCUS, &WX_COLLAPSIBLE_PANE_HEADER::onFocus, this );
    Bind( wxEVT_ENTER_WINDOW, &WX_COLLAPSIBLE_PANE_HEADER::onEnterWindow, this);
    Bind( wxEVT_LEAVE_WINDOW, &WX_COLLAPSIBLE_PANE_HEADER::onLeaveWindow, this);
    Bind( wxEVT_LEFT_UP, &WX_COLLAPSIBLE_PANE_HEADER::onLeftUp, this );
    Bind( wxEVT_CHAR, &WX_COLLAPSIBLE_PANE_HEADER::onChar, this );
 
    return true;
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::SetCollapsed( bool aCollapsed )
{
    m_collapsed = aCollapsed;
    Refresh();
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::doSetCollapsed( bool aCollapsed )
{
    SetCollapsed( aCollapsed );
 
    wxCommandEvent evt( WX_COLLAPSIBLE_PANE_HEADER_CHANGED, GetId() );
    evt.SetEventObject( this );
    ProcessEvent( evt );
}
 
 
wxSize WX_COLLAPSIBLE_PANE_HEADER::DoGetBestClientSize() const
{
    WX_COLLAPSIBLE_PANE_HEADER* self = const_cast<WX_COLLAPSIBLE_PANE_HEADER*>( this );
 
    // The code here parallels that of OnPaint() -- except without drawing.
    wxClientDC dc( self );
    wxString   text;
 
    wxControl::FindAccelIndex( GetLabel(), &text );
 
    wxSize size = dc.GetTextExtent( text );
 
    // Reserve space for arrow (which is a square the height of the text)
    size.x += size.GetHeight() + m_parent->GetMargin() * 2;
    size.y += m_parent->GetMargin() * 2;
 
#ifdef __WXMSW__
    size.IncBy( GetSystemMetrics( SM_CXFOCUSBORDER ), GetSystemMetrics( SM_CYFOCUSBORDER ) );
#endif // __WXMSW__
 
    return size;
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onPaint( wxPaintEvent& aEvent )
{
    wxPaintDC dc( this );
    wxRect    rect( wxPoint( 0, 0 ), GetClientSize() );
 
#ifdef __WXMSW__
    wxBrush brush = dc.GetBrush();
    brush.SetColour( GetParent()->GetBackgroundColour() );
    dc.SetBrush( brush );
    dc.SetPen( *wxTRANSPARENT_PEN );
    dc.DrawRectangle( rect );
#endif
 
    // Make the background look like an AUI toolbar button when the pointer is over it
    if( m_inWindow )
    {
        bool    darkMode       = KIPLATFORM::UI::IsDarkTheme();
        wxColor highlightColor = wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT );
 
        dc.SetPen( wxPen( highlightColor ) );
        dc.SetBrush( wxBrush( highlightColor.ChangeLightness( darkMode ? 40 : 170 ) ) );
        dc.DrawRectangle( rect );
    }
 
    wxString text;
    int      indexAccel = wxControl::FindAccelIndex( GetLabel(), &text );
 
    // Compute all the sizes
    wxSize  textSize = dc.GetTextExtent( text );
    wxRect  arrowRect( 0, 0, textSize.GetHeight(), textSize.GetHeight() );
    wxRect  textRect( arrowRect.GetRight() + m_parent->GetMargin(), 0, textSize.GetWidth(), textSize.GetHeight() );
 
    arrowRect = arrowRect.CenterIn( rect, wxVERTICAL );
    textRect = textRect.CenterIn( rect, wxVERTICAL );
 
    // Find out if the window we are in is active or not
    bool              isActive = true;
    wxTopLevelWindow* tlw      = dynamic_cast<wxTopLevelWindow*>( wxGetTopLevelParent( this ) );
 
    if( tlw && !tlw->IsActive() )
        isActive = false;
 
    // Draw the arrow
    drawArrow( dc, arrowRect, isActive );
 
    // We are responsible for showing the text as disabled when the window isn't active
    wxColour clr = isActive ? wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT )
                            : wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT );
 
    dc.SetTextForeground( clr );
    dc.DrawLabel( text, textRect, wxALIGN_CENTER_VERTICAL, indexAccel );
 
#ifdef __WXMSW__
    int flags = 0;
 
    if( m_inWindow )
        flags |= wxCONTROL_CURRENT;
 
    int focusSize = GetSystemMetrics( SM_CXFOCUSBORDER );
 
    if( HasFocus() )
        wxRendererNative::Get().DrawFocusRect( this, dc, textRect.Inflate( focusSize ), flags );
#endif
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onFocus( wxFocusEvent& aEvent )
{
    Refresh();
    aEvent.Skip();
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onEnterWindow( wxMouseEvent& aEvent )
{
    m_inWindow = true;
    Refresh();
    aEvent.Skip();
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onLeaveWindow( wxMouseEvent& aEvent )
{
    m_inWindow = false;
    Refresh();
    aEvent.Skip();
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onLeftUp( wxMouseEvent& aEvent )
{
    doSetCollapsed( !m_collapsed );
    aEvent.Skip();
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::onChar( wxKeyEvent& aEvent )
{
    switch( aEvent.GetKeyCode() )
    {
    case WXK_SPACE:
    case WXK_RETURN:
    case WXK_NUMPAD_ENTER:
        doSetCollapsed( !m_collapsed );
        break;
 
    default:
        aEvent.Skip();
        break;
    }
}
 
 
void WX_COLLAPSIBLE_PANE_HEADER::drawArrow( wxDC& aDC, wxRect aRect, bool aIsActive )
{
    // The bottom corner of the triangle is located halfway across the area and 3/4 down from
    // the top
    wxPoint btmCorner( aRect.GetLeft() + aRect.GetWidth() / 2, aRect.GetTop() + 3 * aRect.GetHeight() / 4 );
 
    // The right corner of the triangle is located halfway down from the top and 3/4 across the area
    wxPoint rtCorner( aRect.GetLeft() + 3 * aRect.GetWidth() / 4, aRect.GetTop() + aRect.GetHeight() / 2 );
 
    // Choose the other corner depending on if the panel is expanded or collapsed
    wxPoint otherCorner( 0, 0 );
 
    if( m_collapsed )
        otherCorner = wxPoint( aRect.GetLeft() + aRect.GetWidth() / 2, aRect.GetTop() + aRect.GetHeight() / 4 );
    else
        otherCorner = wxPoint( aRect.GetLeft() + aRect.GetWidth() / 4,  aRect.GetTop() + aRect.GetHeight() / 2 );
 
    // Because it looks better
    if( !m_collapsed )
    {
        btmCorner.y -= 1;
        rtCorner.y -= 1;
        otherCorner.y -= 1;
    }
 
    // Choose the color to draw the triangle
    wxColour clr = aIsActive ? wxSystemSettings::GetColour( wxSYS_COLOUR_HOTLIGHT )
                             : wxSystemSettings::GetColour( wxSYS_COLOUR_GRAYTEXT );
 
    // Must set both the pen (for the outline) and the brush (for the polygon fill)
    aDC.SetPen( wxPen( clr ) );
    aDC.SetBrush( wxBrush( clr ) );
 
    // Draw the triangle
    wxPointList points;
    points.Append( &btmCorner );
    points.Append( &rtCorner );
    points.Append( &otherCorner );
 
    aDC.DrawPolygon( &points );
}