pcbnew.py_back

    def GetBoundingBox(self):
        """GetBoundingBox(TRACK_List self) -> EDA_RECT"""
        return _pcbnew.TRACK_List_GetBoundingBox(self)


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


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


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


    def GetLength(self):
        """GetLength(TRACK_List self) -> double"""
        return _pcbnew.TRACK_List_GetLength(self)


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


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


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


    def IsNull(self):
        """IsNull(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNull(self)


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


    def ShowWidth(self):
        """ShowWidth(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_ShowWidth(self)


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


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


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


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


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


    def GetClass(self):
        """GetClass(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetClass(self)


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


    def GetSelectMenuText(self):
        """GetSelectMenuText(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TRACK_List self) -> BITMAP_DEF"""
        return _pcbnew.TRACK_List_GetMenuImage(self)


    def Clone(self):
        """Clone(TRACK_List self) -> EDA_ITEM"""
        return _pcbnew.TRACK_List_Clone(self)


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


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

    __swig_setmethods__["m_TracksConnected"] = _pcbnew.TRACK_List_m_TracksConnected_set
    __swig_getmethods__["m_TracksConnected"] = _pcbnew.TRACK_List_m_TracksConnected_get
    if _newclass:
        m_TracksConnected = _swig_property(_pcbnew.TRACK_List_m_TracksConnected_get, _pcbnew.TRACK_List_m_TracksConnected_set)
    __swig_setmethods__["m_PadsConnected"] = _pcbnew.TRACK_List_m_PadsConnected_set
    __swig_getmethods__["m_PadsConnected"] = _pcbnew.TRACK_List_m_PadsConnected_get
    if _newclass:
        m_PadsConnected = _swig_property(_pcbnew.TRACK_List_m_PadsConnected_get, _pcbnew.TRACK_List_m_PadsConnected_set)

    def IsConnected(self):
        """IsConnected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsConnected(self)


    def GetNet(self):
        """GetNet(TRACK_List self) -> NETINFO_ITEM"""
        return _pcbnew.TRACK_List_GetNet(self)


    def GetNetCode(self):
        """GetNetCode(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetNetCode(self)


    def SetNetCode(self, aNetCode, aNoAssert=False):
        """
        SetNetCode(TRACK_List self, int aNetCode, bool aNoAssert=False) -> bool
        SetNetCode(TRACK_List self, int aNetCode) -> bool
        """
        return _pcbnew.TRACK_List_SetNetCode(self, aNetCode, aNoAssert)


    def GetSubNet(self):
        """GetSubNet(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetSubNet(self)


    def SetSubNet(self, aSubNetCode):
        """SetSubNet(TRACK_List self, int aSubNetCode)"""
        return _pcbnew.TRACK_List_SetSubNet(self, aSubNetCode)


    def GetZoneSubNet(self):
        """GetZoneSubNet(TRACK_List self) -> int"""
        return _pcbnew.TRACK_List_GetZoneSubNet(self)


    def SetZoneSubNet(self, aSubNetCode):
        """SetZoneSubNet(TRACK_List self, int aSubNetCode)"""
        return _pcbnew.TRACK_List_SetZoneSubNet(self, aSubNetCode)


    def GetNetname(self):
        """GetNetname(TRACK_List self) -> wxString const &"""
        return _pcbnew.TRACK_List_GetNetname(self)


    def GetShortNetname(self):
        """GetShortNetname(TRACK_List self) -> wxString const &"""
        return _pcbnew.TRACK_List_GetShortNetname(self)


    def GetNetClass(self):
        """GetNetClass(TRACK_List self) -> boost::shared_ptr< NETCLASS >"""
        return _pcbnew.TRACK_List_GetNetClass(self)


    def GetNetClassName(self):
        """GetNetClassName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetNetClassName(self)


    def GetCenter(self):
        """GetCenter(TRACK_List self) -> wxPoint"""
        return _pcbnew.TRACK_List_GetCenter(self)


    def GetParent(self):
        """GetParent(TRACK_List self) -> BOARD_ITEM"""
        return _pcbnew.TRACK_List_GetParent(self)


    def GetLayer(self):
        """GetLayer(TRACK_List self) -> LAYER_ID"""
        return _pcbnew.TRACK_List_GetLayer(self)


    def GetLayerSet(self):
        """GetLayerSet(TRACK_List self) -> LSET"""
        return _pcbnew.TRACK_List_GetLayerSet(self)


    def SetLayer(self, aLayer):
        """SetLayer(TRACK_List self, LAYER_ID aLayer)"""
        return _pcbnew.TRACK_List_SetLayer(self, aLayer)


    def SwapData(self, aImage):
        """SwapData(TRACK_List self, BOARD_ITEM aImage)"""
        return _pcbnew.TRACK_List_SwapData(self, aImage)


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


    def IsTrack(self):
        """IsTrack(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsTrack(self)


    def IsLocked(self):
        """IsLocked(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsLocked(self)


    def UnLink(self):
        """UnLink(TRACK_List self)"""
        return _pcbnew.TRACK_List_UnLink(self)


    def DeleteStructure(self):
        """DeleteStructure(TRACK_List self)"""
        return _pcbnew.TRACK_List_DeleteStructure(self)


    def ShowShape(self, aShape):
        """ShowShape(TRACK_List self, STROKE_T aShape) -> wxString"""
        return _pcbnew.TRACK_List_ShowShape(self, aShape)


    def GetBoard(self):
        """GetBoard(TRACK_List self) -> BOARD"""
        return _pcbnew.TRACK_List_GetBoard(self)


    def GetLayerName(self):
        """GetLayerName(TRACK_List self) -> wxString"""
        return _pcbnew.TRACK_List_GetLayerName(self)


    def FormatInternalUnits(self, *args):
        """
        FormatInternalUnits(TRACK_List self, int aValue) -> string
        FormatInternalUnits(TRACK_List self, wxPoint aPoint) -> string
        FormatInternalUnits(TRACK_List self, wxSize aSize) -> string
        """
        return _pcbnew.TRACK_List_FormatInternalUnits(self, *args)


    def FormatAngle(self, aAngle):
        """FormatAngle(TRACK_List self, double aAngle) -> string"""
        return _pcbnew.TRACK_List_FormatAngle(self, aAngle)


    def IncrementItemReference(self):
        """IncrementItemReference(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IncrementItemReference(self)


    def Cast_to_TEXTE_PCB(self):
        """Cast_to_TEXTE_PCB(TRACK_List self) -> TEXTE_PCB"""
        return _pcbnew.TRACK_List_Cast_to_TEXTE_PCB(self)


    def Cast_to_DIMENSION(self):
        """Cast_to_DIMENSION(TRACK_List self) -> DIMENSION"""
        return _pcbnew.TRACK_List_Cast_to_DIMENSION(self)


    def Cast_to_MODULE(self):
        """Cast_to_MODULE(TRACK_List self) -> MODULE"""
        return _pcbnew.TRACK_List_Cast_to_MODULE(self)


    def Cast_to_TEXTE_MODULE(self):
        """Cast_to_TEXTE_MODULE(TRACK_List self) -> TEXTE_MODULE"""
        return _pcbnew.TRACK_List_Cast_to_TEXTE_MODULE(self)


    def Cast_to_DRAWSEGMENT(self):
        """Cast_to_DRAWSEGMENT(TRACK_List self) -> DRAWSEGMENT"""
        return _pcbnew.TRACK_List_Cast_to_DRAWSEGMENT(self)


    def Cast_to_MARKER_PCB(self):
        """Cast_to_MARKER_PCB(TRACK_List self) -> MARKER_PCB"""
        return _pcbnew.TRACK_List_Cast_to_MARKER_PCB(self)


    def Cast_to_BOARD(self):
        """Cast_to_BOARD(TRACK_List self) -> BOARD"""
        return _pcbnew.TRACK_List_Cast_to_BOARD(self)


    def Cast_to_EDGE_MODULE(self):
        """Cast_to_EDGE_MODULE(TRACK_List self) -> EDGE_MODULE"""
        return _pcbnew.TRACK_List_Cast_to_EDGE_MODULE(self)


    def Cast_to_D_PAD(self):
        """Cast_to_D_PAD(TRACK_List self) -> D_PAD"""
        return _pcbnew.TRACK_List_Cast_to_D_PAD(self)


    def Cast_to_TRACK(self):
        """Cast_to_TRACK(TRACK_List self) -> TRACK"""
        return _pcbnew.TRACK_List_Cast_to_TRACK(self)


    def Cast_to_VIA(self):
        """Cast_to_VIA(TRACK_List self) -> VIA"""
        return _pcbnew.TRACK_List_Cast_to_VIA(self)


    def Cast_to_ZONE_CONTAINER(self):
        """Cast_to_ZONE_CONTAINER(TRACK_List self) -> ZONE_CONTAINER"""
        return _pcbnew.TRACK_List_Cast_to_ZONE_CONTAINER(self)


    def Cast_to_PCB_TARGET(self):
        """Cast_to_PCB_TARGET(TRACK_List self) -> PCB_TARGET"""
        return _pcbnew.TRACK_List_Cast_to_PCB_TARGET(self)


    def Type(self):
        """Type(TRACK_List self) -> KICAD_T"""
        return _pcbnew.TRACK_List_Type(self)


    def SetTimeStamp(self, aNewTimeStamp):
        """SetTimeStamp(TRACK_List self, time_t aNewTimeStamp)"""
        return _pcbnew.TRACK_List_SetTimeStamp(self, aNewTimeStamp)


    def GetTimeStamp(self):
        """GetTimeStamp(TRACK_List self) -> time_t"""
        return _pcbnew.TRACK_List_GetTimeStamp(self)


    def GetList(self):
        """GetList(TRACK_List self) -> DHEAD"""
        return _pcbnew.TRACK_List_GetList(self)


    def SetParent(self, aParent):
        """SetParent(TRACK_List self, EDA_ITEM aParent)"""
        return _pcbnew.TRACK_List_SetParent(self, aParent)


    def SetList(self, aList):
        """SetList(TRACK_List self, DHEAD aList)"""
        return _pcbnew.TRACK_List_SetList(self, aList)


    def IsNew(self):
        """IsNew(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsNew(self)


    def IsModified(self):
        """IsModified(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsModified(self)


    def IsMoving(self):
        """IsMoving(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsMoving(self)


    def IsDragging(self):
        """IsDragging(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsDragging(self)


    def IsWireImage(self):
        """IsWireImage(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsWireImage(self)


    def IsSelected(self):
        """IsSelected(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsSelected(self)


    def IsResized(self):
        """IsResized(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsResized(self)


    def IsHighlighted(self):
        """IsHighlighted(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsHighlighted(self)


    def IsBrightened(self):
        """IsBrightened(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsBrightened(self)


    def SetWireImage(self):
        """SetWireImage(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetWireImage(self)


    def SetSelected(self):
        """SetSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetSelected(self)


    def SetHighlighted(self):
        """SetHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetHighlighted(self)


    def SetBrightened(self):
        """SetBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetBrightened(self)


    def ClearSelected(self):
        """ClearSelected(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearSelected(self)


    def ClearHighlighted(self):
        """ClearHighlighted(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearHighlighted(self)


    def ClearBrightened(self):
        """ClearBrightened(TRACK_List self)"""
        return _pcbnew.TRACK_List_ClearBrightened(self)


    def SetModified(self):
        """SetModified(TRACK_List self)"""
        return _pcbnew.TRACK_List_SetModified(self)


    def GetState(self, type):
        """GetState(TRACK_List self, int type) -> int"""
        return _pcbnew.TRACK_List_GetState(self, type)


    def SetState(self, type, state):
        """SetState(TRACK_List self, int type, int state)"""
        return _pcbnew.TRACK_List_SetState(self, type, state)


    def GetStatus(self):
        """GetStatus(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetStatus(self)


    def SetStatus(self, aStatus):
        """SetStatus(TRACK_List self, STATUS_FLAGS aStatus)"""
        return _pcbnew.TRACK_List_SetStatus(self, aStatus)


    def SetFlags(self, aMask):
        """SetFlags(TRACK_List self, STATUS_FLAGS aMask)"""
        return _pcbnew.TRACK_List_SetFlags(self, aMask)


    def ClearFlags(self, aMask=-1):
        """
        ClearFlags(TRACK_List self, STATUS_FLAGS aMask=-1)
        ClearFlags(TRACK_List self)
        """
        return _pcbnew.TRACK_List_ClearFlags(self, aMask)


    def GetFlags(self):
        """GetFlags(TRACK_List self) -> STATUS_FLAGS"""
        return _pcbnew.TRACK_List_GetFlags(self)


    def SetImage(self, aItem):
        """SetImage(TRACK_List self, EDA_ITEM aItem)"""
        return _pcbnew.TRACK_List_SetImage(self, aItem)


    def SetForceVisible(self, aEnable):
        """SetForceVisible(TRACK_List self, bool aEnable)"""
        return _pcbnew.TRACK_List_SetForceVisible(self, aEnable)


    def IterateForward(self, listStart, inspector, testData, scanTypes):
        """IterateForward(TRACK_List self, EDA_ITEM listStart, INSPECTOR inspector, void const * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.TRACK_List_IterateForward(self, listStart, inspector, testData, scanTypes)


    def Matches(self, aSearchData, aAuxData, aFindLocation):
        """Matches(TRACK_List self, wxFindReplaceData & aSearchData, void * aAuxData, wxPoint aFindLocation) -> bool"""
        return _pcbnew.TRACK_List_Matches(self, aSearchData, aAuxData, aFindLocation)


    def Replace(self, *args):
        """
        Replace(TRACK_List self, wxFindReplaceData & aSearchData, wxString & aText) -> bool
        Replace(TRACK_List self, wxFindReplaceData & aSearchData, void * aAuxData=None) -> bool
        Replace(TRACK_List self, wxFindReplaceData & aSearchData) -> bool
        """
        return _pcbnew.TRACK_List_Replace(self, *args)


    def IsReplaceable(self):
        """IsReplaceable(TRACK_List self) -> bool"""
        return _pcbnew.TRACK_List_IsReplaceable(self)


    def __lt__(self, aItem):
        """__lt__(TRACK_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.TRACK_List___lt__(self, aItem)


    def Sort(self, aLeft, aRight):
        """Sort(TRACK_List self, EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.TRACK_List_Sort(self, aLeft, aRight)


    def ViewBBox(self):
        """ViewBBox(TRACK_List self) -> BOX2I const"""
        return _pcbnew.TRACK_List_ViewBBox(self)

TRACK_List_swigregister = _pcbnew.TRACK_List_swigregister
TRACK_List_swigregister(TRACK_List)

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

    def Get(self):
        """Get(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Get(self)


    def __deref__(self):
        """__deref__(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List___deref__(self)


    def GetFirst(self):
        """GetFirst(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetFirst(self)


    def GetLast(self):
        """GetLast(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_GetLast(self)


    def Append(self, *args):
        """
        Append(PAD_List self, D_PAD aNewElement)
        Append(PAD_List self, PAD_List aList)
        """
        return _pcbnew.PAD_List_Append(self, *args)


    def Insert(self, aNewElement, aElementAfterMe):
        """Insert(PAD_List self, D_PAD aNewElement, D_PAD aElementAfterMe)"""
        return _pcbnew.PAD_List_Insert(self, aNewElement, aElementAfterMe)


    def Remove(self, aElement):
        """Remove(PAD_List self, D_PAD aElement) -> D_PAD"""
        return _pcbnew.PAD_List_Remove(self, aElement)


    def begin(self):
        """begin(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_begin(self)


    def end(self):
        """end(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_end(self)


    def PopFront(self):
        """PopFront(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopFront(self)


    def PopBack(self):
        """PopBack(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_PopBack(self)


    def PushFront(self, aNewElement):
        """PushFront(PAD_List self, D_PAD aNewElement)"""
        return _pcbnew.PAD_List_PushFront(self, aNewElement)


    def PushBack(self, aNewElement):
        """PushBack(PAD_List self, D_PAD aNewElement)"""
        return _pcbnew.PAD_List_PushBack(self, aNewElement)


    class DLISTIter:
        def __init__(self,aList):
            self.last = aList   # last item is the start of list

        def next(self):         # get the next item

            item = self.last
            try:
              item = item.Get()
            except:
              pass

            if item is None:    # if the item is None, then finish the iteration
                raise StopIteration
            else:
                ret = None

    # first item in list has "Get" as a DLIST
                try:
                    ret = self.last.Get()
                except:
                    ret = self.last # next items do not..

                self.last = self.last.Next()

    # when the iterated object can be casted down in inheritance, just do it..

                if 'Cast' in dir(ret):
                    ret = ret.Cast()

                return ret

    def __iter__(self):
        return self.DLISTIter(self)



    def __init__(self):
        """__init__(DLIST<(D_PAD)> self) -> PAD_List"""
        this = _pcbnew.new_PAD_List()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PAD_List
    __del__ = lambda self: None

    def StandardMask(self):
        """StandardMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_StandardMask(self)


    def SMDMask(self):
        """SMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_SMDMask(self)


    def ConnSMDMask(self):
        """ConnSMDMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_ConnSMDMask(self)


    def UnplatedHoleMask(self):
        """UnplatedHoleMask(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_UnplatedHoleMask(self)


    def ClassOf(self, aItem):
        """ClassOf(PAD_List self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_List_ClassOf(self, aItem)


    def Copy(self, source):
        """Copy(PAD_List self, D_PAD source)"""
        return _pcbnew.PAD_List_Copy(self, source)


    def Next(self):
        """Next(PAD_List self) -> D_PAD"""
        return _pcbnew.PAD_List_Next(self)


    def GetParent(self):
        """GetParent(PAD_List self) -> MODULE"""
        return _pcbnew.PAD_List_GetParent(self)


    def SetPadName(self, name):
        """SetPadName(PAD_List self, wxString const & name)"""
        return _pcbnew.PAD_List_SetPadName(self, name)


    def GetPadName(self):
        """GetPadName(PAD_List self) -> wxString const"""
        return _pcbnew.PAD_List_GetPadName(self)


    def IncrementItemReference(self):
        """IncrementItemReference(PAD_List self) -> bool"""
        return _pcbnew.PAD_List_IncrementItemReference(self)


    def IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps):
        """IncrementPadName(PAD_List self, bool aSkipUnconnectable, bool aFillSequenceGaps) -> bool"""
        return _pcbnew.PAD_List_IncrementPadName(self, aSkipUnconnectable, aFillSequenceGaps)


    def PadNameEqual(self, other):
        """PadNameEqual(PAD_List self, D_PAD other) -> bool"""
        return _pcbnew.PAD_List_PadNameEqual(self, other)


    def GetShape(self):
        """GetShape(PAD_List self) -> PAD_SHAPE_T"""
        return _pcbnew.PAD_List_GetShape(self)


    def SetShape(self, aShape):
        """SetShape(PAD_List self, PAD_SHAPE_T aShape)"""
        return _pcbnew.PAD_List_SetShape(self, aShape)


    def SetPosition(self, aPos):
        """SetPosition(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPosition(self, aPos)


    def GetPosition(self):
        """GetPosition(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPosition(self)


    def SetY(self, y):
        """SetY(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY(self, y)


    def SetX(self, x):
        """SetX(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX(self, x)


    def SetPos0(self, aPos):
        """SetPos0(PAD_List self, wxPoint aPos)"""
        return _pcbnew.PAD_List_SetPos0(self, aPos)


    def GetPos0(self):
        """GetPos0(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetPos0(self)


    def SetY0(self, y):
        """SetY0(PAD_List self, int y)"""
        return _pcbnew.PAD_List_SetY0(self, y)


    def SetX0(self, x):
        """SetX0(PAD_List self, int x)"""
        return _pcbnew.PAD_List_SetX0(self, x)


    def SetSize(self, aSize):
        """SetSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetSize(self, aSize)


    def GetSize(self):
        """GetSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSize(self)


    def SetDelta(self, aSize):
        """SetDelta(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDelta(self, aSize)


    def GetDelta(self):
        """GetDelta(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDelta(self)


    def SetDrillSize(self, aSize):
        """SetDrillSize(PAD_List self, wxSize aSize)"""
        return _pcbnew.PAD_List_SetDrillSize(self, aSize)


    def GetDrillSize(self):
        """GetDrillSize(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetDrillSize(self)


    def SetOffset(self, aOffset):
        """SetOffset(PAD_List self, wxPoint aOffset)"""
        return _pcbnew.PAD_List_SetOffset(self, aOffset)


    def GetOffset(self):
        """GetOffset(PAD_List self) -> wxPoint"""
        return _pcbnew.PAD_List_GetOffset(self)


    def Flip(self, aCentre):
        """Flip(PAD_List self, wxPoint aCentre)"""
        return _pcbnew.PAD_List_Flip(self, aCentre)


    def SetOrientation(self, aAngle):
        """SetOrientation(PAD_List self, double aAngle)"""
        return _pcbnew.PAD_List_SetOrientation(self, aAngle)


    def GetOrientation(self):
        """GetOrientation(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetOrientation(self)


    def SetDrillShape(self, aDrillShape):
        """SetDrillShape(PAD_List self, PAD_DRILL_SHAPE_T aDrillShape)"""
        return _pcbnew.PAD_List_SetDrillShape(self, aDrillShape)


    def GetDrillShape(self):
        """GetDrillShape(PAD_List self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.PAD_List_GetDrillShape(self)


    def GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth):
        """GetOblongDrillGeometry(PAD_List self, wxPoint aStartPoint, wxPoint aEndPoint, int & aWidth)"""
        return _pcbnew.PAD_List_GetOblongDrillGeometry(self, aStartPoint, aEndPoint, aWidth)


    def SetLayerSet(self, aLayerMask):
        """SetLayerSet(PAD_List self, LSET aLayerMask)"""
        return _pcbnew.PAD_List_SetLayerSet(self, aLayerMask)


    def GetLayerSet(self):
        """GetLayerSet(PAD_List self) -> LSET"""
        return _pcbnew.PAD_List_GetLayerSet(self)


    def SetAttribute(self, aAttribute):
        """SetAttribute(PAD_List self, PAD_ATTR_T aAttribute)"""
        return _pcbnew.PAD_List_SetAttribute(self, aAttribute)


    def GetAttribute(self):
        """GetAttribute(PAD_List self) -> PAD_ATTR_T"""
        return _pcbnew.PAD_List_GetAttribute(self)


    def SetPadToDieLength(self, aLength):
        """SetPadToDieLength(PAD_List self, int aLength)"""
        return _pcbnew.PAD_List_SetPadToDieLength(self, aLength)


    def GetPadToDieLength(self):
        """GetPadToDieLength(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetPadToDieLength(self)


    def GetLocalSolderMaskMargin(self):
        """GetLocalSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderMaskMargin(self)


    def SetLocalSolderMaskMargin(self, aMargin):
        """SetLocalSolderMaskMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderMaskMargin(self, aMargin)


    def GetLocalClearance(self):
        """GetLocalClearance(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalClearance(self)


    def SetLocalClearance(self, aClearance):
        """SetLocalClearance(PAD_List self, int aClearance)"""
        return _pcbnew.PAD_List_SetLocalClearance(self, aClearance)


    def GetLocalSolderPasteMargin(self):
        """GetLocalSolderPasteMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMargin(self)


    def SetLocalSolderPasteMargin(self, aMargin):
        """SetLocalSolderPasteMargin(PAD_List self, int aMargin)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMargin(self, aMargin)


    def GetLocalSolderPasteMarginRatio(self):
        """GetLocalSolderPasteMarginRatio(PAD_List self) -> double"""
        return _pcbnew.PAD_List_GetLocalSolderPasteMarginRatio(self)


    def SetLocalSolderPasteMarginRatio(self, aRatio):
        """SetLocalSolderPasteMarginRatio(PAD_List self, double aRatio)"""
        return _pcbnew.PAD_List_SetLocalSolderPasteMarginRatio(self, aRatio)


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


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


    def GetSolderMaskMargin(self):
        """GetSolderMaskMargin(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetSolderMaskMargin(self)


    def GetSolderPasteMargin(self):
        """GetSolderPasteMargin(PAD_List self) -> wxSize"""
        return _pcbnew.PAD_List_GetSolderPasteMargin(self)


    def SetZoneConnection(self, aType):
        """SetZoneConnection(PAD_List self, ZoneConnection aType)"""
        return _pcbnew.PAD_List_SetZoneConnection(self, aType)


    def GetZoneConnection(self):
        """GetZoneConnection(PAD_List self) -> ZoneConnection"""
        return _pcbnew.PAD_List_GetZoneConnection(self)


    def SetThermalWidth(self, aWidth):
        """SetThermalWidth(PAD_List self, int aWidth)"""
        return _pcbnew.PAD_List_SetThermalWidth(self, aWidth)


    def GetThermalWidth(self):
        """GetThermalWidth(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalWidth(self)


    def SetThermalGap(self, aGap):
        """SetThermalGap(PAD_List self, int aGap)"""
        return _pcbnew.PAD_List_SetThermalGap(self, aGap)


    def GetThermalGap(self):
        """GetThermalGap(PAD_List self) -> int"""
        return _pcbnew.PAD_List_GetThermalGap(self)


    def Draw(self, *args):