kicad/eeschema/cmp_tree_model_adapter.cpp

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2017 Chris Pavlina <pavlina.chris@gmail.com>
 * Copyright (C) 2014 Henner Zeller <h.zeller@acm.org>
 * Copyright (C) 2014-2017 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 <http://www.gnu.org/licenses/>.
 */

#include <cmp_tree_model_adapter.h>

#include <eda_pattern_match.h>
#include <wx/tokenzr.h>
#include <symbol_lib_table.h>


CMP_TREE_MODEL_ADAPTER::WIDTH_CACHE CMP_TREE_MODEL_ADAPTER::m_width_cache;


static const int kDataViewIndent = 20;


/**
 * Convert CMP_TREE_NODE -> wxDataViewItem
 */
static wxDataViewItem ToItem( CMP_TREE_NODE const* aNode )
{
    return wxDataViewItem( const_cast<void*>( static_cast<void const*>( aNode ) ) );
}


/**
 * Convert wxDataViewItem -> CMP_TREE_NODE
 */
static CMP_TREE_NODE const* ToNode( wxDataViewItem aItem )
{
    return static_cast<CMP_TREE_NODE const*>( aItem.GetID() );
}


/**
 * Convert CMP_TREE_NODE's children to wxDataViewItemArray
 */
static unsigned int IntoArray( CMP_TREE_NODE const& aNode, wxDataViewItemArray& aChildren )
{
    unsigned int n = 0;

    for( auto const& child: aNode.Children )
    {
        if( child->Score > 0 )
        {
            aChildren.Add( ToItem( &*child ) );
            ++n;
        }
    }

    return n;
}


CMP_TREE_MODEL_ADAPTER::PTR CMP_TREE_MODEL_ADAPTER::Create( SYMBOL_LIB_TABLE* aLibs )
{
    auto adapter = new CMP_TREE_MODEL_ADAPTER( aLibs );
    auto container = CMP_TREE_MODEL_ADAPTER::PTR( adapter );
    return container;
}


CMP_TREE_MODEL_ADAPTER::CMP_TREE_MODEL_ADAPTER( SYMBOL_LIB_TABLE* aLibs )
    :m_filter( CMP_FILTER_NONE ),
     m_show_units( true ),
     m_libs( aLibs ),
     m_preselect_unit( 0 ),
     m_col_part( nullptr ),
     m_col_desc( nullptr ),
     m_widget( nullptr )
{}


CMP_TREE_MODEL_ADAPTER::~CMP_TREE_MODEL_ADAPTER()
{}


void CMP_TREE_MODEL_ADAPTER::SetFilter( CMP_FILTER_TYPE aFilter )
{
    m_filter = aFilter;
}


void CMP_TREE_MODEL_ADAPTER::ShowUnits( bool aShow )
{
    m_show_units = aShow;
}


void CMP_TREE_MODEL_ADAPTER::SetPreselectNode( LIB_ID const& aLibId, int aUnit )
{
    m_preselect_lib_id = aLibId;
    m_preselect_unit = aUnit;
}


void CMP_TREE_MODEL_ADAPTER::AddLibrary( wxString const& aLibNickname )
{
    bool onlyPowerSymbols = ( m_filter == CMP_FILTER_POWER );

    wxArrayString aliases;

    try
    {
        m_libs->EnumerateSymbolLib( aLibNickname, aliases, onlyPowerSymbols );
    }
    catch( const IO_ERROR& ioe )
    {
        wxLogError( wxString::Format( _( "Error occurred loading symbol  library %s."
                                         "\n\n%s" ), aLibNickname, ioe.What() ) );
        return;
    }

    AddAliasList( aLibNickname, aliases );

    m_tree.AssignIntrinsicRanks();
}


void CMP_TREE_MODEL_ADAPTER::AddAliasList(
            wxString const&         aNodeName,
            wxArrayString const&    aAliasNameList )
{
    std::vector<LIB_ALIAS*> alias_list;

    for( const wxString& name: aAliasNameList )
    {
        LIB_ALIAS* a = nullptr;

        try
        {
            a = m_libs->LoadSymbol( aNodeName, name );
        }
        catch( const IO_ERROR& ioe )
        {
            wxLogError( wxString::Format( _( "Error occurred loading symbol %s from library %s."
                                             "\n\n%s" ), name, aNodeName, ioe.What() ) );
            continue;
        }

        if( a )
            alias_list.push_back( a );
    }

    AddAliasList( aNodeName, alias_list );
}


void CMP_TREE_MODEL_ADAPTER::AddAliasList(
            wxString const&         aNodeName,
            std::vector<LIB_ALIAS*> const&  aAliasList )
{
    auto& lib_node = m_tree.AddLib( aNodeName );

    for( auto a: aAliasList )
    {
        lib_node.AddAlias( a );
    }

    lib_node.AssignIntrinsicRanks();
    m_tree.AssignIntrinsicRanks();
}


void CMP_TREE_MODEL_ADAPTER::UpdateSearchString( wxString const& aSearch )
{
    m_tree.ResetScore();

    wxStringTokenizer tokenizer( aSearch );

    while( tokenizer.HasMoreTokens() )
    {
        const wxString term = tokenizer.GetNextToken().Lower();
        EDA_COMBINED_MATCHER matcher( term );

        m_tree.UpdateScore( matcher );
    }

    m_tree.SortNodes();
    Cleared();
    AttachTo( m_widget );

    ShowResults() || ShowPreselect() || ShowSingleLibrary();
}


void CMP_TREE_MODEL_ADAPTER::AttachTo( wxDataViewCtrl* aDataViewCtrl )
{
    m_widget = aDataViewCtrl;
    aDataViewCtrl->Freeze();
    aDataViewCtrl->SetIndent( kDataViewIndent );
    aDataViewCtrl->AssociateModel( this );
    aDataViewCtrl->ClearColumns();

    wxString part_head = _( "Part" );
    wxString desc_head = _( "Desc" );

    m_col_part = aDataViewCtrl->AppendTextColumn( part_head, 0, wxDATAVIEW_CELL_INERT,
                ColWidth( m_tree, 0, part_head ) );
    m_col_desc = aDataViewCtrl->AppendTextColumn( desc_head, 1, wxDATAVIEW_CELL_INERT,
                ColWidth( m_tree, 1, desc_head ) );
    aDataViewCtrl->Thaw();
}


LIB_ID CMP_TREE_MODEL_ADAPTER::GetAliasFor( wxDataViewItem aSelection ) const
{
    auto node = ToNode( aSelection );

    LIB_ID emptyId;

    if( !node )
        return emptyId;

    return node->LibId;
}


int CMP_TREE_MODEL_ADAPTER::GetUnitFor( wxDataViewItem aSelection ) const
{
    auto node = ToNode( aSelection );
    return node ? node->Unit : 0;
}


int CMP_TREE_MODEL_ADAPTER::GetComponentsCount() const
{
    int n = 0;

    for( auto& lib: m_tree.Children )
    {
        for( auto& alias: lib->Children )
        {
            (void) alias;
            ++n;
        }
    }

    return n;
}


bool CMP_TREE_MODEL_ADAPTER::HasContainerColumns( wxDataViewItem const& aItem ) const
{
    return IsContainer( aItem );
}


bool CMP_TREE_MODEL_ADAPTER::IsContainer( wxDataViewItem const& aItem ) const
{
    auto node = ToNode( aItem );
    return node ? node->Children.size() : true;
}


wxDataViewItem CMP_TREE_MODEL_ADAPTER::GetParent( wxDataViewItem const& aItem ) const
{
    auto node = ToNode( aItem );
    auto parent = node ? node->Parent : nullptr;

    // wxDataViewModel has no root node, but rather top-level elements have
    // an invalid (null) parent.
    if( !node || !parent || parent->Type == CMP_TREE_NODE::TYPE::ROOT )
    {
        return ToItem( nullptr );
    }
    else
    {
        return ToItem( parent );
    }
}


unsigned int CMP_TREE_MODEL_ADAPTER::GetChildren(
            wxDataViewItem const&   aItem,
            wxDataViewItemArray&    aChildren ) const
{
    auto node = ( aItem.IsOk() ? ToNode( aItem ) : &m_tree );

    if( node->Type != CMP_TREE_NODE::TYPE::LIBID || m_show_units )
        return IntoArray( *node, aChildren );
    else
        return 0;
}


void CMP_TREE_MODEL_ADAPTER::GetValue(
            wxVariant&              aVariant,
            wxDataViewItem const&   aItem,
            unsigned int            aCol ) const
{
    auto node = ToNode( aItem );
    wxASSERT( node );

    switch( aCol )
    {
    case 0:
        aVariant = node->Name;
        break;
    case 1:
        aVariant = node->Desc;
        break;
    default:
        wxFAIL_MSG( "Invalid column ID!" );
    }
}


bool CMP_TREE_MODEL_ADAPTER::GetAttr(
            wxDataViewItem const&   aItem,
            unsigned int            aCol,
            wxDataViewItemAttr&     aAttr ) const
{
    auto node = ToNode( aItem );
    wxASSERT( node );

    if( node->Type != CMP_TREE_NODE::LIBID )
    {
        // Currently only aliases are formatted at all
        return false;
    }

    if( !node->IsRoot && aCol == 0 )
    {
        // Names of non-root aliases are italicized
        aAttr.SetItalic( true );
        return true;
    }
    else
    {
        return false;
    }
}


int CMP_TREE_MODEL_ADAPTER::ColWidth( CMP_TREE_NODE& aTree, int aCol, wxString const& aHeading )
{
    const int indent = aCol ? 0 : kDataViewIndent;

    int min_width = WidthFor( aHeading, aCol );
    int width = std::max( aTree.Score > 0 ? WidthFor( aTree, aCol ) : 0, min_width );

    if( aTree.Score > 0 )
    {
        for( auto& node: aTree.Children )
        {
            width = std::max( width, ColWidth( *node, aCol, aHeading ) + indent );
        }
    }

    return width;
}


int CMP_TREE_MODEL_ADAPTER::WidthFor( CMP_TREE_NODE& aNode, int aCol )
{
    auto result = m_width_cache.find( aNode.Name );

    if( result != m_width_cache.end() )
    {
        return result->second[aCol];
    }
    else
    {
        int wname = m_widget->GetTextExtent( aNode.Name ).x + kDataViewIndent;
        int wdesc = m_widget->GetTextExtent( aNode.Desc ).x;

        auto& val = m_width_cache[aNode.Name];
        val.push_back( wname );
        val.push_back( wdesc );
        return val[aCol];
    }
}


int CMP_TREE_MODEL_ADAPTER::WidthFor( wxString const& aHeading, int aCol )
{
    static std::vector<int> widths;

    for( int i = (int) widths.size(); i <= aCol; ++i )
    {
        widths.push_back( 0 );
    }

    if( widths[aCol] == 0 )
    {
        widths[aCol] = m_widget->GetTextExtent( aHeading ).x;
    }

    return widths[aCol];
}


bool CMP_TREE_MODEL_ADAPTER::FindAndExpand(
        CMP_TREE_NODE& aNode,
        std::function<bool( CMP_TREE_NODE const* )> aFunc )
{
    for( auto& node: aNode.Children )
    {
        if( aFunc( &*node ) )
        {
            auto item = wxDataViewItem(
                    const_cast<void*>( static_cast<void const*>( &*node ) ) );
            m_widget->ExpandAncestors( item );
            m_widget->EnsureVisible( item );
            m_widget->Select( item );
            return true;
        }
        else if( FindAndExpand( *node, aFunc ) )
        {
            return true;
        }
    }

    return false;
}


bool CMP_TREE_MODEL_ADAPTER::ShowResults()
{
    return FindAndExpand( m_tree,
            []( CMP_TREE_NODE const* n )
            {
                return n->Type == CMP_TREE_NODE::TYPE::LIBID && n->Score > 1;
            } );
}


bool CMP_TREE_MODEL_ADAPTER::ShowPreselect()
{
    if( !m_preselect_lib_id.IsValid() )
        return false;

    return FindAndExpand( m_tree,
            [&]( CMP_TREE_NODE const* n )
            {
                if( n->Type == CMP_TREE_NODE::LIBID && ( n->Children.empty() || !m_preselect_unit ) )
                    return m_preselect_lib_id == n->LibId;
                else if( n->Type == CMP_TREE_NODE::UNIT && m_preselect_unit )
                    return m_preselect_lib_id == n->Parent->LibId && m_preselect_unit == n->Unit;
                else
                    return false;
            } );
}


bool CMP_TREE_MODEL_ADAPTER::ShowSingleLibrary()
{
    return FindAndExpand( m_tree,
            []( CMP_TREE_NODE const* n )
            {
                return n->Type == CMP_TREE_NODE::TYPE::LIBID &&
                       n->Parent->Parent->Children.size() == 1;
            } );
}