pcbnew.py_back

        return _pcbnew.MODULE_SetAttributes(self, aAttributes)


    def SetFlag(self, aFlag):
        """SetFlag(MODULE self, int aFlag)"""
        return _pcbnew.MODULE_SetFlag(self, aFlag)


    def IncrementFlag(self):
        """IncrementFlag(MODULE self)"""
        return _pcbnew.MODULE_IncrementFlag(self)


    def GetFlag(self):
        """GetFlag(MODULE self) -> int"""
        return _pcbnew.MODULE_GetFlag(self)


    def Move(self, aMoveVector):
        """Move(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.MODULE_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(MODULE self, wxPoint aCentre)"""
        return _pcbnew.MODULE_Flip(self, aCentre)


    def MoveAnchorPosition(self, aMoveVector):
        """MoveAnchorPosition(MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_MoveAnchorPosition(self, aMoveVector)


    def IsFlipped(self):
        """IsFlipped(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsFlipped(self)


    def IsLocked(self):
        """IsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsLocked(self)


    def SetLocked(self, isLocked):
        """SetLocked(MODULE self, bool isLocked)"""
        return _pcbnew.MODULE_SetLocked(self, isLocked)


    def IsPlaced(self):
        """IsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_IsPlaced(self)


    def SetIsPlaced(self, isPlaced):
        """SetIsPlaced(MODULE self, bool isPlaced)"""
        return _pcbnew.MODULE_SetIsPlaced(self, isPlaced)


    def NeedsPlaced(self):
        """NeedsPlaced(MODULE self) -> bool"""
        return _pcbnew.MODULE_NeedsPlaced(self)


    def SetNeedsPlaced(self, needsPlaced):
        """SetNeedsPlaced(MODULE self, bool needsPlaced)"""
        return _pcbnew.MODULE_SetNeedsPlaced(self, needsPlaced)


    def PadsLocked(self):
        """PadsLocked(MODULE self) -> bool"""
        return _pcbnew.MODULE_PadsLocked(self)


    def SetPadsLocked(self, aPadsLocked):
        """SetPadsLocked(MODULE self, bool aPadsLocked)"""
        return _pcbnew.MODULE_SetPadsLocked(self, aPadsLocked)


    def SetLastEditTime(self, *args):
        """
        SetLastEditTime(MODULE self, time_t aTime)
        SetLastEditTime(MODULE self)
        """
        return _pcbnew.MODULE_SetLastEditTime(self, *args)


    def GetLastEditTime(self):
        """GetLastEditTime(MODULE self) -> time_t"""
        return _pcbnew.MODULE_GetLastEditTime(self)


    def Draw(self, *args):
        """
        Draw(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.MODULE_Draw(self, *args)


    def DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector):
        """DrawOutlinesWhenMoving(MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, wxPoint aMoveVector)"""
        return _pcbnew.MODULE_DrawOutlinesWhenMoving(self, aPanel, aDC, aMoveVector)


    def TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper=False):
        """
        TransformPadsShapesWithClearanceToPolygon(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool aSkipNPTHPadsWihNoCopper=False)
        TransformPadsShapesWithClearanceToPolygon(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)
        """
        return _pcbnew.MODULE_TransformPadsShapesWithClearanceToPolygon(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor, aSkipNPTHPadsWihNoCopper)


    def TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformGraphicShapesWithClearanceToPolygonSet(MODULE self, LAYER_ID aLayer, SHAPE_POLY_SET & aCornerBuffer, int aInflateValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.MODULE_TransformGraphicShapesWithClearanceToPolygonSet(self, aLayer, aCornerBuffer, aInflateValue, aCircleToSegmentsCount, aCorrectionFactor)


    def DrawEdgesOnly(self, panel, DC, offset, draw_mode):
        """DrawEdgesOnly(MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_DrawEdgesOnly(self, panel, DC, offset, draw_mode)


    def DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode):
        """DrawAncre(MODULE self, EDA_DRAW_PANEL * panel, wxDC * DC, wxPoint offset, int dim_ancre, GR_DRAWMODE draw_mode)"""
        return _pcbnew.MODULE_DrawAncre(self, panel, DC, offset, dim_ancre, draw_mode)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(MODULE self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.MODULE_GetMsgPanelInfo(self, aList)


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


    def GetReference(self):
        """GetReference(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetReference(self)


    def SetReference(self, aReference):
        """SetReference(MODULE self, wxString const & aReference)"""
        return _pcbnew.MODULE_SetReference(self, aReference)


    def GetReferencePrefix(self):
        """GetReferencePrefix(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetReferencePrefix(self)


    def GetValue(self):
        """GetValue(MODULE self) -> wxString const &"""
        return _pcbnew.MODULE_GetValue(self)


    def SetValue(self, aValue):
        """SetValue(MODULE self, wxString const & aValue)"""
        return _pcbnew.MODULE_SetValue(self, aValue)


    def Value(self, *args):
        """
        Value(MODULE self) -> TEXTE_MODULE
        Value(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Value(self, *args)


    def Reference(self, *args):
        """
        Reference(MODULE self) -> TEXTE_MODULE
        Reference(MODULE self) -> TEXTE_MODULE
        """
        return _pcbnew.MODULE_Reference(self, *args)


    def IncrementItemReference(self):
        """IncrementItemReference(MODULE self) -> bool"""
        return _pcbnew.MODULE_IncrementItemReference(self)


    def IncrementReference(self, aFillSequenceGaps):
        """IncrementReference(MODULE self, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.MODULE_IncrementReference(self, aFillSequenceGaps)


    def FindPadByName(self, aPadName):
        """FindPadByName(MODULE self, wxString const & aPadName) -> D_PAD"""
        return _pcbnew.MODULE_FindPadByName(self, aPadName)


    def GetPad(self, *args):
        """
        GetPad(MODULE self, wxPoint aPosition, LSET aLayerMask) -> D_PAD
        GetPad(MODULE self, wxPoint aPosition) -> D_PAD
        """
        return _pcbnew.MODULE_GetPad(self, *args)


    def GetPadCount(self, *args):
        """
        GetPadCount(MODULE self, INCLUDE_NPTH_T aIncludeNPTH) -> unsigned int
        GetPadCount(MODULE self) -> unsigned int
        """
        return _pcbnew.MODULE_GetPadCount(self, *args)


    def GetNextPadName(self, aFillSequenceGaps):
        """GetNextPadName(MODULE self, bool aFillSequenceGaps) -> wxString"""
        return _pcbnew.MODULE_GetNextPadName(self, aFillSequenceGaps)


    def GetArea(self):
        """GetArea(MODULE self) -> double"""
        return _pcbnew.MODULE_GetArea(self)


    def GetLink(self):
        """GetLink(MODULE self) -> time_t"""
        return _pcbnew.MODULE_GetLink(self)


    def SetLink(self, aLink):
        """SetLink(MODULE self, time_t aLink)"""
        return _pcbnew.MODULE_SetLink(self, aLink)


    def GetPlacementCost180(self):
        """GetPlacementCost180(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost180(self)


    def SetPlacementCost180(self, aCost):
        """SetPlacementCost180(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost180(self, aCost)


    def GetPlacementCost90(self):
        """GetPlacementCost90(MODULE self) -> int"""
        return _pcbnew.MODULE_GetPlacementCost90(self)


    def SetPlacementCost90(self, aCost):
        """SetPlacementCost90(MODULE self, int aCost)"""
        return _pcbnew.MODULE_SetPlacementCost90(self, aCost)


    def DuplicateAndAddItem(self, item, aIncrementPadNumbers):
        """DuplicateAndAddItem(MODULE self, BOARD_ITEM item, bool aIncrementPadNumbers) -> BOARD_ITEM"""
        return _pcbnew.MODULE_DuplicateAndAddItem(self, item, aIncrementPadNumbers)


    def Add3DModel(self, a3DModel):
        """Add3DModel(MODULE self, S3D_MASTER * a3DModel)"""
        return _pcbnew.MODULE_Add3DModel(self, a3DModel)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(MODULE self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.MODULE_Visit(self, inspector, testData, scanTypes)


    def GetClass(self):
        """GetClass(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(MODULE self) -> wxString"""
        return _pcbnew.MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(MODULE self) -> BITMAP_DEF"""
        return _pcbnew.MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(MODULE self) -> EDA_ITEM"""
        return _pcbnew.MODULE_Clone(self)


    def RunOnChildren(self, aFunction):
        """RunOnChildren(MODULE self, boost::function< void (BOARD_ITEM *) > aFunction)"""
        return _pcbnew.MODULE_RunOnChildren(self, aFunction)


    def ViewUpdate(self, *args):
        """
        ViewUpdate(MODULE self, int aUpdateFlags)
        ViewUpdate(MODULE self)
        """
        return _pcbnew.MODULE_ViewUpdate(self, *args)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(MODULE self, int [] aLayers, int & aCount)"""
        return _pcbnew.MODULE_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(MODULE self, int aLayer) -> unsigned int"""
        return _pcbnew.MODULE_ViewGetLOD(self, aLayer)


    def ViewBBox(self):
        """ViewBBox(MODULE self) -> BOX2I const"""
        return _pcbnew.MODULE_ViewBBox(self)


    def CopyNetlistSettings(self, aModule):
        """CopyNetlistSettings(MODULE self, MODULE aModule)"""
        return _pcbnew.MODULE_CopyNetlistSettings(self, aModule)


    def IsLibNameValid(aName):
        """IsLibNameValid(wxString const & aName) -> bool"""
        return _pcbnew.MODULE_IsLibNameValid(aName)

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

    def StringLibNameInvalidChars(aUserReadable):
        """StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)

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

    def SetInitialComments(self, aInitialComments):
        """SetInitialComments(MODULE self, wxArrayString * aInitialComments)"""
        return _pcbnew.MODULE_SetInitialComments(self, aInitialComments)


    def PadCoverageRatio(self):
        """PadCoverageRatio(MODULE self) -> double"""
        return _pcbnew.MODULE_PadCoverageRatio(self)


    def GetInitialComments(self):
        """GetInitialComments(MODULE self) -> wxArrayString const *"""
        return _pcbnew.MODULE_GetInitialComments(self)



        #def SaveToLibrary(self,filename):
        #  return SaveModuleToLibrary(filename,self)

        #
        # add function, clears the thisown to avoid python from deleting
        # the object in the garbage collector
        #

    def Add(self,item):

        itemC = item.Cast()

        if type(itemC) is D_PAD:
            item.thisown=0
            self.Pads().PushBack(itemC)
        elif type(itemC) in [ TEXTE_PCB, DIMENSION, TEXTE_MODULE, DRAWSEGMENT,EDGE_MODULE]:
            item.thisown = 0
            self.GraphicalItems().PushBack(item)

MODULE_swigregister = _pcbnew.MODULE_swigregister
MODULE_swigregister(MODULE)

def MODULE_ClassOf(aItem):
    """MODULE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.MODULE_ClassOf(aItem)

_pcbnew.MODULE_is_LOCKED_swigconstant(_pcbnew)
MODULE_is_LOCKED = _pcbnew.MODULE_is_LOCKED

_pcbnew.MODULE_is_PLACED_swigconstant(_pcbnew)
MODULE_is_PLACED = _pcbnew.MODULE_is_PLACED

_pcbnew.MODULE_to_PLACE_swigconstant(_pcbnew)
MODULE_to_PLACE = _pcbnew.MODULE_to_PLACE

_pcbnew.MODULE_PADS_LOCKED_swigconstant(_pcbnew)
MODULE_PADS_LOCKED = _pcbnew.MODULE_PADS_LOCKED

def MODULE_IsLibNameValid(aName):
    """MODULE_IsLibNameValid(wxString const & aName) -> bool"""
    return _pcbnew.MODULE_IsLibNameValid(aName)

def MODULE_StringLibNameInvalidChars(aUserReadable):
    """MODULE_StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
    return _pcbnew.MODULE_StringLibNameInvalidChars(aUserReadable)


_pcbnew.VIA_THROUGH_swigconstant(_pcbnew)
VIA_THROUGH = _pcbnew.VIA_THROUGH

_pcbnew.VIA_BLIND_BURIED_swigconstant(_pcbnew)
VIA_BLIND_BURIED = _pcbnew.VIA_BLIND_BURIED

_pcbnew.VIA_MICROVIA_swigconstant(_pcbnew)
VIA_MICROVIA = _pcbnew.VIA_MICROVIA

_pcbnew.VIA_NOT_DEFINED_swigconstant(_pcbnew)
VIA_NOT_DEFINED = _pcbnew.VIA_NOT_DEFINED

_pcbnew.UNDEFINED_DRILL_DIAMETER_swigconstant(_pcbnew)
UNDEFINED_DRILL_DIAMETER = _pcbnew.UNDEFINED_DRILL_DIAMETER

_pcbnew.MIN_VIA_DRAW_SIZE_swigconstant(_pcbnew)
MIN_VIA_DRAW_SIZE = _pcbnew.MIN_VIA_DRAW_SIZE

def GetTrack(aStartTrace, aEndTrace, aPosition, aLayerMask):
    """GetTrack(TRACK aStartTrace, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> TRACK"""
    return _pcbnew.GetTrack(aStartTrace, aEndTrace, aPosition, aLayerMask)
class TRACK(BOARD_CONNECTED_ITEM):
    """Proxy of C++ TRACK class"""
    __swig_setmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TRACK, name, value)
    __swig_getmethods__ = {}
    for _s in [BOARD_CONNECTED_ITEM]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TRACK, name)
    __repr__ = _swig_repr

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_ClassOf(aItem)

    if _newclass:
        ClassOf = staticmethod(ClassOf)
    __swig_getmethods__["ClassOf"] = lambda x: ClassOf
    __swig_setmethods__["start"] = _pcbnew.TRACK_start_set
    __swig_getmethods__["start"] = _pcbnew.TRACK_start_get
    if _newclass:
        start = _swig_property(_pcbnew.TRACK_start_get, _pcbnew.TRACK_start_set)
    __swig_setmethods__["end"] = _pcbnew.TRACK_end_set
    __swig_getmethods__["end"] = _pcbnew.TRACK_end_get
    if _newclass:
        end = _swig_property(_pcbnew.TRACK_end_get, _pcbnew.TRACK_end_set)
    __swig_setmethods__["m_Param"] = _pcbnew.TRACK_m_Param_set
    __swig_getmethods__["m_Param"] = _pcbnew.TRACK_m_Param_get
    if _newclass:
        m_Param = _swig_property(_pcbnew.TRACK_m_Param_get, _pcbnew.TRACK_m_Param_set)

    def __init__(self, *args):
        """
        __init__(TRACK self, BOARD_ITEM aParent, KICAD_T idtype) -> TRACK
        __init__(TRACK self, BOARD_ITEM aParent) -> TRACK
        """
        this = _pcbnew.new_TRACK(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Next(self):
        """Next(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Next(self)


    def Back(self):
        """Back(TRACK self) -> TRACK"""
        return _pcbnew.TRACK_Back(self)


    def Move(self, aMoveVector):
        """Move(TRACK self, wxPoint aMoveVector)"""
        return _pcbnew.TRACK_Move(self, aMoveVector)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(TRACK self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.TRACK_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(TRACK self, wxPoint aCentre)"""
        return _pcbnew.TRACK_Flip(self, aCentre)


    def SetPosition(self, aPos):
        """SetPosition(TRACK self, wxPoint aPos)"""
        return _pcbnew.TRACK_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetPosition(self)


    def SetWidth(self, aWidth):
        """SetWidth(TRACK self, int aWidth)"""
        return _pcbnew.TRACK_SetWidth(self, aWidth)


    def GetWidth(self):
        """GetWidth(TRACK self) -> int"""
        return _pcbnew.TRACK_GetWidth(self)


    def SetEnd(self, aEnd):
        """SetEnd(TRACK self, wxPoint aEnd)"""
        return _pcbnew.TRACK_SetEnd(self, aEnd)


    def GetEnd(self):
        """GetEnd(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetEnd(self)


    def SetStart(self, aStart):
        """SetStart(TRACK self, wxPoint aStart)"""
        return _pcbnew.TRACK_SetStart(self, aStart)


    def GetStart(self):
        """GetStart(TRACK self) -> wxPoint"""
        return _pcbnew.TRACK_GetStart(self)


    def GetEndPoint(self, aEndPoint):
        """GetEndPoint(TRACK self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.TRACK_GetEndPoint(self, aEndPoint)


    def GetBoundingBox(self):
        """GetBoundingBox(TRACK self) -> EDA_RECT"""
        return _pcbnew.TRACK_GetBoundingBox(self)


    def GetBestInsertPoint(self, aPcb):
        """GetBestInsertPoint(TRACK self, BOARD aPcb) -> TRACK"""
        return _pcbnew.TRACK_GetBestInsertPoint(self, aPcb)


    def GetStartNetCode(self, NetCode):
        """GetStartNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetStartNetCode(self, NetCode)


    def GetEndNetCode(self, NetCode):
        """GetEndNetCode(TRACK self, int NetCode) -> TRACK"""
        return _pcbnew.TRACK_GetEndNetCode(self, NetCode)


    def GetLength(self):
        """GetLength(TRACK self) -> double"""
        return _pcbnew.TRACK_GetLength(self)


    def Draw(self, *args):
        """
        Draw(TRACK self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(TRACK self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TRACK_Draw(self, *args)


    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor):
        """TransformShapeWithClearanceToPolygon(TRACK self, SHAPE_POLY_SET & aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor)"""
        return _pcbnew.TRACK_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aCircleToSegmentsCount, aCorrectionFactor)


    def IsPointOnEnds(self, point, min_dist=0):
        """
        IsPointOnEnds(TRACK self, wxPoint point, int min_dist=0) -> STATUS_FLAGS
        IsPointOnEnds(TRACK self, wxPoint point) -> STATUS_FLAGS
        """
        return _pcbnew.TRACK_IsPointOnEnds(self, point, min_dist)


    def IsNull(self):
        """IsNull(TRACK self) -> bool"""
        return _pcbnew.TRACK_IsNull(self)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(TRACK self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.TRACK_GetMsgPanelInfo(self, aList)


    def ShowWidth(self):
        """ShowWidth(TRACK self) -> wxString"""
        return _pcbnew.TRACK_ShowWidth(self)


    def Visit(self, inspector, testData, scanTypes):
        """Visit(TRACK self, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.TRACK_Visit(self, inspector, testData, scanTypes)


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


    def GetVia(self, *args):
        """
        GetVia(TRACK self, wxPoint aPosition, LAYER_ID aLayer) -> VIA
        GetVia(TRACK self, wxPoint aPosition) -> VIA
        GetVia(TRACK self, TRACK aEndTrace, wxPoint aPosition, LSET aLayerMask) -> VIA
        """
        return _pcbnew.TRACK_GetVia(self, *args)


    def GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential):
        """GetTrack(TRACK self, TRACK aStartTrace, TRACK aEndTrace, ENDPOINT_T aEndPoint, bool aSameNetOnly, bool aSequential) -> TRACK"""
        return _pcbnew.TRACK_GetTrack(self, aStartTrace, aEndTrace, aEndPoint, aSameNetOnly, aSequential)


    def GetEndSegments(self, NbSegm, StartTrack, EndTrack):
        """GetEndSegments(TRACK self, int NbSegm, TRACK ** StartTrack, TRACK ** EndTrack) -> int"""
        return _pcbnew.TRACK_GetEndSegments(self, NbSegm, StartTrack, EndTrack)


    def GetClass(self):
        """GetClass(TRACK self) -> wxString"""
        return _pcbnew.TRACK_GetClass(self)


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


    def GetSelectMenuText(self):
        """GetSelectMenuText(TRACK self) -> wxString"""
        return _pcbnew.TRACK_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TRACK self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_GetMenuImage(self)


    def Clone(self):
        """Clone(TRACK self) -> EDA_ITEM"""
        return _pcbnew.TRACK_Clone(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(TRACK self, int [] aLayers, int & aCount)"""
        return _pcbnew.TRACK_ViewGetLayers(self, aLayers, aCount)


    def ViewGetLOD(self, aLayer):
        """ViewGetLOD(TRACK self, int aLayer) -> unsigned int"""
        return _pcbnew.TRACK_ViewGetLOD(self, aLayer)

    __swig_destroy__ = _pcbnew.delete_TRACK
    __del__ = lambda self: None
TRACK_swigregister = _pcbnew.TRACK_swigregister
TRACK_swigregister(TRACK)

def TRACK_ClassOf(aItem):
    """TRACK_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.TRACK_ClassOf(aItem)

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

    def __init__(self, aParent):
        """__init__(SEGZONE self, BOARD_ITEM aParent) -> SEGZONE"""
        this = _pcbnew.new_SEGZONE(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetClass(self):
        """GetClass(SEGZONE self) -> wxString"""
        return _pcbnew.SEGZONE_GetClass(self)


    def Next(self):
        """Next(SEGZONE self) -> SEGZONE"""
        return _pcbnew.SEGZONE_Next(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(SEGZONE self) -> wxString"""
        return _pcbnew.SEGZONE_GetSelectMenuText(self)


    def Draw(self, *args):
        """
        Draw(SEGZONE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(SEGZONE self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.SEGZONE_Draw(self, *args)


    def GetMenuImage(self):
        """GetMenuImage(SEGZONE self) -> BITMAP_DEF"""
        return _pcbnew.SEGZONE_GetMenuImage(self)


    def Clone(self):
        """Clone(SEGZONE self) -> EDA_ITEM"""
        return _pcbnew.SEGZONE_Clone(self)

    __swig_destroy__ = _pcbnew.delete_SEGZONE
    __del__ = lambda self: None
SEGZONE_swigregister = _pcbnew.SEGZONE_swigregister
SEGZONE_swigregister(SEGZONE)

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

    def __init__(self, aParent):
        """__init__(VIA self, BOARD_ITEM aParent) -> VIA"""
        this = _pcbnew.new_VIA(aParent)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ClassOf(aItem):
        """ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.VIA_ClassOf(aItem)

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

    def Draw(self, *args):
        """
        Draw(VIA self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        Draw(VIA self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.VIA_Draw(self, *args)


    def IsOnLayer(self, aLayer):
        """IsOnLayer(VIA self, LAYER_ID aLayer) -> bool"""
        return _pcbnew.VIA_IsOnLayer(self, aLayer)


    def GetLayerSet(self):
        """GetLayerSet(VIA self) -> LSET"""
        return _pcbnew.VIA_GetLayerSet(self)


    def SetLayerPair(self, aTopLayer, aBottomLayer):
        """SetLayerPair(VIA self, LAYER_ID aTopLayer, LAYER_ID aBottomLayer)"""
        return _pcbnew.VIA_SetLayerPair(self, aTopLayer, aBottomLayer)


    def LayerPair(self, top_layer, bottom_layer):
        """LayerPair(VIA self, LAYER_ID * top_layer, LAYER_ID * bottom_layer)"""
        return _pcbnew.VIA_LayerPair(self, top_layer, bottom_layer)


    def GetPosition(self):
        """GetPosition(VIA self) -> wxPoint"""
        return _pcbnew.VIA_GetPosition(self)


    def SetPosition(self, aPoint):
        """SetPosition(VIA self, wxPoint aPoint)"""
        return _pcbnew.VIA_SetPosition(self, aPoint)


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


    def GetClass(self):
        """GetClass(VIA self) -> wxString"""
        return _pcbnew.VIA_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(VIA self) -> wxString"""
        return _pcbnew.VIA_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(VIA self) -> BITMAP_DEF"""
        return _pcbnew.VIA_GetMenuImage(self)


    def Clone(self):
        """Clone(VIA self) -> EDA_ITEM"""
        return _pcbnew.VIA_Clone(self)


    def ViewGetLayers(self, aLayers, aCount):
        """ViewGetLayers(VIA self, int [] aLayers, int & aCount)"""
        return _pcbnew.VIA_ViewGetLayers(self, aLayers, aCount)


    def Flip(self, aCentre):
        """Flip(VIA self, wxPoint aCentre)"""
        return _pcbnew.VIA_Flip(self, aCentre)


    def GetViaType(self):
        """GetViaType(VIA self) -> VIATYPE_T"""
        return _pcbnew.VIA_GetViaType(self)


    def SetViaType(self, aViaType):
        """SetViaType(VIA self, VIATYPE_T aViaType)"""
        return _pcbnew.VIA_SetViaType(self, aViaType)


    def SetDrill(self, aDrill):
        """SetDrill(VIA self, int aDrill)"""
        return _pcbnew.VIA_SetDrill(self, aDrill)


    def GetDrill(self):
        """GetDrill(VIA self) -> int"""
        return _pcbnew.VIA_GetDrill(self)


    def GetDrillValue(self):
        """GetDrillValue(VIA self) -> int"""
        return _pcbnew.VIA_GetDrillValue(self)


    def SetDrillDefault(self):
        """SetDrillDefault(VIA self)"""
        return _pcbnew.VIA_SetDrillDefault(self)


    def IsDrillDefault(self):
        """IsDrillDefault(VIA self) -> bool"""
        return _pcbnew.VIA_IsDrillDefault(self)

    __swig_destroy__ = _pcbnew.delete_VIA
    __del__ = lambda self: None
VIA_swigregister = _pcbnew.VIA_swigregister
VIA_swigregister(VIA)

def VIA_ClassOf(aItem):
    """VIA_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.VIA_ClassOf(aItem)


def GetFirstVia(aTrk, aStopPoint=None):
    """
    GetFirstVia(TRACK aTrk, TRACK aStopPoint=None) -> VIA
    GetFirstVia(TRACK aTrk) -> VIA
    """
    return _pcbnew.GetFirstVia(aTrk, aStopPoint)
class SEGMENT(_object):
    """Proxy of C++ SEGMENT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SEGMENT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SEGMENT, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_Start"] = _pcbnew.SEGMENT_m_Start_set
    __swig_getmethods__["m_Start"] = _pcbnew.SEGMENT_m_Start_get
    if _newclass:
        m_Start = _swig_property(_pcbnew.SEGMENT_m_Start_get, _pcbnew.SEGMENT_m_Start_set)
    __swig_setmethods__["m_End"] = _pcbnew.SEGMENT_m_End_set
    __swig_getmethods__["m_End"] = _pcbnew.SEGMENT_m_End_get
    if _newclass:
        m_End = _swig_property(_pcbnew.SEGMENT_m_End_get, _pcbnew.SEGMENT_m_End_set)

    def __init__(self, *args):
        """
        __init__(SEGMENT self) -> SEGMENT
        __init__(SEGMENT self, wxPoint aStart, wxPoint aEnd) -> SEGMENT
        """
        this = _pcbnew.new_SEGMENT(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_SEGMENT
    __del__ = lambda self: None
SEGMENT_swigregister = _pcbnew.SEGMENT_swigregister
SEGMENT_swigregister(SEGMENT)

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

    def __init__(self, *args):
        """
        __init__(ZONE_CONTAINER self, BOARD parent) -> ZONE_CONTAINER
        __init__(ZONE_CONTAINER self, ZONE_CONTAINER aZone) -> ZONE_CONTAINER
        """
        this = _pcbnew.new_ZONE_CONTAINER(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_ZONE_CONTAINER
    __del__ = lambda self: None

    def GetPosition(self):
        """GetPosition(ZONE_CONTAINER self) -> wxPoint"""
        return _pcbnew.ZONE_CONTAINER_GetPosition(self)


    def SetPosition(self, aPos):
        """SetPosition(ZONE_CONTAINER self, wxPoint aPos)"""
        return _pcbnew.ZONE_CONTAINER_SetPosition(self, aPos)


    def SetPriority(self, aPriority):
        """SetPriority(ZONE_CONTAINER self, unsigned int aPriority)"""
        return _pcbnew.ZONE_CONTAINER_SetPriority(self, aPriority)


    def GetPriority(self):
        """GetPriority(ZONE_CONTAINER self) -> unsigned int"""
        return _pcbnew.ZONE_CONTAINER_GetPriority(self)


    def Copy(self, src):
        """Copy(ZONE_CONTAINER self, ZONE_CONTAINER src)"""
        return _pcbnew.ZONE_CONTAINER_Copy(self, src)


    def GetMsgPanelInfo(self, aList):
        """GetMsgPanelInfo(ZONE_CONTAINER self, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.ZONE_CONTAINER_GetMsgPanelInfo(self, aList)


    def Draw(self, *args):
        """
        Draw(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        Draw(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.ZONE_CONTAINER_Draw(self, *args)


    def DrawFilledArea(self, *args):
        """
        DrawFilledArea(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode, wxPoint offset)
        DrawFilledArea(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.ZONE_CONTAINER_DrawFilledArea(self, *args)


    def DrawWhileCreateOutline(self, *args):
        """
        DrawWhileCreateOutline(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC, GR_DRAWMODE draw_mode)
        DrawWhileCreateOutline(ZONE_CONTAINER self, EDA_DRAW_PANEL * panel, wxDC * DC)