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 (C) 2004-2023 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 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 <view/view.h>
#include <board_item.h>
 
class COLLECTORS_GUIDE
{
public:
 virtual ~COLLECTORS_GUIDE() {}
 
 virtual bool IsLayerVisible( PCB_LAYER_ID layer ) const = 0;
 
 virtual PCB_LAYER_ID GetPreferredLayer() const = 0;
 
 virtual bool IgnoreLockedItems() const = 0;
 
 virtual bool IncludeSecondary() const = 0;
 
 virtual bool IgnoreHiddenFPText() 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;
 
 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 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( LSET aVisibleLayerMask, PCB_LAYER_ID aPreferredLayer,
 KIGFX::VIEW* aView )
 {
 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_ignoreHiddenFPText = true; // g_ModuleTextNOVColor;
 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_onePixelInIU = abs( aView->ToWorld( one, false ).x );
 }
 
 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( 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 IgnoreHiddenFPText() const override { return m_ignoreHiddenFPText; }
 void SetIgnoreMTextsMarkedNoShow( bool ignore ) { m_ignoreHiddenFPText = ignore; }
 
 bool IgnoreFPTextOnBack() const override { return m_ignoreFPTextOnBack; }
 void SetIgnoreMTextsOnBack( bool ignore ) { m_ignoreFPTextOnBack = ignore; }
 
 bool IgnoreFPTextOnFront() const override { return m_ignoreFPTextOnFront; }
 void SetIgnoreMTextsOnFront( bool ignore ) { m_ignoreFPTextOnFront = ignore; }
 
 bool IgnoreFootprintsOnBack() const override { return m_ignoreFootprintsOnBack; }
 void SetIgnoreModulesOnBack( bool ignore ) { m_ignoreFootprintsOnBack = ignore; }
 
 bool IgnoreFootprintsOnFront() const override { return m_ignoreFootprintsOnFront; }
 void SetIgnoreModulesOnFront( 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 SetIgnoreModulesVals(bool ignore) { m_ignoreFPValues = ignore; }
 
 bool IgnoreFPReferences() const override { return m_ignoreFPReferences; }
 void SetIgnoreModulesRefs(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; }
 
 double OnePixelInIU() const override { return m_onePixelInIU; }
 void SetOnePixelInIU( double aValue ) { m_onePixelInIU = aValue; }
 
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_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;
};
 
 
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