2007-12-10 05:42:42 +00:00
|
|
|
/*
|
2011-09-30 18:15:37 +00:00
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
2007-12-10 05:42:42 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Dick Hollenbeck, dick@softplc.com
|
2020-02-28 00:05:40 +00:00
|
|
|
* Copyright (C) 2015-2020 KiCad Developers, see change_log.txt for contributors.
|
2007-12-10 05:42:42 +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.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2008-05-05 19:54:21 +00:00
|
|
|
|
2020-02-24 17:23:53 +00:00
|
|
|
#include "wx/html/m_templ.h"
|
|
|
|
#include "wx/html/styleparams.h"
|
2020-03-16 11:05:01 +00:00
|
|
|
#include <drc/drc_item.h>
|
2020-11-12 20:19:22 +00:00
|
|
|
#include <board.h>
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2007-12-09 12:59:06 +00:00
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
// These, being statically-defined, require specialized I18N handling. We continue to
|
|
|
|
// use the _() macro so that string harvesting by the I18N framework doesn't have to be
|
|
|
|
// specialized, but we don't translate on initialization and instead do it in the getters.
|
|
|
|
|
|
|
|
#undef _
|
|
|
|
#define _(s) s
|
|
|
|
|
2020-10-13 22:03:07 +00:00
|
|
|
// NOTE: Avoid changing the settings key for a DRC item after it has been created
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::unconnectedItems( DRCE_UNCONNECTED_ITEMS,
|
|
|
|
_( "Unconnected items" ),
|
|
|
|
wxT( "unconnected_items" ) );
|
|
|
|
|
2020-07-30 20:41:52 +00:00
|
|
|
DRC_ITEM DRC_ITEM::shortingItems( DRCE_SHORTING_ITEMS,
|
|
|
|
_( "Items shorting two nets" ),
|
|
|
|
wxT( "shorting_items" ) );
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::itemsNotAllowed( DRCE_ALLOWED_ITEMS,
|
|
|
|
_( "Items not allowed" ),
|
|
|
|
wxT( "items_not_allowed" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::clearance( DRCE_CLEARANCE,
|
|
|
|
_( "Clearance violation" ),
|
|
|
|
wxT( "clearance" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::tracksCrossing( DRCE_TRACKS_CROSSING,
|
|
|
|
_( "Tracks crossing" ),
|
|
|
|
wxT( "tracks_crossing" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::copperEdgeClearance( DRCE_COPPER_EDGE_CLEARANCE,
|
|
|
|
_( "Board edge clearance violation" ),
|
|
|
|
wxT( "copper_edge_clearance" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::zonesIntersect( DRCE_ZONES_INTERSECT,
|
|
|
|
_( "Copper areas intersect" ),
|
|
|
|
wxT( "zones_intersect" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::zoneHasEmptyNet( DRCE_ZONE_HAS_EMPTY_NET,
|
|
|
|
_( "Copper zone net has no pads" ),
|
|
|
|
wxT( "zone_has_empty_net" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::viaDangling( DRCE_DANGLING_VIA,
|
|
|
|
_( "Via is not connected" ),
|
|
|
|
wxT( "via_dangling" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::trackDangling( DRCE_DANGLING_TRACK,
|
|
|
|
_( "Track has unconnected end" ),
|
|
|
|
wxT( "track_dangling" ) );
|
|
|
|
|
2020-09-11 15:04:11 +00:00
|
|
|
DRC_ITEM DRC_ITEM::holeClearance( DRCE_HOLE_CLEARANCE,
|
2020-10-06 12:20:29 +00:00
|
|
|
_( "Hole clearance violation" ),
|
2020-09-11 15:04:11 +00:00
|
|
|
wxT( "hole_clearance" ) );
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::holeNearHole( DRCE_DRILLED_HOLES_TOO_CLOSE,
|
|
|
|
_( "Drilled holes too close together" ),
|
|
|
|
wxT( "hole_near_hole" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::trackWidth( DRCE_TRACK_WIDTH,
|
2020-09-23 10:46:41 +00:00
|
|
|
_( "Track width" ),
|
2020-06-08 02:19:46 +00:00
|
|
|
wxT( "track_width" ) );
|
|
|
|
|
2020-09-23 10:46:41 +00:00
|
|
|
DRC_ITEM DRC_ITEM::annularWidth( DRCE_ANNULAR_WIDTH,
|
|
|
|
_( "Annular width" ),
|
|
|
|
wxT( "annular_width" ) );
|
2020-06-08 02:19:46 +00:00
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::drillTooSmall( DRCE_TOO_SMALL_DRILL,
|
|
|
|
_( "Drill too small" ),
|
|
|
|
wxT( "drill_too_small" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::viaHoleLargerThanPad( DRCE_VIA_HOLE_BIGGER,
|
|
|
|
_( "Via hole larger than diameter" ),
|
|
|
|
wxT( "via_hole_larger_than_pad" ) );
|
|
|
|
|
2020-09-18 12:31:56 +00:00
|
|
|
DRC_ITEM DRC_ITEM::viaDiameter( DRCE_VIA_DIAMETER,
|
2020-09-23 10:46:41 +00:00
|
|
|
_( "Via diameter" ),
|
2020-09-18 12:31:56 +00:00
|
|
|
wxT( "via_diameter" ) );
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::padstack( DRCE_PADSTACK,
|
|
|
|
_( "Padstack is not valid" ),
|
|
|
|
wxT( "padstack" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::microviaDrillTooSmall( DRCE_TOO_SMALL_MICROVIA_DRILL,
|
|
|
|
_( "Micro via drill too small" ),
|
|
|
|
wxT( "microvia_drill_too_small" ) );
|
2020-05-07 13:35:50 +00:00
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::keepout( DRCE_KEEPOUT,
|
|
|
|
_( "Keepout violation" ),
|
|
|
|
wxT( "keepout" ) );
|
2020-05-07 13:35:50 +00:00
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::courtyardsOverlap( DRCE_OVERLAPPING_FOOTPRINTS,
|
|
|
|
_( "Courtyards overlap" ),
|
|
|
|
wxT( "courtyards_overlap" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::missingCourtyard( DRCE_MISSING_COURTYARD,
|
|
|
|
_( "Footprint has no courtyard defined" ),
|
|
|
|
wxT( "missing_courtyard" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::malformedCourtyard( DRCE_MALFORMED_COURTYARD,
|
|
|
|
_( "Footprint has malformed courtyard" ),
|
|
|
|
wxT( "malformed_courtyard" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::pthInsideCourtyard( DRCE_PTH_IN_COURTYARD,
|
|
|
|
_( "PTH inside courtyard" ),
|
|
|
|
wxT( "pth_inside_courtyard" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::npthInsideCourtyard( DRCE_NPTH_IN_COURTYARD,
|
|
|
|
_( "NPTH inside courtyard" ),
|
|
|
|
wxT( "npth_inside_courtyard" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::itemOnDisabledLayer( DRCE_DISABLED_LAYER_ITEM,
|
|
|
|
_( "Item on a disabled layer" ),
|
|
|
|
wxT( "item_on_disabled_layer" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::invalidOutline( DRCE_INVALID_OUTLINE,
|
|
|
|
_( "Board has malformed outline" ),
|
|
|
|
wxT( "invalid_outline" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::duplicateFootprints( DRCE_DUPLICATE_FOOTPRINT,
|
|
|
|
_( "Duplicate footprints" ),
|
|
|
|
wxT( "duplicate_footprints" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::missingFootprint( DRCE_MISSING_FOOTPRINT,
|
|
|
|
_( "Missing footprint" ),
|
|
|
|
wxT( "missing_footprint" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::extraFootprint( DRCE_EXTRA_FOOTPRINT,
|
|
|
|
_( "Extra footprint" ),
|
|
|
|
wxT( "extra_footprint" ) );
|
|
|
|
|
2020-09-04 09:32:20 +00:00
|
|
|
DRC_ITEM DRC_ITEM::netConflict( DRCE_NET_CONFLICT,
|
|
|
|
_( "Pad net doesn't match schematic" ),
|
|
|
|
wxT( "net_conflict" ) );
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM DRC_ITEM::unresolvedVariable( DRCE_UNRESOLVED_VARIABLE,
|
|
|
|
_( "Unresolved text variable" ),
|
|
|
|
wxT( "unresolved_variable" ) );
|
|
|
|
|
2020-10-04 11:44:22 +00:00
|
|
|
DRC_ITEM DRC_ITEM::silkMaskClearance( DRCE_SILK_MASK_CLEARANCE,
|
|
|
|
_( "Silkscreen clipped by solder mask" ),
|
|
|
|
wxT( "silk_over_copper" ) );
|
2020-09-18 14:24:09 +00:00
|
|
|
|
2020-10-11 21:30:43 +00:00
|
|
|
DRC_ITEM DRC_ITEM::silkOverlaps( DRCE_OVERLAPPING_SILK,
|
2020-10-04 11:44:22 +00:00
|
|
|
_( "Silkscreen overlap" ),
|
|
|
|
wxT( "silk_overlap" ) );
|
2020-09-18 14:24:09 +00:00
|
|
|
|
2020-09-23 21:46:22 +00:00
|
|
|
DRC_ITEM DRC_ITEM::lengthOutOfRange( DRCE_LENGTH_OUT_OF_RANGE,
|
|
|
|
_( "Trace length out of range" ),
|
|
|
|
wxT( "length_out_of_range" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::skewOutOfRange( DRCE_SKEW_OUT_OF_RANGE,
|
|
|
|
_( "Skew between traces out of range" ),
|
|
|
|
wxT( "skew_out_of_range" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::tooManyVias( DRCE_TOO_MANY_VIAS,
|
|
|
|
_( "Too many vias on a connection" ),
|
|
|
|
wxT( "too_many_vias" ) );
|
2020-06-08 02:19:46 +00:00
|
|
|
|
2020-09-26 20:42:09 +00:00
|
|
|
DRC_ITEM DRC_ITEM::diffPairGapOutOfRange( DRCE_DIFF_PAIR_GAP_OUT_OF_RANGE,
|
|
|
|
_( "Differential pair gap out of range" ),
|
|
|
|
wxT( "diff_pair_gap_out_of_range" ) );
|
|
|
|
|
|
|
|
DRC_ITEM DRC_ITEM::diffPairUncoupledLengthTooLong( DRCE_DIFF_PAIR_UNCOUPLED_LENGTH_TOO_LONG,
|
|
|
|
_( "Differential uncoupled length too long" ),
|
|
|
|
wxT( "diff_pair_uncoupled_length_too_long" ) );
|
|
|
|
|
2020-06-08 02:19:46 +00:00
|
|
|
std::vector<std::reference_wrapper<RC_ITEM>> DRC_ITEM::allItemTypes( {
|
|
|
|
DRC_ITEM::unconnectedItems,
|
2020-07-30 20:41:52 +00:00
|
|
|
DRC_ITEM::shortingItems,
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM::itemsNotAllowed,
|
|
|
|
DRC_ITEM::clearance,
|
|
|
|
DRC_ITEM::tracksCrossing,
|
|
|
|
DRC_ITEM::copperEdgeClearance,
|
|
|
|
DRC_ITEM::zonesIntersect,
|
|
|
|
DRC_ITEM::zoneHasEmptyNet,
|
|
|
|
DRC_ITEM::viaDangling,
|
|
|
|
DRC_ITEM::trackDangling,
|
|
|
|
DRC_ITEM::holeNearHole,
|
2020-09-11 15:04:11 +00:00
|
|
|
DRC_ITEM::holeClearance,
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM::trackWidth,
|
2020-09-23 10:46:41 +00:00
|
|
|
DRC_ITEM::annularWidth,
|
2020-06-08 02:19:46 +00:00
|
|
|
DRC_ITEM::drillTooSmall,
|
|
|
|
DRC_ITEM::viaHoleLargerThanPad,
|
|
|
|
DRC_ITEM::padstack,
|
|
|
|
DRC_ITEM::microviaDrillTooSmall,
|
|
|
|
DRC_ITEM::keepout,
|
|
|
|
DRC_ITEM::courtyardsOverlap,
|
|
|
|
DRC_ITEM::missingCourtyard,
|
|
|
|
DRC_ITEM::malformedCourtyard,
|
|
|
|
DRC_ITEM::pthInsideCourtyard,
|
|
|
|
DRC_ITEM::npthInsideCourtyard,
|
|
|
|
DRC_ITEM::itemOnDisabledLayer,
|
|
|
|
DRC_ITEM::invalidOutline,
|
|
|
|
DRC_ITEM::duplicateFootprints,
|
|
|
|
DRC_ITEM::missingFootprint,
|
|
|
|
DRC_ITEM::extraFootprint,
|
2020-09-11 15:04:11 +00:00
|
|
|
DRC_ITEM::netConflict,
|
2020-09-23 21:46:22 +00:00
|
|
|
DRC_ITEM::unresolvedVariable,
|
2020-10-11 21:30:43 +00:00
|
|
|
DRC_ITEM::silkOverlaps,
|
2020-10-04 11:44:22 +00:00
|
|
|
DRC_ITEM::silkMaskClearance,
|
2020-09-23 21:46:22 +00:00
|
|
|
DRC_ITEM::lengthOutOfRange,
|
|
|
|
DRC_ITEM::skewOutOfRange,
|
2020-09-26 20:42:09 +00:00
|
|
|
DRC_ITEM::tooManyVias,
|
|
|
|
DRC_ITEM::diffPairGapOutOfRange,
|
|
|
|
DRC_ITEM::diffPairUncoupledLengthTooLong
|
2020-06-08 02:19:46 +00:00
|
|
|
} );
|
|
|
|
|
|
|
|
|
2020-08-11 13:33:16 +00:00
|
|
|
std::shared_ptr<DRC_ITEM> DRC_ITEM::Create( int aErrorCode )
|
2020-05-07 13:35:50 +00:00
|
|
|
{
|
2020-06-08 02:19:46 +00:00
|
|
|
switch( aErrorCode )
|
2020-05-07 13:35:50 +00:00
|
|
|
{
|
2020-08-15 00:37:23 +00:00
|
|
|
case DRCE_UNCONNECTED_ITEMS: return std::make_shared<DRC_ITEM>( unconnectedItems );
|
|
|
|
case DRCE_SHORTING_ITEMS: return std::make_shared<DRC_ITEM>( shortingItems );
|
|
|
|
case DRCE_ALLOWED_ITEMS: return std::make_shared<DRC_ITEM>( itemsNotAllowed );
|
|
|
|
case DRCE_CLEARANCE: return std::make_shared<DRC_ITEM>( clearance );
|
|
|
|
case DRCE_TRACKS_CROSSING: return std::make_shared<DRC_ITEM>( tracksCrossing );
|
|
|
|
case DRCE_COPPER_EDGE_CLEARANCE: return std::make_shared<DRC_ITEM>( copperEdgeClearance );
|
|
|
|
case DRCE_ZONES_INTERSECT: return std::make_shared<DRC_ITEM>( zonesIntersect );
|
|
|
|
case DRCE_ZONE_HAS_EMPTY_NET: return std::make_shared<DRC_ITEM>( zoneHasEmptyNet );
|
|
|
|
case DRCE_DANGLING_VIA: return std::make_shared<DRC_ITEM>( viaDangling );
|
|
|
|
case DRCE_DANGLING_TRACK: return std::make_shared<DRC_ITEM>( trackDangling );
|
|
|
|
case DRCE_DRILLED_HOLES_TOO_CLOSE: return std::make_shared<DRC_ITEM>( holeNearHole );
|
2020-09-11 15:04:11 +00:00
|
|
|
case DRCE_HOLE_CLEARANCE: return std::make_shared<DRC_ITEM>( holeClearance );
|
2020-08-15 00:37:23 +00:00
|
|
|
case DRCE_TRACK_WIDTH: return std::make_shared<DRC_ITEM>( trackWidth );
|
2020-09-23 10:46:41 +00:00
|
|
|
case DRCE_ANNULAR_WIDTH: return std::make_shared<DRC_ITEM>( annularWidth );
|
2020-08-15 00:37:23 +00:00
|
|
|
case DRCE_TOO_SMALL_DRILL: return std::make_shared<DRC_ITEM>( drillTooSmall );
|
|
|
|
case DRCE_VIA_HOLE_BIGGER: return std::make_shared<DRC_ITEM>( viaHoleLargerThanPad );
|
2020-09-18 12:31:56 +00:00
|
|
|
case DRCE_VIA_DIAMETER: return std::make_shared<DRC_ITEM>( viaDiameter );
|
2020-08-15 00:37:23 +00:00
|
|
|
case DRCE_PADSTACK: return std::make_shared<DRC_ITEM>( padstack );
|
|
|
|
case DRCE_TOO_SMALL_MICROVIA_DRILL: return std::make_shared<DRC_ITEM>( microviaDrillTooSmall );
|
|
|
|
case DRCE_KEEPOUT: return std::make_shared<DRC_ITEM>( keepout );
|
|
|
|
case DRCE_OVERLAPPING_FOOTPRINTS: return std::make_shared<DRC_ITEM>( courtyardsOverlap );
|
|
|
|
case DRCE_MISSING_COURTYARD: return std::make_shared<DRC_ITEM>( missingCourtyard );
|
|
|
|
case DRCE_MALFORMED_COURTYARD: return std::make_shared<DRC_ITEM>( malformedCourtyard );
|
|
|
|
case DRCE_PTH_IN_COURTYARD: return std::make_shared<DRC_ITEM>( pthInsideCourtyard );
|
|
|
|
case DRCE_NPTH_IN_COURTYARD: return std::make_shared<DRC_ITEM>( npthInsideCourtyard );
|
|
|
|
case DRCE_DISABLED_LAYER_ITEM: return std::make_shared<DRC_ITEM>( itemOnDisabledLayer );
|
|
|
|
case DRCE_INVALID_OUTLINE: return std::make_shared<DRC_ITEM>( invalidOutline );
|
2020-08-22 14:38:32 +00:00
|
|
|
case DRCE_MISSING_FOOTPRINT: return std::make_shared<DRC_ITEM>( missingFootprint );
|
|
|
|
case DRCE_DUPLICATE_FOOTPRINT: return std::make_shared<DRC_ITEM>( duplicateFootprints );
|
2020-09-04 09:32:20 +00:00
|
|
|
case DRCE_NET_CONFLICT: return std::make_shared<DRC_ITEM>( netConflict );
|
2020-08-15 00:37:23 +00:00
|
|
|
case DRCE_EXTRA_FOOTPRINT: return std::make_shared<DRC_ITEM>( extraFootprint );
|
|
|
|
case DRCE_UNRESOLVED_VARIABLE: return std::make_shared<DRC_ITEM>( unresolvedVariable );
|
2020-10-11 21:30:43 +00:00
|
|
|
case DRCE_OVERLAPPING_SILK: return std::make_shared<DRC_ITEM>( silkOverlaps );
|
2020-10-04 11:44:22 +00:00
|
|
|
case DRCE_SILK_MASK_CLEARANCE: return std::make_shared<DRC_ITEM>( silkMaskClearance );
|
2020-09-23 21:46:22 +00:00
|
|
|
case DRCE_LENGTH_OUT_OF_RANGE: return std::make_shared<DRC_ITEM>( lengthOutOfRange );
|
|
|
|
case DRCE_SKEW_OUT_OF_RANGE: return std::make_shared<DRC_ITEM>( skewOutOfRange );
|
|
|
|
case DRCE_TOO_MANY_VIAS: return std::make_shared<DRC_ITEM>( tooManyVias );
|
2020-09-26 20:42:09 +00:00
|
|
|
case DRCE_DIFF_PAIR_GAP_OUT_OF_RANGE: return std::make_shared<DRC_ITEM>( diffPairGapOutOfRange );
|
|
|
|
case DRCE_DIFF_PAIR_UNCOUPLED_LENGTH_TOO_LONG: return std::make_shared<DRC_ITEM>( diffPairUncoupledLengthTooLong );
|
2020-06-08 02:19:46 +00:00
|
|
|
default:
|
|
|
|
wxFAIL_MSG( "Unknown DRC error code" );
|
|
|
|
return nullptr;
|
2020-05-07 13:35:50 +00:00
|
|
|
}
|
2020-08-11 13:33:16 +00:00
|
|
|
|
2020-08-15 00:37:23 +00:00
|
|
|
return nullptr;
|
2020-05-07 13:35:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-11 13:33:16 +00:00
|
|
|
std::shared_ptr<DRC_ITEM> DRC_ITEM::Create( const wxString& aErrorKey )
|
2020-05-07 13:35:50 +00:00
|
|
|
{
|
2020-06-08 02:19:46 +00:00
|
|
|
for( const RC_ITEM& item : allItemTypes )
|
2007-12-09 12:59:06 +00:00
|
|
|
{
|
2020-06-08 02:19:46 +00:00
|
|
|
if( aErrorKey == item.GetSettingsKey() )
|
2020-08-15 00:37:23 +00:00
|
|
|
return std::make_shared<DRC_ITEM>( static_cast<const DRC_ITEM&>( item ) );
|
2007-12-09 12:59:06 +00:00
|
|
|
}
|
2020-05-07 13:35:50 +00:00
|
|
|
|
2020-07-06 16:53:55 +00:00
|
|
|
// This can happen if a project has old-format exclusions. Just drop these items.
|
2020-06-08 02:19:46 +00:00
|
|
|
return nullptr;
|
2007-12-09 12:59:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-03-16 11:05:01 +00:00
|
|
|
wxString escapeHtml( wxString aString )
|
2007-12-09 12:59:06 +00:00
|
|
|
{
|
2020-03-16 11:05:01 +00:00
|
|
|
aString.Replace( wxT("<"), wxT("<") );
|
|
|
|
aString.Replace( wxT(">"), wxT(">") );
|
|
|
|
return aString;
|
2007-12-09 12:59:06 +00:00
|
|
|
}
|
2018-01-28 09:35:33 +00:00
|
|
|
|
2018-01-30 14:13:34 +00:00
|
|
|
|