kicad/pcbnew/collectors.h

675 lines
21 KiB
C
Raw Normal View History

2007-08-23 04:28:46 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
2007-08-23 04:28:46 +00:00
*
* Copyright (C) 2007-2008 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
2021-06-04 13:04:30 +00:00
* Copyright (C) 2004-2021 KiCad Developers, see AUTHORS.txt for contributors.
2008-02-19 16:54:57 +00:00
*
2007-08-23 04:28:46 +00:00
* 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.
2008-02-19 16:54:57 +00:00
*
2007-08-23 04:28:46 +00:00
* 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.
2008-02-19 16:54:57 +00:00
*
2007-08-23 04:28:46 +00:00
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
2008-02-19 16:54:57 +00:00
* 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.,
2007-08-23 04:28:46 +00:00
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef COLLECTORS_H
#define COLLECTORS_H
2020-11-13 02:57:11 +00:00
/*
* This module contains a number of COLLECTOR implementations which are used
* to augment the functionality of class PCB_EDIT_FRAME.
*/
2007-08-23 04:28:46 +00:00
#include <collector.h>
#include <layer_ids.h> // LAYER_COUNT, layer defs
#include <view/view.h>
2020-11-14 18:11:28 +00:00
#include <board_item.h>
2007-08-30 03:53:26 +00:00
/**
* An abstract base class whose derivatives may be passed to a GENERAL_COLLECTOR,
2008-02-19 16:54:57 +00:00
* telling GENERAL_COLLECTOR what should be collected (aside from HitTest()ing
* and KICAD_T scanTypes[], information which are provided to the GENERAL_COLLECTOR
* through attributes or arguments separately).
2007-08-30 22:20:52 +00:00
* <p>
* A justification for this class is to keep the structural storage details of
2008-02-19 16:54:57 +00:00
* the program's "global preferences" or "configuration options" out of
2007-08-30 22:20:52 +00:00
* GENERAL_COLLECTOR::Inspect(). This class carries all the necessary details
* in with it to the Inspect() call. The constructors or other functions of
* this class's derivatives are then the only place where knowledge of the
2008-02-19 16:54:57 +00:00
* 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 (and even then it is
2007-08-30 22:20:52 +00:00
* not simple enough).
* </p>
2007-08-30 03:53:26 +00:00
* This class introduces the notion of layer locking.
*/
2008-02-19 16:54:57 +00:00
class COLLECTORS_GUIDE
2007-08-30 03:53:26 +00:00
{
public:
virtual ~COLLECTORS_GUIDE() {}
/**
2021-06-04 13:04:30 +00:00
* @return true if the given layer is locked, else false.
2007-08-30 03:53:26 +00:00
*/
virtual bool IsLayerLocked( PCB_LAYER_ID layer ) const = 0;
2008-02-19 16:54:57 +00:00
2007-08-30 03:53:26 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if the given layer is visible, else false.
2007-08-30 03:53:26 +00:00
*/
virtual bool IsLayerVisible( PCB_LAYER_ID layer ) const = 0;
2008-02-19 16:54:57 +00:00
2007-08-30 03:53:26 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore locked layers, else false.
2007-08-30 03:53:26 +00:00
*/
virtual bool IgnoreLockedLayers() const = 0;
2008-02-19 16:54:57 +00:00
2007-08-30 03:53:26 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore non-visible layers, else false.
2007-08-30 03:53:26 +00:00
*/
virtual bool IgnoreNonVisibleLayers() const = 0;
2008-02-19 16:54:57 +00:00
2007-08-30 03:53:26 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return the preferred layer for HitTest()ing.
2007-08-30 03:53:26 +00:00
*/
virtual PCB_LAYER_ID GetPreferredLayer() const = 0;
2007-08-30 22:20:52 +00:00
/**
* Provide wildcard behavior regarding the preferred layer.
*
2021-06-04 13:04:30 +00:00
* @return true if should ignore preferred layer, else false.
2007-08-30 22:20:52 +00:00
*/
virtual bool IgnorePreferredLayer() const = 0;
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore locked items, else false.
2007-08-30 22:20:52 +00:00
*/
virtual bool IgnoreLockedItems() const = 0;
/**
* Determine if the secondary criteria or 2nd choice items should be included.
*
2021-06-04 13:04:30 +00:00
* @return true if should include, else false.
2007-08-30 22:20:52 +00:00
*/
virtual bool IncludeSecondary() const = 0;
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if footprint texts marked as "no show" should be ignored.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreHiddenFPText() const = 0;
2008-02-19 16:54:57 +00:00
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprint text on back layers
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFPTextOnBack() const = 0;
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprint text on front layers.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFPTextOnFront() const = 0;
2008-02-19 16:54:57 +00:00
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore FOOTPRINTs on Back Side.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFootprintsOnBack() const = 0;
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore FOOTPRINTs on Front Side.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFootprintsOnFront() const = 0;
2007-09-25 15:10:01 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore Pads on Back Side.
*/
virtual bool IgnorePadsOnBack() const = 0;
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore PADSs on Front Side.
*/
virtual bool IgnorePadsOnFront() const = 0;
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore through-hole PADSs.
*/
virtual bool IgnoreThroughHolePads() const = 0;
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore PADSs on Front side and Back side.
*/
virtual bool IgnorePads() const
{
return IgnorePadsOnFront() && IgnorePadsOnBack() && IgnoreThroughHolePads();
}
2008-02-19 16:54:57 +00:00
2011-12-14 22:35:03 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprint values.
2011-12-14 22:35:03 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFPValues() const = 0;
2011-12-14 22:35:03 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprint references.
2011-12-14 22:35:03 +00:00
*/
2020-11-12 23:06:47 +00:00
virtual bool IgnoreFPReferences() const = 0;
2011-12-14 22:35:03 +00:00
/**
* @return true if should ignore through-hole vias
*/
virtual bool IgnoreThroughVias() const = 0;
/**
* @return true if should ignore blind/buried vias
*/
virtual bool IgnoreBlindBuriedVias() const = 0;
/**
* @return true if should ignore micro vias
*/
virtual bool IgnoreMicroVias() const = 0;
/**
* @return true if should ignore tracks
*/
virtual bool IgnoreTracks() const = 0;
/**
* @return true if should ignore the interiors of zones
*/
virtual bool IgnoreZoneFills() const = 0;
virtual double OnePixelInIU() const = 0;
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if Inspect() should use BOARD_ITEM::HitTest()
* or false if Inspect() should use BOARD_ITEM::BoundsTest().
2007-08-30 22:20:52 +00:00
virtual bool UseHitTesting() const = 0;
*/
2007-08-30 03:53:26 +00:00
};
2007-08-23 04:28:46 +00:00
/**
* Collect #BOARD_ITEM objects.
*
* All this object really does is override the [] operator and return a #BOARD_ITEM instead
* of a #EDA_ITEM. Derive all board collector objects from this class instead of the base
* #COLLECTOR object.
*
* @see class COLLECTOR
*/
class PCB_COLLECTOR : public COLLECTOR
{
public:
/**
* Overload the COLLECTOR::operator[](int) to return a #BOARD_ITEM instead of an #EDA_ITEM.
*
* @param ndx The index into the list.
2021-06-04 13:04:30 +00:00
* @return a board item or NULL.
*/
BOARD_ITEM* operator[]( int ndx ) const override
{
if( (unsigned)ndx < (unsigned)GetCount() )
2020-10-02 20:25:14 +00:00
return (BOARD_ITEM*) m_list[ ndx ];
2021-06-04 13:04:30 +00:00
return nullptr;
}
};
/**
* Used when the right click button is pressed, or when the select tool is in effect.
* This class can be used by window classes such as PCB_EDIT_FRAME.
2007-08-23 04:28:46 +00:00
*
* Philosophy: this class knows nothing of the context in which a BOARD is used
2008-02-19 16:54:57 +00:00
* and that means it knows nothing about which layers are visible or current,
2007-08-23 04:28:46 +00:00
* but can handle those concerns by the SetPreferredLayer() function and the
* SetLayerSet() function.
2007-08-23 04:28:46 +00:00
*/
class GENERAL_COLLECTOR : public PCB_COLLECTOR
2007-08-23 04:28:46 +00:00
{
2008-02-19 16:54:57 +00:00
protected:
2007-08-23 04:28:46 +00:00
/**
2008-02-19 16:54:57 +00:00
* A place to hold collected objects which don't match precisely the search
* criteria, but would be acceptable if nothing else is found.
* "2nd" choice, which will be appended to the end of COLLECTOR's prime
2007-08-23 04:28:46 +00:00
* "list" at the end of the search.
*/
2007-08-30 22:20:52 +00:00
std::vector<BOARD_ITEM*> m_List2nd;
2008-02-19 16:54:57 +00:00
2007-08-23 04:28:46 +00:00
/**
2021-06-04 13:04:30 +00:00
* Determine which items are to be collected by Inspect().
2007-08-23 04:28:46 +00:00
*/
2007-09-11 04:15:39 +00:00
const COLLECTORS_GUIDE* m_Guide;
2008-02-19 16:54:57 +00:00
/**
2008-02-19 16:54:57 +00:00
* The number of items that were originally in the primary list before the
* m_List2nd was concatenated onto the end of it.
*/
int m_PrimaryLength;
2007-08-30 22:20:52 +00:00
2007-08-23 04:28:46 +00:00
public:
2007-09-11 04:15:39 +00:00
/**
* A scan list for all editable board items
2007-09-11 04:15:39 +00:00
*/
2007-08-23 04:28:46 +00:00
static const KICAD_T AllBoardItems[];
/**
* A scan list for zones outlines only
*/
static const KICAD_T Zones[];
2008-02-19 16:54:57 +00:00
/**
2007-09-11 04:15:39 +00:00
* A scan list for all primary board items, omitting items which are subordinate to
* a FOOTPRINT, such as PAD and FP_TEXT.
2007-10-10 14:08:26 +00:00
*/
static const KICAD_T BoardLevelItems[];
/**
2020-11-14 19:16:42 +00:00
* A scan list for only FOOTPRINTs
*/
2020-11-14 19:16:42 +00:00
static const KICAD_T Footprints[];
/**
* A scan list for PADs, TRACKs, or VIAs
*/
static const KICAD_T PadsOrTracks[];
2008-02-19 16:54:57 +00:00
/**
2020-11-14 19:16:42 +00:00
* A scan list for primary footprint items.
*/
2020-11-14 19:16:42 +00:00
static const KICAD_T FootprintItems[];
/**
2020-11-13 15:15:52 +00:00
* A scan list for only TRACKs
*/
static const KICAD_T Tracks[];
2008-02-19 16:54:57 +00:00
/**
2020-11-13 15:15:52 +00:00
* A scan list for TRACKs, VIAs, FOOTPRINTs
*/
static const KICAD_T LockableItems[];
/**
* A scan list for dimensions
*/
static const KICAD_T Dimensions[];
/**
* A scan list for items that can be dragged
*/
static const KICAD_T DraggableItems[];
2007-08-30 22:20:52 +00:00
GENERAL_COLLECTOR()
2007-08-23 04:28:46 +00:00
{
2021-06-04 13:04:30 +00:00
m_Guide = nullptr;
m_PrimaryLength = 0;
2007-08-23 04:28:46 +00:00
SetScanTypes( AllBoardItems );
}
void Empty2nd()
{
2007-08-30 22:20:52 +00:00
m_List2nd.clear();
2007-08-23 04:28:46 +00:00
}
void Append2nd( BOARD_ITEM* item )
2007-08-23 04:28:46 +00:00
{
2007-08-30 22:20:52 +00:00
m_List2nd.push_back( item );
2007-08-23 04:28:46 +00:00
}
2007-08-30 22:20:52 +00:00
/**
* Record which COLLECTORS_GUIDE to use.
*
2007-08-30 22:20:52 +00:00
* @param aGuide Which guide to use in the collection.
*/
void SetGuide( const COLLECTORS_GUIDE* aGuide ) { m_Guide = aGuide; }
2008-02-19 16:54:57 +00:00
const COLLECTORS_GUIDE* GetGuide() const { return m_Guide; }
/**
2021-06-04 13:04:30 +00:00
* @return The number of items which met the primary search criteria
*/
int GetPrimaryCount() { return m_PrimaryLength; }
2008-02-19 16:54:57 +00:00
2007-08-23 04:28:46 +00:00
/**
* The examining function within the INSPECTOR which is passed to the Iterate function.
*
2021-06-04 13:04:30 +00:00
* Search and collect all the objects which match the test data.
2007-08-23 04:28:46 +00:00
*
* @param testItem An EDA_ITEM to examine.
2007-08-23 04:28:46 +00:00
* @param testData is not used in this class.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
2021-06-04 13:04:30 +00:00
* else SCAN_CONTINUE;
2008-02-19 16:54:57 +00:00
*/
SEARCH_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;
2008-02-19 16:54:57 +00:00
2007-08-23 04:28:46 +00:00
/**
* Scan a BOARD_ITEM using this class's Inspector method, which does the collection.
*
* @param aItem A BOARD_ITEM to scan, may be a BOARD or FOOTPRINT, or whatever.
2008-02-19 16:54:57 +00:00
* @param aScanList A list of KICAD_Ts with a terminating EOT, that specs
* what is to be collected and the priority order of the resultant
2020-10-02 20:25:14 +00:00
* collection in "m_list".
2007-08-30 22:20:52 +00:00
* @param aRefPos A wxPoint to use in hit-testing.
* @param aGuide The COLLECTORS_GUIDE to use in collecting items.
2007-08-30 03:53:26 +00:00
*/
2008-02-19 16:54:57 +00:00
void Collect( BOARD_ITEM* aItem, const KICAD_T aScanList[],
2021-06-04 13:04:30 +00:00
const wxPoint& aRefPos, const COLLECTORS_GUIDE& aGuide );
2007-08-23 04:28:46 +00:00
};
2007-08-30 22:20:52 +00:00
/**
* A general implementation of a COLLECTORS_GUIDE. One of its constructors is
2007-08-30 22:20:52 +00:00
* entitled to grab information from the program's global preferences.
2008-02-19 16:54:57 +00:00
*/
2007-08-30 22:20:52 +00:00
class GENERAL_COLLECTORS_GUIDE : public COLLECTORS_GUIDE
{
public:
/**
* Grab stuff from global preferences and uses reasonable defaults.
*
2007-08-30 22:20:52 +00:00
* Add more constructors as needed.
*
2021-06-04 13:04:30 +00:00
* @param aVisibleLayerMask is the current visible layers (bit mask).
* @param aPreferredLayer is the layer to search first.
2007-08-30 22:20:52 +00:00
*/
GENERAL_COLLECTORS_GUIDE( LSET aVisibleLayerMask, PCB_LAYER_ID aPreferredLayer,
KIGFX::VIEW* aView )
2007-08-30 22:20:52 +00:00
{
VECTOR2I one( 1, 1 );
2020-11-12 23:06:47 +00:00
m_preferredLayer = aPreferredLayer;
m_ignorePreferredLayer = false;
m_visibleLayers = aVisibleLayerMask;
2020-11-12 23:06:47 +00:00
m_ignoreLockedLayers = true;
m_ignoreNonVisibleLayers = true;
m_ignoreLockedItems = false;
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
#if defined(USE_MATCH_LAYER)
m_includeSecondary = false;
2008-02-19 16:54:57 +00:00
#else
2020-11-12 23:06:47 +00:00
m_includeSecondary = true;
2008-02-19 16:54:57 +00:00
#endif
2007-09-01 12:00:30 +00:00
m_ignoreHiddenFPText = true; // g_ModuleTextNOVColor;
2020-11-12 23:06:47 +00:00
m_ignoreFPTextOnBack = true;
m_ignoreFPTextOnFront = false;
m_ignoreFootprintsOnBack = true; // !Show_footprints_Cmp;
m_ignoreFootprintsOnFront = false;
2010-12-29 17:47:32 +00:00
2020-11-12 23:06:47 +00:00
m_ignorePadsOnFront = false;
m_ignorePadsOnBack = false;
m_ignoreThroughHolePads = false;
2011-12-14 22:35:03 +00:00
m_ignoreFPValues = false;
m_ignoreFPReferences = false;
2020-11-12 23:06:47 +00:00
m_ignoreThroughVias = false;
m_ignoreBlindBuriedVias = false;
m_ignoreMicroVias = false;
m_ignoreTracks = false;
m_ignoreZoneFills = true;
2020-11-12 23:06:47 +00:00
m_onePixelInIU = abs( aView->ToWorld( one, false ).x );
2007-09-05 04:48:47 +00:00
}
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if the given layer is locked, else false.
2007-08-30 22:20:52 +00:00
*/
bool IsLayerLocked( PCB_LAYER_ID aLayerId ) const override
2007-08-30 22:20:52 +00:00
{
2020-11-12 23:06:47 +00:00
return m_lockedLayers[aLayerId];
2007-08-30 22:20:52 +00:00
}
void SetLayerLocked( PCB_LAYER_ID aLayerId, bool isLocked )
{
2020-11-12 23:06:47 +00:00
m_lockedLayers.set( aLayerId, isLocked );
}
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if the given layer is visible, else false.
2007-08-30 22:20:52 +00:00
*/
bool IsLayerVisible( PCB_LAYER_ID aLayerId ) const override
{
2020-11-12 23:06:47 +00:00
return m_visibleLayers[aLayerId];
}
void SetLayerVisible( PCB_LAYER_ID aLayerId, bool isVisible )
2007-08-30 22:20:52 +00:00
{
2020-11-12 23:06:47 +00:00
m_visibleLayers.set( aLayerId, isVisible );
2007-08-30 22:20:52 +00:00
}
2020-11-12 23:06:47 +00:00
void SetLayerVisibleBits( LSET aLayerBits ) { m_visibleLayers = aLayerBits; }
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore locked layers, else false.
2007-08-30 22:20:52 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreLockedLayers() const override { return m_ignoreLockedLayers; }
void SetIgnoreLockedLayers( bool ignore ) { m_ignoreLockedLayers = ignore; }
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore non-visible layers, else false.
2007-08-30 22:20:52 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreNonVisibleLayers() const override { return m_ignoreNonVisibleLayers; }
void SetIgnoreNonVisibleLayers( bool ignore ) { m_ignoreLockedLayers = ignore; }
2007-08-30 22:20:52 +00:00
/**
* @return int - the preferred layer for HitTest()ing.
*/
2020-11-12 23:06:47 +00:00
PCB_LAYER_ID GetPreferredLayer() const override { return m_preferredLayer; }
void SetPreferredLayer( PCB_LAYER_ID aLayer ) { m_preferredLayer = aLayer; }
2007-08-30 22:20:52 +00:00
/**
* Provide wildcard behavior regarding the preferred layer.
*
2021-06-04 13:04:30 +00:00
* @return true if should ignore preferred layer, else false.
2007-08-30 22:20:52 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnorePreferredLayer() const override { return m_ignorePreferredLayer; }
void SetIgnorePreferredLayer( bool ignore ) { m_ignorePreferredLayer = ignore; }
2008-02-19 16:54:57 +00:00
2007-08-30 22:20:52 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore locked items, else false.
2007-08-30 22:20:52 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreLockedItems() const override { return m_ignoreLockedItems; }
void SetIgnoreLockedItems( bool ignore ) { m_ignoreLockedItems = ignore; }
2007-08-30 22:20:52 +00:00
/**
* Determine if the secondary criteria, or 2nd choice items should be included.
*
2021-06-04 13:04:30 +00:00
* @return true if should include, else false.
2007-08-30 22:20:52 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IncludeSecondary() const override { return m_includeSecondary; }
void SetIncludeSecondary( bool include ) { m_includeSecondary = include; }
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if MTexts marked as "no show" should be ignored.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreHiddenFPText() const override { return m_ignoreHiddenFPText; }
void SetIgnoreMTextsMarkedNoShow( bool ignore ) { m_ignoreHiddenFPText = ignore; }
2008-02-19 16:54:57 +00:00
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore MTexts on back layers
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFPTextOnBack() const override { return m_ignoreFPTextOnBack; }
void SetIgnoreMTextsOnBack( bool ignore ) { m_ignoreFPTextOnBack = ignore; }
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore MTexts on front layers
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFPTextOnFront() const override { return m_ignoreFPTextOnFront; }
void SetIgnoreMTextsOnFront( bool ignore ) { m_ignoreFPTextOnFront = ignore; }
2008-02-19 16:54:57 +00:00
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore MODULEs on the back side
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFootprintsOnBack() const override { return m_ignoreFootprintsOnBack; }
void SetIgnoreModulesOnBack( bool ignore ) { m_ignoreFootprintsOnBack = ignore; }
2007-09-01 12:00:30 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore MODULEs on component layer.
2007-09-01 12:00:30 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFootprintsOnFront() const override { return m_ignoreFootprintsOnFront; }
void SetIgnoreModulesOnFront( bool ignore ) { m_ignoreFootprintsOnFront = ignore; }
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore Pads on Back Side.
*/
2020-11-12 23:06:47 +00:00
bool IgnorePadsOnBack() const override { return m_ignorePadsOnBack; }
void SetIgnorePadsOnBack(bool ignore) { m_ignorePadsOnBack = ignore; }
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore PADSs on Front Side.
*/
2020-11-12 23:06:47 +00:00
bool IgnorePadsOnFront() const override { return m_ignorePadsOnFront; }
void SetIgnorePadsOnFront(bool ignore) { m_ignorePadsOnFront = ignore; }
2011-12-14 22:35:03 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore through-hole PADSs.
*/
2020-11-12 23:06:47 +00:00
bool IgnoreThroughHolePads() const override { return m_ignoreThroughHolePads; }
void SetIgnoreThroughHolePads(bool ignore) { m_ignoreThroughHolePads = ignore; }
2011-12-14 22:35:03 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprints values.
2011-12-14 22:35:03 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFPValues() const override { return m_ignoreFPValues; }
void SetIgnoreModulesVals(bool ignore) { m_ignoreFPValues = ignore; }
2011-12-14 22:35:03 +00:00
/**
2021-06-04 13:04:30 +00:00
* @return true if should ignore footprints references.
2011-12-14 22:35:03 +00:00
*/
2020-11-12 23:06:47 +00:00
bool IgnoreFPReferences() const override { return m_ignoreFPReferences; }
void SetIgnoreModulesRefs(bool ignore) { m_ignoreFPReferences = ignore; }
2020-11-12 23:06:47 +00:00
bool IgnoreThroughVias() const override { return m_ignoreThroughVias; }
void SetIgnoreThroughVias( bool ignore ) { m_ignoreThroughVias = ignore; }
2020-11-12 23:06:47 +00:00
bool IgnoreBlindBuriedVias() const override { return m_ignoreBlindBuriedVias; }
void SetIgnoreBlindBuriedVias( bool ignore ) { m_ignoreBlindBuriedVias = ignore; }
2020-11-12 23:06:47 +00:00
bool IgnoreMicroVias() const override { return m_ignoreMicroVias; }
void SetIgnoreMicroVias( bool ignore ) { m_ignoreMicroVias = ignore; }
2020-11-12 23:06:47 +00:00
bool IgnoreTracks() const override { return m_ignoreTracks; }
void SetIgnoreTracks( bool ignore ) { m_ignoreTracks = ignore; }
2020-11-12 23:06:47 +00:00
bool IgnoreZoneFills() const override { return m_ignoreZoneFills; }
void SetIgnoreZoneFills( bool ignore ) { m_ignoreZoneFills = ignore; }
2020-11-12 23:06:47 +00:00
double OnePixelInIU() const override { return m_onePixelInIU; }
void SetOnePixelInIU( double aValue ) { m_onePixelInIU = aValue; }
2021-06-04 13:04:30 +00:00
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;
bool m_ignorePreferredLayer;
LSET m_lockedLayers; ///< bit-mapped layer locked bits
bool m_ignoreLockedLayers;
LSET m_visibleLayers; ///< bit-mapped layer visible bits
bool m_ignoreNonVisibleLayers;
bool m_ignoreLockedItems;
bool m_includeSecondary;
bool m_ignoreHiddenFPText;
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;
double m_onePixelInIU;
2007-08-30 22:20:52 +00:00
};
/**
* Collect all #BOARD_ITEM objects of a given set of #KICAD_T type(s).
*
* @see class COLLECTOR
*/
class PCB_TYPE_COLLECTOR : public PCB_COLLECTOR
{
public:
/**
* The examining function within the INSPECTOR which is passed to the Iterate function.
*
* @param testItem An EDA_ITEM to examine.
* @param testData is not used in this class.
2021-06-04 13:04:30 +00:00
* @return SEARCH_QUIT if the Iterator is to stop the scan, else SCAN_CONTINUE;
*/
SEARCH_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;
/**
* Collect #BOARD_ITEM objects using this class's Inspector method, which does the collection.
*
* @param aBoard The BOARD_ITEM to scan.
* @param aScanList The KICAD_Ts to gather up.
*/
void Collect( BOARD_ITEM* aBoard, const KICAD_T aScanList[] );
};
/**
* Collect all #BOARD_ITEM objects on a given layer.
*
* This only uses the primary object layer for comparison.
*/
class PCB_LAYER_COLLECTOR : public PCB_COLLECTOR
{
public:
PCB_LAYER_COLLECTOR( PCB_LAYER_ID aLayerId = UNDEFINED_LAYER ) :
m_layer_id( aLayerId )
{
}
2008-02-19 16:54:57 +00:00
void SetLayerId( PCB_LAYER_ID aLayerId ) { m_layer_id = aLayerId; }
/**
* The examining function within the INSPECTOR which is passed to the iterate function.
*
* @param testItem An EDA_ITEM to examine.
* @param testData is not used in this class.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
2008-02-19 16:54:57 +00:00
*/
SEARCH_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;
/**
2021-06-04 13:04:30 +00:00
* Test a BOARD_ITEM using this class's Inspector method, which does the collection.
*
* @param aBoard The BOARD_ITEM to scan.
* @param aScanList The KICAD_Ts to gather up.
*/
void Collect( BOARD_ITEM* aBoard, const KICAD_T aScanList[] );
2021-06-04 13:04:30 +00:00
private:
PCB_LAYER_ID m_layer_id;
};
2007-08-23 04:28:46 +00:00
#endif // COLLECTORS_H