sch_sheet.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * 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 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 SCH_SHEEET_H
#define SCH_SHEEET_H
 
#include <sch_field.h>
 
class KIID_PATH;
class SCH_SCREEN;
class SCH_IO_KICAD_SEXPR_PARSER;
class SCH_SHEET_LIST;
class SCH_SHEET_PIN;
class SCH_SHEET_PATH;
class EDA_DRAW_FRAME;
 
 
#define MIN_SHEET_WIDTH  500    // Units are mils.
#define MIN_SHEET_HEIGHT 150    // Units are mils.
 
 
class SCH_SHEET : public SCH_ITEM
{
public:
    SCH_SHEET( EDA_ITEM* aParent = nullptr, const VECTOR2I& aPos = VECTOR2I( 0, 0 ),
               VECTOR2I aSize = VECTOR2I( schIUScale.MilsToIU( MIN_SHEET_WIDTH ),
                                          schIUScale.MilsToIU( MIN_SHEET_HEIGHT ) ) );
 
    SCH_SHEET( const SCH_SHEET& aSheet );
 
    ~SCH_SHEET();
 
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && SCH_SHEET_T == aItem->Type();
    }
 
    wxString GetClass() const override
    {
        return wxT( "SCH_SHEET" );
    }
 
    bool IsMovableFromAnchorPoint() const override { return false; }
 
    std::vector<SCH_FIELD>& GetFields() { return m_fields; }
    const std::vector<SCH_FIELD>& GetFields() const { return m_fields; }
 
    SCH_FIELD* GetField( FIELD_T aFieldType );
    const SCH_FIELD* GetField( FIELD_T aFieldNdx ) const;
 
    int GetNextFieldOrdinal() const;
 
    void SetFields( const std::vector<SCH_FIELD>& aFields );
 
    wxString GetShownName( bool aAllowExtraText ) const
    {
        return GetField( FIELD_T::SHEET_NAME )->GetShownText( aAllowExtraText );
    }
    wxString GetName() const { return GetField( FIELD_T::SHEET_NAME )->GetText(); }
    void SetName( const wxString& aName ) { GetField( FIELD_T::SHEET_NAME )->SetText( aName ); }
 
    SCH_SCREEN* GetScreen() const { return m_screen; }
 
    VECTOR2I GetSize() const { return m_size; }
    void     SetSize( const VECTOR2I& aSize ) { m_size = aSize; }
 
    int GetBorderWidth() const { return m_borderWidth; }
    void SetBorderWidth( int aWidth ) { m_borderWidth = aWidth; }
 
    KIGFX::COLOR4D GetBorderColor() const { return m_borderColor; }
    void SetBorderColor( KIGFX::COLOR4D aColor ) { m_borderColor = aColor; }
 
    KIGFX::COLOR4D GetBackgroundColor() const { return m_backgroundColor; }
    void SetBackgroundColor( KIGFX::COLOR4D aColor ) { m_backgroundColor = aColor; }
 
    bool IsRootSheet() const;
 
    void SetScreen( SCH_SCREEN* aScreen );
 
    int GetScreenCount() const;
 
    void GetContextualTextVars( wxArrayString* aVars ) const;
 
    bool ResolveTextVar( const SCH_SHEET_PATH* aPath, wxString* token, int aDepth = 0 ) const;
 
    void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;
 
    /* there is no member for orientation in sch_sheet, to preserve file
     * format, we detect orientation based on pin edges
     */
    bool IsVerticalOrientation() const;
 
    void SetPositionIgnoringPins( const VECTOR2I& aPosition );
 
    void AddPin( SCH_SHEET_PIN* aSheetPin );
 
    std::vector<SCH_SHEET_PIN*>& GetPins() { return m_pins; }
    const std::vector<SCH_SHEET_PIN*>& GetPins() const { return m_pins; }
 
    void RemovePin( const SCH_SHEET_PIN* aSheetPin );
 
    void CleanupSheet();
 
    SCH_SHEET_PIN* GetPin( const VECTOR2I& aPosition );
 
    bool HasPin( const wxString& aName ) const;
 
    bool HasPins() const { return !m_pins.empty(); }
 
    bool HasUndefinedPins() const;
 
    int GetMinWidth( bool aFromLeft ) const;
 
    int GetMinHeight( bool aFromTop ) const;
 
    int GetPenWidth() const override;
 
    const BOX2I GetBodyBoundingBox() const;
 
    const BOX2I GetBoundingBox() const override;
 
    VECTOR2I GetRotationCenter() const;
 
    void swapData( SCH_ITEM* aItem ) override;
 
    int SymbolCount() const;
 
    bool SearchHierarchy( const wxString& aFilename, SCH_SCREEN** aScreen );
 
    bool LocatePathOfScreen( SCH_SCREEN* aScreen, SCH_SHEET_PATH* aList );
 
    int CountSheets() const;
 
    int CountSheets( const wxString& aFileName ) const;
 
    wxString GetFileName() const
    {
        return GetField( FIELD_T::SHEET_FILENAME )->GetText();
    }
 
    // Set a new filename without changing anything else
    void SetFileName( const wxString& aFilename )
    {
        // Filenames are stored using unix notation
        wxString tmp = aFilename;
        tmp.Replace( wxT( "\\" ), wxT( "/" ) );
        GetField( FIELD_T::SHEET_FILENAME )->SetText( tmp );
    }
 
    // Geometric transforms (used in block operations):
 
    void Move( const VECTOR2I& aMoveVector ) override;
    void MirrorHorizontally( int aCenter ) override;
    void MirrorVertically( int aCenter ) override;
    void Rotate( const VECTOR2I& aCenter, bool aRotateCCW ) override;
 
    bool Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const override;
 
    bool IsReplaceable() const override { return true; }
 
    void Resize( const VECTOR2I& aSize );
 
    void AutoplaceFields( SCH_SCREEN* aScreen, AUTOPLACE_ALGO aAlgo ) override;
 
    void GetEndPoints( std::vector <DANGLING_END_ITEM>& aItemList ) override;
 
    bool UpdateDanglingState( std::vector<DANGLING_END_ITEM>& aItemListByType,
                              std::vector<DANGLING_END_ITEM>& aItemListByPos,
                              const SCH_SHEET_PATH*           aPath = nullptr ) override;
 
    bool IsConnectable() const override { return true; }
 
    bool HasConnectivityChanges( const SCH_ITEM* aItem,
                                 const SCH_SHEET_PATH* aInstance = nullptr ) const override;
 
    bool CanConnect( const SCH_ITEM* aItem ) const override
    {
        return ( aItem->Type() == SCH_LINE_T && aItem->GetLayer() == LAYER_WIRE )
                || ( aItem->Type() == SCH_LINE_T && aItem->GetLayer() == LAYER_BUS )
                || ( aItem->Type() == SCH_NO_CONNECT_T )
                || ( aItem->Type() == SCH_SYMBOL_T );
    }
 
    std::vector<VECTOR2I> GetConnectionPoints() const override;
 
    INSPECT_RESULT Visit( INSPECTOR inspector, void* testData,
                          const std::vector<KICAD_T>& aScanTypes ) override;
 
    void RunOnChildren( const std::function<void( SCH_ITEM* )>& aFunction, RECURSE_MODE aMode ) override;
 
    void SetExcludedFromSim( bool aExcludeFromSim ) override { m_excludedFromSim = aExcludeFromSim; }
    bool GetExcludedFromSim() const override { return m_excludedFromSim; }
 
    void SetExcludedFromBOM( bool aExcludeFromBOM ) { m_excludedFromBOM = aExcludeFromBOM; }
    bool GetExcludedFromBOM() const { return m_excludedFromBOM; }
 
    void SetExcludedFromBoard( bool aExcludeFromBoard ) { m_excludedFromBoard = aExcludeFromBoard; }
    bool GetExcludedFromBoard() const { return m_excludedFromBoard; }
 
    bool GetDNP() const { return m_DNP; }
    void SetDNP( bool aDNP ) { m_DNP = aDNP; }
 
    wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const override;
 
    BITMAPS GetMenuImage() const override;
 
    SCH_SHEET& operator=( const SCH_ITEM& aSheet );
 
    bool operator <( const SCH_ITEM& aItem ) const override;
 
    std::vector<int> ViewGetLayers() const override;
 
    VECTOR2I GetPosition() const override { return m_pos; }
    void     SetPosition( const VECTOR2I& aPosition ) override;
 
    bool HitTest( const VECTOR2I& aPosition, int aAccuracy ) const override;
    bool HitTest( const BOX2I& aRect, bool aContained, int aAccuracy = 0 ) const override;
 
    void Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
               int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed ) override;
 
    EDA_ITEM* Clone() const override;
 
    const std::vector<SCH_SHEET_INSTANCE>& GetInstances() const { return m_instances; }
 
    bool HasRootInstance() const;
 
    const SCH_SHEET_INSTANCE& GetRootInstance() const;
 
    void RemoveInstance( const KIID_PATH& aInstancePath );
 
    void AddInstance( const SCH_SHEET_INSTANCE& aInstance );
 
    bool HasPageNumberChanges( const SCH_SHEET& aOther ) const;
 
    static int ComparePageNum( const wxString& aPageNumberA, const wxString& aPageNumberB );
 
    double Similarity( const SCH_ITEM& aOther ) const override;
 
    bool operator==( const SCH_ITEM& aOther ) const override;
 
#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const override;
#endif
 
protected:
    friend SCH_SHEET_PATH;
    friend SCH_IO_KICAD_SEXPR_PARSER;
 
    void setInstances( const std::vector<SCH_SHEET_INSTANCE>& aInstances )
    {
        m_instances = aInstances;
    }
 
    bool addInstance( const KIID_PATH& aInstance );
 
    wxString getPageNumber( const KIID_PATH& aInstance ) const;
 
    void setPageNumber( const KIID_PATH& aInstance, const wxString& aPageNumber );
 
    bool getInstance( SCH_SHEET_INSTANCE& aInstance, const KIID_PATH& aSheetPath,
                      bool aTestFromEnd = false ) const;
 
    void renumberPins();
 
    SCH_SHEET_PATH findSelf() const;
 
private:
    bool doIsConnected( const VECTOR2I& aPosition ) const override;
 
    friend class SCH_SHEET_PIN;
    friend class SCH_SHEET_LIST;
 
private:
    SCH_SCREEN*                 m_screen;       // Screen that contains the physical data for the
                                                // sheet.  In complex hierarchies multiple sheets
                                                // can share a common screen.
 
    std::vector<SCH_SHEET_PIN*> m_pins;         // The list of sheet connection points.
    std::vector<SCH_FIELD>      m_fields;
 
    bool                        m_excludedFromSim;
    bool                        m_excludedFromBOM;
    bool                        m_excludedFromBoard;
    bool                        m_DNP;
 
    VECTOR2I                    m_pos;          // The position of the sheet.
    VECTOR2I                    m_size;         // The size of the sheet.
    int                         m_borderWidth;
    KIGFX::COLOR4D              m_borderColor;
    KIGFX::COLOR4D              m_backgroundColor;
 
    std::vector<SCH_SHEET_INSTANCE> m_instances;
};
 
 
#endif // SCH_SHEEET_H