mirror of
https://gitlab.com/kicad/code/kicad.git
synced 2025-09-13 17:53:11 +02:00
0b2d4d4879
Recommendation is to avoid using the year nomenclature as this information is already encoded in the git repo. Avoids needing to repeatly update. Also updates AUTHORS.txt from current repo with contributor names
696 lines
24 KiB
OpenEdge ABL
696 lines
24 KiB
OpenEdge ABL
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2012 NBEE Embedded Systems, Miguel Angel Ajo <miguelangel@nbee.es>
|
|
* Copyright The KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/**
|
|
* This file builds the base classes for all kind of python plugins that
|
|
* can be included into kicad.
|
|
* they provide generic code to all the classes:
|
|
*
|
|
* KiCadPlugin
|
|
* /|\
|
|
* |
|
|
* |\-FilePlugin
|
|
* |\-FootprintWizardPlugin
|
|
* |\-ActionPlugin
|
|
*
|
|
* It defines the LoadPlugins() function that loads all the plugins
|
|
* available in the system
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Remark:
|
|
* Avoid using the print function in python wizards
|
|
*
|
|
* Be aware print messages create IO exceptions, because the wizard
|
|
* is run from Pcbnew. And if pcbnew is not run from a console, there is
|
|
* no io channel to read the output of print function.
|
|
* When the io buffer is full, a IO exception is thrown.
|
|
*/
|
|
|
|
%pythoncode
|
|
{
|
|
|
|
KICAD_PLUGINS={} # the list of loaded footprint wizards
|
|
|
|
""" the list of not loaded python scripts
|
|
(usually because there is a syntax error in python script)
|
|
this is the python script full filenames list.
|
|
filenames are separated by '\n'
|
|
"""
|
|
NOT_LOADED_WIZARDS=""
|
|
|
|
""" the list of paths used to search python scripts.
|
|
Stored here to be displayed on request in Pcbnew
|
|
paths are separated by '\n'
|
|
"""
|
|
PLUGIN_DIRECTORIES_SEARCH=""
|
|
|
|
"""
|
|
the trace of errors during execution of footprint wizards scripts
|
|
Warning: strings (internally unicode) are returned as UTF-8 compatible C strings
|
|
"""
|
|
|
|
FULL_BACK_TRACE=""
|
|
|
|
def GetUnLoadableWizards():
|
|
global NOT_LOADED_WIZARDS
|
|
import sys
|
|
|
|
if sys.version_info[0] < 3:
|
|
utf8_str = NOT_LOADED_WIZARDS.encode( 'UTF-8' )
|
|
else:
|
|
utf8_str = NOT_LOADED_WIZARDS
|
|
|
|
return utf8_str
|
|
|
|
def GetWizardsSearchPaths():
|
|
global PLUGIN_DIRECTORIES_SEARCH
|
|
import sys
|
|
|
|
if sys.version_info[0] < 3:
|
|
utf8_str = PLUGIN_DIRECTORIES_SEARCH.encode( 'UTF-8' )
|
|
else:
|
|
utf8_str = PLUGIN_DIRECTORIES_SEARCH
|
|
|
|
return utf8_str
|
|
|
|
def GetWizardsBackTrace():
|
|
global FULL_BACK_TRACE # Already correct format
|
|
return FULL_BACK_TRACE
|
|
|
|
|
|
def LoadPluginModule(Dirname, ModuleName, FileName):
|
|
"""
|
|
Load the plugin module named ModuleName located in the folder Dirname.
|
|
The module can be either inside a file called FileName or a subdirectory
|
|
called FileName that contains a __init__.py file.
|
|
If this module cannot be loaded, its name is stored in failed_wizards_list
|
|
and the error trace is stored in FULL_BACK_TRACE
|
|
"""
|
|
import os
|
|
import sys
|
|
import traceback
|
|
|
|
global NOT_LOADED_WIZARDS
|
|
global FULL_BACK_TRACE
|
|
global KICAD_PLUGINS
|
|
|
|
try: # If there is an error loading the script, skip it
|
|
|
|
module_filename = os.path.join( Dirname, FileName )
|
|
mtime = os.path.getmtime( module_filename )
|
|
mods_before = set( sys.modules )
|
|
|
|
if ModuleName in KICAD_PLUGINS:
|
|
plugin = KICAD_PLUGINS[ModuleName]
|
|
|
|
for dependency in plugin["dependencies"]:
|
|
if dependency in sys.modules:
|
|
del sys.modules[dependency]
|
|
|
|
mods_before = set( sys.modules )
|
|
|
|
if sys.version_info >= (3,0,0):
|
|
import importlib
|
|
mod = importlib.import_module( ModuleName )
|
|
else:
|
|
mod = __import__( ModuleName, locals(), globals() )
|
|
|
|
mods_after = set( sys.modules ).difference( mods_before )
|
|
dependencies = [m for m in mods_after if m.startswith(ModuleName)]
|
|
|
|
KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
|
|
"modification_time":mtime,
|
|
"ModuleName":mod,
|
|
"dependencies": dependencies }
|
|
|
|
except:
|
|
if ModuleName in KICAD_PLUGINS:
|
|
del KICAD_PLUGINS[ModuleName]
|
|
|
|
if NOT_LOADED_WIZARDS != "" :
|
|
NOT_LOADED_WIZARDS += "\n"
|
|
NOT_LOADED_WIZARDS += module_filename
|
|
FULL_BACK_TRACE += traceback.format_exc()
|
|
|
|
|
|
def LoadPlugins(bundlepath=None, userpath=None, thirdpartypath=None):
|
|
"""
|
|
Initialise Scripting/Plugin python environment and load plugins.
|
|
|
|
Arguments:
|
|
Note: bundlepath and userpath are given utf8 encoded, to be compatible with asimple C string
|
|
bundlepath -- The path to the bundled scripts.
|
|
The bundled Plugins are relative to this path, in the
|
|
"plugins" subdirectory.
|
|
WARNING: bundlepath must use '/' as path separator, and not '\'
|
|
because it creates issues:
|
|
\n and \r are seen as a escaped seq when passing this string to this method
|
|
I am thinking this is due to the fact LoadPlugins is called from C++ code by
|
|
PyRun_SimpleString()
|
|
|
|
NOTE: These are all of the possible "default" search paths for kicad
|
|
python scripts. These paths will ONLY be added to the python
|
|
search path ONLY IF they already exist.
|
|
|
|
The Scripts bundled with the KiCad installation:
|
|
<bundlepath>/
|
|
<bundlepath>/plugins/
|
|
|
|
The Scripts relative to the KiCad Users configuration:
|
|
<userpath>/
|
|
<userpath>/plugins/
|
|
|
|
The plugins from 3rd party packages:
|
|
$KICAD_3RD_PARTY/plugins/
|
|
"""
|
|
import os
|
|
import sys
|
|
import traceback
|
|
import pcbnew
|
|
|
|
if sys.version_info >= (3,3,0):
|
|
import importlib
|
|
importlib.invalidate_caches()
|
|
|
|
"""
|
|
bundlepath and userpath are strings utf-8 encoded (compatible "C" strings).
|
|
So convert these utf8 encoding to unicode strings to avoid any encoding issue.
|
|
"""
|
|
try:
|
|
bundlepath = bundlepath.decode( 'UTF-8' )
|
|
userpath = userpath.decode( 'UTF-8' )
|
|
thirdpartypath = thirdpartypath.decode( 'UTF-8' )
|
|
except AttributeError:
|
|
pass
|
|
|
|
config_path = pcbnew.SETTINGS_MANAGER.GetUserSettingsPath()
|
|
plugin_directories=[]
|
|
|
|
"""
|
|
To be consistent with others paths, on windows, convert the unix '/' separator
|
|
to the windows separator, although using '/' works
|
|
"""
|
|
if sys.platform.startswith('win32'):
|
|
if bundlepath:
|
|
bundlepath = bundlepath.replace("/","\\")
|
|
if thirdpartypath:
|
|
thirdpartypath = thirdpartypath.replace("/","\\")
|
|
|
|
if bundlepath:
|
|
plugin_directories.append(bundlepath)
|
|
plugin_directories.append(os.path.join(bundlepath, 'plugins'))
|
|
|
|
if config_path:
|
|
plugin_directories.append(os.path.join(config_path, 'scripting'))
|
|
plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))
|
|
|
|
if userpath:
|
|
plugin_directories.append(userpath)
|
|
plugin_directories.append(os.path.join(userpath, 'plugins'))
|
|
|
|
if thirdpartypath:
|
|
plugin_directories.append(thirdpartypath)
|
|
|
|
global PLUGIN_DIRECTORIES_SEARCH
|
|
PLUGIN_DIRECTORIES_SEARCH=""
|
|
for plugins_dir in plugin_directories: # save search path list for later use
|
|
if PLUGIN_DIRECTORIES_SEARCH != "" :
|
|
PLUGIN_DIRECTORIES_SEARCH += "\n"
|
|
PLUGIN_DIRECTORIES_SEARCH += plugins_dir
|
|
|
|
global FULL_BACK_TRACE
|
|
FULL_BACK_TRACE="" # clear any existing trace
|
|
|
|
global NOT_LOADED_WIZARDS
|
|
NOT_LOADED_WIZARDS = "" # save not loaded wizards names list for later use
|
|
|
|
global KICAD_PLUGINS
|
|
|
|
for plugins_dir in plugin_directories:
|
|
if not os.path.isdir( plugins_dir ):
|
|
continue
|
|
|
|
if plugins_dir not in sys.path:
|
|
sys.path.append( plugins_dir )
|
|
|
|
for module in os.listdir(plugins_dir):
|
|
fullPath = os.path.join( plugins_dir, module )
|
|
|
|
if os.path.isdir( fullPath ):
|
|
if os.path.exists( os.path.join( fullPath, '__init__.py' ) ):
|
|
LoadPluginModule( plugins_dir, module, module )
|
|
else:
|
|
if NOT_LOADED_WIZARDS != "" :
|
|
NOT_LOADED_WIZARDS += "\n"
|
|
NOT_LOADED_WIZARDS += 'Skip subdir ' + fullPath
|
|
continue
|
|
|
|
if module == '__init__.py' or module[-3:] != '.py':
|
|
continue
|
|
|
|
LoadPluginModule( plugins_dir, module[:-3], module )
|
|
|
|
|
|
class KiCadPlugin:
|
|
def __init__(self):
|
|
pass
|
|
|
|
def register(self):
|
|
import inspect
|
|
import os
|
|
|
|
if isinstance(self,FilePlugin):
|
|
pass # register to file plugins in C++
|
|
|
|
if isinstance(self,FootprintWizardPlugin):
|
|
PYTHON_FOOTPRINT_WIZARD_LIST.register_wizard(self)
|
|
return
|
|
|
|
if isinstance(self,ActionPlugin):
|
|
"""
|
|
Get path to .py or .pyc that has definition of plugin class.
|
|
If path is binary but source also exists, assume definition is in source.
|
|
"""
|
|
self.__plugin_path = inspect.getfile(self.__class__)
|
|
if self.__plugin_path.endswith('.pyc') and os.path.isfile(self.__plugin_path[:-1]):
|
|
self.__plugin_path = self.__plugin_path[:-1]
|
|
self.__plugin_path = self.__plugin_path + '/' + self.__class__.__name__
|
|
PYTHON_ACTION_PLUGINS.register_action(self)
|
|
return
|
|
|
|
return
|
|
|
|
def deregister(self):
|
|
if isinstance(self,FilePlugin):
|
|
pass # deregister to file plugins in C++
|
|
|
|
if isinstance(self,FootprintWizardPlugin):
|
|
PYTHON_FOOTPRINT_WIZARD_LIST.deregister_wizard(self)
|
|
return
|
|
|
|
if isinstance(self,ActionPlugin):
|
|
PYTHON_ACTION_PLUGINS.deregister_action(self)
|
|
return
|
|
|
|
return
|
|
|
|
def GetPluginPath( self ):
|
|
return self.__plugin_path
|
|
|
|
|
|
class FilePlugin(KiCadPlugin):
|
|
def __init__(self):
|
|
KiCadPlugin.__init__(self)
|
|
|
|
|
|
from math import ceil, floor, sqrt
|
|
|
|
uMM = "mm" # Millimetres
|
|
uMils = "mils" # Mils
|
|
uFloat = "float" # Natural number units (dimensionless)
|
|
uInteger = "integer" # Integer (no decimals, numeric, dimensionless)
|
|
uBool = "bool" # Boolean value
|
|
uRadians = "radians" # Angular units (radians)
|
|
uDegrees = "degrees" # Angular units (degrees)
|
|
uPercent = "%" # Percent (0% -> 100%)
|
|
uString = "string" # Raw string
|
|
|
|
uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent] # List of numeric types
|
|
uUnits = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString] # List of allowable types
|
|
|
|
class FootprintWizardParameter(object):
|
|
_true = ['true','t','y','yes','on','1',1,]
|
|
_false = ['false','f','n','no','off','0',0,'',None]
|
|
|
|
_bools = _true + _false
|
|
|
|
def __init__(self, page, name, units, default, **kwarg):
|
|
self.page = page
|
|
self.name = name
|
|
self.hint = kwarg.get('hint','') # Parameter hint (shown as mouse-over text)
|
|
self.designator = kwarg.get('designator',' ') # Parameter designator such as "e, D, p" (etc)
|
|
|
|
if units.lower() in uUnits:
|
|
self.units = units.lower()
|
|
elif units.lower() == 'percent':
|
|
self.units = uPercent
|
|
elif type(units) in [list, tuple]: # Convert a list of options into a single string
|
|
self.units = ",".join([str(el).strip() for el in units])
|
|
else:
|
|
self.units = units
|
|
|
|
self.multiple = int(kwarg.get('multiple',1)) # Check integer values are multiples of this number
|
|
self.min_value = kwarg.get('min_value',None) # Check numeric values are above or equal to this number
|
|
self.max_value = kwarg.get('max_value',None) # Check numeric values are below or equal to this number
|
|
|
|
self.SetValue(default)
|
|
self.default = self.raw_value # Save value as default
|
|
|
|
def ClearErrors(self):
|
|
self.error_list = []
|
|
|
|
def AddError(self, err, info=None):
|
|
|
|
if err in self.error_list: # prevent duplicate error messages
|
|
return
|
|
if info is not None:
|
|
err = err + " (" + str(info) + ")"
|
|
|
|
self.error_list.append(err)
|
|
|
|
def Check(self, min_value=None, max_value=None, multiple=None, info=None):
|
|
|
|
if min_value is None:
|
|
min_value = self.min_value
|
|
if max_value is None:
|
|
max_value = self.max_value
|
|
if multiple is None:
|
|
multiple = self.multiple
|
|
|
|
if self.units not in uUnits and ',' not in self.units: # Allow either valid units or a list of strings
|
|
self.AddError("type '{t}' unknown".format(t=self.units),info)
|
|
self.AddError("Allowable types: " + str(self.units),info)
|
|
|
|
if self.units in uNumeric:
|
|
try:
|
|
to_num = float(self.raw_value)
|
|
|
|
if min_value is not None: # Check minimum value if it is present
|
|
if to_num < min_value:
|
|
self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)
|
|
|
|
if max_value is not None: # Check maximum value if it is present
|
|
if to_num > max_value:
|
|
self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)
|
|
|
|
except:
|
|
self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)
|
|
|
|
if self.units == uInteger: # Perform integer specific checks
|
|
try:
|
|
to_int = int(self.raw_value)
|
|
|
|
if multiple is not None and multiple > 1:
|
|
if (to_int % multiple) > 0:
|
|
self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
|
|
except:
|
|
self.AddError("value '{v}' is not an integer".format(v=self.raw_value),info)
|
|
|
|
if self.units == uBool: # Check that the value is of a correct boolean format
|
|
if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
|
|
pass
|
|
else:
|
|
self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)
|
|
|
|
@property
|
|
def value(self): # Return the current value, converted to appropriate units (from string representation) if required
|
|
v = str(self.raw_value) # Enforce string type for known starting point
|
|
|
|
if self.units == uInteger: # Integer values
|
|
return int(v)
|
|
elif self.units in uNumeric: # Any values that use floating points
|
|
v = v.replace(",",".") # Replace "," separators with "."
|
|
v = float(v)
|
|
|
|
if self.units == uMM: # Convert from millimetres to nanometres
|
|
return FromMM(v)
|
|
|
|
elif self.units == uMils: # Convert from mils to nanometres
|
|
return FromMils(v)
|
|
|
|
else: # Any other floating-point values
|
|
return v
|
|
|
|
elif self.units == uBool:
|
|
if v.lower() in self._true:
|
|
return True
|
|
else:
|
|
return False
|
|
else:
|
|
return v
|
|
|
|
def DefaultValue(self): # Reset the value of the parameter to its default
|
|
self.raw_value = str(self.default)
|
|
|
|
def SetValue(self, new_value): # Update the value
|
|
new_value = str(new_value)
|
|
|
|
if len(new_value.strip()) == 0:
|
|
if not self.units in [uString, uBool]:
|
|
return # Ignore empty values unless for strings or bools
|
|
|
|
if self.units == uBool: # Enforce the same boolean representation as is used in KiCad
|
|
new_value = "1" if new_value.lower() in self._true else "0"
|
|
elif self.units in uNumeric:
|
|
new_value = new_value.replace(",", ".") # Enforce decimal point separators
|
|
elif ',' in self.units: # Select from a list of values
|
|
if new_value not in self.units.split(','):
|
|
new_value = self.units.split(',')[0]
|
|
|
|
self.raw_value = new_value
|
|
|
|
def __str__(self): # pretty-print the parameter
|
|
|
|
s = self.name + ": " + str(self.raw_value)
|
|
|
|
if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
|
|
s += self.units
|
|
elif self.units == uBool: # Special case for Boolean values
|
|
s = self.name + ": {b}".format(b = "True" if self.value else "False")
|
|
elif self.units == uString:
|
|
s = self.name + ": '" + self.raw_value + "'"
|
|
|
|
return s
|
|
|
|
|
|
class FootprintWizardPlugin(KiCadPlugin, object):
|
|
def __init__(self):
|
|
KiCadPlugin.__init__(self)
|
|
self.defaults()
|
|
|
|
def defaults(self):
|
|
self.module = None
|
|
self.params = [] # List of added parameters that observes addition order
|
|
|
|
self.name = "KiCad FP Wizard"
|
|
self.description = "Undefined Footprint Wizard plugin"
|
|
self.image = ""
|
|
self.buildmessages = ""
|
|
|
|
def AddParam(self, page, name, unit, default, **kwarg):
|
|
|
|
if self.GetParam(page,name) is not None: # Param already exists!
|
|
return
|
|
|
|
param = FootprintWizardParameter(page, name, unit, default, **kwarg) # Create a new parameter
|
|
self.params.append(param)
|
|
|
|
@property
|
|
def parameters(self): # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
|
|
pages = {} # Page dict
|
|
for p in self.params:
|
|
if p.page not in pages:
|
|
pages[p.page] = {}
|
|
|
|
pages[p.page][p.name] = p.value # Return the 'converted' value (convert from string to actual useful units)
|
|
|
|
return pages
|
|
|
|
@property
|
|
def values(self): # Same as above
|
|
return self.parameters
|
|
|
|
def ResetWizard(self): # Reset all parameters to default values
|
|
for p in self.params:
|
|
p.DefaultValue()
|
|
|
|
def GetName(self): # Return the name of this wizard
|
|
return self.name
|
|
|
|
def GetImage(self): # Return the filename of the preview image associated with this wizard
|
|
return self.image
|
|
|
|
def GetDescription(self): # Return the description text
|
|
return self.description
|
|
|
|
def GetValue(self):
|
|
raise NotImplementedError
|
|
|
|
def GetReferencePrefix(self):
|
|
return "REF" # Default reference prefix for any footprint
|
|
|
|
def GetParam(self, page, name): # Grab a parameter
|
|
for p in self.params:
|
|
if p.page == page and p.name == name:
|
|
return p
|
|
|
|
return None
|
|
|
|
def CheckParam(self, page, name, **kwarg):
|
|
self.GetParam(page,name).Check(**kwarg)
|
|
|
|
def AnyErrors(self):
|
|
return any([len(p.error_list) > 0 for p in self.params])
|
|
|
|
@property
|
|
def pages(self): # Return an (ordered) list of the available page names
|
|
page_list = []
|
|
for p in self.params:
|
|
if p.page not in page_list:
|
|
page_list.append(p.page)
|
|
|
|
return page_list
|
|
|
|
def GetNumParameterPages(self): # Return the number of parameter pages
|
|
return len(self.pages)
|
|
|
|
def GetParameterPageName(self,page_n): # Return the name of a page at a given index
|
|
return self.pages[page_n]
|
|
|
|
def GetParametersByPageName(self, page_name): # Return a list of parameters on a given page
|
|
params = []
|
|
|
|
for p in self.params:
|
|
if p.page == page_name:
|
|
params.append(p)
|
|
|
|
return params
|
|
|
|
def GetParametersByPageIndex(self, page_index): # Return an ordered list of parameters on a given page
|
|
return self.GetParametersByPageName(self.GetParameterPageName(page_index))
|
|
|
|
def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [p.designator for p in params]
|
|
|
|
def GetParameterNames(self,page_index): # Return the list of names associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [p.name for p in params]
|
|
|
|
def GetParameterValues(self,page_index): # Return the list of values associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [str(p.raw_value) for p in params]
|
|
|
|
def GetParameterErrors(self,page_index): # Return list of errors associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [str("\n".join(p.error_list)) for p in params]
|
|
|
|
def GetParameterTypes(self, page_index): # Return list of units associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [str(p.units) for p in params]
|
|
|
|
def GetParameterHints(self, page_index): # Return a list of units associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [str(p.hint) for p in params]
|
|
|
|
def GetParameterDesignators(self, page_index): # Return a list of designators associated with a given page
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
return [str(p.designator) for p in params]
|
|
|
|
def SetParameterValues(self, page_index, list_of_values): # Update values on a given page
|
|
|
|
params = self.GetParametersByPageIndex(page_index)
|
|
|
|
for i, param in enumerate(params):
|
|
if i >= len(list_of_values):
|
|
break
|
|
param.SetValue(list_of_values[i])
|
|
|
|
def GetFootprint( self ):
|
|
self.BuildFootprint()
|
|
return self.module
|
|
|
|
def BuildFootprint(self):
|
|
return
|
|
|
|
def GetBuildMessages( self ):
|
|
return self.buildmessages
|
|
|
|
def Show(self):
|
|
text = "Footprint Wizard Name: {name}\n".format(name=self.GetName())
|
|
text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())
|
|
|
|
n_pages = self.GetNumParameterPages()
|
|
|
|
text += "Pages: {n}\n".format(n=n_pages)
|
|
|
|
for i in range(n_pages):
|
|
name = self.GetParameterPageName(i)
|
|
|
|
params = self.GetParametersByPageName(name)
|
|
|
|
text += "{name}\n".format(name=name)
|
|
|
|
for j in range(len(params)):
|
|
text += ("\t{param}{err}\n".format(
|
|
param = str(params[j]),
|
|
err = ' *' if len(params[j].error_list) > 0 else ''
|
|
))
|
|
|
|
if self.AnyErrors():
|
|
text += " * Errors exist for these parameters"
|
|
|
|
return text
|
|
|
|
class ActionPlugin(KiCadPlugin, object):
|
|
def __init__( self ):
|
|
KiCadPlugin.__init__( self )
|
|
self.icon_file_name = ""
|
|
self.dark_icon_file_name = ""
|
|
self.show_toolbar_button = False
|
|
self.defaults()
|
|
|
|
def defaults( self ):
|
|
self.name = "Undefined Action plugin"
|
|
self.category = "Undefined"
|
|
self.description = ""
|
|
|
|
def GetClassName(self):
|
|
return type(self).__name__
|
|
|
|
def GetName( self ):
|
|
return self.name
|
|
|
|
def GetCategoryName( self ):
|
|
return self.category
|
|
|
|
def GetDescription( self ):
|
|
return self.description
|
|
|
|
def GetShowToolbarButton( self ):
|
|
return self.show_toolbar_button
|
|
|
|
def GetIconFileName( self, dark ):
|
|
if dark and self.dark_icon_file_name:
|
|
return self.dark_icon_file_name
|
|
else:
|
|
return self.icon_file_name
|
|
|
|
def Run(self):
|
|
return
|
|
|
|
}
|