sch_view.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2018 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Tomasz Wlostowski <[email protected]>
 * @author Maciej Suminski <[email protected]>
 *
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
#include <core/typeinfo.h>
#include <memory>
#include <view/view.h>
#include <view/view_rtree.h>
#include <view/wx_view_controls.h>
#include <drawing_sheet/ds_proxy_view_item.h>
#include <tool/tool_manager.h>
#include <layer_ids.h>
#include <sch_screen.h>
#include <schematic.h>
#include <schematic_text_var_adapter.h>
#include <text_var_dependency.h>
#include <sch_base_frame.h>
#include <sch_edit_frame.h>
#include <string_utils.h>
 
#include "sch_view.h"
 
 
namespace KIGFX {
 
 
SCH_VIEW::SCH_VIEW( SCH_BASE_FRAME* aFrame ) :
    VIEW()
{
    m_frame = aFrame;
}
 
 
SCH_VIEW::~SCH_VIEW()
{
    DetachTextVarTracker();
}
 
 
void SCH_VIEW::DetachTextVarTracker()
{
    if( m_drawingSheet )
        m_drawingSheet->AttachToTracker( nullptr );
 
    if( m_textVarListenerTracker && m_textVarListenerHandle != TEXT_VAR_TRACKER::INVALID_LISTENER )
    {
        m_textVarListenerTracker->RemoveInvalidateListener( m_textVarListenerHandle );
        m_textVarListenerHandle = TEXT_VAR_TRACKER::INVALID_LISTENER;
        m_textVarListenerTracker = nullptr;
    }
}
 
 
void SCH_VIEW::Update( const KIGFX::VIEW_ITEM* aItem, int aUpdateFlags ) const
{
    if( aItem->IsSCH_ITEM() )
    {
        // The equivalent function in PCB_VIEW doesn't need to do this, but
        // that's only because RunOnChildren's constness is misleading in the PCB editor;
        // it doesn't modify target item, but our uses of it modify its children.
        SCH_ITEM* schItem = const_cast<SCH_ITEM*>( static_cast<const SCH_ITEM*>( aItem ) );
 
        if( schItem->Type() == SCH_TABLECELL_T )
        {
            VIEW::Update( schItem->GetParent() );
        }
        else
        {
            schItem->RunOnChildren(
                    [this, aUpdateFlags]( SCH_ITEM* child )
                    {
                        VIEW::Update( child, aUpdateFlags );
                    },
                    RECURSE_MODE::RECURSE );
        }
    }
 
    VIEW::Update( aItem, aUpdateFlags );
}
 
 
void SCH_VIEW::Update( const KIGFX::VIEW_ITEM* aItem ) const
{
    SCH_VIEW::Update( aItem, KIGFX::ALL );
}
 
 
void SCH_VIEW::Cleanup()
{
    Clear();
    m_drawingSheet.reset();
    m_preview.reset();
}
 
 
void SCH_VIEW::SetScale( double aScale, VECTOR2D aAnchor )
{
    VIEW::SetScale( aScale, aAnchor );
 
    // Redraw items whose rendering is dependent on zoom
    if( m_frame )
        m_frame->RefreshZoomDependentItems();
}
 
 
void SCH_VIEW::DisplaySheet( const SCH_SCREEN *aScreen )
{
    for( SCH_ITEM* item : aScreen->Items() )
        Add( item );
 
    m_drawingSheet.reset( new DS_PROXY_VIEW_ITEM( schIUScale, &aScreen->GetPageSettings(),
                                                  &aScreen->Schematic()->Project(),
                                                  &aScreen->GetTitleBlock(),
                                                  aScreen->Schematic()->GetProperties() ) );
    m_drawingSheet->SetColorLayer( LAYER_SCHEMATIC_DRAWINGSHEET );
    m_drawingSheet->SetPageBorderColorLayer( LAYER_SCHEMATIC_PAGE_LIMITS );
 
    if( m_frame && m_frame->IsType( FRAME_SCH ) )
    {
        SCH_EDIT_FRAME* editFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
 
        wxCHECK( editFrame, /* void */ );
 
        // The title block metadata (sheet name/path, first-page flag) is derived from the
        // current sheet, so the screen being displayed must be the current sheet's screen.
        wxCHECK( editFrame->GetCurrentSheet().LastScreen() == aScreen, /* void */ );
 
        syncDrawingSheetToCurrentSheet( editFrame );
    }
    else
    {
        m_drawingSheet->SetPageNumber( TO_UTF8( aScreen->GetPageNumber() ) );
        m_drawingSheet->SetSheetCount( aScreen->GetPageCount() );
        m_drawingSheet->SetFileName( TO_UTF8( aScreen->GetFileName() ) );
        m_drawingSheet->SetIsFirstPage( aScreen->GetVirtualPageNumber() == 1 );
        m_drawingSheet->SetSheetName( "" );
        m_drawingSheet->SetSheetPath( "" );
        m_drawingSheet->SetVariantName( "" );
        m_drawingSheet->SetVariantDesc( "" );
    }
 
    Add( m_drawingSheet.get() );
 
    // Reactive title-block repaint: register this proxy with the schematic's
    // text-var tracker. The listener that routes invalidations to VIEW::Update
    // is installed lazily here too; it outlives individual proxy instances
    // since it re-reads the current drawing sheet on every fire.
    if( aScreen->Schematic() )
    {
        if( SCHEMATIC_TEXT_VAR_ADAPTER* adapter = aScreen->Schematic()->GetTextVarAdapter() )
        {
            m_drawingSheet->AttachToTracker( &adapter->Tracker() );
 
            TEXT_VAR_TRACKER* tracker = &adapter->Tracker();
 
            if( m_textVarListenerTracker != tracker
                && m_textVarListenerHandle != TEXT_VAR_TRACKER::INVALID_LISTENER )
            {
                m_textVarListenerTracker->RemoveInvalidateListener( m_textVarListenerHandle );
                m_textVarListenerHandle = TEXT_VAR_TRACKER::INVALID_LISTENER;
                m_textVarListenerTracker = nullptr;
            }
 
            if( m_textVarListenerHandle == TEXT_VAR_TRACKER::INVALID_LISTENER )
            {
                m_textVarListenerTracker = tracker;
                m_textVarListenerHandle = tracker->AddInvalidateListener(
                        [this]( EDA_ITEM* aDep, const TEXT_VAR_REF_KEY& )
                        {
                            if( !aDep )
                                return;
 
                            if( m_drawingSheet && aDep == m_drawingSheet.get() )
                            {
                                RefreshDrawingSheetPageInfo();
                                return;
                            }
 
                            if( aDep->IsSCH_ITEM() )
                            {
                                if( SCH_TEXT* text = dynamic_cast<SCH_TEXT*>( aDep ) )
                                {
                                    text->ClearRenderCache();
                                    text->ClearBoundingBoxCache();
                                }
 
                                Update( aDep, KIGFX::GEOMETRY | KIGFX::REPAINT );
                            }
                        } );
            }
        }
    }
 
    InitPreview();
 
    // Allow tools to add anything they require to the view (such as the selection VIEW_GROUP)
    if( m_frame && m_frame->GetToolManager() )
        m_frame->GetToolManager()->ResetTools( TOOL_BASE::REDRAW );
}
 
 
void SCH_VIEW::syncDrawingSheetToCurrentSheet( SCH_EDIT_FRAME* aFrame )
{
    SCH_SCREEN* screen = aFrame->GetScreen();
 
    wxCHECK( screen, /* void */ );
 
    m_drawingSheet->SetPageNumber( TO_UTF8( screen->GetPageNumber() ) );
    m_drawingSheet->SetSheetCount( screen->GetPageCount() );
    m_drawingSheet->SetFileName( TO_UTF8( screen->GetFileName() ) );
 
    // Use the sheet path's virtual page number rather than the screen's, because the screen's
    // value can be stale after operations like save that temporarily overwrite all screen page
    // numbers for serialization.
    m_drawingSheet->SetIsFirstPage( aFrame->GetCurrentSheet().GetVirtualPageNumber() == 1 );
    m_drawingSheet->SetSheetName( TO_UTF8( aFrame->GetScreenDesc() ) );
    m_drawingSheet->SetSheetPath( TO_UTF8( aFrame->GetFullScreenDesc() ) );
 
    wxString currentVariant = aFrame->Schematic().GetCurrentVariant();
    wxString variantDesc = aFrame->Schematic().GetVariantDescription( currentVariant );
 
    m_drawingSheet->SetVariantName( TO_UTF8( currentVariant ) );
    m_drawingSheet->SetVariantDesc( TO_UTF8( variantDesc ) );
}
 
 
void SCH_VIEW::RefreshDrawingSheetPageInfo()
{
    if( !m_drawingSheet )
        return;
 
    if( m_frame && m_frame->IsType( FRAME_SCH ) )
    {
        SCH_EDIT_FRAME* editFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
 
        if( !editFrame )
            return;
 
        syncDrawingSheetToCurrentSheet( editFrame );
        Update( m_drawingSheet.get(), KIGFX::REPAINT );
    }
}
 
 
void SCH_VIEW::DisplaySymbol( LIB_SYMBOL* aSymbol )
{
    Clear();
 
    if( !aSymbol )
        return;
 
    // Draw the fields.
    for( SCH_ITEM& item : aSymbol->GetDrawItems() )
    {
        if( item.Type() == SCH_FIELD_T )
            Add( &item );
    }
 
    LIB_SYMBOL* drawnSymbol = aSymbol;
 
    // Draw the parent items if the symbol is inherited from another symbol.
    if( aSymbol->IsDerived() )
    {
        if( std::shared_ptr< LIB_SYMBOL > parent = aSymbol->GetRootSymbol() )
            drawnSymbol = parent.get();
        else
        {
            wxCHECK( false, /* void */ );
        }
    }
 
    for( SCH_ITEM& item : drawnSymbol->GetDrawItems() )
    {
        // Fields already drawn above.  (Besides, we don't want to show parent symbol fields as
        // users may be confused by shown fields that can not be edited.)
        if( item.Type() == SCH_FIELD_T )
            continue;
 
        Add( &item );
    }
 
    InitPreview();
}
 
 
void SCH_VIEW::ClearHiddenFlags()
{
    for( VIEW_ITEM* item : *m_allItems )
    {
        if( !item )
            continue;
 
        Hide( item, false );
    }
}
 
 
void SCH_VIEW::HideDrawingSheet()
{
    //    SetVisible( m_drawingSheet.get(), false );
}
 
 
}; // namespace KIGFX