==python scripts==

updated version of bevel center by Loic Berthe

1 files changed, 303 insertions, 371 deletions

diff --git a/release/scripts/bevel_center.py b/release/scripts/bevel_center.py
index 3a0169f2dfb..1e3fb3c78d7 100644
--- a/release/scripts/bevel_center.py
+++ b/release/scripts/bevel_center.py
@@ -2,21 +2,21 @@
 
 """ Registration info for Blender menus
 Name: 'Bevel Center'
-Blender: 236
+Blender: 240
 Group: 'Mesh'
-Tip: 'Bevel selected vertices'
+Tip: 'Bevel selected faces, edges, and vertices'
 """
 
-__author__ = "Loic Berthe"
+__author__ = "Loic BERTHE"
 __url__ = ("blender", "elysiun")
-__version__ = "1.0"
+__version__ = "2.0"
 
 __bpydoc__ = """\
-This script implements vertex bevelling in Blender.
+This script implements vertex and edges bevelling in Blender.
 
 Usage:
 
-Select the mesh you want to work on, enter Edit Mode and select the vertices
+Select the mesh you want to work on, enter Edit Mode and select the edges
 to bevel.  Then run this script from the 3d View's Mesh->Scripts menu.
 
 You can control the thickness of the bevel with the slider -- redefine the
@@ -24,358 +24,295 @@ end points for bigger or smaller ranges.  The thickness can be changed even
 after applying the bevel, as many times as needed.
 
 For an extra smoothing after or instead of direct bevel, set the level of
-recursiveness and use the "Recursive" button.
+recursiveness and use the "Recursive" button. 
+
+This "Recursive" Button, won't work in face select mode, unless you choose
+"faces" in the select mode menu.
 
 Notes:<br>
-    You can undo and redo your steps just like with normal mesh operations in
+	You can undo and redo your steps just like with normal mesh operations in
 Blender.
 """
 
-# $Id$
-#
 ######################################################################
-# Bevel Center v1 for Blender
-#
-# This script lets you bevel the selected vertices and control the
+# Bevel Center v2.0 for Blender
+
+# This script lets you bevel the selected vertices or edges and control the
 # thickness of the bevel
-#
-# (c) 2004 Loïc Berthe (loic.berthe@lilotux.net)
+
+# (c) 2004-2006 Loïc Berthe (loic+blender@lilotux.net)
 # released under Blender Artistic License
-#
+
 ######################################################################
 
 import Blender
-from Blender import NMesh, Window
+from Blender import NMesh, Window, Scene
 from Blender.Draw import *
+from Blender.Mathutils import *
 from Blender.BGL import *
 
-from math import pi, sin, sqrt
-
 ######################################################################
-# Functions to handle the global structures of the script NV, NE and NC
-# which contain informations about the vertices, faces and corners to be
-# created
-
-class Dir:
-	def __init__(self, co):
-		self.co = co
-
-def add_to_NV(old,co,new):
-	dir = Dir(co)
-	#
-	if old in NV.keys():
-		NV[old][dir] = new
-	else:
-		NV[old] = {dir:new}
-
-def is_in_NV(old,co):
-	if old in NV.keys():
-		for dir in NV[old]:
-			if dir.co == co : return NV[old][dir]
-	#
-	return False
-
-def add_to_NE(old, new):
-	ind1 = old[0].index
-	ind2 = old[1].index
-	if ind1 > ind2:
-		new.reverse()
-		ind1,ind2 = ind2,ind1
-	id = str(ind1)+"_"+str(ind2)
-	if id in NE.keys():
-		[NE[id].append(v) for v in new]
-	else:
-		NE[id] = new
-
-def add_to_NC(old,edge):
-	if old in NC.keys():
-		NC[old].append(edge)
-	else:
-		NC[old] = [edge]
-		
-######################################################################
-# Geometric functions
-		
-def norm(vec):
-	n = sqrt(vec[0]**2+vec[1]**2+vec[2]**2)
-	return [vec[0]/n,vec[1]/n,vec[2]/n]
-
-def parall_coord(old, dir):
-	co = old.co
-	vec = [0.0,0.0,0.0]
-	nco = [0.0,0.0,0.0]
-	#
-	if len(dir) == 1:
-		for i in range(3): vec[i] = dir[0].co[i] - co[i] 
-		vec = norm(vec)
-	#
-	elif len(dir) == 2:
-		vec1 = [0.0,0.0,0.0]
-		vec2 = [0.0,0.0,0.0]
-		for i in range(3):
-			vec1[i] = dir[0].co[i] - co[i] 
-			vec2[i] = dir[1].co[i] - co[i] 
-		vec1 = norm(vec1)
-		vec2 = norm(vec2)
-		for i in range(3) : vec[i] = vec1[i]+vec2[i]
-	#
-	for i in range(3): nco[i] = co[i] + dist.val*vec[i]
-	return (nco,vec)
-
-def get_vert(old, dir):
-	""" Look in NV if a vertex corresponding to the vertex old and the
-	direction dir already exists, and create one otherwise""" 
-	(nco, vec) = parall_coord(old, dir)
-	v = is_in_NV(old,vec)
-	if v: return v
-	#
-	v = NMesh.Vert(nco[0],nco[1],nco[2])
-	v.sel = 1
+# Functions to handle the global structures of the script NF, NE and NC
+# which contain informations about faces and corners to be created
+
+global E_selected
+E_selected = NMesh.EdgeFlags['SELECT']
+
+def make_sel_vert(*co):
+	vi= NMesh.Vert(*co)
+	v.sel = 1 
 	me.verts.append(v)
-	add_to_NV(old,vec,v)
 	return v
-			
-######################################################################
-# Functions to create the differents faces
+
+def make_sel_face(verts):
+	f = NMesh.Face(verts)
+	f.sel = 1
+	me.addFace(f)
+
+def add_to_NV(old,dir,new):
+	if old in NV.keys():		NV[old][dir] = new
+	else:					   NV[old] = {dir:new}
+
+def get_v(old, *neighbors):
+
+	# compute the direction of the new vert
+	if len(neighbors) == 1 : dir = (neighbors[0].co - old.co).normalize()
+	else : dir = (neighbors[0].co - old.co).normalize() + (neighbors[1].co-old.co).normalize()
+	 
+	# look in NV if this vert already exists
+	key = tuple(dir)
+	if old in NV and key in NV[old] : return NV[old][key]
 	
-def make_NF():
-	""" Analyse the mesh, sort the faces containing selected vertices and
-	create a liste NF : NF = [[flag, vertlist, old_face]]. Flag describes the
-	topology of the face.""" 
-	#
+	# else, create it 
+	new = old.co + dist.val*dir
+	v = make_sel_vert(new.x,new.y,new.z)
+	add_to_NV(old,key,v)
+	return v
+
+def make_faces():
+	""" Analyse the mesh, make the faces corresponding to selected faces and
+	fill the structures NE and NC """
+
+	# make the differents flags consistent
+	for e in me.edges:
+		if e.flag & E_selected :
+			e.v1.sel = 1
+			e.v2.sel = 1
+	
+	NF =[]			  # NF : New faces
 	for f in me.faces:
 		V = f.v
-		v_sel = [x.sel for x in V]
-		nb_sel = sum(v_sel)
-		if nb_sel == 0 :
-			pass
-		else:
-			nb_v = len(V)
-			#
-			if nb_v == 4:
-				#
-				if nb_sel == 4:
-					NF.append([1,V,f])
-				#
-				elif nb_sel == 3:
-					if v_sel == [0,1,1,1]: V = [V[1],V[2],V[3],V[0]]
-					elif v_sel == [1,0,1,1]: V = [V[2],V[3],V[0],V[1]]
-					elif v_sel == [1,1,0,1]: V = [V[3],V[0],V[1],V[2]]
-					NF.append([2,V,f])
-				#		
-				elif nb_sel == 2:
-					if v_sel == [1,0,1,0] or v_sel == [0,1,0,1]:
-						if	v_sel == [0,1,0,1]: V = [V[1],V[2],V[3],V[0]]
-						NF.append([5,[V[0],V[1],V[3]],f])
-						NF.append([5,[V[2],V[1],V[3]]])
-					else:
-						if v_sel == [0,1,1,0]: V = [V[1],V[2],V[3],V[0]]
-						elif v_sel == [0,0,1,1]: V = [V[2],V[3],V[0],V[1]]
-						elif v_sel == [1,0,0,1]: V = [V[3],V[0],V[1],V[2]]
-						NF.append([3,V,f])
-				#
-				else:
-					if v_sel == [0,1,0,0]: V = [V[1],V[2],V[3],V[0]]
-					elif v_sel == [0,0,1,0]: V = [V[2],V[3],V[0],V[1]]
-					elif v_sel == [0,0,0,1]: V = [V[3],V[0],V[1],V[2]]
-					NF.append([4,V,f])
-			#
-			elif nb_v == 3:
-				#
-				if nb_sel == 3:
-					NF.append([6,V,f])
-				#
-				elif nb_sel == 2:
-					if v_sel == [0,1,1]: V = [V[1],V[2],V[0]]
-					elif v_sel == [1,0,1]: V = [V[2],V[0],V[1]]
-					NF.append([7,V,f])
-				#
-				else:
-					if v_sel == [0,1,0]: V = [V[1],V[2],V[0]]
-					elif v_sel == [0,0,1]: V = [V[2],V[0],V[1]]
-					NF.append([5,V,f])
+		nV = len(V)
+		enumV = range(nV)
+		E = [me.findEdge(V[i],V[(i+1) % nV]) for i in enumV]
+		Esel = [x.flag & E_selected for x in E]
+		
+		# look for selected vertices and creates a list containing the new vertices
+		newV = V[:] 
+		changes = False
+		for (i,v) in enumerate(V):
+			if v.sel :
+				changes = True
+				if   Esel[i-1] == 0 and Esel[i] == 1 :  newV[i] = get_v(v,V[i-1])
+				elif Esel[i-1] == 1 and Esel[i] == 0 :  newV[i] = get_v(v,V[(i+1) % nV])
+				elif Esel[i-1] == 1 and Esel[i] == 1 :  newV[i] = get_v(v,V[i-1],V[(i+1) % nV])
+				else :								  newV[i] = [get_v(v,V[i-1]),get_v(v,V[(i+1) % nV])]
+		
+		if changes:
+			# determine and store the face to be created
 
-def make_faces():
-	""" Make the new faces according to NF """
-	#
-	for N in NF:
-		cas = N[0]
-		V = N[1]
-		#
-		if cas < 6:
-			new_v = [0,0,0,0]
-			if cas == 1:				# v_sel = [1,1,1,1]
-				for i in range(-1,3):
-					new_v[i] = get_vert(V[i],[V[i-1],V[i+1]])
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				for i in range(-1,3):
-					add_to_NE([V[i],V[i+1]],[new_v[i],new_v[i+1]])
-			#
-			elif cas == 2:				# v_sel = [1,1,1,0]
-				new_v[0] = get_vert(V[0],[V[3]])
-				new_v[1] = get_vert(V[1],[V[0],V[2]])
-				new_v[2] = get_vert(V[2],[V[3]])
-				new_v[3] = V[3]
-				#
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				#
-				add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
-				add_to_NE([V[1],V[2]],[new_v[1],new_v[2]])
-			#		
-			elif cas == 3:				# v_sel = [1,1,0,0]
-				new_v[0] = get_vert(V[0],[V[3]])
-				new_v[1] = get_vert(V[1],[V[2]])
-				new_v[2] = V[2]
-				new_v[3] = V[3]
-				#
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				#
-				add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
-			#
-			elif cas == 4:				# v_sel = [1,0,0,0]
-				new_v[0] = get_vert(V[0],[V[3]])
-				new_v[1] = get_vert(V[0],[V[1]])
-				new_v[2] = V[1]
-				new_v[3] = V[3]
-				#
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				#
-				add_to_NC(V[0], new_v[0:2])
-				#
-				new_v[0] = V[1]
-				new_v[1] = V[2]
-				new_v[2] = V[3]
-				#
-				new_f = NMesh.Face(new_v[:3])
-				me.faces.append(new_f)
-			#
-			else:				# v_sel = [1,0,0]
-				new_v[0] = get_vert(V[0],[V[2]])
-				new_v[1] = get_vert(V[0],[V[1]])
-				new_v[2] = V[1]
-				new_v[3] = V[2]
-				#
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				#
-				add_to_NC(V[0], new_v[0:2])
-		#
-		else:
-			new_v = [0,0,0]
-			#
-			if cas == 6:				# v_sel = [1,1,1]
-				for i in range(-1,2):
-					new_v[i] = get_vert(V[i],[V[i-1],V[i+1]])
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				for i in range(-1,2):
-					add_to_NE([V[i],V[i+1]],[new_v[i],new_v[i+1]])
-			#
-			elif cas == 7:				# v_sel = [1,1,0]
-				new_v[0] = get_vert(V[0],[V[2]])
-				new_v[1] = get_vert(V[1],[V[2]])
-				new_v[2] = V[2]
-				#
-				new_f = NMesh.Face(new_v)
-				me.faces.append(new_f)
-				add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
+			lenV = [len(x) for x in newV]
+			
+			if 2 not in lenV :			  
+				new_f = NMesh.Face(newV)
+				if sum(Esel) == nV : new_f.sel = 1
+				NF.append(new_f)
+				
+			else :
+				nb2 = lenV.count(2)
+				
+				if nV == 4 :				# f is a quad
+					if nb2 == 1 :
+						ind2 = lenV.index(2)
+						NF.append(NMesh.Face([newV[ind2-1],newV[ind2][0],newV[ind2][1],newV[ind2-3]]))
+						NF.append(NMesh.Face([newV[ind2-1],newV[ind2-2],newV[ind2-3]]))
+					
+					elif nb2 == 2 :
+						# We must know if the tuples are neighbours
+						ind2 = ''.join([str(x) for x in lenV+lenV[:1]]).find('22')
+						
+						if ind2 != -1 :	 # They are 
+							NF.append(NMesh.Face([newV[ind2][0],newV[ind2][1],newV[ind2-3][0],newV[ind2-3][1]]))
+							NF.append(NMesh.Face([newV[ind2][0],newV[ind2-1],newV[ind2-2],newV[ind2-3][1]]))
+						
+						else:			   # They aren't
+							ind2 = lenV.index(2)
+							NF.append(NMesh.Face([newV[ind2][0],newV[ind2][1],newV[ind2-2][0],newV[ind2-2][1]]))
+							NF.append(NMesh.Face([newV[ind2][1],newV[ind2-3],newV[ind2-2][0]]))
+							NF.append(NMesh.Face([newV[ind2][0],newV[ind2-1],newV[ind2-2][1]]))
+					
+					elif nb2 == 3 :
+						ind2 = lenV.index(3)
+						NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2],newV[ind2-3][0]]))
+						NF.append(NMesh.Face([newV[ind2-1][0],newV[ind2-1][1],newV[ind2-3][0],newV[ind2-3][1]]))
+						NF.append(NMesh.Face([newV[ind2-3][1],newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0]]))
+					
+					else:
+						if	(newV[0][1].co-newV[3][0].co).length + (newV[1][0].co-newV[2][1].co).length \
+							< (newV[0][0].co-newV[1][1].co).length + (newV[2][0].co-newV[3][1].co).length :
+							ind2 = 0
+						else :
+							ind2 = 1
+						NF.append(NMesh.Face([newV[ind2-1][0],newV[ind2-1][1],newV[ind2][0],newV[ind2][1]]))
+						NF.append(NMesh.Face([newV[ind2][1],newV[ind2-3][0],newV[ind2-2][1],newV[ind2-1][0]]))
+						NF.append(NMesh.Face([newV[ind2-3][0],newV[ind2-3][1],newV[ind2-2][0],newV[ind2-2][1]]))
+				
+				else :					  # f is a tri
+					if nb2 == 1:
+						ind2 = lenV.index(2)
+						NF.append(NMesh.Face([newV[ind2-2],newV[ind2-1],newV[ind2][0],newV[ind2][1]]))
+					
+					elif nb2 == 2:
+						ind2 = lenV.index(3)
+						NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2],newV[ind2-2][0]]))
+						NF.append(NMesh.Face([newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0],newV[ind2-1][1]]))
+					
+					else:
+						ind2 = min(((newV[i][1].co-newV[i-1][0].co).length, i) for i in enumV)[1]
+						NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2][0],newV[ind2][1],newV[ind2-2][0]]))
+						NF.append(NMesh.Face([newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0],newV[ind2-1][1]]))
+				
+				# Preparing the corners
+				for i in enumV:
+					if lenV[i] == 2 :	   NC.setdefault(V[i],[]).append(newV[i])
+			
+			old_faces.append(f)
+			
+			# Preparing the Edges
+			for i in enumV:
+				if Esel[i]:
+					verts = [newV[i],newV[(i+1) % nV]]
+					if V[i].index > V[(i+1) % nV].index : verts.reverse()
+					NE.setdefault(E[i],[]).append(verts)
+	
+	# Create the faces
+	for f in NF: me.addFace(f)
 
 def make_edges():
 	""" Make the faces corresponding to selected edges """
-	#
-	for l in NE.values():
-		if len(l) == 4:
-			f = NMesh.Face([l[0],l[1],l[3],l[2]])
-			me.faces.append(f)
+
+	for old,new in NE.iteritems() :
+		if len(new) == 1 :					  # This edge was on a border 
+			oldv = [old.v1, old.v2]
+			if old.v1.index < old.v2.index : oldv.reverse()
+			
+			make_sel_face(oldv+new[0])
+
+			me.findEdge(*oldv).flag   |= E_selected
+			me.findEdge(*new[0]).flag |= E_selected
+
+			for v in oldv : NV_ext.add(v)
+		
+		else:
+			make_sel_face(new[0] + new[1][::-1])
+
+			me.findEdge(*new[0]).flag |= E_selected
+			me.findEdge(*new[1]).flag |= E_selected
 
 def make_corners():
-	""" Make the faces corresponding to selected corners """
-	#
+	""" Make the faces corresponding to corners """
+
 	for v in NV.keys():
 		V = NV[v].values()
-		nb_v = len(V)
-		#
-		if nb_v < 3:
-			pass
-		#
-		elif nb_v == 3:
-			new_f = NMesh.Face(V)
-			me.faces.append(new_f)
-		#
+		nV = len(V)
+		
+		if nV == 1:	 pass
+		
+		elif nV == 2 :
+			if v in NV_ext:
+				make_sel_face(V+[v])
+				me.findEdge(*V).flag   |= E_selected
+				
 		else:
-			# We need to know which are the edges around the corner.
-			# First, we look for the quads surrounding the corner.
-			q = [NE[id] for id in NE.keys() if str(v.index) in id.split('_')]
-			#
-			# We will put the associated edges in the list eed
-			is_in_v = lambda x:x in V
-			eed =  [filter(is_in_v, l) for l in q]
-			#
-			# We will add the edges coming from faces where only one vertex is selected.
-			# They are stocked in NC.
-			if v in NC.keys():
-				eed = eed+NC[v]
-			b = eed.pop()
-			# b will contain the sorted list of vertices
-			#
-			while  eed:
-				for l in eed:
-					if l[0] == b[-1]:
-						b.append(l[1])
-						eed.remove(l)
-						break
-					elif l[1] == b[-1]:
-						b.append(l[0])
-						eed.remove(l)
-						break
-			# Now we can create the faces
-			if nb_v == 4:
-				new_f = NMesh.Face(b[:4])
-				me.faces.append(new_f)
-			#
-			else:
-				co = [0.0, 0.0,0.0]
-				vec = [0.0, 0.0,0.0]
-				for x in V:
-					co[0] += x[0]
-					co[1] += x[1]
-					co[2] += x[2]
-				#
-				for dir in NV[v]:
-					vec[0] += dir.co[0]
-					vec[1] += dir.co[1]
-					vec[2] += dir.co[2]
-				#
-				co = [x/nb_v for x in co]
-				vec = [x/nb_v for x in vec]
-				center = NMesh.Vert(co[0],co[1],co[2])
-				center.sel = 1
-				me.verts.append(center)
-				add_to_NV(v,vec,center)
-				#
-				for k in range(nb_v):
-					new_f = NMesh.Face([center, b[k], b[k+1]])
-					me.faces.append(new_f)
-		#
+			if nV == 3 and v not in NV_ext : make_sel_face(V)
+			
+			else :
+				
+				# We need to know which are the edges around the corner.
+				# First, we look for the quads surrounding the corner.
+				eed = []
+				for old, new in NE.iteritems():
+					if v in (old.v1,old.v2) :
+						if v.index == min(old.v1.index,old.v2.index) :   ind = 0
+						else										 :   ind = 1
+						
+						if len(new) == 1:	   eed.append([v,new[0][ind]])
+						else :				  eed.append([new[0][ind],new[1][ind]])
+				
+				# We will add the edges coming from faces where only one vertice is selected.
+				# They are stored in NC.
+				if v in NC:					 eed = eed+NC[v]
+
+				# Now we have to sort these vertices
+				hc = {}
+				for (a,b) in eed :
+					hc.setdefault(a,[]).append(b)
+					hc.setdefault(b,[]).append(a)
+				
+				for x0,edges in hc.iteritems():
+					if len(edges) == 1 :		break
+				
+				b = [x0]						# b will contain the sorted list of vertices
+				
+				for i in range(len(hc)-1):
+					for x in hc[x0] :
+						if x not in b :		 break
+					b.append(x)
+					x0 = x
+
+				b.append(b[0])
+
+				# Now we can create the faces
+				if len(b) == 5:				 make_sel_face(b[:4])
+
+				else:
+					New_V = Vector(0.0, 0.0,0.0)
+					New_d = [0.0, 0.0,0.0]
+		
+					for x in hc.keys():		 New_V += x.co
+					for dir in NV[v] :
+						for i in xrange(3):	 New_d[i] += dir[i]
+
+					New_V *= 1./len(hc)
+					for i in range(3) :		 New_d[i] /= nV
+					
+					center = make_sel_vert(New_V.x,New_V.y,New_V.z)
+					add_to_NV(v,tuple(New_d),center)
+
+					for k in range(len(b)-1):   make_sel_face([center, b[k], b[k+1]])
+				
+		if  2 < nV and v in NC :
+			for edge in NC[v] :				 me.findEdge(*edge).flag   |= E_selected
 
 def clear_old():
 	""" Erase old faces and vertices """
-	for F in NF:
-		if len(F) == 3:
-			me.faces.remove(F[2])
-	#
+
+	for f in old_faces: me.removeFace(f)
+	
 	for v in NV.keys():
-		me.verts.remove(v)
+		if v not in NV_ext :  me.verts.remove(v)
+
+	for e in me.edges:
+		if e.flag & E_selected :
+			e.v1.sel = 1
+			e.v2.sel = 1
+	
 
 ######################################################################
 # Interface
-#
+
 global dist
-NV = {}
+	
 dist = Create(0.2)
 left = Create(0.0)
 right = Create(1.0)
@@ -393,83 +330,79 @@ def draw():
 	global EVENT_NOEVENT, EVENT_BEVEL, EVENT_UPDATE, EVENT_RECURS, EVENT_EXIT
 
 	glClear(GL_COLOR_BUFFER_BIT)
-	Button("Bevel",EVENT_BEVEL,10,100,300,25)
-	left=Number('',  EVENT_NOEVENT,10,70,50, 20,left.val,0,right.val,'Set the minimum of the slider')
-	right = Number("",EVENT_NOEVENT,260,70,50,20,right.val,left.val,200,"Set the maximum of the slider")
-	dist=Slider("Thickness ",EVENT_UPDATE,65,70,190,20,dist.val,left.val,right.val,0,"Thickness of the bevel, can be changed even after bevelling")
-	glRasterPos2d(10,40)
+	Button("Bevel",EVENT_BEVEL,10,100,280,25)
+	left=Number('',  EVENT_NOEVENT,10,70,45, 20,left.val,0,right.val,'Set the minimum of the slider')
+	right = Number("",EVENT_NOEVENT,245,70,45,20,right.val,left.val,200,"Set the maximum of the slider")
+	dist=Slider("Thickness  ",EVENT_UPDATE,60,70,180,20,dist.val,left.val,right.val,0, \
+			"Thickness of the bevel, can be changed even after bevelling")
+	glRasterPos2d(8,40)
 	Text('To finish, you can use recursive bevel to smooth it')
-	num=Number('',	EVENT_NOEVENT,10,10,50, 16,num.val,1,100,'Recursion level')
-	Button("Recursive",EVENT_RECURS,65,10,100,16)
-	Button("Exit",EVENT_EXIT,230,10,80,20)
+	num=Number('',  EVENT_NOEVENT,10,10,40, 16,num.val,1,100,'Recursion level')
+	Button("Recursive",EVENT_RECURS,55,10,100,16)
+	Button("Exit",EVENT_EXIT,210,10,80,20)
 
 def event(evt, val):
-	if ((evt == QKEY or evt == ESCKEY) and not val):
-		Exit()
+	if ((evt == QKEY or evt == ESCKEY) and not val): Exit()
 
 def bevent(evt):
-	if evt == EVENT_EXIT :
-		Exit()
-	#
-	elif evt == EVENT_BEVEL:
-		bevel()
-	#
-	elif evt == EVENT_UPDATE:
-		try:
-			bevel_update()
-		except NameError:
-			pass
-	#
-	elif evt == EVENT_RECURS:
-		recursive()
+	if evt == EVENT_EXIT		: Exit()
+	elif evt == EVENT_BEVEL	 : bevel()
+	elif evt == EVENT_UPDATE	:
+		try: bevel_update()
+		except NameError		: pass
+	elif evt == EVENT_RECURS	: recursive()
 
 Register(draw, event, bevent)
 
 ######################################################################
 def bevel():
 	""" The main function, which creates the bevel """
-	global me,NF,NV,NE,NC, old_dist
-	#
-	is_editmode = Window.EditMode()
-	if is_editmode: Window.EditMode(0)
-	objects = Blender.Object.GetSelected() 
-	bev_obj = objects[0]
-	if bev_obj.getType() != "Mesh":
-		PupMenu("ERROR: active object must be a mesh")
+	global me,NV,NV_ext,NE,NC, old_faces,old_dist
+
+	scn = Scene.GetCurrent()
+	ob = scn.getActiveObject() 
+	if ob == None or ob.getType() != 'Mesh': 
+		Draw.PupMenu('ERROR%t|Select a mesh object.')
 		return
-	me = NMesh.GetRaw(bev_obj.getData(name_only = True))
-	#
-	NF = []
+	
+	Window.WaitCursor(1) # Change the Cursor
+	
+	is_editmode = Window.EditMode() 
+	if is_editmode: Window.EditMode(0)
+	
+	me = ob.getData()
+
 	NV = {}
+	NV_ext = set()
 	NE = {}
 	NC = {}
-	#
-	make_NF()
+	old_faces = []
+
 	make_faces()
 	make_edges()
 	make_corners()
 	clear_old()
-	#
+
 	old_dist = dist.val
-	#
+
 	me.update(1)
 	if is_editmode: Window.EditMode(1)
+	Window.WaitCursor(0)
 	Blender.Redraw()
 
 def bevel_update():
 	""" Use NV to update the bevel """
-	global dist, old_dist, NV
-	if not NV: return
+	global dist, old_dist
 	is_editmode = Window.EditMode()
 	if is_editmode: Window.EditMode(0)
 	fac = dist.val - old_dist
 	old_dist = dist.val
-	#
+
 	for old_v in NV.keys():
 		for dir in NV[old_v].keys():
 			for i in range(3):
-				NV[old_v][dir].co[i] += fac*dir.co[i]
-	#
+				NV[old_v][dir].co[i] += fac*dir[i]
+
 	me.update(1)
 	if is_editmode: Window.EditMode(1)
 	Blender.Redraw()
@@ -477,24 +410,23 @@ def bevel_update():
 def recursive():
 	""" Make a recursive bevel... still experimental """
 	global dist
-	#
+	from math import pi, sin
+
 	if num.val > 1:
 		a = pi/4
 		ang = []
 		for k in range(num.val):
 			ang.append(a)
 			a = (pi+2*a)/4
-		#
+
 		l = [2*(1-sin(x))/sin(2*x) for x in ang]
 		R = dist.val/sum(l)
 		l = [x*R for x in l]
-		#
+
 		dist.val = l[0]
 		bevel_update()
-		#
+
 		for x in l[1:]:
 			dist.val = x
 			bevel()
-	
-# vim:set ts=4 sw=4: