collectors.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2007-2008 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef COLLECTORS_H
#define COLLECTORS_H
 
/*
 *  This module contains a number of COLLECTOR implementations which are used
 *  to augment the functionality of class PCB_EDIT_FRAME.
 */
 
#include <collector.h>
#include <layer_ids.h>              // LAYER_COUNT, layer defs
#include <lset.h>
#include <view/view.h>
#include <board_item.h>

 * should be collected (aside from HitTest()ing and KICAD_T scanTypes, which are provided to the
 * GENERAL_COLLECTOR through attributes or arguments separately).
 * <p>
 * A justification for this class is to keep the structural storage details of the program's
 * "configuration options" out of GENERAL_COLLECTOR::Inspect().  This class carries all the
 * necessary details with it into the Inspect() call. The constructors or other functions of this
 * class's derivatives are then the only place where knowledge of the specific structure of the
 * global preference storage is needed.  Thus, GENERAL_COLLECTOR::Inspect() can be kept as simple
 * as possible, and insulated from changes in global preference storage.
 * </p>
 * This class introduces the notion of layer locking.
 */
class COLLECTORS_GUIDE
{
public:
    virtual ~COLLECTORS_GUIDE() {}

    virtual bool IsLayerVisible( PCB_LAYER_ID layer ) const = 0;

    virtual PCB_LAYER_ID GetPreferredLayer() const = 0;

     * @return true if should ignore locked items, else false.
     */
    virtual bool IgnoreLockedItems() const = 0;

    virtual bool IncludeSecondary() const = 0;

    virtual bool IgnoreFPTextOnBack() const = 0;

    virtual bool IgnoreFPTextOnFront() const = 0;


    virtual bool IgnoreFootprintsOnBack() const = 0;


    virtual bool IgnoreFootprintsOnFront() const = 0;

    virtual bool IgnorePadsOnBack() const = 0;


     */
    virtual bool IgnorePadsOnFront() const = 0;

    virtual bool IgnoreThroughHolePads() const = 0;

    virtual bool IgnorePads() const
    {
        return IgnorePadsOnFront() && IgnorePadsOnBack() && IgnoreThroughHolePads();
    }

    virtual bool IgnoreFPValues() const = 0;

     * @return true if should ignore footprint references.
     */
    virtual bool IgnoreFPReferences() const = 0;


    virtual bool IgnoreThroughVias() const = 0;

    virtual bool IgnoreBlindBuriedVias() const = 0;


     */
    virtual bool IgnoreMicroVias() const = 0;

    virtual bool IgnoreTracks() const = 0;

    virtual bool IgnoreZoneFills() const = 0;

    virtual bool IgnoreNoNets() const = 0;
 
    virtual int Accuracy() const = 0;
 
    virtual double OnePixelInIU() const = 0;
};
 
 

class PCB_COLLECTOR : public COLLECTOR
{
public:
    BOARD_ITEM* operator[]( int ndx ) const override
    {
        if( (unsigned)ndx < (unsigned)GetCount() )
            return (BOARD_ITEM*) m_list[ ndx ];
 
        return nullptr;
    }
};
 

class GENERAL_COLLECTOR : public PCB_COLLECTOR
{
protected:
    std::vector<EDA_ITEM*>      m_List2nd;

    const COLLECTORS_GUIDE*     m_Guide;
 
public:

    static const std::vector<KICAD_T> AllBoardItems;

    static const std::vector<KICAD_T> Zones;

    static const std::vector<KICAD_T> BoardLevelItems;

    static const std::vector<KICAD_T> Footprints;

    static const std::vector<KICAD_T> PadsOrTracks;

    static const std::vector<KICAD_T> FootprintItems;

    static const std::vector<KICAD_T> Tracks;

    static const std::vector<KICAD_T> Dimensions;

    static const std::vector<KICAD_T> DraggableItems;
 
    GENERAL_COLLECTOR() :
            m_Guide( nullptr )
    {
        SetScanTypes( AllBoardItems );
    }
 
    void Empty2nd()
    {
        m_List2nd.clear();
    }
 
    void Append2nd( EDA_ITEM* item )
    {
        m_List2nd.push_back( item );
    }

    void SetGuide( const COLLECTORS_GUIDE* aGuide ) { m_Guide = aGuide; }
 
    const COLLECTORS_GUIDE* GetGuide() const { return m_Guide; }

    INSPECT_RESULT Inspect( EDA_ITEM* aTestItem, void* aTestData )  override;

    void Collect( BOARD_ITEM* aItem, const std::vector<KICAD_T>& aScanList,
                  const VECTOR2I& aRefPos, const COLLECTORS_GUIDE& aGuide );
};
 

class GENERAL_COLLECTORS_GUIDE : public COLLECTORS_GUIDE
{
public:

    GENERAL_COLLECTORS_GUIDE( const LSET& aVisibleLayerMask, PCB_LAYER_ID aPreferredLayer,
                              KIGFX::VIEW* aView )
    {
        static const VECTOR2I one( 1, 1 );
 
        m_preferredLayer            = aPreferredLayer;
        m_visibleLayers             = aVisibleLayerMask;
        m_ignoreLockedItems         = false;
 
#if defined(USE_MATCH_LAYER)
        m_includeSecondary          = false;
#else
        m_includeSecondary          = true;
#endif
 
        m_ignoreFPTextOnBack        = true;
        m_ignoreFPTextOnFront       = false;
        m_ignoreFootprintsOnBack    = true; // !Show_footprints_Cmp;
        m_ignoreFootprintsOnFront   = false;
 
        m_ignorePadsOnFront         = false;
        m_ignorePadsOnBack          = false;
        m_ignoreThroughHolePads     = false;
 
        m_ignoreFPValues            = false;
        m_ignoreFPReferences        = false;
 
        m_ignoreThroughVias         = false;
        m_ignoreBlindBuriedVias     = false;
        m_ignoreMicroVias           = false;
        m_ignoreTracks              = false;
        m_ignoreZoneFills           = true;
        m_ignoreNoNets              = false;
 
        m_onePixelInIU = abs( aView->ToWorld( one, false ).x );
        m_accuracy = KiROUND( 5 * m_onePixelInIU );
    }

    bool IsLayerVisible( PCB_LAYER_ID aLayerId ) const override
    {
        return m_visibleLayers[aLayerId];
    }
    void SetLayerVisible( PCB_LAYER_ID aLayerId, bool isVisible )
    {
        m_visibleLayers.set( aLayerId, isVisible );
    }
    void SetLayerVisibleBits( const LSET& aLayerBits ) { m_visibleLayers = aLayerBits; }

    PCB_LAYER_ID GetPreferredLayer() const override    { return m_preferredLayer; }
    void SetPreferredLayer( PCB_LAYER_ID aLayer )      { m_preferredLayer = aLayer; }

    bool IgnoreLockedItems() const override         { return m_ignoreLockedItems; }
    void SetIgnoreLockedItems( bool ignore )        { m_ignoreLockedItems = ignore; }

    bool IncludeSecondary() const override { return m_includeSecondary; }
    void SetIncludeSecondary( bool include ) { m_includeSecondary = include; }

    bool IgnoreFPTextOnBack() const override { return m_ignoreFPTextOnBack; }
    void SetIgnoreFPTextOnBack( bool ignore ) { m_ignoreFPTextOnBack = ignore; }

    bool IgnoreFPTextOnFront() const override { return m_ignoreFPTextOnFront; }
    void SetIgnoreFPTextOnFront( bool ignore ) { m_ignoreFPTextOnFront = ignore; }

    bool IgnoreFootprintsOnBack() const override { return m_ignoreFootprintsOnBack; }
    void SetIgnoreFootprintsOnBack( bool ignore ) { m_ignoreFootprintsOnBack = ignore; }

    bool IgnoreFootprintsOnFront() const override { return m_ignoreFootprintsOnFront; }
    void SetIgnoreFootprintsOnFront( bool ignore ) { m_ignoreFootprintsOnFront = ignore; }

    bool IgnorePadsOnBack() const override { return m_ignorePadsOnBack; }
    void SetIgnorePadsOnBack(bool ignore) { m_ignorePadsOnBack = ignore; }

    bool IgnorePadsOnFront() const override { return m_ignorePadsOnFront; }
    void SetIgnorePadsOnFront(bool ignore) { m_ignorePadsOnFront = ignore; }

    bool IgnoreThroughHolePads() const override { return m_ignoreThroughHolePads; }
    void SetIgnoreThroughHolePads(bool ignore) { m_ignoreThroughHolePads = ignore; }

    bool IgnoreFPValues() const override { return m_ignoreFPValues; }
    void SetIgnoreFPValues( bool ignore) { m_ignoreFPValues = ignore; }

    bool IgnoreFPReferences() const override { return m_ignoreFPReferences; }
    void SetIgnoreFPReferences( bool ignore) { m_ignoreFPReferences = ignore; }
 
    bool IgnoreThroughVias() const override { return m_ignoreThroughVias; }
    void SetIgnoreThroughVias( bool ignore ) { m_ignoreThroughVias = ignore; }
 
    bool IgnoreBlindBuriedVias() const override { return m_ignoreBlindBuriedVias; }
    void SetIgnoreBlindBuriedVias( bool ignore ) { m_ignoreBlindBuriedVias = ignore; }
 
    bool IgnoreMicroVias() const override { return m_ignoreMicroVias; }
    void SetIgnoreMicroVias( bool ignore ) { m_ignoreMicroVias = ignore; }
 
    bool IgnoreTracks() const override { return m_ignoreTracks; }
    void SetIgnoreTracks( bool ignore ) { m_ignoreTracks = ignore; }
 
    bool IgnoreZoneFills() const override { return m_ignoreZoneFills; }
    void SetIgnoreZoneFills( bool ignore ) { m_ignoreZoneFills = ignore; }
 
    bool IgnoreNoNets() const override { return m_ignoreNoNets; }
    void SetIgnoreNoNets( bool ignore ) { m_ignoreNoNets = ignore; }
 
    int  Accuracy() const override { return m_accuracy; }
    void SetAccuracy( int aValue ) { m_accuracy = aValue; }
 
    double OnePixelInIU() const override { return m_onePixelInIU; }
 
private:
    // the storage architecture here is not important, since this is only
    // a carrier object and its functions are what is used, and data only indirectly.
 
    PCB_LAYER_ID m_preferredLayer;
 
    LSET    m_visibleLayers;                 
 
    bool    m_ignoreLockedItems;
    bool    m_includeSecondary;
 
    bool    m_ignoreFPTextOnBack;
    bool    m_ignoreFPTextOnFront;
    bool    m_ignoreFootprintsOnBack;
    bool    m_ignoreFootprintsOnFront;
    bool    m_ignorePadsOnFront;
    bool    m_ignorePadsOnBack;
    bool    m_ignoreThroughHolePads;
    bool    m_ignoreFPValues;
    bool    m_ignoreFPReferences;
    bool    m_ignoreThroughVias;
    bool    m_ignoreBlindBuriedVias;
    bool    m_ignoreMicroVias;
    bool    m_ignoreTracks;
    bool    m_ignoreZoneFills;
    bool    m_ignoreNoNets;
 
    double m_onePixelInIU;
    int    m_accuracy;
};
 

class PCB_TYPE_COLLECTOR : public PCB_COLLECTOR
{
public:

    INSPECT_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;

    void Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes );
};
 

class PCB_LAYER_COLLECTOR : public PCB_COLLECTOR
{
public:
    PCB_LAYER_COLLECTOR( PCB_LAYER_ID aLayerId = UNDEFINED_LAYER ) :
        m_layer_id( aLayerId )
    { }
 
    void SetLayerId( PCB_LAYER_ID aLayerId ) { m_layer_id = aLayerId; }

    INSPECT_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;

    void Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes );
 
private:
    PCB_LAYER_ID m_layer_id;
};
 
#endif // COLLECTORS_H