pcbnew.py_back

    def SetLocalCoord(self):
        """SetLocalCoord(TEXTE_MODULE self)"""
        return _pcbnew.TEXTE_MODULE_SetLocalCoord(self)


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


    def DrawUmbilical(self, *args):
        """
        DrawUmbilical(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode, wxPoint aOffset)
        DrawUmbilical(TEXTE_MODULE self, EDA_DRAW_PANEL * aPanel, wxDC * aDC, GR_DRAWMODE aDrawMode)
        """
        return _pcbnew.TEXTE_MODULE_DrawUmbilical(self, *args)


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


    def HitTest(self, aPosition):
        """HitTest(TEXTE_MODULE self, wxPoint aPosition) -> bool"""
        return _pcbnew.TEXTE_MODULE_HitTest(self, aPosition)


    def GetClass(self):
        """GetClass(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(TEXTE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.TEXTE_MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(TEXTE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.TEXTE_MODULE_Clone(self)


    def GetShownText(self):
        """GetShownText(TEXTE_MODULE self) -> wxString"""
        return _pcbnew.TEXTE_MODULE_GetShownText(self)


    def ViewBBox(self):
        """ViewBBox(TEXTE_MODULE self) -> BOX2I const"""
        return _pcbnew.TEXTE_MODULE_ViewBBox(self)


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


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

TEXTE_MODULE_swigregister = _pcbnew.TEXTE_MODULE_swigregister
TEXTE_MODULE_swigregister(TEXTE_MODULE)

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

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

    def __init__(self, parent, aShape=S_SEGMENT):
        """
        __init__(EDGE_MODULE self, MODULE parent, STROKE_T aShape=S_SEGMENT) -> EDGE_MODULE
        __init__(EDGE_MODULE self, MODULE parent) -> EDGE_MODULE
        """
        this = _pcbnew.new_EDGE_MODULE(parent, aShape)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_EDGE_MODULE
    __del__ = lambda self: None

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

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

    def Copy(self, source):
        """Copy(EDGE_MODULE self, EDGE_MODULE source)"""
        return _pcbnew.EDGE_MODULE_Copy(self, source)


    def Move(self, aMoveVector):
        """Move(EDGE_MODULE self, wxPoint aMoveVector)"""
        return _pcbnew.EDGE_MODULE_Move(self, aMoveVector)


    def Mirror(self, aCentre, aMirrorAroundXAxis):
        """Mirror(EDGE_MODULE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.EDGE_MODULE_Mirror(self, aCentre, aMirrorAroundXAxis)


    def Rotate(self, aRotCentre, aAngle):
        """Rotate(EDGE_MODULE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.EDGE_MODULE_Rotate(self, aRotCentre, aAngle)


    def Flip(self, aCentre):
        """Flip(EDGE_MODULE self, wxPoint aCentre)"""
        return _pcbnew.EDGE_MODULE_Flip(self, aCentre)


    def SetStart0(self, aPoint):
        """SetStart0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetStart0(self, aPoint)


    def GetStart0(self):
        """GetStart0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetStart0(self)


    def SetEnd0(self, aPoint):
        """SetEnd0(EDGE_MODULE self, wxPoint aPoint)"""
        return _pcbnew.EDGE_MODULE_SetEnd0(self, aPoint)


    def GetEnd0(self):
        """GetEnd0(EDGE_MODULE self) -> wxPoint"""
        return _pcbnew.EDGE_MODULE_GetEnd0(self)


    def SetLocalCoord(self):
        """SetLocalCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetLocalCoord(self)


    def SetDrawCoord(self):
        """SetDrawCoord(EDGE_MODULE self)"""
        return _pcbnew.EDGE_MODULE_SetDrawCoord(self)


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


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


    def GetClass(self):
        """GetClass(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetClass(self)


    def GetSelectMenuText(self):
        """GetSelectMenuText(EDGE_MODULE self) -> wxString"""
        return _pcbnew.EDGE_MODULE_GetSelectMenuText(self)


    def GetMenuImage(self):
        """GetMenuImage(EDGE_MODULE self) -> BITMAP_DEF"""
        return _pcbnew.EDGE_MODULE_GetMenuImage(self)


    def Clone(self):
        """Clone(EDGE_MODULE self) -> EDA_ITEM"""
        return _pcbnew.EDGE_MODULE_Clone(self)

    __swig_setmethods__["m_Start0"] = _pcbnew.EDGE_MODULE_m_Start0_set
    __swig_getmethods__["m_Start0"] = _pcbnew.EDGE_MODULE_m_Start0_get
    if _newclass:
        m_Start0 = _swig_property(_pcbnew.EDGE_MODULE_m_Start0_get, _pcbnew.EDGE_MODULE_m_Start0_set)
    __swig_setmethods__["m_End0"] = _pcbnew.EDGE_MODULE_m_End0_set
    __swig_getmethods__["m_End0"] = _pcbnew.EDGE_MODULE_m_End0_get
    if _newclass:
        m_End0 = _swig_property(_pcbnew.EDGE_MODULE_m_End0_get, _pcbnew.EDGE_MODULE_m_End0_set)
EDGE_MODULE_swigregister = _pcbnew.EDGE_MODULE_swigregister
EDGE_MODULE_swigregister(EDGE_MODULE)

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


_pcbnew.MAX_ZONE_CORNER_RADIUS_MILS_swigconstant(_pcbnew)
MAX_ZONE_CORNER_RADIUS_MILS = _pcbnew.MAX_ZONE_CORNER_RADIUS_MILS
class ZONE_SETTINGS(_object):
    """Proxy of C++ ZONE_SETTINGS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZONE_SETTINGS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ZONE_SETTINGS, name)
    __repr__ = _swig_repr
    SMOOTHING_NONE = _pcbnew.ZONE_SETTINGS_SMOOTHING_NONE
    SMOOTHING_CHAMFER = _pcbnew.ZONE_SETTINGS_SMOOTHING_CHAMFER
    SMOOTHING_FILLET = _pcbnew.ZONE_SETTINGS_SMOOTHING_FILLET
    SMOOTHING_LAST = _pcbnew.ZONE_SETTINGS_SMOOTHING_LAST
    __swig_setmethods__["m_FillMode"] = _pcbnew.ZONE_SETTINGS_m_FillMode_set
    __swig_getmethods__["m_FillMode"] = _pcbnew.ZONE_SETTINGS_m_FillMode_get
    if _newclass:
        m_FillMode = _swig_property(_pcbnew.ZONE_SETTINGS_m_FillMode_get, _pcbnew.ZONE_SETTINGS_m_FillMode_set)
    __swig_setmethods__["m_ZonePriority"] = _pcbnew.ZONE_SETTINGS_m_ZonePriority_set
    __swig_getmethods__["m_ZonePriority"] = _pcbnew.ZONE_SETTINGS_m_ZonePriority_get
    if _newclass:
        m_ZonePriority = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZonePriority_get, _pcbnew.ZONE_SETTINGS_m_ZonePriority_set)
    __swig_setmethods__["m_ZoneClearance"] = _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set
    __swig_getmethods__["m_ZoneClearance"] = _pcbnew.ZONE_SETTINGS_m_ZoneClearance_get
    if _newclass:
        m_ZoneClearance = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZoneClearance_get, _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set)
    __swig_setmethods__["m_ZoneMinThickness"] = _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set
    __swig_getmethods__["m_ZoneMinThickness"] = _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get
    if _newclass:
        m_ZoneMinThickness = _swig_property(_pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get, _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set)
    __swig_setmethods__["m_NetcodeSelection"] = _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set
    __swig_getmethods__["m_NetcodeSelection"] = _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get
    if _newclass:
        m_NetcodeSelection = _swig_property(_pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get, _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set)
    __swig_setmethods__["m_CurrentZone_Layer"] = _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_set
    __swig_getmethods__["m_CurrentZone_Layer"] = _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_get
    if _newclass:
        m_CurrentZone_Layer = _swig_property(_pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_get, _pcbnew.ZONE_SETTINGS_m_CurrentZone_Layer_set)
    __swig_setmethods__["m_Zone_HatchingStyle"] = _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_set
    __swig_getmethods__["m_Zone_HatchingStyle"] = _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_get
    if _newclass:
        m_Zone_HatchingStyle = _swig_property(_pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_get, _pcbnew.ZONE_SETTINGS_m_Zone_HatchingStyle_set)
    __swig_setmethods__["m_ArcToSegmentsCount"] = _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_set
    __swig_getmethods__["m_ArcToSegmentsCount"] = _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_get
    if _newclass:
        m_ArcToSegmentsCount = _swig_property(_pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_get, _pcbnew.ZONE_SETTINGS_m_ArcToSegmentsCount_set)
    __swig_setmethods__["m_ThermalReliefGap"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set
    __swig_getmethods__["m_ThermalReliefGap"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get
    if _newclass:
        m_ThermalReliefGap = _swig_property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set)
    __swig_setmethods__["m_ThermalReliefCopperBridge"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_set
    __swig_getmethods__["m_ThermalReliefCopperBridge"] = _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_get
    if _newclass:
        m_ThermalReliefCopperBridge = _swig_property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefCopperBridge_set)
    __swig_setmethods__["m_Zone_45_Only"] = _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set
    __swig_getmethods__["m_Zone_45_Only"] = _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get
    if _newclass:
        m_Zone_45_Only = _swig_property(_pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get, _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set)

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

    def __lshift__(self, aSource):
        """__lshift__(ZONE_SETTINGS self, ZONE_CONTAINER aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)


    def ExportSetting(self, aTarget, aFullExport=True):
        """
        ExportSetting(ZONE_SETTINGS self, ZONE_CONTAINER aTarget, bool aFullExport=True)
        ExportSetting(ZONE_SETTINGS self, ZONE_CONTAINER aTarget)
        """
        return _pcbnew.ZONE_SETTINGS_ExportSetting(self, aTarget, aFullExport)


    def SetCornerSmoothingType(self, aType):
        """SetCornerSmoothingType(ZONE_SETTINGS self, int aType)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerSmoothingType(self, aType)


    def GetCornerSmoothingType(self):
        """GetCornerSmoothingType(ZONE_SETTINGS self) -> int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerSmoothingType(self)


    def SetCornerRadius(self, aRadius):
        """SetCornerRadius(ZONE_SETTINGS self, int aRadius)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerRadius(self, aRadius)


    def GetCornerRadius(self):
        """GetCornerRadius(ZONE_SETTINGS self) -> unsigned int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerRadius(self)


    def GetPadConnection(self):
        """GetPadConnection(ZONE_SETTINGS self) -> ZoneConnection"""
        return _pcbnew.ZONE_SETTINGS_GetPadConnection(self)


    def SetPadConnection(self, aPadConnection):
        """SetPadConnection(ZONE_SETTINGS self, ZoneConnection aPadConnection)"""
        return _pcbnew.ZONE_SETTINGS_SetPadConnection(self, aPadConnection)


    def GetIsKeepout(self):
        """GetIsKeepout(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetIsKeepout(self)


    def GetDoNotAllowCopperPour(self):
        """GetDoNotAllowCopperPour(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowCopperPour(self)


    def GetDoNotAllowVias(self):
        """GetDoNotAllowVias(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowVias(self)


    def GetDoNotAllowTracks(self):
        """GetDoNotAllowTracks(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowTracks(self)


    def SetIsKeepout(self, aEnable):
        """SetIsKeepout(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetIsKeepout(self, aEnable)


    def SetDoNotAllowCopperPour(self, aEnable):
        """SetDoNotAllowCopperPour(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowCopperPour(self, aEnable)


    def SetDoNotAllowVias(self, aEnable):
        """SetDoNotAllowVias(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowVias(self, aEnable)


    def SetDoNotAllowTracks(self, aEnable):
        """SetDoNotAllowTracks(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowTracks(self, aEnable)

    __swig_destroy__ = _pcbnew.delete_ZONE_SETTINGS
    __del__ = lambda self: None
ZONE_SETTINGS_swigregister = _pcbnew.ZONE_SETTINGS_swigregister
ZONE_SETTINGS_swigregister(ZONE_SETTINGS)

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

    def __init__(self, aName):
        """__init__(NETCLASS self, wxString const & aName) -> NETCLASS"""
        this = _pcbnew.new_NETCLASS(aName)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETCLASS
    __del__ = lambda self: None

    def GetClass(self):
        """GetClass(NETCLASS self) -> wxString"""
        return _pcbnew.NETCLASS_GetClass(self)


    def GetName(self):
        """GetName(NETCLASS self) -> wxString const &"""
        return _pcbnew.NETCLASS_GetName(self)


    def SetName(self, aName):
        """SetName(NETCLASS self, wxString const & aName)"""
        return _pcbnew.NETCLASS_SetName(self, aName)


    def GetCount(self):
        """GetCount(NETCLASS self) -> unsigned int"""
        return _pcbnew.NETCLASS_GetCount(self)


    def Clear(self):
        """Clear(NETCLASS self)"""
        return _pcbnew.NETCLASS_Clear(self)


    def AddNative(self, aNetname):
        """AddNative(NETCLASS self, wxString const & aNetname)"""
        return _pcbnew.NETCLASS_AddNative(self, aNetname)


    def begin(self, *args):
        """
        begin(NETCLASS self) -> NETCLASS::iterator
        begin(NETCLASS self) -> NETCLASS::const_iterator
        """
        return _pcbnew.NETCLASS_begin(self, *args)


    def end(self, *args):
        """
        end(NETCLASS self) -> NETCLASS::iterator
        end(NETCLASS self) -> NETCLASS::const_iterator
        """
        return _pcbnew.NETCLASS_end(self, *args)


    def Remove(self, *args):
        """
        Remove(NETCLASS self, NETCLASS::iterator aName)
        Remove(NETCLASS self, wxString const & aName)
        """
        return _pcbnew.NETCLASS_Remove(self, *args)


    def GetDescription(self):
        """GetDescription(NETCLASS self) -> wxString const &"""
        return _pcbnew.NETCLASS_GetDescription(self)


    def SetDescription(self, aDesc):
        """SetDescription(NETCLASS self, wxString const & aDesc)"""
        return _pcbnew.NETCLASS_SetDescription(self, aDesc)


    def GetClearance(self):
        """GetClearance(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetClearance(self)


    def SetClearance(self, aClearance):
        """SetClearance(NETCLASS self, int aClearance)"""
        return _pcbnew.NETCLASS_SetClearance(self, aClearance)


    def GetTrackWidth(self):
        """GetTrackWidth(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetTrackWidth(self)


    def SetTrackWidth(self, aWidth):
        """SetTrackWidth(NETCLASS self, int aWidth)"""
        return _pcbnew.NETCLASS_SetTrackWidth(self, aWidth)


    def GetViaDiameter(self):
        """GetViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDiameter(self)


    def SetViaDiameter(self, aDia):
        """SetViaDiameter(NETCLASS self, int aDia)"""
        return _pcbnew.NETCLASS_SetViaDiameter(self, aDia)


    def GetViaDrill(self):
        """GetViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetViaDrill(self)


    def SetViaDrill(self, aSize):
        """SetViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetViaDrill(self, aSize)


    def GetuViaDiameter(self):
        """GetuViaDiameter(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDiameter(self)


    def SetuViaDiameter(self, aSize):
        """SetuViaDiameter(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDiameter(self, aSize)


    def GetuViaDrill(self):
        """GetuViaDrill(NETCLASS self) -> int"""
        return _pcbnew.NETCLASS_GetuViaDrill(self)


    def SetuViaDrill(self, aSize):
        """SetuViaDrill(NETCLASS self, int aSize)"""
        return _pcbnew.NETCLASS_SetuViaDrill(self, aSize)


    def SetParams(self, aDefaults):
        """SetParams(NETCLASS self, NETCLASS aDefaults)"""
        return _pcbnew.NETCLASS_SetParams(self, aDefaults)


    def Format(self, aFormatter, aNestLevel, aControlBits):
        """Format(NETCLASS self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.NETCLASS_Format(self, aFormatter, aNestLevel, aControlBits)

NETCLASS_swigregister = _pcbnew.NETCLASS_swigregister
NETCLASS_swigregister(NETCLASS)
NETCLASS.Default = _pcbnew.cvar.NETCLASS_Default

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

    def __init__(self):
        """__init__(NETCLASSES self) -> NETCLASSES"""
        this = _pcbnew.new_NETCLASSES()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_NETCLASSES
    __del__ = lambda self: None

    def Clear(self):
        """Clear(NETCLASSES self)"""
        return _pcbnew.NETCLASSES_Clear(self)


    def begin(self, *args):
        """
        begin(NETCLASSES self) -> NETCLASSES::iterator
        begin(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_begin(self, *args)


    def end(self, *args):
        """
        end(NETCLASSES self) -> NETCLASSES::iterator
        end(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_end(self, *args)


    def GetCount(self):
        """GetCount(NETCLASSES self) -> unsigned int"""
        return _pcbnew.NETCLASSES_GetCount(self)


    def GetDefault(self):
        """GetDefault(NETCLASSES self) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_GetDefault(self)


    def AddNative(self, aNetclass):
        """AddNative(NETCLASSES self, NETCLASSPTR aNetclass) -> bool"""
        return _pcbnew.NETCLASSES_AddNative(self, aNetclass)


    def Remove(self, aNetName):
        """Remove(NETCLASSES self, wxString const & aNetName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Remove(self, aNetName)


    def Find(self, aName):
        """Find(NETCLASSES self, wxString const & aName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Find(self, aName)

NETCLASSES_swigregister = _pcbnew.NETCLASSES_swigregister
NETCLASSES_swigregister(NETCLASSES)

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

    def __init__(self, aBoard):
        """__init__(PLOT_CONTROLLER self, BOARD aBoard) -> PLOT_CONTROLLER"""
        this = _pcbnew.new_PLOT_CONTROLLER(aBoard)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _pcbnew.delete_PLOT_CONTROLLER
    __del__ = lambda self: None

    def GetPlotOptions(self):
        """GetPlotOptions(PLOT_CONTROLLER self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotOptions(self)


    def SetLayer(self, aLayer):
        """SetLayer(PLOT_CONTROLLER self, LAYER_NUM aLayer)"""
        return _pcbnew.PLOT_CONTROLLER_SetLayer(self, aLayer)


    def GetLayer(self):
        """GetLayer(PLOT_CONTROLLER self) -> LAYER_NUM"""
        return _pcbnew.PLOT_CONTROLLER_GetLayer(self)


    def IsPlotOpen(self):
        """IsPlotOpen(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_IsPlotOpen(self)


    def ClosePlot(self):
        """ClosePlot(PLOT_CONTROLLER self)"""
        return _pcbnew.PLOT_CONTROLLER_ClosePlot(self)


    def OpenPlotfile(self, aSuffix, aFormat, aSheetDesc):
        """OpenPlotfile(PLOT_CONTROLLER self, wxString const & aSuffix, PlotFormat aFormat, wxString const & aSheetDesc) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_OpenPlotfile(self, aSuffix, aFormat, aSheetDesc)


    def PlotLayer(self):
        """PlotLayer(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayer(self)


    def SetColorMode(self, aColorMode):
        """SetColorMode(PLOT_CONTROLLER self, bool aColorMode)"""
        return _pcbnew.PLOT_CONTROLLER_SetColorMode(self, aColorMode)


    def GetColorMode(self):
        """GetColorMode(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_GetColorMode(self)

PLOT_CONTROLLER_swigregister = _pcbnew.PLOT_CONTROLLER_swigregister
PLOT_CONTROLLER_swigregister(PLOT_CONTROLLER)

class PCB_PLOT_PARAMS(_object):
    """Proxy of C++ PCB_PLOT_PARAMS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCB_PLOT_PARAMS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PCB_PLOT_PARAMS, name)
    __repr__ = _swig_repr
    NO_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_NO_DRILL_SHAPE
    SMALL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_SMALL_DRILL_SHAPE
    FULL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_FULL_DRILL_SHAPE

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

    def SetSkipPlotNPTH_Pads(self, aSkip):
        """SetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self, bool aSkip)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSkipPlotNPTH_Pads(self, aSkip)


    def GetSkipPlotNPTH_Pads(self):
        """GetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSkipPlotNPTH_Pads(self)


    def Format(self, aFormatter, aNestLevel, aControl=0):
        """
        Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER * aFormatter, int aNestLevel, int aControl=0)
        Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER * aFormatter, int aNestLevel)
        """
        return _pcbnew.PCB_PLOT_PARAMS_Format(self, aFormatter, aNestLevel, aControl)


    def Parse(self, aParser):
        """Parse(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS_PARSER * aParser)"""
        return _pcbnew.PCB_PLOT_PARAMS_Parse(self, aParser)


    def __eq__(self, aPcbPlotParams):
        """__eq__(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS___eq__(self, aPcbPlotParams)


    def __ne__(self, aPcbPlotParams):
        """__ne__(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS___ne__(self, aPcbPlotParams)


    def SetColor(self, aVal):
        """SetColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColor(self, aVal)


    def GetColor(self):
        """GetColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetColor(self)


    def SetReferenceColor(self, aVal):
        """SetReferenceColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetReferenceColor(self, aVal)


    def GetReferenceColor(self):
        """GetReferenceColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetReferenceColor(self)


    def SetValueColor(self, aVal):
        """SetValueColor(PCB_PLOT_PARAMS self, EDA_COLOR_T aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetValueColor(self, aVal)


    def GetValueColor(self):
        """GetValueColor(PCB_PLOT_PARAMS self) -> EDA_COLOR_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetValueColor(self)


    def SetTextMode(self, aVal):
        """SetTextMode(PCB_PLOT_PARAMS self, PlotTextMode aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetTextMode(self, aVal)


    def GetTextMode(self):
        """GetTextMode(PCB_PLOT_PARAMS self) -> PlotTextMode"""
        return _pcbnew.PCB_PLOT_PARAMS_GetTextMode(self)


    def SetPlotMode(self, aPlotMode):
        """SetPlotMode(PCB_PLOT_PARAMS self, EDA_DRAW_MODE_T aPlotMode)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotMode(self, aPlotMode)


    def GetPlotMode(self):
        """GetPlotMode(PCB_PLOT_PARAMS self) -> EDA_DRAW_MODE_T"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotMode(self)


    def SetDrillMarksType(self, aVal):
        """SetDrillMarksType(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS::DrillMarksType aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDrillMarksType(self, aVal)


    def GetDrillMarksType(self):
        """GetDrillMarksType(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS::DrillMarksType"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDrillMarksType(self)


    def SetScale(self, aVal):
        """SetScale(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScale(self, aVal)


    def GetScale(self):
        """GetScale(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScale(self)


    def SetFineScaleAdjustX(self, aVal):
        """SetFineScaleAdjustX(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustX(self, aVal)


    def GetFineScaleAdjustX(self):
        """GetFineScaleAdjustX(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustX(self)


    def SetFineScaleAdjustY(self, aVal):
        """SetFineScaleAdjustY(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustY(self, aVal)


    def GetFineScaleAdjustY(self):
        """GetFineScaleAdjustY(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustY(self)


    def SetWidthAdjust(self, aVal):
        """SetWidthAdjust(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetWidthAdjust(self, aVal)


    def GetWidthAdjust(self):
        """GetWidthAdjust(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetWidthAdjust(self)


    def SetAutoScale(self, aFlag):
        """SetAutoScale(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetAutoScale(self, aFlag)


    def GetAutoScale(self):
        """GetAutoScale(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetAutoScale(self)


    def SetMirror(self, aFlag):
        """SetMirror(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetMirror(self, aFlag)


    def GetMirror(self):
        """GetMirror(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetMirror(self)


    def SetPlotPadsOnSilkLayer(self, aFlag):
        """SetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotPadsOnSilkLayer(self, aFlag)


    def GetPlotPadsOnSilkLayer(self):
        """GetPlotPadsOnSilkLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotPadsOnSilkLayer(self)


    def SetPlotInvisibleText(self, aFlag):
        """SetPlotInvisibleText(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotInvisibleText(self, aFlag)


    def GetPlotInvisibleText(self):
        """GetPlotInvisibleText(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotInvisibleText(self)


    def SetPlotValue(self, aFlag):
        """SetPlotValue(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotValue(self, aFlag)


    def GetPlotValue(self):
        """GetPlotValue(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotValue(self)


    def SetPlotReference(self, aFlag):
        """SetPlotReference(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotReference(self, aFlag)


    def GetPlotReference(self):
        """GetPlotReference(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotReference(self)


    def SetNegative(self, aFlag):
        """SetNegative(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetNegative(self, aFlag)


    def GetNegative(self):
        """GetNegative(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetNegative(self)


    def SetPlotViaOnMaskLayer(self, aFlag):
        """SetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotViaOnMaskLayer(self, aFlag)


    def GetPlotViaOnMaskLayer(self):
        """GetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotViaOnMaskLayer(self)


    def SetPlotFrameRef(self, aFlag):
        """SetPlotFrameRef(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotFrameRef(self, aFlag)


    def GetPlotFrameRef(self):
        """GetPlotFrameRef(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotFrameRef(self)


    def SetExcludeEdgeLayer(self, aFlag):
        """SetExcludeEdgeLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetExcludeEdgeLayer(self, aFlag)


    def GetExcludeEdgeLayer(self):
        """GetExcludeEdgeLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetExcludeEdgeLayer(self)


    def SetFormat(self, aFormat):
        """SetFormat(PCB_PLOT_PARAMS self, PlotFormat aFormat)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFormat(self, aFormat)


    def GetFormat(self):
        """GetFormat(PCB_PLOT_PARAMS self) -> PlotFormat"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFormat(self)


    def SetOutputDirectory(self, aDir):
        """SetOutputDirectory(PCB_PLOT_PARAMS self, wxString aDir)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetOutputDirectory(self, aDir)


    def GetOutputDirectory(self):
        """GetOutputDirectory(PCB_PLOT_PARAMS self) -> wxString"""
        return _pcbnew.PCB_PLOT_PARAMS_GetOutputDirectory(self)


    def SetUseGerberAttributes(self, aUse):
        """SetUseGerberAttributes(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberAttributes(self, aUse)


    def GetUseGerberAttributes(self):
        """GetUseGerberAttributes(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberAttributes(self)


    def SetUseGerberExtensions(self, aUse):
        """SetUseGerberExtensions(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberExtensions(self, aUse)


    def GetUseGerberExtensions(self):
        """GetUseGerberExtensions(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberExtensions(self)


    def SetGerberPrecision(self, aPrecision):
        """SetGerberPrecision(PCB_PLOT_PARAMS self, int aPrecision)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetGerberPrecision(self, aPrecision)


    def GetGerberPrecision(self):
        """GetGerberPrecision(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberPrecision(self)


    def GetGerberDefaultPrecision():
        """GetGerberDefaultPrecision() -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()

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

    def SetSubtractMaskFromSilk(self, aSubtract):
        """SetSubtractMaskFromSilk(PCB_PLOT_PARAMS self, bool aSubtract)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSubtractMaskFromSilk(self, aSubtract)


    def GetSubtractMaskFromSilk(self):
        """GetSubtractMaskFromSilk(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSubtractMaskFromSilk(self)


    def SetLayerSelection(self, aSelection):
        """SetLayerSelection(PCB_PLOT_PARAMS self, LSET aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetLayerSelection(self, aSelection)


    def GetLayerSelection(self):
        """GetLayerSelection(PCB_PLOT_PARAMS self) -> LSET"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLayerSelection(self)


    def SetUseAuxOrigin(self, aAux):
        """SetUseAuxOrigin(PCB_PLOT_PARAMS self, bool aAux)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseAuxOrigin(self, aAux)


    def GetUseAuxOrigin(self):
        """GetUseAuxOrigin(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseAuxOrigin(self)


    def SetScaleSelection(self, aSelection):
        """SetScaleSelection(PCB_PLOT_PARAMS self, int aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScaleSelection(self, aSelection)


    def GetScaleSelection(self):
        """GetScaleSelection(PCB_PLOT_PARAMS self) -> int"""