Cleanup and fixes to mesh_discombobulator

Run Flake8 on __init__ and mesh_discombobulator
Clean up the bl_info (the scipt is now a module)
Moved the discombobulator props to a separate property group
Removed the duplicate entries of props in the script
Added poll functions for discombobulator operators
Used a prop_dialog instead of popup
Moved the execution operator from draw to execute
Added a remove all doodads option
Moved the list of doodads from the label to a separate menu
Expanded on Usage Information to cover more limitations
and changed it to a menu
Limit the repeat protusions to 4 instead of 10
(There is no RAM and CPU big enough in the world
to take all in the hubris of unrealistic ambitions)

1 files changed, 370 insertions, 292 deletions

diff --git a/add_mesh_extra_objects/mesh_discombobulator.py b/add_mesh_extra_objects/mesh_discombobulator.py
index 69e7a88c..9d9469d2 100644
--- a/add_mesh_extra_objects/mesh_discombobulator.py
+++ b/add_mesh_extra_objects/mesh_discombobulator.py
@@ -1,38 +1,18 @@
-# ##### 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 #####
-
-bl_info = {
-    "name": "Discombobulator",
-    "description": "Its job is to easily add scifi details to a surface to create nice-looking space-ships or futuristic cities.",
-    "author": "Evan J. Rosky (syrux), Chichiri, Jace Priester",
-    "version": (0,2),
-    "blender": (2, 71, 0),
-    "location": "View3D > Toolshelf > Tools Tab",
-    "warning": '',
-    'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts',
-    'tracker_url': 'https://developer.blender.org/maniphest/task/create/?project=3&type=Bug',
-    "category": "Mesh"}
+# GPL # Original Authors: Evan J. Rosky (syrux), Chichiri, Jace Priester #
 
 import bpy
 import random
-import mathutils
 import math
-from mathutils import *
+from bpy.types import (
+                Operator,
+                Menu,
+                )
+from mathutils import (
+                Vector,
+                Quaternion,
+                )
+
+# ################### Globals #################### #
 
 doprots = True
 
@@ -43,42 +23,46 @@ Verts = []
 Polygons = []
 dVerts = []
 dPolygons = []
-i_prots = [] # index of the top polygons on whow we will generate the doodads
-i_dood_type = [] # type of doodad (given by index of the doodad obj)
+i_prots = []        # index of the top polygons on which we'll generate the doodads
+i_dood_type = []    # type of doodad (given by index of the doodad obj)
+
 
-bpy.types.Scene.DISC_doodads = []
+# ############### Utility Functions ############### #
 
 def randnum(a, b):
-    return random.random()*(b-a)+a
+    return random.random() * (b - a) + a
+
 
 def randVertex(a, b, c, d, Verts):
     """Return a vector of a random vertex on a quad-polygon"""
-    i = random.randint(1,2)
+    i = random.randint(1, 2)
     A, B, C, D = 0, 0, 0, 0
-    if(a==1):
+    if(a == 1):
         A, B, C, D = a, b, c, d
     else:
         A, B, C, D = a, d, c, b
 
     i = randnum(0.1, 0.9)
 
+    vecAB = Verts[B] - Verts[A]
+    E = Verts[A] + vecAB * i
 
-    vecAB=Verts[B]-Verts[A]
-    E=Verts[A]+vecAB*i
-
-    vecDC=Verts[C]-Verts[D]
-    F=Verts[D]+vecDC*i
+    vecDC = Verts[C] - Verts[D]
+    F = Verts[D] + vecDC * i
 
     i = randnum(0.1, 0.9)
-    vecEF=F-E
+    vecEF = F - E
 
-    O=E+vecEF*i
+    O = E + vecEF * i
     return O
 
-################################ Protusions ###################################
+
+# ################## Protusions #################### #
 
 def fill_older_datas(verts, polygon):
-    """ Specifically coded to be called by the function addProtusionToPolygon, its sets up a tuple which contains the vertices from the base and the top of the protusions. """
+    """ Specifically coded to be called by the function addProtusionToPolygon,
+        its sets up a tuple which contains the vertices from the base and the top of the protusions.
+    """
     temp_vertices = []
     temp_vertices.append(verts[polygon[0]].copy())
     temp_vertices.append(verts[polygon[1]].copy())
@@ -90,15 +74,19 @@ def fill_older_datas(verts, polygon):
     temp_vertices.append(verts[polygon[3]].copy())
     return temp_vertices
 
+
 def extrude_top(temp_vertices, normal, height):
-    """ This function extrude the polygon composed of the four first members of the tuple temp_vertices along the normal multiplied by the height of the extrusion."""
+    """ This function extrude the polygon composed of the four first members of the tuple
+        temp_vertices along the normal multiplied by the height of the extrusion.
+    """
     j = 0
     while j < 3:
-        temp_vertices[0][j]+=normal[j]*height
-        temp_vertices[1][j]+=normal[j]*height
-        temp_vertices[2][j]+=normal[j]*height
-        temp_vertices[3][j]+=normal[j]*height
-        j+=1
+        temp_vertices[0][j] += normal[j] * height
+        temp_vertices[1][j] += normal[j] * height
+        temp_vertices[2][j] += normal[j] * height
+        temp_vertices[3][j] += normal[j] * height
+        j += 1
+
 
 def scale_top(temp_vertices, center, normal, height, scale_ratio):
     """ This function scale the polygon composed of the four first members of the tuple temp_vertices. """
@@ -109,41 +97,47 @@ def scale_top(temp_vertices, center, normal, height, scale_ratio):
 
     j = 0
     while j < 3:
-        center[j]+=normal[j]*height
+        center[j] += normal[j] * height
         vec1[j] = temp_vertices[0][j] - center[j]
         vec2[j] = temp_vertices[1][j] - center[j]
         vec3[j] = temp_vertices[2][j] - center[j]
         vec4[j] = temp_vertices[3][j] - center[j]
-        temp_vertices[0][j] = center[j] + vec1[j]*(1-scale_ratio)
-        temp_vertices[1][j] = center[j] + vec2[j]*(1-scale_ratio)
-        temp_vertices[2][j] = center[j] + vec3[j]*(1-scale_ratio)
-        temp_vertices[3][j] = center[j] + vec4[j]*(1-scale_ratio)
-        j+=1
+        temp_vertices[0][j] = center[j] + vec1[j] * (1 - scale_ratio)
+        temp_vertices[1][j] = center[j] + vec2[j] * (1 - scale_ratio)
+        temp_vertices[2][j] = center[j] + vec3[j] * (1 - scale_ratio)
+        temp_vertices[3][j] = center[j] + vec4[j] * (1 - scale_ratio)
+        j += 1
+
 
 def add_prot_polygons(temp_vertices):
-    """ Specifically coded to be called by addProtusionToPolygon, this function put the data from the generated protusion at the end the tuples Verts and Polygons, which will later used to generate the final mesh. """
+    """ Specifically coded to be called by addProtusionToPolygon, this function
+        put the data from the generated protusion at the end the tuples Verts and Polygons,
+        which will later used to generate the final mesh.
+    """
     global Verts
     global Polygons
     global i_prots
 
     findex = len(Verts)
-    Verts+=temp_vertices
+    Verts += temp_vertices
 
-    polygontop = [findex+0, findex+1, findex+2, findex+3]
-    polygon1 = [findex+0, findex+1, findex+5, findex+4]
-    polygon2 = [findex+1, findex+2, findex+6, findex+5]
-    polygon3 = [findex+2, findex+3, findex+7, findex+6]
-    polygon4 = [findex+3, findex+0, findex+4, findex+7]
+    polygontop = [findex + 0, findex + 1, findex + 2, findex + 3]
+    polygon1 = [findex + 0, findex + 1, findex + 5, findex + 4]
+    polygon2 = [findex + 1, findex + 2, findex + 6, findex + 5]
+    polygon3 = [findex + 2, findex + 3, findex + 7, findex + 6]
+    polygon4 = [findex + 3, findex + 0, findex + 4, findex + 7]
 
     Polygons.append(polygontop)
-    i_prots.append(len(Polygons)-1)
+    i_prots.append(len(Polygons) - 1)
     Polygons.append(polygon1)
     Polygons.append(polygon2)
     Polygons.append(polygon3)
     Polygons.append(polygon4)
 
+
 def addProtusionToPolygon(obpolygon, verts, minHeight, maxHeight, minTaper, maxTaper):
-    """Create a protusion from the polygon "obpolygon" of the original object and use several values sent by the user. It calls in this order the following functions:
+    """Create a protusion from the polygon "obpolygon" of the original object and use
+       several values sent by the user. It calls in this order the following functions:
        - fill_older_data;
        - extrude_top;
        - scale_top;
@@ -151,24 +145,20 @@ def addProtusionToPolygon(obpolygon, verts, minHeight, maxHeight, minTaper, maxT
    """
     # some useful variables
     polygon = obpolygon.vertices
-    polygontop = polygon
-    polygon1 = []
-    polygon2 = []
-    polygon3 = []
-    polygon4 = []
-    vertices = []
-    tVerts = list(fill_older_datas(verts, polygon)) # list of temp vertices
-    height = randnum(minHeight, maxHeight) # height of generated protusion
+
+    tVerts = list(fill_older_datas(verts, polygon))     # list of temp vertices
+    height = randnum(minHeight, maxHeight)              # height of generated protusion
     scale_ratio = randnum(minTaper, maxTaper)
 
     # extrude the top polygon
     extrude_top(tVerts, obpolygon.normal, height)
     # Now, we scale, the top polygon along its normal
-    scale_top(tVerts, GetPolyCentroid(obpolygon,verts), obpolygon.normal, height, scale_ratio)
+    scale_top(tVerts, GetPolyCentroid(obpolygon, verts), obpolygon.normal, height, scale_ratio)
     # Finally, we add the protusions to the list of polygons
     add_prot_polygons(tVerts)
 
-################################## Divide a polygon ##################################
+
+# ################# Divide a polygon ############### #
 
 def divide_one(list_polygons, list_vertices, verts, polygon, findex):
     """ called by divide_polygon, to generate a polygon from one polygon, maybe I could simplify this process """
@@ -178,63 +168,73 @@ def divide_one(list_polygons, list_vertices, verts, polygon, findex):
     temp_vertices.append(verts[polygon[2]].copy())
     temp_vertices.append(verts[polygon[3]].copy())
 
-    list_vertices+=temp_vertices
+    list_vertices += temp_vertices
+
+    list_polygons.append([findex + 0, findex + 1, findex + 2, findex + 3])
 
-    list_polygons.append([findex+0, findex+1, findex+2, findex+3])
 
 def divide_two(list_polygons, list_vertices, verts, polygon, findex):
-    """ called by divide_polygon, to generate two polygons from one polygon and add them to the list of polygons and vertices which form the discombobulated mesh"""
+    """ called by divide_polygon, to generate two polygons from one polygon and
+        add them to the list of polygons and vertices which form the discombobulated mesh
+    """
     temp_vertices = []
     temp_vertices.append(verts[polygon[0]].copy())
     temp_vertices.append(verts[polygon[1]].copy())
     temp_vertices.append(verts[polygon[2]].copy())
     temp_vertices.append(verts[polygon[3]].copy())
-    temp_vertices.append((verts[polygon[0]]+verts[polygon[1]])/2)
-    temp_vertices.append((verts[polygon[2]]+verts[polygon[3]])/2)
+    temp_vertices.append((verts[polygon[0]] + verts[polygon[1]]) / 2)
+    temp_vertices.append((verts[polygon[2]] + verts[polygon[3]]) / 2)
 
-    list_vertices+=temp_vertices
+    list_vertices += temp_vertices
+
+    list_polygons.append([findex + 0, findex + 4, findex + 5, findex + 3])
+    list_polygons.append([findex + 1, findex + 2, findex + 5, findex + 4])
 
-    list_polygons.append([findex+0, findex+4, findex+5, findex+3])
-    list_polygons.append([findex+1, findex+2, findex+5, findex+4])
 
 def divide_three(list_polygons, list_vertices, verts, polygon, findex, center):
-    """ called by divide_polygon, to generate three polygons from one polygon and add them to the list of polygons and vertices which form the discombobulated mesh"""
+    """ called by divide_polygon, to generate three polygons from one polygon and
+        add them to the list of polygons and vertices which form the discombobulated mesh
+    """
     temp_vertices = []
     temp_vertices.append(verts[polygon[0]].copy())
     temp_vertices.append(verts[polygon[1]].copy())
     temp_vertices.append(verts[polygon[2]].copy())
     temp_vertices.append(verts[polygon[3]].copy())
-    temp_vertices.append((verts[polygon[0]]+verts[polygon[1]])/2)
-    temp_vertices.append((verts[polygon[2]]+verts[polygon[3]])/2)
-    temp_vertices.append((verts[polygon[1]]+verts[polygon[2]])/2)
+    temp_vertices.append((verts[polygon[0]] + verts[polygon[1]]) / 2)
+    temp_vertices.append((verts[polygon[2]] + verts[polygon[3]]) / 2)
+    temp_vertices.append((verts[polygon[1]] + verts[polygon[2]]) / 2)
     temp_vertices.append(center.copy())
 
-    list_vertices+=temp_vertices
+    list_vertices += temp_vertices
+
+    list_polygons.append([findex + 0, findex + 4, findex + 5, findex + 3])
+    list_polygons.append([findex + 1, findex + 6, findex + 7, findex + 4])
+    list_polygons.append([findex + 6, findex + 2, findex + 5, findex + 7])
 
-    list_polygons.append([findex+0, findex+4, findex+5, findex+3])
-    list_polygons.append([findex+1, findex+6, findex+7, findex+4])
-    list_polygons.append([findex+6, findex+2, findex+5, findex+7])
 
 def divide_four(list_polygons, list_vertices, verts, polygon, findex, center):
-    """ called by divide_polygon, to generate four polygons from one polygon and add them to the list of polygons and vertices which form the discombobulated mesh"""
+    """ called by divide_polygon, to generate four polygons from one polygon and
+        add them to the list of polygons and vertices which form the discombobulated mesh
+    """
     temp_vertices = []
     temp_vertices.append(verts[polygon[0]].copy())
     temp_vertices.append(verts[polygon[1]].copy())
     temp_vertices.append(verts[polygon[2]].copy())
     temp_vertices.append(verts[polygon[3]].copy())
-    temp_vertices.append((verts[polygon[0]]+verts[polygon[1]])/2)
-    temp_vertices.append((verts[polygon[2]]+verts[polygon[3]])/2)
-    temp_vertices.append((verts[polygon[1]]+verts[polygon[2]])/2)
+    temp_vertices.append((verts[polygon[0]] + verts[polygon[1]]) / 2)
+    temp_vertices.append((verts[polygon[2]] + verts[polygon[3]]) / 2)
+    temp_vertices.append((verts[polygon[1]] + verts[polygon[2]]) / 2)
     temp_vertices.append(center.copy())
-    temp_vertices.append((verts[polygon[0]]+verts[polygon[3]])/2)
+    temp_vertices.append((verts[polygon[0]] + verts[polygon[3]]) / 2)
     temp_vertices.append(center.copy())
 
-    list_vertices+=temp_vertices
+    list_vertices += temp_vertices
+
+    list_polygons.append([findex + 0, findex + 4, findex + 7, findex + 8])
+    list_polygons.append([findex + 1, findex + 6, findex + 7, findex + 4])
+    list_polygons.append([findex + 6, findex + 2, findex + 5, findex + 7])
+    list_polygons.append([findex + 8, findex + 7, findex + 5, findex + 3])
 
-    list_polygons.append([findex+0, findex+4, findex+7, findex+8])
-    list_polygons.append([findex+1, findex+6, findex+7, findex+4])
-    list_polygons.append([findex+6, findex+2, findex+5, findex+7])
-    list_polygons.append([findex+8, findex+7, findex+5, findex+3])
 
 def dividepolygon(obpolygon, verts, number):
     """Divide the poly into the wanted number of polygons"""
@@ -242,38 +242,45 @@ def dividepolygon(obpolygon, verts, number):
     global nVerts
 
     poly = obpolygon.vertices
-    tVerts = []
 
-    if(number==1):
+    if(number == 1):
         divide_one(nPolygons, nVerts, verts, poly, len(nVerts))
-    elif(number==2):
+    elif(number == 2):
         divide_two(nPolygons, nVerts, verts, poly, len(nVerts))
-    elif(number==3):
-        divide_three(nPolygons, nVerts, verts, poly, len(nVerts), GetPolyCentroid(obpolygon,verts))
-    elif(number==4):
-        divide_four(nPolygons, nVerts, verts, poly, len(nVerts), GetPolyCentroid(obpolygon,verts))
+    elif(number == 3):
+        divide_three(nPolygons, nVerts, verts, poly, len(nVerts), GetPolyCentroid(obpolygon, verts))
+    elif(number == 4):
+        divide_four(nPolygons, nVerts, verts, poly, len(nVerts), GetPolyCentroid(obpolygon, verts))
+
 
-############################### Discombobulate ################################
+# ################## Discombobulate ################ #
 
-def GetPolyCentroid(obpolygon,allvertcoords):
-    centroid=mathutils.Vector((0,0,0))
+def GetPolyCentroid(obpolygon, allvertcoords):
+    centroid = Vector((0, 0, 0))
     for vindex in obpolygon.vertices:
-        centroid+=mathutils.Vector(allvertcoords[vindex])
-    centroid/=len(obpolygon.vertices)
+        centroid += Vector(allvertcoords[vindex])
+    centroid /= len(obpolygon.vertices)
     return centroid
 
+
 def division(obpolygons, verts, sf1, sf2, sf3, sf4):
     """Function to divide each of the selected polygons"""
     divide = []
-    if(sf1): divide.append(1)
-    if(sf2): divide.append(2)
-    if(sf3): divide.append(3)
-    if(sf4): divide.append(4)
+    if (sf1):
+        divide.append(1)
+    if (sf2):
+        divide.append(2)
+    if (sf3):
+        divide.append(3)
+    if (sf4):
+        divide.append(4)
+
     for poly in obpolygons:
-        if(poly.select == True and len(poly.vertices)==4):
-            a = random.randint(0, len(divide)-1)
+        if(poly.select is True and len(poly.vertices) == 4):
+            a = random.randint(0, len(divide) - 1)
             dividepolygon(poly, verts, divide[a])
 
+
 def protusion(obverts, obpolygons, minHeight, maxHeight, minTaper, maxTaper):
     """function to generate the protusions"""
     verts = []
@@ -281,30 +288,33 @@ def protusion(obverts, obpolygons, minHeight, maxHeight, minTaper, maxTaper):
         verts.append(vertex.co)
 
     for polygon in obpolygons:
-        if(polygon.select == True):
+        if(polygon.select is True):
             if(len(polygon.vertices) == 4):
                 addProtusionToPolygon(polygon, verts, minHeight, maxHeight, minTaper, maxTaper)
 
+
 def test_v2_near_v1(v1, v2):
-    if(v1.x - 0.1 <= v2.x <= v1.x + 0.1
-        and v1.y - 0.1 <= v2.y <= v1.y + 0.1
-        and v1.z - 0.1 <= v2.z <= v1.z + 0.1):
+    if (v1.x - 0.1 <= v2.x <= v1.x + 0.1 and
+       v1.y - 0.1 <= v2.y <= v1.y + 0.1 and
+       v1.z - 0.1 <= v2.z <= v1.z + 0.1):
         return True
 
     return False
 
+
 def angle_between_nor(nor_orig, nor_result):
     angle = math.acos(nor_orig.dot(nor_result))
     axis = nor_orig.cross(nor_result).normalized()
 
-    q = mathutils.Quaternion()
-    q.x = axis.x*math.sin(angle/2)
-    q.y = axis.y*math.sin(angle/2)
-    q.z = axis.z*math.sin(angle/2)
-    q.w = math.cos(angle/2)
+    q = Quaternion()
+    q.x = axis.x * math.sin(angle / 2)
+    q.y = axis.y * math.sin(angle / 2)
+    q.z = axis.z * math.sin(angle / 2)
+    q.w = math.cos(angle / 2)
 
     return q
 
+
 def doodads(object1, mesh1, dmin, dmax):
     """function to generate the doodads"""
     global dVerts
@@ -312,61 +322,67 @@ def doodads(object1, mesh1, dmin, dmax):
     i = 0
     # on parcoure cette boucle pour ajouter des doodads a toutes les polygons
     # english translation: this loops adds doodads to all polygons
-    while(i<len(object1.data.polygons)):
-        if object1.data.polygons[i].select==False:
+    while(i < len(object1.data.polygons)):
+        if object1.data.polygons[i].select is False:
             continue
+
         doods_nbr = random.randint(dmin, dmax)
         j = 0
-        while(j<=doods_nbr):
-            origin_dood = randVertex(object1.data.polygons[i].vertices[0], object1.data.polygons[i].vertices[1], object1.data.polygons[i].vertices[2], object1.data.polygons[i].vertices[3], Verts)
-            type_dood = random.randint(0, len(bpy.context.scene.DISC_doodads)-1)
+
+        while(j <= doods_nbr):
+            origin_dood = randVertex(object1.data.polygons[i].vertices[0], object1.data.polygons[i].vertices[1],
+                                     object1.data.polygons[i].vertices[2], object1.data.polygons[i].vertices[3], Verts)
+            type_dood = random.randint(0, len(bpy.context.scene.discomb.DISC_doodads) - 1)
             polygons_add = []
             verts_add = []
 
             # First we have to apply scaling and rotation to the mesh
-            bpy.ops.object.select_pattern(pattern=bpy.context.scene.DISC_doodads[type_dood],extend=False)
-            bpy.context.scene.objects.active=bpy.data.objects[bpy.context.scene.DISC_doodads[type_dood]]
+            bpy.ops.object.select_pattern(pattern=bpy.context.scene.discomb.DISC_doodads[type_dood], extend=False)
+            bpy.context.scene.objects.active = bpy.data.objects[bpy.context.scene.discomb.DISC_doodads[type_dood]]
             bpy.ops.object.transform_apply(rotation=True, scale=True)
 
-            for polygon in bpy.data.objects[bpy.context.scene.DISC_doodads[type_dood]].data.polygons:
+            for polygon in bpy.data.objects[bpy.context.scene.discomb.DISC_doodads[type_dood]].data.polygons:
                 polygons_add.append(polygon.vertices)
-            for vertex in bpy.data.objects[bpy.context.scene.DISC_doodads[type_dood]].data.vertices:
+            for vertex in bpy.data.objects[bpy.context.scene.discomb.DISC_doodads[type_dood]].data.vertices:
                 verts_add.append(vertex.co.copy())
             normal_original_polygon = object1.data.polygons[i].normal
 
-            nor_def = mathutils.Vector((0.0, 0.0, 1.0))
+            nor_def = Vector((0.0, 0.0, 1.0))
             qr = nor_def.rotation_difference(normal_original_polygon.normalized())
 
-            case_z = False
             if(test_v2_near_v1(nor_def, -normal_original_polygon)):
-                case_z = True
-                qr = mathutils.Quaternion((0.0, 0.0, 0.0, 0.0))
-            #qr = angle_between_nor(nor_def, normal_original_polygon)
+                qr = Quaternion((0.0, 0.0, 0.0, 0.0))
+
+            # qr = angle_between_nor(nor_def, normal_original_polygon)
             for vertex in verts_add:
                 vertex.rotate(qr)
-                vertex+=origin_dood
+                vertex += origin_dood
             findex = len(dVerts)
+
             for polygon in polygons_add:
-                dPolygons.append([polygon[0]+findex, polygon[1]+findex, polygon[2]+findex, polygon[3]+findex])
-                i_dood_type.append(bpy.data.objects[bpy.context.scene.DISC_doodads[type_dood]].name)
+                dPolygons.append([polygon[0] + findex, polygon[1] + findex, polygon[2] + findex, polygon[3] + findex])
+                i_dood_type.append(bpy.data.objects[bpy.context.scene.discomb.DISC_doodads[type_dood]].name)
+
             for vertex in verts_add:
                 dVerts.append(vertex)
-            j+=1
-        i+=5
+            j += 1
+        i += 5
+
 
 def protusions_repeat(object1, mesh1, r_prot):
 
         for j in i_prots:
-            if j<len(object1.data.polygons):
-                object1.data.polygons[j].select=True
+            if j < len(object1.data.polygons):
+                object1.data.polygons[j].select = True
             else:
                 print("Warning: hit end of polygons in object1")
 
+
 # add material to discombobulated mesh
 def setMatProt(discObj, origObj, sideProtMat, topProtMat):
     # First we put the materials in their slots
-    bpy.ops.object.select_pattern(pattern = discObj.name,extend=False)
-    bpy.context.scene.objects.active=bpy.data.objects[discObj.name]
+    bpy.ops.object.select_pattern(pattern=discObj.name, extend=False)
+    bpy.context.scene.objects.active = bpy.data.objects[discObj.name]
     try:
         origObj.material_slots[topProtMat]
         origObj.material_slots[sideProtMat]
@@ -385,30 +401,32 @@ def setMatProt(discObj, origObj, sideProtMat, topProtMat):
         else:
             polygon.material_index = 1
 
+
 def setMatDood(doodObj):
     # First we add the materials slots
-    bpy.ops.object.select_pattern(pattern = doodObj.name,extend=False)
-    bpy.context.scene.objects.active=doodObj
-    for name in bpy.context.scene.DISC_doodads:
+    bpy.ops.object.select_pattern(pattern=doodObj.name, extend=False)
+    bpy.context.scene.objects.active = doodObj
+    for name in bpy.context.scene.discomb.DISC_doodads:
         try:
             bpy.ops.object.material_slot_add()
             doodObj.material_slots[-1].material = bpy.data.objects[name].material_slots[0].material
             for polygon in doodObj.data.polygons:
                 if i_dood_type[polygon.index] == name:
-                    polygon.material_index = len(doodObj.material_slots)-1
+                    polygon.material_index = len(doodObj.material_slots) - 1
         except:
             print()
 
 
 def clean_doodads():
-    current_doodads=list(bpy.context.scene.DISC_doodads)
+    current_doodads = list(bpy.context.scene.discomb.DISC_doodads)
 
     for name in current_doodads:
         if name not in bpy.data.objects:
-            bpy.context.scene.DISC_doodads.remove(name)
+            bpy.context.scene.discomb.DISC_doodads.remove(name)
 
 
-def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4, dmin, dmax, r_prot, sideProtMat, topProtMat, isLast):
+def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
+                   dmin, dmax, r_prot, sideProtMat, topProtMat, isLast):
     global doprots
     global nVerts
     global nPolygons
@@ -418,14 +436,11 @@ def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
     global dPolygons
     global i_prots
 
-
     bpy.ops.object.mode_set(mode="OBJECT")
 
-
-    #start by cleaning up doodads that don't exist anymore
+    # start by cleaning up doodads that don't exist anymore
     clean_doodads()
 
-
     # Create the discombobulated mesh
     mesh = bpy.data.meshes.new("tmp")
     object = bpy.data.objects.new("tmp", mesh)
@@ -443,8 +458,8 @@ def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
 
     # There we collect the rotation, translation and scaling datas from the original mesh
     to_translate = bpy.context.active_object.location
-    to_scale     = bpy.context.active_object.scale
-    to_rotate    = bpy.context.active_object.rotation_euler
+    to_scale = bpy.context.active_object.scale
+    to_rotate = bpy.context.active_object.rotation_euler
 
     # First, we collect all the informations we will need from the previous mesh
     obverts = bpy.context.active_object.data.vertices
@@ -457,12 +472,12 @@ def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
 
     # Fill in the discombobulated mesh with the new polygons
     mesh.from_pydata(nVerts, [], nPolygons)
-    mesh.update(calc_edges = True)
+    mesh.update(calc_edges=True)
 
     # Reload the datas
     bpy.ops.object.select_all(action="DESELECT")
-    bpy.ops.object.select_pattern(pattern = object.name,extend=False)
-    bpy.context.scene.objects.active=bpy.data.objects[object.name]
+    bpy.ops.object.select_pattern(pattern=object.name, extend=False)
+    bpy.context.scene.objects.active = bpy.data.objects[object.name]
     obverts = bpy.context.active_object.data.vertices
     obpolygons = bpy.context.active_object.data.polygons
 
@@ -473,213 +488,276 @@ def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
     object1 = bpy.data.objects.new("discombobulated_mesh", mesh1)
     bpy.context.scene.objects.link(object1)
     mesh1.from_pydata(Verts, [], Polygons)
-    mesh1.update(calc_edges = True)
-
+    mesh1.update(calc_edges=True)
 
     # Set the material's of discombobulated object
     setMatProt(object1, origObj, sideProtMat, topProtMat)
 
-    bpy.ops.object.select_pattern(pattern = object1.name,extend=False)
-    bpy.context.scene.objects.active=bpy.data.objects[object1.name]
+    bpy.ops.object.select_pattern(pattern=object1.name, extend=False)
+    bpy.context.scene.objects.active = bpy.data.objects[object1.name]
     bpy.ops.object.mode_set(mode='EDIT')
     bpy.ops.mesh.normals_make_consistent(inside=False)
     bpy.ops.mesh.select_all(action='DESELECT')
     bpy.ops.object.mode_set(mode='OBJECT')
 
-    #if(bpy.context.scene.repeatprot):
+    # if(bpy.context.scene.repeatprot):
     protusions_repeat(object1, mesh1, r_prot)
 
-    if(len(bpy.context.scene.DISC_doodads) != 0 and bpy.context.scene.dodoodads and isLast):
+    if(len(bpy.context.scene.discomb.DISC_doodads) != 0 and bpy.context.scene.discomb.dodoodads and isLast):
         doodads(object1, mesh1, dmin, dmax)
         mesh2 = bpy.data.meshes.new("dood_mesh")
         object2 = bpy.data.objects.new("dood_obj", mesh2)
         bpy.context.scene.objects.link(object2)
         mesh2.from_pydata(dVerts, [], dPolygons)
-        mesh2.update(calc_edges = True)
+        mesh2.update(calc_edges=True)
         setMatDood(object2)
-        object2.location        = to_translate
-        object2.rotation_euler  = to_rotate
-        object2.scale           = to_scale
+        object2.location = to_translate
+        object2.rotation_euler = to_rotate
+        object2.scale = to_scale
 
-    bpy.ops.object.select_pattern(pattern = object.name,extend=False)
-    bpy.context.scene.objects.active=bpy.data.objects[object.name]
+    bpy.ops.object.select_pattern(pattern=object.name, extend=False)
+    bpy.context.scene.objects.active = bpy.data.objects[object.name]
     bpy.ops.object.delete()
 
-    bpy.ops.object.select_pattern(pattern=object1.name,extend=False)
-    bpy.context.scene.objects.active=bpy.data.objects[object1.name]
+    bpy.ops.object.select_pattern(pattern=object1.name, extend=False)
+    bpy.context.scene.objects.active = bpy.data.objects[object1.name]
     bpy.context.scene.update()
 
     # translate, scale and rotate discombobulated results
-    object1.location        = to_translate
-    object1.rotation_euler  = to_rotate
-    object1.scale           = to_scale
+    object1.location = to_translate
+    object1.rotation_euler = to_rotate
+    object1.scale = to_scale
 
-    #set all polys to selected. this allows recursive discombobulating.
+    # set all polys to selected. this allows recursive discombobulating.
     for poly in mesh1.polygons:
-        poly.select=True
+        poly.select = True
+
 
-############ Operator to select and deslect an object as a doodad ###############
+# ### Operators for selecting and deselecting an object as a doodad ### #
 
-class chooseDoodad(bpy.types.Operator):
+class chooseDoodad(Operator):
     bl_idname = "object.discombobulate_set_doodad"
     bl_label = "Discombobulate set doodad object"
+    bl_description = ("Save the Active Object as Doodad \n"
+                      "Object has to be quads only")
+    bl_options = {'REGISTER'}
+
+    @classmethod
+    def poll(cls, context):
+        obj = bpy.context.active_object
+        if (obj is not None and obj.type == "MESH"):
+            mesh = obj.data
+
+            for polygon in mesh.polygons:
+                is_ok = len(polygon.vertices)
+                if is_ok != 4:
+                    return False
+            return True
+
+        return False
 
     def execute(self, context):
-        bpy.context.scene.DISC_doodads.append(bpy.context.active_object.name)
+        obj_name = bpy.context.active_object.name
+        msg = "Object with this name already saved"
+
+        if obj_name not in bpy.context.scene.discomb.DISC_doodads:
+            bpy.context.scene.discomb.DISC_doodads.append(obj_name)
+            msg = "Saved Doodad object: {}".format(obj_name)
+
+        self.report({'INFO'}, message=msg)
 
     def invoke(self, context, event):
         self.execute(context)
         return {'FINISHED'}
 
-class unchooseDoodad(bpy.types.Operator):
+
+class unchooseDoodad(Operator):
     bl_idname = "object.discombobulate_unset_doodad"
     bl_label = "Discombobulate unset doodad object"
+    bl_description = "Remove the saved Doodad Object(s)"
+    bl_options = {'REGISTER'}
+
+    remove_all = bpy.props.BoolProperty(
+                        name="Remove all Doodads",
+                        default=False,
+                        )
 
     def execute(self, context):
-        for name in bpy.context.scene.DISC_doodads:
-            if name == bpy.context.active_object.name:
-                bpy.context.scene.DISC_doodads.remove(name)
+        msg = ("No doodads to remove")
+        doodadery = bpy.context.scene.discomb.DISC_doodads
+        if len(doodadery) > 0:
+            if not self.remove_all:
+                name = bpy.context.active_object.name
+                if name in doodadery:
+                    bpy.context.scene.discomb.DISC_doodads.remove(name)
+                    msg = ("Removed Doodad object: {}".format(name))
+            else:
+                bpy.context.scene.discomb.DISC_doodads[:] = []
+                msg = "Removed all Doodads"
+        else:
+            msg = "No Doodads to Remove"
+
+        self.report({'INFO'}, message=msg)
 
     def invoke(self, context, event):
         self.execute(context)
         return {'FINISHED'}
 
-################################## Interpolygon ####################################
 
-class discombobulator(bpy.types.Operator):
+# ################## Interpolygon ################## #
+
+class discombobulator(Operator):
     bl_idname = "object.discombobulate"
     bl_label = "Discombobulate"
+    bl_description = "Apply"
     bl_options = {'REGISTER', 'UNDO'}
 
     def execute(self, context):
-        scn = context.scene
-        i=0
-        while i<scn.repeatprot:
-            isLast=False
-            if i==scn.repeatprot-1:
-                isLast=True
-            discombobulate(scn.minHeight, scn.maxHeight, scn.minTaper, scn.maxTaper, scn.subpolygon1, scn.subpolygon2, scn.subpolygon3, scn.subpolygon4, scn.mindoodads, scn.maxdoodads, scn.repeatprot, scn.sideProtMat, scn.topProtMat, isLast)
-            i+=1
+        scn = context.scene.discomb
+        i = 0
+        while i < bpy.context.scene.discomb.repeatprot:
+            isLast = False
+            if i == scn.repeatprot - 1:
+                isLast = True
+            discombobulate(scn.minHeight, scn.maxHeight, scn.minTaper, scn.maxTaper, scn.subpolygon1,
+                           scn.subpolygon2, scn.subpolygon3, scn.subpolygon4, scn.mindoodads, scn.maxdoodads,
+                           scn.repeatprot, scn.sideProtMat, scn.topProtMat, isLast)
+            i += 1
         return {'FINISHED'}
 
-class discombob_help(bpy.types.Operator):
-    bl_idname = 'help.discombobulator'
-    bl_label = ''
+
+class discombobulator_dodads_list(Menu):
+    bl_idname = "object.discombobulator_dodad_list"
+    bl_label = "List of saved Doodads"
+    bl_description = "List of the saved Doodad Object Names"
+    bl_options = {'REGISTER'}
 
     def draw(self, context):
         layout = self.layout
-        layout.label('To use:')
-        layout.label('Works with Quads only not Ngons.')
-        layout.label('Select a face or faces')
-        layout.label('Press Discombobulate to create greebles')
-
 
+        doodle = len(bpy.context.scene.discomb.DISC_doodads)
+        layout.label("Saved doodads : {}".format(doodle))
+        layout.separator()
+        if doodle > 0:
+            for name in bpy.context.scene.discomb.DISC_doodads:
+                layout.label(text=name)
 
-    def execute(self, context):
-        return {'FINISHED'}
 
-    def invoke(self, context, event):
-        return context.window_manager.invoke_popup(self, width = 300)
+class discombob_help(Menu):
+    bl_idname = "help.discombobulator"
+    bl_label = "Usage Information"
+    bl_description = "Help"
+    bl_options = {'REGISTER'}
 
-class VIEW3D_PT_tools_discombobulate(bpy.types.Operator):
-    bl_idname = 'discombobulate.ops'
+    def draw(self, context):
+        layout = self.layout
+        layout.label(text="Usage Information:", icon="INFO")
+        layout.separator()
+        layout.label(text="Quads only, not Triangles or Ngons", icon="ERROR")
+        layout.label("Works only with Mesh object that have faces")
+        layout.separator()
+        layout.label("Select a face or faces")
+        layout.label("Press Discombobulate to create greebles")
+        layout.label("In object mode, still needs a selection in Edit Mode")
+        layout.separator()
+        layout.label("Doodads - additional objects layered on the mesh surface")
+        layout.label("(Similar to dupliverts - but as one separate object)")
+        layout.separator()
+        layout.label(text="Limitations:", icon="MOD_EXPLODE")
+        layout.label("Be careful with the repeat protusions setting")
+        layout.label("(Runs reqursively)")
+        layout.label("If possible, avoid using on a high polycount base mesh")
+        layout.label("(It can run out of memory and take a long time to compute)")
+
+
+class VIEW3D_OT_tools_discombobulate(Operator):
+    bl_idname = "discombobulate.ops"
     bl_label = "Discombobulator"
+    bl_description = ("Easily add sci-fi details to a surface \n"
+                      "Needs an existing active Mesh with Faces")
+    bl_options = {'REGISTER'}
+
+    executing = False
+
+    @classmethod
+    def poll(cls, context):
+        return (context.active_object is not None and
+                context.active_object.type == "MESH")
 
     def draw(self, context):
         layout = self.layout
+
         row = layout.row()
-        row = layout.split(0.80)
-        row.operator('object.discombobulate', text = 'Discombobulate', icon = 'PLUGIN')
-        row.operator('help.discombobulator', icon = 'INFO')
+        row.menu('help.discombobulator', icon='INFO')
         box = layout.box()
         box.label("Protusions settings")
         row = box.row()
-        row.prop(context.scene, 'doprots')
+        row.prop(context.scene.discomb, 'doprots')
         row = box.row()
-        row.prop(context.scene, 'minHeight')
+        row.prop(context.scene.discomb, 'minHeight')
         row = box.row()
-        row.prop(context.scene, 'maxHeight')
+        row.prop(context.scene.discomb, 'maxHeight')
         row = box.row()
-        row.prop(context.scene, 'minTaper')
+        row.prop(context.scene.discomb, 'minTaper')
         row = box.row()
-        row.prop(context.scene, 'maxTaper')
+        row.prop(context.scene.discomb, 'maxTaper')
         row = box.row()
-        col1 = row.column(align = True)
-        col1.prop(context.scene, "subpolygon1")
-        col2 = row.column(align = True)
-        col2.prop(context.scene, "subpolygon2")
-        col3 = row.column(align = True)
-        col3.prop(context.scene, "subpolygon3")
-        col4 = row.column(align = True)
-        col4.prop(context.scene, "subpolygon4")
+        col1 = row.column(align=True)
+        col1.prop(context.scene.discomb, "subpolygon1")
+        col2 = row.column(align=True)
+        col2.prop(context.scene.discomb, "subpolygon2")
+        col3 = row.column(align=True)
+        col3.prop(context.scene.discomb, "subpolygon3")
+        col4 = row.column(align=True)
+        col4.prop(context.scene.discomb, "subpolygon4")
         row = box.row()
-        row.prop(context.scene, "repeatprot")
+        row.prop(context.scene.discomb, "repeatprot")
         box = layout.box()
         box.label("Doodads settings")
         row = box.row()
-        row.prop(context.scene, 'dodoodads')
+        is_doodad = context.scene.discomb.dodoodads
+        row.prop(context.scene.discomb, 'dodoodads')
+
         row = box.row()
-        row.prop(context.scene, "mindoodads")
+        row.enabled = is_doodad
+        row.prop(context.scene.discomb, "mindoodads")
         row = box.row()
-        row.prop(context.scene, "maxdoodads")
+        row.enabled = is_doodad
+        row.prop(context.scene.discomb, "maxdoodads")
         row = box.row()
-        row.operator("object.discombobulate_set_doodad", text = "Pick doodad")
+        row.enabled = is_doodad
+        row.operator("object.discombobulate_set_doodad", text="Pick doodad")
+
         row = box.row()
-        row.operator("object.discombobulate_unset_doodad", text = "Remove doodad")
-        col = box.column(align = True)
-        for name in bpy.context.scene.DISC_doodads:
-            col.label(text = name)
+        splits = row.split(0.5)
+        splits.enabled = is_doodad
+        splits.operator("object.discombobulate_unset_doodad",
+                        text="Remove active doodad").remove_all = False
+        splits.operator("object.discombobulate_unset_doodad",
+                        text="Remove all doodads").remove_all = True
+
+        col = box.column(align=True)
+        doodle = len(bpy.context.scene.discomb.DISC_doodads)
+
+        col.enabled = (True if doodle > 0 else False)
+        col.menu("object.discombobulator_dodad_list",
+                     text="List of saved Doodads ({})".format(doodle))
+
         box = layout.box()
         box.label("Materials settings")
         row = box.row()
-        row.prop(context.scene, 'topProtMat')
+        row.prop(context.scene.discomb, 'topProtMat')
         row = box.row()
-        row.prop(context.scene, "sideProtMat")
-        row = box.row()
-    def execute(self, context):
-        return {'FINISHED'}
+        row.prop(context.scene.discomb, "sideProtMat")
 
     def invoke(self, context, event):
-        return context.window_manager.invoke_popup(self, width = 300)
-# registering and menu integration
-def register():
-    # Protusions Buttons:
-    bpy.types.Scene.repeatprot = bpy.props.IntProperty(name="Repeat protusions", description="make several layers of protusion", default = 1, min = 1, max = 10)
-    bpy.types.Scene.doprots = bpy.props.BoolProperty(name="Make protusions", description = "Check if we want to add protusions to the mesh", default = True)
-    bpy.types.Scene.polygonschangedpercent = bpy.props.FloatProperty(name="Polygon %", description = "Percentage of changed polygons", default = 1.0)
-    bpy.types.Scene.minHeight = bpy.props.FloatProperty(name="Min height", description="Minimal height of the protusions", default=0.2)
-    bpy.types.Scene.maxHeight = bpy.props.FloatProperty(name="Max height", description="Maximal height of the protusions", default = 0.4)
-    bpy.types.Scene.minTaper = bpy.props.FloatProperty(name="Min taper", description="Minimal height of the protusions", default=0.15, min = 0.0, max = 1.0, subtype = 'PERCENTAGE')
-    bpy.types.Scene.maxTaper = bpy.props.FloatProperty(name="Max taper", description="Maximal height of the protusions", default = 0.35, min = 0.0, max = 1.0, subtype = 'PERCENTAGE')
-    bpy.types.Scene.subpolygon1 = bpy.props.BoolProperty(name="1", default = True)
-    bpy.types.Scene.subpolygon2 = bpy.props.BoolProperty(name="2", default = True)
-    bpy.types.Scene.subpolygon3 = bpy.props.BoolProperty(name="3", default = True)
-    bpy.types.Scene.subpolygon4 = bpy.props.BoolProperty(name="4", default = True)
-
-    # Doodads buttons:
-    bpy.types.Scene.dodoodads = bpy.props.BoolProperty(name="Make doodads", description = "Check if we want to generate doodads", default = True)
-    bpy.types.Scene.mindoodads = bpy.props.IntProperty(name="Minimum doodads number", description = "Ask for the minimum number of doodads to generate per polygon", default = 1, min = 0, max = 50)
-    bpy.types.Scene.maxdoodads = bpy.props.IntProperty(name="Maximum doodads number", description = "Ask for the maximum number of doodads to generate per polygon", default = 6, min = 1, max = 50)
-    bpy.types.Scene.doodMinScale = bpy.props.FloatProperty(name="Scale min", description="Minimum scaling of doodad", default = 0.5, min = 0.0, max = 1.0, subtype = 'PERCENTAGE')
-    bpy.types.Scene.doodMaxScale = bpy.props.FloatProperty(name="Scale max", description="Maximum scaling of doodad", default = 1.0, min = 0.0, max = 1.0, subtype = 'PERCENTAGE')
-
-    # Materials buttons:
-    bpy.types.Scene.sideProtMat = bpy.props.IntProperty(name="Side's prot mat", description = "Material of protusion's sides", default = 0, min = 0)
-    bpy.types.Scene.topProtMat = bpy.props.IntProperty(name = "Prot's top mat", description = "Material of protusion's top", default = 0, min = 0)
-
-    bpy.utils.register_class(discombobulator)
-    bpy.utils.register_class(chooseDoodad)
-    bpy.utils.register_class(unchooseDoodad)
-    bpy.utils.register_class(VIEW3D_PT_tools_discombobulate)
-    bpy.utils.register_class(discombob_help)
-
-# unregistering and removing menus
-def unregister():
-    bpy.utils.unregister_class(discombobulator)
-    bpy.utils.unregister_class(chooseDoodad)
-    bpy.utils.unregister_class(unchooseDoodad)
-    bpy.utils.unregister_class(VIEW3D_PT_tools_discombobulate)
-    bpy.utils.unregister_class(discombob_help)
-
-if __name__ == "__main__":
-    register()
+        return context.window_manager.invoke_props_dialog(self, width=300)
+
+    def check(self, context):
+        return not self.executing
+
+    def execute(self, context):
+        self.executing = True
+        bpy.ops.object.discombobulate('INVOKE_DEFAULT')
+
+        return {'FINISHED'}