diff options
author | Campbell Barton <ideasman42@gmail.com> | 2010-02-15 02:33:18 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2010-02-15 02:33:18 +0300 |
commit | 677386e53a079a10e0c965759156f298471409ca (patch) | |
tree | b59341b10978e1d28a5a07e1af96f165d265e7d9 /release/scripts | |
parent | 9b3ac70b6d4b074d722b2b3fe49c99d04f83da01 (diff) |
initial support for extensions in the user preferences
only one script at the moment:
[#20848] Blender Gears for 2.5 (for ideasman42)
from Michel Anders (varkenvarken)
Diffstat (limited to 'release/scripts')
-rw-r--r-- | release/scripts/extensions/add_mesh_gears.py | 371 | ||||
-rw-r--r-- | release/scripts/modules/bpy/utils.py | 118 | ||||
-rw-r--r-- | release/scripts/ui/space_userpref.py | 122 |
3 files changed, 558 insertions, 53 deletions
diff --git a/release/scripts/extensions/add_mesh_gears.py b/release/scripts/extensions/add_mesh_gears.py new file mode 100644 index 00000000000..a7e08f7a3bc --- /dev/null +++ b/release/scripts/extensions/add_mesh_gears.py @@ -0,0 +1,371 @@ +# add_mesh_gear.py (c) 2009, 2010 Michel J. Anders (varkenvarken) +# +# add gears/cogwheels to the blender 2.50 add->mesh menu +# +# tested with the official blender 2.50 alpha 0 32-bit windows +# also tested with trunk svn 26208 on 32-bit windows +# +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# 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, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# ##### END GPL LICENSE BLOCK ##### + + +# blender 1 line description +"Add Gears (View3D > Add > Mesh > Gears)" + +""" +What was needed to port it from 2.49 -> 2.50 alpha 0? + +The basic functions that calculate the geometry (verts and faces) are unchanged +( add_tooth(), add_spoke2(), add_gear() ) + +These functions were designed to return lists of tuples (x,y,z) (for the vertices) and +lists of lists [i,k,l,m] (for the faces). Because the Blender 2.50 API does not provide +facilties to alter individual elements of the the verts and faces attributes of a mesh +directly we have to add the calculated vertices and faces in bulk by using the +mesh.add_geometry(nverts,nedges,nfaces) methodfolowed by +mesh.verts.foreach_set("co", verts_loc) and mesh.faces.foreach_set("verts_raw", faces). + +Both the foreach_set() methods take flattened lists as arguments, not lists of tuples, so we +added a simple function to flatten a list of lists or tuples. + +Also, the vertex group API is changed a little bit but the concepts are the same: +vertexgroup = ob.add_vertex_group('NAME_OF_VERTEXGROUP') # add a vertex group +for i in vertexgroup_vertex_indices: + ob.add_vertex_to_group(i, vertexgroup, weight, 'ADD') + +Now for some reason the name does not 'stick' and we have to set it this way: +vertexgroup.name = 'NAME_OF_VERTEXGROUP' + +Conversion to 2.50 also meant we could simply do away with our crude user interface. +Just definining the appropriate properties in the AddGear() operator will display the +properties in the Blender GUI with the added benefit of making it interactive: changing +a property will redo the AddGear() operator providing the user with instant feedback. + +FInally we had to convert/throw away some print statements to print functions as Blender +nows uses Python 3.x + +The most puzzling issue was that the built in Python zip() function changed its behavior. +In 3.x it returns a zip object (that can be iterated over) instead of a list of tuples. This meant +we could no longer use deepcopy(zip(...)) but had to convert the zip object to a list of tuples +first. + +The code to actually implement the AddGear() function is mostly copied from add_mesh_torus() +(distributed with Blender). + +Unresolved issues: + +- removing doubles: + the code that produces the teeth of the gears produces some duplicate vertices. The original + script just called remove_doubles() but if we do that in 2.50 we have a problem. To apply + the bpy.ops.mesh.remove_doubles() operator we have to change to edit mode. The moment + we do that we loose to possibilty to interactively change the properties. Also changing back + to object mode raises a strange exception (to investigate). So for now, removing doubles is left + to the user once satisfied with the chosen setting for a gear, + +- no suitable icon: + a rather minor point but I reused the torus icon for the add->mesh->gear menu entry as there + doesn't seem to be a generic mesh icon or a way to add custom icons. Too bad, but as this is + just eye candy it's no big deal. + +""" + +import bpy +import Mathutils +from math import cos, sin, tan, atan, asin, pi,radians as rad +from copy import deepcopy as dc + +def flatten(alist): + "Flatten a list of lists or tuples." + return sum([list(a) for a in alist],[]) + +#constants +faces=[[0,5,6,1],[1,6,7,2],[2,7,8,3],[3,8,9,4],[6,10,11,7],[7,11,12,8],[10,13,14,11],[11,14,15,12]] +L=16 # number of vertices +#edgefaces +ef = [5,6,10,13,14,15,12,8,9] +ef2 = [i+L for i in ef] +# in python 3, zip() returns a zip object so we have to force the result into a list of lists to keep +# deepcopy happy later on in the script. +efc = [ [i,j,k,l] for i,j,k,l in zip(ef[:-1],ef2[:-1],ef2[1:],ef[1:])] +vv = [5,6,8,9,21,22,24,25] #vertices in a valley +tv = [13,14,15,29,30,31] #vertices on a tooth + +spokefaces=((0,1,2,5),(2,3,4,7),(5,2,7,6),(5,6,9,8),(6,7,10,9),(11,8,13,12),(8,9,10,13),(13,10,15,14)) + +def add_tooth(a,t,d,r,Ad,De,b,p,rack=0,crown=0.0): + """ + private function: calculate the vertex coords for a single side + section of a gear tooth. returns them as a list of lists. + """ + + A=[a,a+t/4,a+t/2,a+3*t/4,a+t] + C=[cos(i) for i in A] + S=[sin(i) for i in A] + + Ra=r+Ad + Rd=r-De + Rb=Rd-b + + #Pressure angle calc + O =Ad*tan(p) + p =atan(O/Ra) + if r<0 : p = -p + + if rack : + S =[sin(t/4)*I for I in range(-2,3)] + Sp=[0,sin(-t/4+p),0,sin(t/4-p)] + + v=[(Rb,r*S[I],d) for I in range(5)] + v.extend([(Rd,r*S[I],d) for I in range(5)]) + v.extend([(r,r*S[I],d) for I in range(1,4)]) + v.extend([(Ra,r*Sp[I],d) for I in range(1,4)]) + + else : + Cp=[0,cos(a+t/4+p),cos(a+t/2),cos(a+3*t/4-p)] + Sp=[0,sin(a+t/4+p),sin(a+t/2),sin(a+3*t/4-p)] + + v=[(Rb*C[I],Rb*S[I],d) for I in range(5)] + v.extend([(Rd*C[I],Rd*S[I],d) for I in range(5)]) + v.extend([(r*C[I],r*S[I],d+crown/3) for I in range(1,4)]) + v.extend([(Ra*Cp[I],Ra*Sp[I],d+crown) for I in range(1,4)]) + + return v + +def add_spoke2(a,t,d,r,De,b,s,w,l,gap=0,width=19): + """ + EXPERIMENTAL private function: calculate the vertex coords for a single side + section of a gearspoke. returns them as a list of lists. + """ + + Rd=r-De + Rb=Rd-b + Rl=Rb + + v =[] + ef =[] + ef2=[] + sf =[] + if not gap : + for N in range(width,1,-2) : + ef.append(len(v)) + ts = t/4 + tm = a + 2*ts + te = asin(w/Rb) + td = te - ts + t4 = ts+td*(width-N)/(width-3.0) + A=[tm+(i-int(N/2))*t4 for i in range(N)] + C=[cos(i) for i in A] + S=[sin(i) for i in A] + v.extend([ (Rb*I,Rb*J,d) for (I,J) in zip(C,S)]) + ef2.append(len(v)-1) + Rb= Rb-s + n=0 + for N in range(width,3,-2) : + sf.extend([(i+n,i+1+n,i+2+n,i+N+n) for i in range(0,N-1,2)]) + sf.extend([(i+2+n,i+N+n,i+N+1+n,i+N+2+n) for i in range(0,N-3,2)]) + n = n + N + + return v,ef,ef2,sf + +def add_gear(N,r,Ad,De,b,p,D=1,skew=0,conangle=0,rack=0,crown=0.0, spoke=0,spbevel=0.1,spwidth=0.2,splength=1.0,spresol=9): + """ + """ + worm =0 + if N<5 : (worm,N)=(N,24) + t =2*pi/N + if rack: N=1 + p =rad(p) + conangle=rad(conangle) + skew =rad(skew) + scale = (r - 2*D*tan(conangle) )/r + + f =[] + v =[] + tg=[] #vertexgroup of top vertices. + vg=[] #vertexgroup of valley vertices + + + M=[0] + if worm : (M,skew,D)=(range(32),rad(11.25),D/2) + + for W in M: + fl=W*N*L*2 + l=0 #number of vertices + for I in range(int(N)): + a=I*t + for(s,d,c,first) in ((W*skew,W*2*D-D,1,1),((W+1)*skew,W*2*D+D,scale,0)): + if worm and I%(int(N)/worm)!=0: + v.extend(add_tooth(a+s,t,d,r-De,0.0,0.0,b,p)) + else: + v.extend(add_tooth(a+s,t,d,r*c,Ad*c,De*c,b*c,p,rack,crown)) + if not worm or (W==0 and first) or (W==(len(M)-1) and not first) : + f.extend([ [j+l+fl for j in i]for i in dc(faces)]) + l += L + + #print (len(f)) + #print (dc(efc)) + f.extend([ [j+I*L*2+fl for j in i] for i in dc(efc)]) + #print (len(f)) + tg.extend([i+I*L*2 for i in tv]) + vg.extend([i+I*L*2 for i in vv]) + # EXPERIMENTAL: add spokes + if not worm and spoke>0 : + fl=len(v) + for I in range(int(N)): + a=I*t + s=0 # for test + if I%spoke==0 : + for d in (-D,D) : + (sv,ef,ef2,sf) = add_spoke2(a+s,t,d,r*c,De*c,b*c,spbevel,spwidth,splength,0,spresol) + v.extend(sv) + f.extend([ [j+fl for j in i]for i in sf]) + fl += len(sv) + d1 = fl-len(sv) + d2 = fl-2*len(sv) + f.extend([(i+d2,j+d2,j+d1,i+d1) for (i,j) in zip(ef[:-1],ef[1:])]) + f.extend([(i+d2,j+d2,j+d1,i+d1) for (i,j) in zip(ef2[:-1],ef2[1:])]) + else : + for d in (-D,D) : + (sv,ef,ef2,sf) = add_spoke2(a+s,t,d,r*c,De*c,b*c,spbevel,spwidth,splength,1,spresol) + v.extend(sv) + fl += len(sv) + d1 = fl-len(sv) + d2 = fl-2*len(sv) + #f.extend([(i+d2,i+1+d2,i+1+d1,i+d1) for (i) in (0,1,2,3)]) + #f.extend([(i+d2,i+1+d2,i+1+d1,i+d1) for (i) in (5,6,7,8)]) + + return flatten(v), flatten(f), tg, vg + + +from bpy.props import * + + +class AddGear(bpy.types.Operator): + '''Add a gear mesh.''' + bl_idname = "mesh.gear_add" + bl_label = "Add Gear" + bl_register = True + bl_undo = True + + number_of_teeth = IntProperty(name="Number of Teeth", + description="Number of teeth on the gear", + default=12,min=4,max=200) + radius = FloatProperty(name="Radius", + description="Radius of the gear, negative for crown gear", + default=1.0, min=-100.0, max=100.0) + addendum = FloatProperty(name="Addendum", + description="Addendum, extent of tooth above radius", + default=0.1, min=0.01, max=100.0) + dedendum = FloatProperty(name="Dedendum", + description="Dedendum, extent of tooth below radius", + default=0.1, min=0.0, max=100.0) + angle = FloatProperty(name="Pressure Angle", + description="Pressure angle, skewness of tooth tip (degrees)", + default=20.0, min=0.0, max=45.0) + base = FloatProperty(name="Base", + description="Base, extent of gear below radius", + default=0.2, min=0.0, max=100.0) + width = FloatProperty(name="Width", + description="Width, thickness of gear", + default=0.2, min=0.05, max=100.0) + skew = FloatProperty(name="Skewness", + description="Skew of teeth (degrees)", + default=0.0, min=-90.0, max=90.0) + conangle = FloatProperty(name="Conical angle", + description="Conical angle of gear (degrees)", + default=0.0, min=0.0, max=90.0) + crown = FloatProperty(name="Crown", + description="Inward pointing extend of crown teeth", + default=0.0, min=0.0, max=100.0) + + def execute(self, context): + + verts_loc, faces, tip_vertices, valley_vertices = add_gear(self.properties.number_of_teeth, + self.properties.radius, + self.properties.addendum, + self.properties.dedendum, + self.properties.base, + self.properties.angle, + self.properties.width, + skew=self.properties.skew, + conangle=self.properties.conangle, + crown=self.properties.crown) + + #print(len(verts_loc)/3,faces) + + mesh = bpy.data.meshes.new("Gear") + + mesh.add_geometry(int(len(verts_loc) / 3), 0, int(len(faces) / 4)) + mesh.verts.foreach_set("co", verts_loc) + mesh.faces.foreach_set("verts_raw", faces) + + scene = context.scene + + # ugh (to quote the author of add_mesh_torus :-) + for ob in scene.objects: + ob.selected = False + + mesh.update() + + ob_new = bpy.data.objects.new('Gear','MESH') + ob_new.data = mesh + + tipgroup = ob_new.add_vertex_group('Tips') + # for some reason the name does not 'stick' and we have to set it this way: + tipgroup.name = 'Tips' + for i in tip_vertices: + ob_new.add_vertex_to_group(i, tipgroup, 1.0, 'ADD') + + valleygroup = ob_new.add_vertex_group('Valleys') + # for some reason the name does not 'stick' and we have to set it this way: + valleygroup.name = 'Valleys' + for i in valley_vertices: + ob_new.add_vertex_to_group(i, valleygroup, 1.0, 'ADD') + + scene.objects.link(ob_new) + scene.objects.active = ob_new + ob_new.selected = True + + #print(1,bpy.context.mode) + #bpy.ops.object.mode_set(mode='EDIT') + #print(2,bpy.context.mode) + #bpy.ops.mesh.remove_doubles() + #print(3,bpy.context.mode) + # unfortunately the next line wont get us back to object mode but bombs + #bpy.ops.object.mode_set('OBJECT') + #print(4,bpy.context.mode) + + ob_new.location = tuple(context.scene.cursor_location) + + return {'FINISHED'} + + +# Add to a menu, reuse an icon used elsewhere that happens to have fitting name +# unfortunately, the icon shown is the one I expected from looking at the +# blenderbuttons file from the release/datafiles directory + +menu_func = (lambda self, context: self.layout.operator(AddGear.bl_idname, + text="Gear", icon='GEARS')) + +def register(): + bpy.types.register(AddGear) + bpy.types.INFO_MT_mesh_add.append(menu_func) + +def unregister(): + bpy.types.unregister(AddGear) + bpy.types.INFO_MT_mesh_add.remove(menu_func) diff --git a/release/scripts/modules/bpy/utils.py b/release/scripts/modules/bpy/utils.py index 8e2e86acb66..cfe0207c7ca 100644 --- a/release/scripts/modules/bpy/utils.py +++ b/release/scripts/modules/bpy/utils.py @@ -29,6 +29,52 @@ import sys as _sys from _bpy import home_paths + +def _test_import(module_name, loaded_modules): + import traceback + import time + if module_name in loaded_modules: + return None + if "." in module_name: + print("Ignoring '%s', can't import files containing multiple periods." % module_name) + return None + + try: + t = time.time() + ret = __import__(module_name) + if _bpy.app.debug: + print("time %s %.4f" % (module_name, time.time() - t)) + return ret + except: + traceback.print_exc() + return None + + +def modules_from_path(path, loaded_modules): + """ + Load all modules in a path and return them as a list. + """ + import traceback + import time + + modules = [] + + for f in sorted(_os.listdir(path)): + if f.endswith(".py"): + # python module + mod = _test_import(f[0:-3], loaded_modules) + elif ("." not in f) and (_os.path.isfile(_os.path.join(path, f, "__init__.py"))): + # python package + mod = _test_import(f, loaded_modules) + else: + mod = None + + if mod: + modules.append(mod) + + return modules + + def load_scripts(reload_scripts=False, refresh_scripts=False): import traceback import time @@ -37,29 +83,28 @@ def load_scripts(reload_scripts=False, refresh_scripts=False): loaded_modules = set() - def test_import(module_name): - if module_name in loaded_modules: - return None - if "." in module_name: - print("Ignoring '%s', can't import files containing multiple periods." % module_name) - return None - - try: - t = time.time() - ret = __import__(module_name) - if _bpy.app.debug: - print("time %s %.4f" % (module_name, time.time() - t)) - return ret - except: - traceback.print_exc() - return None + def sys_path_ensure(path): + if path not in _sys.path: # reloading would add twice + _sys.path.insert(0, path) def test_reload(module): try: return reload(module) except: traceback.print_exc() - + + def test_register(mod): + if reload_scripts and mod: + print("Reloading:", mod) + mod = test_reload(mod) + + if mod: + register = getattr(mod, "register", None) + if register: + register() + else: + print("\nWarning! '%s' has no register function, this is now a requirement for registerable scripts." % mod.__file__) + if reload_scripts: # reload modules that may not be directly included for type_class_name in dir(_bpy.types): @@ -83,28 +128,21 @@ def load_scripts(reload_scripts=False, refresh_scripts=False): if refresh_scripts and path in _sys.path: continue - if path not in _sys.path: # reloading would add twice - _sys.path.insert(0, path) - for f in sorted(_os.listdir(path)): - if f.endswith(".py"): - # python module - mod = test_import(f[0:-3]) - elif ("." not in f) and (_os.path.isfile(_os.path.join(path, f, "__init__.py"))): - # python package - mod = test_import(f) - else: - mod = None - - if reload_scripts and mod: - print("Reloading:", mod) - mod = test_reload(mod) - - if mod: - register = getattr(mod, "register", None) - if register: - register() - else: - print("\nWarning! '%s%s%s' has no register function, this is now a requirement for registerable scripts." % (path, _os.sep, f)) + sys_path_ensure(path) + + for mod in modules_from_path(path, loaded_modules): + test_register(mod) + + + # load extensions + used_ext = {ext.module for ext in _bpy.context.user_preferences.extensions} + paths = script_paths("extensions") + for path in paths: + sys_path_ensure(path) + + for module_name in sorted(used_ext): + mod = _test_import(module_name, loaded_modules) + test_register(mod) if _bpy.app.debug: @@ -196,7 +234,7 @@ def script_paths(*args): path_subdir = _os.path.join(path, subdir) if _os.path.isdir(path_subdir): script_paths.append(path_subdir) - print(script_paths) + return script_paths diff --git a/release/scripts/ui/space_userpref.py b/release/scripts/ui/space_userpref.py index f05f9246ade..2c5e77ec2d9 100644 --- a/release/scripts/ui/space_userpref.py +++ b/release/scripts/ui/space_userpref.py @@ -1349,8 +1349,100 @@ class USERPREF_PT_input(bpy.types.Panel): #print("runtime", time.time() - start) +class USERPREF_PT_extensions(bpy.types.Panel): + bl_space_type = 'USER_PREFERENCES' + bl_label = "Extensions" + bl_region_type = 'WINDOW' + bl_show_header = False + + def poll(self, context): + userpref = context.user_preferences + return (userpref.active_section == 'EXTENSIONS') + + def _extension_list(self): + import sys + modules = [] + loaded_modules = set() + paths = bpy.utils.script_paths("extensions") + # sys.path.insert(0, None) + for path in paths: + # sys.path[0] = path + modules.extend(bpy.utils.modules_from_path(path, loaded_modules)) + + # del sys.path[0] + return modules + + def draw(self, context): + layout = self.layout + + userpref = context.user_preferences + used_ext = {ext.module for ext in userpref.extensions} + + col = layout.column() + + for mod in self._extension_list(): + box = col.box() + row = box.row() + row.label(text=mod.__doc__) + module_name = mod.__name__ + row.operator("wm.extension_disable" if module_name in used_ext else "wm.extension_enable").module = module_name + + from bpy.props import * +class WM_OT_extension_enable(bpy.types.Operator): + "Enable an extension" + bl_idname = "wm.extension_enable" + bl_label = "Enable Extension" + + module = StringProperty(name="Module", description="Module name of the extension to enable") + + def execute(self, context): + import traceback + ext = context.user_preferences.extensions.new() + module_name = self.properties.module + ext.module = module_name + + try: + mod = __import__(module_name) + reload(mod) # FIXME: workaround for the same class not registering twice properly + mod.register() + except: + traceback.print_exc() + + return {'FINISHED'} + + +class WM_OT_extension_disable(bpy.types.Operator): + "Disable an extension" + bl_idname = "wm.extension_disable" + bl_label = "Disable Extension" + + module = StringProperty(name="Module", description="Module name of the extension to disable") + + def execute(self, context): + import traceback + module_name = self.properties.module + + try: + mod = __import__(module_name) + mod.unregister() + reload(mod) # FIXME: workaround for the same class not registering twice properly + except: + traceback.print_exc() + + extensions = context.user_preferences.extensions + ok = True + while ok: # incase its in more then once. + ok = False + for ext in extensions: + if ext.module == module_name: + extensions.remove(ext) + ok = True + break + + return {'FINISHED'} + class WM_OT_keyconfig_test(bpy.types.Operator): "Test keyconfig for conflicts" @@ -1493,14 +1585,14 @@ class WM_OT_keyconfig_import(bpy.types.Operator): bl_idname = "wm.keyconfig_import" bl_label = "Import Key Configuration..." - path = bpy.props.StringProperty(name="File Path", description="File path to write file to") - filename = bpy.props.StringProperty(name="File Name", description="Name of the file") - directory = bpy.props.StringProperty(name="Directory", description="Directory of the file") - filter_folder = bpy.props.BoolProperty(name="Filter folders", description="", default=True, options={'HIDDEN'}) - filter_text = bpy.props.BoolProperty(name="Filter text", description="", default=True, options={'HIDDEN'}) - filter_python = bpy.props.BoolProperty(name="Filter python", description="", default=True, options={'HIDDEN'}) + path = StringProperty(name="File Path", description="File path to write file to") + filename = StringProperty(name="File Name", description="Name of the file") + directory = StringProperty(name="Directory", description="Directory of the file") + filter_folder = BoolProperty(name="Filter folders", description="", default=True, options={'HIDDEN'}) + filter_text = BoolProperty(name="Filter text", description="", default=True, options={'HIDDEN'}) + filter_python = BoolProperty(name="Filter python", description="", default=True, options={'HIDDEN'}) - keep_original = bpy.props.BoolProperty(name="Keep original", description="Keep original file after copying to configuration folder", default=True) + keep_original = BoolProperty(name="Keep original", description="Keep original file after copying to configuration folder", default=True) def execute(self, context): if not self.properties.path: @@ -1552,12 +1644,12 @@ class WM_OT_keyconfig_export(bpy.types.Operator): bl_idname = "wm.keyconfig_export" bl_label = "Export Key Configuration..." - path = bpy.props.StringProperty(name="File Path", description="File path to write file to") - filename = bpy.props.StringProperty(name="File Name", description="Name of the file") - directory = bpy.props.StringProperty(name="Directory", description="Directory of the file") - filter_folder = bpy.props.BoolProperty(name="Filter folders", description="", default=True, options={'HIDDEN'}) - filter_text = bpy.props.BoolProperty(name="Filter text", description="", default=True, options={'HIDDEN'}) - filter_python = bpy.props.BoolProperty(name="Filter python", description="", default=True, options={'HIDDEN'}) + path = StringProperty(name="File Path", description="File path to write file to") + filename = StringProperty(name="File Name", description="Name of the file") + directory = StringProperty(name="Directory", description="Directory of the file") + filter_folder = BoolProperty(name="Filter folders", description="", default=True, options={'HIDDEN'}) + filter_text = BoolProperty(name="Filter text", description="", default=True, options={'HIDDEN'}) + filter_python = BoolProperty(name="Filter python", description="", default=True, options={'HIDDEN'}) def execute(self, context): if not self.properties.path: @@ -1757,6 +1849,10 @@ classes = [ USERPREF_PT_system, USERPREF_PT_file, USERPREF_PT_input, + USERPREF_PT_extensions, + + WM_OT_extension_enable, + WM_OT_extension_disable, WM_OT_keyconfig_export, WM_OT_keyconfig_import, |