pcbnew.py_back

        """
        return _pcbnew.ZONE_CONTAINER_DrawWhileCreateOutline(self, *args)


    def GetBoundingBox(self):
        """GetBoundingBox(ZONE_CONTAINER self) -> EDA_RECT"""
        return _pcbnew.ZONE_CONTAINER_GetBoundingBox(self)


    def GetClearance(self, aItem=None):
        """
        GetClearance(ZONE_CONTAINER self, BOARD_CONNECTED_ITEM aItem=None) -> int
        GetClearance(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetClearance(self, aItem)


    def TestForCopperIslandAndRemoveInsulatedIslands(self, aPcb):
        """TestForCopperIslandAndRemoveInsulatedIslands(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_TestForCopperIslandAndRemoveInsulatedIslands(self, aPcb)


    def IsOnCopperLayer(self):
        """IsOnCopperLayer(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsOnCopperLayer(self)


    def SetFillMode(self, aFillMode):
        """SetFillMode(ZONE_CONTAINER self, int aFillMode)"""
        return _pcbnew.ZONE_CONTAINER_SetFillMode(self, aFillMode)


    def GetFillMode(self):
        """GetFillMode(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetFillMode(self)


    def SetThermalReliefGap(self, aThermalReliefGap):
        """SetThermalReliefGap(ZONE_CONTAINER self, int aThermalReliefGap)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefGap(self, aThermalReliefGap)


    def GetThermalReliefGap(self, aPad=None):
        """
        GetThermalReliefGap(ZONE_CONTAINER self, D_PAD aPad=None) -> int
        GetThermalReliefGap(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefGap(self, aPad)


    def SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge):
        """SetThermalReliefCopperBridge(ZONE_CONTAINER self, int aThermalReliefCopperBridge)"""
        return _pcbnew.ZONE_CONTAINER_SetThermalReliefCopperBridge(self, aThermalReliefCopperBridge)


    def GetThermalReliefCopperBridge(self, aPad=None):
        """
        GetThermalReliefCopperBridge(ZONE_CONTAINER self, D_PAD aPad=None) -> int
        GetThermalReliefCopperBridge(ZONE_CONTAINER self) -> int
        """
        return _pcbnew.ZONE_CONTAINER_GetThermalReliefCopperBridge(self, aPad)


    def SetArcSegmentCount(self, aArcSegCount):
        """SetArcSegmentCount(ZONE_CONTAINER self, int aArcSegCount)"""
        return _pcbnew.ZONE_CONTAINER_SetArcSegmentCount(self, aArcSegCount)


    def GetArcSegmentCount(self):
        """GetArcSegmentCount(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetArcSegmentCount(self)


    def IsFilled(self):
        """IsFilled(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsFilled(self)


    def SetIsFilled(self, isFilled):
        """SetIsFilled(ZONE_CONTAINER self, bool isFilled)"""
        return _pcbnew.ZONE_CONTAINER_SetIsFilled(self, isFilled)


    def GetZoneClearance(self):
        """GetZoneClearance(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetZoneClearance(self)


    def SetZoneClearance(self, aZoneClearance):
        """SetZoneClearance(ZONE_CONTAINER self, int aZoneClearance)"""
        return _pcbnew.ZONE_CONTAINER_SetZoneClearance(self, aZoneClearance)


    def GetPadConnection(self, aPad=None):
        """
        GetPadConnection(ZONE_CONTAINER self, D_PAD aPad=None) -> ZoneConnection
        GetPadConnection(ZONE_CONTAINER self) -> ZoneConnection
        """
        return _pcbnew.ZONE_CONTAINER_GetPadConnection(self, aPad)


    def SetPadConnection(self, aPadConnection):
        """SetPadConnection(ZONE_CONTAINER self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_CONTAINER_SetPadConnection(self, aPadConnection)


    def GetMinThickness(self):
        """GetMinThickness(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetMinThickness(self)


    def SetMinThickness(self, aMinThickness):
        """SetMinThickness(ZONE_CONTAINER self, int aMinThickness)"""
        return _pcbnew.ZONE_CONTAINER_SetMinThickness(self, aMinThickness)


    def GetSelectedCorner(self):
        """GetSelectedCorner(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetSelectedCorner(self)


    def SetSelectedCorner(self, *args):
        """
        SetSelectedCorner(ZONE_CONTAINER self, int aCorner)
        SetSelectedCorner(ZONE_CONTAINER self, wxPoint aPosition)
        """
        return _pcbnew.ZONE_CONTAINER_SetSelectedCorner(self, *args)


    def GetLocalFlags(self):
        """GetLocalFlags(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetLocalFlags(self)


    def SetLocalFlags(self, aFlags):
        """SetLocalFlags(ZONE_CONTAINER self, int aFlags)"""
        return _pcbnew.ZONE_CONTAINER_SetLocalFlags(self, aFlags)


    def FillSegments(self, *args):
        """
        FillSegments(ZONE_CONTAINER self) -> std::vector< SEGMENT,std::allocator< SEGMENT > >
        FillSegments(ZONE_CONTAINER self) -> std::vector< SEGMENT,std::allocator< SEGMENT > > const &
        """
        return _pcbnew.ZONE_CONTAINER_FillSegments(self, *args)


    def Outline(self, *args):
        """
        Outline(ZONE_CONTAINER self) -> CPolyLine
        Outline(ZONE_CONTAINER self) -> CPolyLine
        """
        return _pcbnew.ZONE_CONTAINER_Outline(self, *args)


    def SetOutline(self, aOutline):
        """SetOutline(ZONE_CONTAINER self, CPolyLine aOutline)"""
        return _pcbnew.ZONE_CONTAINER_SetOutline(self, aOutline)


    def HitTestInsideZone(self, aPosition):
        """HitTestInsideZone(ZONE_CONTAINER self, wxPoint aPosition) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestInsideZone(self, aPosition)


    def HitTestFilledArea(self, aRefPos):
        """HitTestFilledArea(ZONE_CONTAINER self, wxPoint aRefPos) -> bool"""
        return _pcbnew.ZONE_CONTAINER_HitTestFilledArea(self, aRefPos)


    def TransformSolidAreasShapesToPolygonSet(self, aCornerBuffer, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformSolidAreasShapesToPolygonSet(ZONE_CONTAINER self, SHAPE_POLY_SET & aCornerBuffer, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.ZONE_CONTAINER_TransformSolidAreasShapesToPolygonSet(self, aCornerBuffer, aCircleToSegmentsCount, aCorrectionFactor)


    def BuildFilledSolidAreasPolygons(self, aPcb, aOutlineBuffer=None):
        """
        BuildFilledSolidAreasPolygons(ZONE_CONTAINER self, BOARD aPcb, SHAPE_POLY_SET * aOutlineBuffer=None) -> bool
        BuildFilledSolidAreasPolygons(ZONE_CONTAINER self, BOARD aPcb) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_BuildFilledSolidAreasPolygons(self, aPcb, aOutlineBuffer)


    def AddClearanceAreasPolygonsToPolysList(self, aPcb):
        """AddClearanceAreasPolygonsToPolysList(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_AddClearanceAreasPolygonsToPolysList(self, aPcb)


    def AddClearanceAreasPolygonsToPolysList_NG(self, aPcb):
        """AddClearanceAreasPolygonsToPolysList_NG(ZONE_CONTAINER self, BOARD aPcb)"""
        return _pcbnew.ZONE_CONTAINER_AddClearanceAreasPolygonsToPolysList_NG(self, aPcb)


    def TransformOutlinesShapeWithClearanceToPolygon(self, aCornerBuffer, aMinClearanceValue, aUseNetClearance):
        """TransformOutlinesShapeWithClearanceToPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET & aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance)"""
        return _pcbnew.ZONE_CONTAINER_TransformOutlinesShapeWithClearanceToPolygon(self, aCornerBuffer, aMinClearanceValue, aUseNetClearance)


    def HitTestForCorner(self, refPos):
        """HitTestForCorner(ZONE_CONTAINER self, wxPoint refPos) -> int"""
        return _pcbnew.ZONE_CONTAINER_HitTestForCorner(self, refPos)


    def HitTestForEdge(self, refPos):
        """HitTestForEdge(ZONE_CONTAINER self, wxPoint refPos) -> int"""
        return _pcbnew.ZONE_CONTAINER_HitTestForEdge(self, refPos)


    def HitTest(self, *args):
        """
        HitTest(ZONE_CONTAINER self, wxPoint aPosition) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect, bool aContained=True) -> bool
        HitTest(ZONE_CONTAINER self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.ZONE_CONTAINER_HitTest(self, *args)


    def FillZoneAreasWithSegments(self):
        """FillZoneAreasWithSegments(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_FillZoneAreasWithSegments(self)


    def UnFill(self):
        """UnFill(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_UnFill(self)


    def Move(self, offset):
        """Move(ZONE_CONTAINER self, wxPoint offset)"""
        return _pcbnew.ZONE_CONTAINER_Move(self, offset)


    def MoveEdge(self, offset, aEdge):
        """MoveEdge(ZONE_CONTAINER self, wxPoint offset, int aEdge)"""
        return _pcbnew.ZONE_CONTAINER_MoveEdge(self, offset, aEdge)


    def Rotate(self, centre, angle):
        """Rotate(ZONE_CONTAINER self, wxPoint centre, double angle)"""
        return _pcbnew.ZONE_CONTAINER_Rotate(self, centre, angle)


    def Flip(self, aCentre):
        """Flip(ZONE_CONTAINER self, wxPoint aCentre)"""
        return _pcbnew.ZONE_CONTAINER_Flip(self, aCentre)


    def Mirror(self, mirror_ref):
        """Mirror(ZONE_CONTAINER self, wxPoint mirror_ref)"""
        return _pcbnew.ZONE_CONTAINER_Mirror(self, mirror_ref)


    def GetClass(self):
        """GetClass(ZONE_CONTAINER self) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetClass(self)


    def GetNumCorners(self):
        """GetNumCorners(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetNumCorners(self)


    def RemoveAllContours(self):
        """RemoveAllContours(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_RemoveAllContours(self)


    def GetCornerPosition(self, aCornerIndex):
        """GetCornerPosition(ZONE_CONTAINER self, int aCornerIndex) -> wxPoint"""
        return _pcbnew.ZONE_CONTAINER_GetCornerPosition(self, aCornerIndex)


    def SetCornerPosition(self, aCornerIndex, new_pos):
        """SetCornerPosition(ZONE_CONTAINER self, int aCornerIndex, wxPoint new_pos)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerPosition(self, aCornerIndex, new_pos)


    def AppendCorner(self, position):
        """AppendCorner(ZONE_CONTAINER self, wxPoint position)"""
        return _pcbnew.ZONE_CONTAINER_AppendCorner(self, position)


    def GetHatchStyle(self):
        """GetHatchStyle(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetHatchStyle(self)


    def SetHatchStyle(self, aStyle):
        """SetHatchStyle(ZONE_CONTAINER self, CPolyLine::HATCH_STYLE aStyle)"""
        return _pcbnew.ZONE_CONTAINER_SetHatchStyle(self, aStyle)


    def IsSame(self, aZoneToCompare):
        """IsSame(ZONE_CONTAINER self, ZONE_CONTAINER aZoneToCompare) -> bool"""
        return _pcbnew.ZONE_CONTAINER_IsSame(self, aZoneToCompare)


    def ClearFilledPolysList(self):
        """ClearFilledPolysList(ZONE_CONTAINER self)"""
        return _pcbnew.ZONE_CONTAINER_ClearFilledPolysList(self)


    def GetFilledPolysList(self):
        """GetFilledPolysList(ZONE_CONTAINER self) -> SHAPE_POLY_SET const &"""
        return _pcbnew.ZONE_CONTAINER_GetFilledPolysList(self)


    def AddFilledPolysList(self, aPolysList):
        """AddFilledPolysList(ZONE_CONTAINER self, SHAPE_POLY_SET & aPolysList)"""
        return _pcbnew.ZONE_CONTAINER_AddFilledPolysList(self, aPolysList)


    def GetSmoothedPoly(self):
        """GetSmoothedPoly(ZONE_CONTAINER self) -> CPolyLine"""
        return _pcbnew.ZONE_CONTAINER_GetSmoothedPoly(self)


    def SetCornerSmoothingType(self, aType):
        """SetCornerSmoothingType(ZONE_CONTAINER self, int aType)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerSmoothingType(self, aType)


    def GetCornerSmoothingType(self):
        """GetCornerSmoothingType(ZONE_CONTAINER self) -> int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerSmoothingType(self)


    def SetCornerRadius(self, aRadius):
        """SetCornerRadius(ZONE_CONTAINER self, unsigned int aRadius)"""
        return _pcbnew.ZONE_CONTAINER_SetCornerRadius(self, aRadius)


    def GetCornerRadius(self):
        """GetCornerRadius(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetCornerRadius(self)


    def AddPolygon(self, aPolygon):
        """AddPolygon(ZONE_CONTAINER self, wxPoint_Vector aPolygon)"""
        return _pcbnew.ZONE_CONTAINER_AddPolygon(self, aPolygon)


    def AddFilledPolygon(self, aPolygon):
        """AddFilledPolygon(ZONE_CONTAINER self, SHAPE_POLY_SET & aPolygon)"""
        return _pcbnew.ZONE_CONTAINER_AddFilledPolygon(self, aPolygon)


    def AddFillSegments(self, aSegments):
        """AddFillSegments(ZONE_CONTAINER self, std::vector< SEGMENT,std::allocator< SEGMENT > > & aSegments)"""
        return _pcbnew.ZONE_CONTAINER_AddFillSegments(self, aSegments)


    def GetSelectMenuText(self):
        """GetSelectMenuText(ZONE_CONTAINER self) -> wxString"""
        return _pcbnew.ZONE_CONTAINER_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(ZONE_CONTAINER self) -> BITMAP_DEF"""
        return _pcbnew.ZONE_CONTAINER_GetMenuImage(self)


    def Clone(self):
        """Clone(ZONE_CONTAINER self) -> EDA_ITEM"""
        return _pcbnew.ZONE_CONTAINER_Clone(self)


    def GetIsKeepout(self):
        """GetIsKeepout(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetIsKeepout(self)


    def GetDoNotAllowCopperPour(self):
        """GetDoNotAllowCopperPour(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowCopperPour(self)


    def GetDoNotAllowVias(self):
        """GetDoNotAllowVias(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowVias(self)


    def GetDoNotAllowTracks(self):
        """GetDoNotAllowTracks(ZONE_CONTAINER self) -> bool"""
        return _pcbnew.ZONE_CONTAINER_GetDoNotAllowTracks(self)


    def SetIsKeepout(self, aEnable):
        """SetIsKeepout(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetIsKeepout(self, aEnable)


    def SetDoNotAllowCopperPour(self, aEnable):
        """SetDoNotAllowCopperPour(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowCopperPour(self, aEnable)


    def SetDoNotAllowVias(self, aEnable):
        """SetDoNotAllowVias(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowVias(self, aEnable)


    def SetDoNotAllowTracks(self, aEnable):
        """SetDoNotAllowTracks(ZONE_CONTAINER self, bool aEnable)"""
        return _pcbnew.ZONE_CONTAINER_SetDoNotAllowTracks(self, aEnable)

ZONE_CONTAINER_swigregister = _pcbnew.ZONE_CONTAINER_swigregister
ZONE_CONTAINER_swigregister(ZONE_CONTAINER)


_pcbnew.F_Cu_swigconstant(_pcbnew)
F_Cu = _pcbnew.F_Cu

_pcbnew.In1_Cu_swigconstant(_pcbnew)
In1_Cu = _pcbnew.In1_Cu

_pcbnew.In2_Cu_swigconstant(_pcbnew)
In2_Cu = _pcbnew.In2_Cu

_pcbnew.In3_Cu_swigconstant(_pcbnew)
In3_Cu = _pcbnew.In3_Cu

_pcbnew.In4_Cu_swigconstant(_pcbnew)
In4_Cu = _pcbnew.In4_Cu

_pcbnew.In5_Cu_swigconstant(_pcbnew)
In5_Cu = _pcbnew.In5_Cu

_pcbnew.In6_Cu_swigconstant(_pcbnew)
In6_Cu = _pcbnew.In6_Cu

_pcbnew.In7_Cu_swigconstant(_pcbnew)
In7_Cu = _pcbnew.In7_Cu

_pcbnew.In8_Cu_swigconstant(_pcbnew)
In8_Cu = _pcbnew.In8_Cu

_pcbnew.In9_Cu_swigconstant(_pcbnew)
In9_Cu = _pcbnew.In9_Cu

_pcbnew.In10_Cu_swigconstant(_pcbnew)
In10_Cu = _pcbnew.In10_Cu

_pcbnew.In11_Cu_swigconstant(_pcbnew)
In11_Cu = _pcbnew.In11_Cu

_pcbnew.In12_Cu_swigconstant(_pcbnew)
In12_Cu = _pcbnew.In12_Cu

_pcbnew.In13_Cu_swigconstant(_pcbnew)
In13_Cu = _pcbnew.In13_Cu

_pcbnew.In14_Cu_swigconstant(_pcbnew)
In14_Cu = _pcbnew.In14_Cu

_pcbnew.In15_Cu_swigconstant(_pcbnew)
In15_Cu = _pcbnew.In15_Cu

_pcbnew.In16_Cu_swigconstant(_pcbnew)
In16_Cu = _pcbnew.In16_Cu

_pcbnew.In17_Cu_swigconstant(_pcbnew)
In17_Cu = _pcbnew.In17_Cu

_pcbnew.In18_Cu_swigconstant(_pcbnew)
In18_Cu = _pcbnew.In18_Cu

_pcbnew.In19_Cu_swigconstant(_pcbnew)
In19_Cu = _pcbnew.In19_Cu

_pcbnew.In20_Cu_swigconstant(_pcbnew)
In20_Cu = _pcbnew.In20_Cu

_pcbnew.In21_Cu_swigconstant(_pcbnew)
In21_Cu = _pcbnew.In21_Cu

_pcbnew.In22_Cu_swigconstant(_pcbnew)
In22_Cu = _pcbnew.In22_Cu

_pcbnew.In23_Cu_swigconstant(_pcbnew)
In23_Cu = _pcbnew.In23_Cu

_pcbnew.In24_Cu_swigconstant(_pcbnew)
In24_Cu = _pcbnew.In24_Cu

_pcbnew.In25_Cu_swigconstant(_pcbnew)
In25_Cu = _pcbnew.In25_Cu

_pcbnew.In26_Cu_swigconstant(_pcbnew)
In26_Cu = _pcbnew.In26_Cu

_pcbnew.In27_Cu_swigconstant(_pcbnew)
In27_Cu = _pcbnew.In27_Cu

_pcbnew.In28_Cu_swigconstant(_pcbnew)
In28_Cu = _pcbnew.In28_Cu

_pcbnew.In29_Cu_swigconstant(_pcbnew)
In29_Cu = _pcbnew.In29_Cu

_pcbnew.In30_Cu_swigconstant(_pcbnew)
In30_Cu = _pcbnew.In30_Cu

_pcbnew.B_Cu_swigconstant(_pcbnew)
B_Cu = _pcbnew.B_Cu

_pcbnew.B_Adhes_swigconstant(_pcbnew)
B_Adhes = _pcbnew.B_Adhes

_pcbnew.F_Adhes_swigconstant(_pcbnew)
F_Adhes = _pcbnew.F_Adhes

_pcbnew.B_Paste_swigconstant(_pcbnew)
B_Paste = _pcbnew.B_Paste

_pcbnew.F_Paste_swigconstant(_pcbnew)
F_Paste = _pcbnew.F_Paste

_pcbnew.B_SilkS_swigconstant(_pcbnew)
B_SilkS = _pcbnew.B_SilkS

_pcbnew.F_SilkS_swigconstant(_pcbnew)
F_SilkS = _pcbnew.F_SilkS

_pcbnew.B_Mask_swigconstant(_pcbnew)
B_Mask = _pcbnew.B_Mask

_pcbnew.F_Mask_swigconstant(_pcbnew)
F_Mask = _pcbnew.F_Mask

_pcbnew.Dwgs_User_swigconstant(_pcbnew)
Dwgs_User = _pcbnew.Dwgs_User

_pcbnew.Cmts_User_swigconstant(_pcbnew)
Cmts_User = _pcbnew.Cmts_User

_pcbnew.Eco1_User_swigconstant(_pcbnew)
Eco1_User = _pcbnew.Eco1_User

_pcbnew.Eco2_User_swigconstant(_pcbnew)
Eco2_User = _pcbnew.Eco2_User

_pcbnew.Edge_Cuts_swigconstant(_pcbnew)
Edge_Cuts = _pcbnew.Edge_Cuts

_pcbnew.Margin_swigconstant(_pcbnew)
Margin = _pcbnew.Margin

_pcbnew.B_CrtYd_swigconstant(_pcbnew)
B_CrtYd = _pcbnew.B_CrtYd

_pcbnew.F_CrtYd_swigconstant(_pcbnew)
F_CrtYd = _pcbnew.F_CrtYd

_pcbnew.B_Fab_swigconstant(_pcbnew)
B_Fab = _pcbnew.B_Fab

_pcbnew.F_Fab_swigconstant(_pcbnew)
F_Fab = _pcbnew.F_Fab

_pcbnew.LAYER_ID_COUNT_swigconstant(_pcbnew)
LAYER_ID_COUNT = _pcbnew.LAYER_ID_COUNT
class LSEQ(base_seqVect):
    """Proxy of C++ LSEQ class"""
    __swig_setmethods__ = {}
    for _s in [base_seqVect]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LSEQ, name, value)
    __swig_getmethods__ = {}
    for _s in [base_seqVect]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LSEQ, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(LSEQ self) -> LSEQ"""
        this = _pcbnew.new_LSEQ()
        try:
            self.this.append(this)
        except:
            self.this = this

    def Rewind(self):
        """Rewind(LSEQ self)"""
        return _pcbnew.LSEQ_Rewind(self)


    def __nonzero__(self):
        return _pcbnew.LSEQ___nonzero__(self)
    __bool__ = __nonzero__



    def __ref__(self):
        """__ref__(LSEQ self) -> LAYER_ID"""
        return _pcbnew.LSEQ___ref__(self)

    __swig_destroy__ = _pcbnew.delete_LSEQ
    __del__ = lambda self: None
LSEQ_swigregister = _pcbnew.LSEQ_swigregister
LSEQ_swigregister(LSEQ)

class LSET(_object):
    """Proxy of C++ LSET class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LSET, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LSET, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LSET self) -> LSET
        __init__(LSET self, BASE_SET const & aOther) -> LSET
        __init__(LSET self, LAYER_ID aLayer) -> LSET
        __init__(LSET self, LAYER_ID const * aArray, unsigned int aCount) -> LSET
        __init__(LSET self, unsigned int aIdCount, LAYER_ID aFirst) -> LSET
        """
        this = _pcbnew.new_LSET(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Name(aLayerId):
        """Name(LAYER_ID aLayerId) -> wxChar const *"""
        return _pcbnew.LSET_Name(aLayerId)

    if _newclass:
        Name = staticmethod(Name)
    __swig_getmethods__["Name"] = lambda x: Name

    def InternalCuMask():
        """InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()

    if _newclass:
        InternalCuMask = staticmethod(InternalCuMask)
    __swig_getmethods__["InternalCuMask"] = lambda x: InternalCuMask

    def AllCuMask(*args):
        """
        AllCuMask(int aCuLayerCount) -> LSET
        AllCuMask() -> LSET
        """
        return _pcbnew.LSET_AllCuMask(*args)

    if _newclass:
        AllCuMask = staticmethod(AllCuMask)
    __swig_getmethods__["AllCuMask"] = lambda x: AllCuMask

    def AllNonCuMask():
        """AllNonCuMask() -> LSET"""
        return _pcbnew.LSET_AllNonCuMask()

    if _newclass:
        AllNonCuMask = staticmethod(AllNonCuMask)
    __swig_getmethods__["AllNonCuMask"] = lambda x: AllNonCuMask

    def AllLayersMask():
        """AllLayersMask() -> LSET"""
        return _pcbnew.LSET_AllLayersMask()

    if _newclass:
        AllLayersMask = staticmethod(AllLayersMask)
    __swig_getmethods__["AllLayersMask"] = lambda x: AllLayersMask

    def FrontTechMask():
        """FrontTechMask() -> LSET"""
        return _pcbnew.LSET_FrontTechMask()

    if _newclass:
        FrontTechMask = staticmethod(FrontTechMask)
    __swig_getmethods__["FrontTechMask"] = lambda x: FrontTechMask

    def BackTechMask():
        """BackTechMask() -> LSET"""
        return _pcbnew.LSET_BackTechMask()

    if _newclass:
        BackTechMask = staticmethod(BackTechMask)
    __swig_getmethods__["BackTechMask"] = lambda x: BackTechMask

    def AllTechMask():
        """AllTechMask() -> LSET"""
        return _pcbnew.LSET_AllTechMask()

    if _newclass:
        AllTechMask = staticmethod(AllTechMask)
    __swig_getmethods__["AllTechMask"] = lambda x: AllTechMask

    def FrontMask():
        """FrontMask() -> LSET"""
        return _pcbnew.LSET_FrontMask()

    if _newclass:
        FrontMask = staticmethod(FrontMask)
    __swig_getmethods__["FrontMask"] = lambda x: FrontMask

    def BackMask():
        """BackMask() -> LSET"""
        return _pcbnew.LSET_BackMask()

    if _newclass:
        BackMask = staticmethod(BackMask)
    __swig_getmethods__["BackMask"] = lambda x: BackMask

    def UserMask():
        """UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()

    if _newclass:
        UserMask = staticmethod(UserMask)
    __swig_getmethods__["UserMask"] = lambda x: UserMask

    def CuStack(self):
        """CuStack(LSET self) -> LSEQ"""
        return _pcbnew.LSET_CuStack(self)


    def Technicals(self, *args):
        """
        Technicals(LSET self, LSET aSubToOmit) -> LSEQ
        Technicals(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Technicals(self, *args)


    def Users(self):
        """Users(LSET self) -> LSEQ"""
        return _pcbnew.LSET_Users(self)


    def UIOrder(self):
        """UIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_UIOrder(self)


    def Seq(self, *args):
        """
        Seq(LSET self, LAYER_ID const * aWishListSequence, unsigned int aCount) -> LSEQ
        Seq(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Seq(self, *args)


    def SeqStackupBottom2Top(self):
        """SeqStackupBottom2Top(LSET self) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupBottom2Top(self)


    def FmtHex(self):
        """FmtHex(LSET self) -> string"""
        return _pcbnew.LSET_FmtHex(self)


    def ParseHex(self, aStart, aCount):
        """ParseHex(LSET self, char const * aStart, int aCount) -> int"""
        return _pcbnew.LSET_ParseHex(self, aStart, aCount)


    def FmtBin(self):
        """FmtBin(LSET self) -> string"""
        return _pcbnew.LSET_FmtBin(self)


    def ExtractLayer(self):
        """ExtractLayer(LSET self) -> LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)

    __swig_destroy__ = _pcbnew.delete_LSET
    __del__ = lambda self: None
LSET_swigregister = _pcbnew.LSET_swigregister
LSET_swigregister(LSET)

def LSET_Name(aLayerId):
    """LSET_Name(LAYER_ID aLayerId) -> wxChar const *"""
    return _pcbnew.LSET_Name(aLayerId)

def LSET_InternalCuMask():
    """LSET_InternalCuMask() -> LSET"""
    return _pcbnew.LSET_InternalCuMask()

def LSET_AllCuMask(*args):
    """
    AllCuMask(int aCuLayerCount) -> LSET
    LSET_AllCuMask() -> LSET
    """
    return _pcbnew.LSET_AllCuMask(*args)

def LSET_AllNonCuMask():
    """LSET_AllNonCuMask() -> LSET"""
    return _pcbnew.LSET_AllNonCuMask()

def LSET_AllLayersMask():
    """LSET_AllLayersMask() -> LSET"""
    return _pcbnew.LSET_AllLayersMask()

def LSET_FrontTechMask():
    """LSET_FrontTechMask() -> LSET"""
    return _pcbnew.LSET_FrontTechMask()

def LSET_BackTechMask():
    """LSET_BackTechMask() -> LSET"""
    return _pcbnew.LSET_BackTechMask()

def LSET_AllTechMask():
    """LSET_AllTechMask() -> LSET"""
    return _pcbnew.LSET_AllTechMask()

def LSET_FrontMask():
    """LSET_FrontMask() -> LSET"""
    return _pcbnew.LSET_FrontMask()

def LSET_BackMask():
    """LSET_BackMask() -> LSET"""
    return _pcbnew.LSET_BackMask()

def LSET_UserMask():
    """LSET_UserMask() -> LSET"""
    return _pcbnew.LSET_UserMask()


_pcbnew.VIAS_VISIBLE_swigconstant(_pcbnew)
VIAS_VISIBLE = _pcbnew.VIAS_VISIBLE

_pcbnew.VIA_MICROVIA_VISIBLE_swigconstant(_pcbnew)
VIA_MICROVIA_VISIBLE = _pcbnew.VIA_MICROVIA_VISIBLE

_pcbnew.VIA_BBLIND_VISIBLE_swigconstant(_pcbnew)
VIA_BBLIND_VISIBLE = _pcbnew.VIA_BBLIND_VISIBLE

_pcbnew.VIA_THROUGH_VISIBLE_swigconstant(_pcbnew)
VIA_THROUGH_VISIBLE = _pcbnew.VIA_THROUGH_VISIBLE

_pcbnew.NON_PLATED_VISIBLE_swigconstant(_pcbnew)
NON_PLATED_VISIBLE = _pcbnew.NON_PLATED_VISIBLE

_pcbnew.MOD_TEXT_FR_VISIBLE_swigconstant(_pcbnew)
MOD_TEXT_FR_VISIBLE = _pcbnew.MOD_TEXT_FR_VISIBLE

_pcbnew.MOD_TEXT_BK_VISIBLE_swigconstant(_pcbnew)
MOD_TEXT_BK_VISIBLE = _pcbnew.MOD_TEXT_BK_VISIBLE

_pcbnew.MOD_TEXT_INVISIBLE_swigconstant(_pcbnew)
MOD_TEXT_INVISIBLE = _pcbnew.MOD_TEXT_INVISIBLE

_pcbnew.ANCHOR_VISIBLE_swigconstant(_pcbnew)
ANCHOR_VISIBLE = _pcbnew.ANCHOR_VISIBLE

_pcbnew.PAD_FR_VISIBLE_swigconstant(_pcbnew)
PAD_FR_VISIBLE = _pcbnew.PAD_FR_VISIBLE

_pcbnew.PAD_BK_VISIBLE_swigconstant(_pcbnew)
PAD_BK_VISIBLE = _pcbnew.PAD_BK_VISIBLE

_pcbnew.RATSNEST_VISIBLE_swigconstant(_pcbnew)
RATSNEST_VISIBLE = _pcbnew.RATSNEST_VISIBLE

_pcbnew.GRID_VISIBLE_swigconstant(_pcbnew)
GRID_VISIBLE = _pcbnew.GRID_VISIBLE

_pcbnew.NO_CONNECTS_VISIBLE_swigconstant(_pcbnew)
NO_CONNECTS_VISIBLE = _pcbnew.NO_CONNECTS_VISIBLE

_pcbnew.MOD_FR_VISIBLE_swigconstant(_pcbnew)
MOD_FR_VISIBLE = _pcbnew.MOD_FR_VISIBLE

_pcbnew.MOD_BK_VISIBLE_swigconstant(_pcbnew)
MOD_BK_VISIBLE = _pcbnew.MOD_BK_VISIBLE

_pcbnew.MOD_VALUES_VISIBLE_swigconstant(_pcbnew)
MOD_VALUES_VISIBLE = _pcbnew.MOD_VALUES_VISIBLE

_pcbnew.MOD_REFERENCES_VISIBLE_swigconstant(_pcbnew)
MOD_REFERENCES_VISIBLE = _pcbnew.MOD_REFERENCES_VISIBLE

_pcbnew.TRACKS_VISIBLE_swigconstant(_pcbnew)
TRACKS_VISIBLE = _pcbnew.TRACKS_VISIBLE

_pcbnew.PADS_VISIBLE_swigconstant(_pcbnew)
PADS_VISIBLE = _pcbnew.PADS_VISIBLE

_pcbnew.PADS_HOLES_VISIBLE_swigconstant(_pcbnew)
PADS_HOLES_VISIBLE = _pcbnew.PADS_HOLES_VISIBLE

_pcbnew.VIAS_HOLES_VISIBLE_swigconstant(_pcbnew)
VIAS_HOLES_VISIBLE = _pcbnew.VIAS_HOLES_VISIBLE

_pcbnew.DRC_VISIBLE_swigconstant(_pcbnew)
DRC_VISIBLE = _pcbnew.DRC_VISIBLE

_pcbnew.WORKSHEET_swigconstant(_pcbnew)
WORKSHEET = _pcbnew.WORKSHEET

_pcbnew.GP_OVERLAY_swigconstant(_pcbnew)
GP_OVERLAY = _pcbnew.GP_OVERLAY

_pcbnew.END_PCB_VISIBLE_LIST_swigconstant(_pcbnew)
END_PCB_VISIBLE_LIST = _pcbnew.END_PCB_VISIBLE_LIST

_pcbnew.PAD_FR_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PAD_FR_NETNAMES_VISIBLE = _pcbnew.PAD_FR_NETNAMES_VISIBLE

_pcbnew.PAD_BK_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PAD_BK_NETNAMES_VISIBLE = _pcbnew.PAD_BK_NETNAMES_VISIBLE

_pcbnew.PADS_NETNAMES_VISIBLE_swigconstant(_pcbnew)
PADS_NETNAMES_VISIBLE = _pcbnew.PADS_NETNAMES_VISIBLE

_pcbnew.END_NETNAMES_VISIBLE_LIST_swigconstant(_pcbnew)
END_NETNAMES_VISIBLE_LIST = _pcbnew.END_NETNAMES_VISIBLE_LIST

def IsValidLayer(aLayerId):
    """IsValidLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsValidLayer(aLayerId)

def IsPcbLayer(aLayer):
    """IsPcbLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsPcbLayer(aLayer)

def IsCopperLayer(aLayerId):
    """IsCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsCopperLayer(aLayerId)

def IsNonCopperLayer(aLayerId):
    """IsNonCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsNonCopperLayer(aLayerId)

def IsUserLayer(aLayerId):
    """IsUserLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsUserLayer(aLayerId)

def IsFrontLayer(aLayerId):
    """IsFrontLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsFrontLayer(aLayerId)

def IsBackLayer(aLayerId):
    """IsBackLayer(LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsBackLayer(aLayerId)

def FlipLayer(oldlayer):
    """FlipLayer(LAYER_ID oldlayer) -> LAYER_ID"""
    return _pcbnew.FlipLayer(oldlayer)

def FlipLayerMask(aMask):
    """FlipLayerMask(LSET aMask) -> LSET"""
    return _pcbnew.FlipLayerMask(aMask)

def LayerMaskDescribe(aBoard, aMask):
    """LayerMaskDescribe(BOARD aBoard, LSET aMask) -> wxString"""
    return _pcbnew.LayerMaskDescribe(aBoard, aMask)

def GetNetnameLayer(aLayer):
    """GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)

def IsNetnameLayer(aLayer):
    """IsNetnameLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)

def ToLAYER_ID(aLayer):
    """ToLAYER_ID(int aLayer) -> LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
class PAD_DRAWINFO(_object):
    """Proxy of C++ PAD_DRAWINFO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PAD_DRAWINFO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PAD_DRAWINFO, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_DrawPanel"] = _pcbnew.PAD_DRAWINFO_m_DrawPanel_set
    __swig_getmethods__["m_DrawPanel"] = _pcbnew.PAD_DRAWINFO_m_DrawPanel_get
    if _newclass:
        m_DrawPanel = _swig_property(_pcbnew.PAD_DRAWINFO_m_DrawPanel_get, _pcbnew.PAD_DRAWINFO_m_DrawPanel_set)
    __swig_setmethods__["m_DrawMode"] = _pcbnew.PAD_DRAWINFO_m_DrawMode_set
    __swig_getmethods__["m_DrawMode"] = _pcbnew.PAD_DRAWINFO_m_DrawMode_get
    if _newclass:
        m_DrawMode = _swig_property(_pcbnew.PAD_DRAWINFO_m_DrawMode_get, _pcbnew.PAD_DRAWINFO_m_DrawMode_set)
    __swig_setmethods__["m_Color"] = _pcbnew.PAD_DRAWINFO_m_Color_set
    __swig_getmethods__["m_Color"] = _pcbnew.PAD_DRAWINFO_m_Color_get
    if _newclass:
        m_Color = _swig_property(_pcbnew.PAD_DRAWINFO_m_Color_get, _pcbnew.PAD_DRAWINFO_m_Color_set)
    __swig_setmethods__["m_HoleColor"] = _pcbnew.PAD_DRAWINFO_m_HoleColor_set
    __swig_getmethods__["m_HoleColor"] = _pcbnew.PAD_DRAWINFO_m_HoleColor_get
    if _newclass:
        m_HoleColor = _swig_property(_pcbnew.PAD_DRAWINFO_m_HoleColor_get, _pcbnew.PAD_DRAWINFO_m_HoleColor_set)
    __swig_setmethods__["m_NPHoleColor"] = _pcbnew.PAD_DRAWINFO_m_NPHoleColor_set
    __swig_getmethods__["m_NPHoleColor"] = _pcbnew.PAD_DRAWINFO_m_NPHoleColor_get
    if _newclass:
        m_NPHoleColor = _swig_property(_pcbnew.PAD_DRAWINFO_m_NPHoleColor_get, _pcbnew.PAD_DRAWINFO_m_NPHoleColor_set)
    __swig_setmethods__["m_PadClearance"] = _pcbnew.PAD_DRAWINFO_m_PadClearance_set
    __swig_getmethods__["m_PadClearance"] = _pcbnew.PAD_DRAWINFO_m_PadClearance_get
    if _newclass:
        m_PadClearance = _swig_property(_pcbnew.PAD_DRAWINFO_m_PadClearance_get, _pcbnew.PAD_DRAWINFO_m_PadClearance_set)
    __swig_setmethods__["m_Mask_margin"] = _pcbnew.PAD_DRAWINFO_m_Mask_margin_set
    __swig_getmethods__["m_Mask_margin"] = _pcbnew.PAD_DRAWINFO_m_Mask_margin_get
    if _newclass:
        m_Mask_margin = _swig_property(_pcbnew.PAD_DRAWINFO_m_Mask_margin_get, _pcbnew.PAD_DRAWINFO_m_Mask_margin_set)