archipack: T52120 release to official

1 files changed, 2849 insertions, 0 deletions

diff --git a/archipack/archipack_stair.py b/archipack/archipack_stair.py
new file mode 100644
index 00000000..c7e7f02c
--- /dev/null
+++ b/archipack/archipack_stair.py
@@ -0,0 +1,2849 @@
+# -*- coding:utf-8 -*-
+
+# ##### 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 #####
+
+# <pep8 compliant>
+
+# ----------------------------------------------------------
+# Author: Stephen Leger (s-leger)
+#
+# ----------------------------------------------------------
+# noinspection PyUnresolvedReferences
+import bpy
+# noinspection PyUnresolvedReferences
+from bpy.types import Operator, PropertyGroup, Mesh, Panel
+from bpy.props import (
+    FloatProperty, BoolProperty, IntProperty, CollectionProperty,
+    StringProperty, EnumProperty, FloatVectorProperty
+    )
+from .bmesh_utils import BmeshEdit as bmed
+from .panel import Panel as Lofter
+from mathutils import Vector, Matrix
+from math import sin, cos, pi, floor, acos
+from .archipack_manipulator import Manipulable, archipack_manipulator
+from .archipack_2d import Line, Arc
+from .archipack_preset import ArchipackPreset, PresetMenuOperator
+from .archipack_object import ArchipackCreateTool, ArchipackObject
+
+
+class Stair():
+    def __init__(self, left_offset, right_offset, steps_type, nose_type, z_mode, nose_z, bottom_z):
+        self.steps_type = steps_type
+        self.nose_type = nose_type
+        self.l_shape = None
+        self.r_shape = None
+        self.next_type = 'NONE'
+        self.last_type = 'NONE'
+        self.z_mode = z_mode
+        # depth of open step
+        self.nose_z = nose_z
+        # size under the step on bottom
+        self.bottom_z = bottom_z
+        self.left_offset = left_offset
+        self.right_offset = right_offset
+        self.last_height = 0
+
+    def set_matids(self, matids):
+        self.idmat_top, self.idmat_step_front, self.idmat_raise, \
+        self.idmat_side, self.idmat_bottom, self.idmat_step_side = matids
+
+    def set_height(self, step_height, z0):
+        self.step_height = step_height
+        self.z0 = z0
+
+    @property
+    def height(self):
+        return self.n_step * self.step_height
+
+    @property
+    def top_offset(self):
+        return self.t_step / self.step_depth
+
+    @property
+    def top(self):
+        return self.z0 + self.height
+
+    @property
+    def left_length(self):
+        return self.get_length("LEFT")
+
+    @property
+    def right_length(self):
+        return self.get_length("RIGHT")
+
+    def step_size(self, step_depth):
+        t_step, n_step = self.steps(step_depth)
+        self.n_step = n_step
+        self.t_step = t_step
+        self.step_depth = step_depth
+        return n_step
+
+    def p3d_left(self, verts, p2d, i, t, landing=False):
+        x, y = p2d
+        nose_z = min(self.step_height, self.nose_z)
+        zl = self.z0 + t * self.height
+        zs = self.z0 + i * self.step_height
+        if self.z_mode == 'LINEAR':
+            z0 = max(0, zl)
+            z1 = z0 - self.bottom_z
+            verts.extend([(x, y, z0), (x, y, z1)])
+        else:
+            if "FULL" in self.steps_type:
+                z0 = 0
+            else:
+                z0 = max(0, zl - nose_z - self.bottom_z)
+            z3 = zs + max(0, self.step_height - nose_z)
+            z4 = zs + self.step_height
+            if landing:
+                if "FULL" in self.steps_type:
+                    z2 = 0
+                    z1 = 0
+                else:
+                    z2 = max(0, min(z3, z3 - self.bottom_z))
+                    z1 = z2
+            else:
+                z1 = min(z3, max(z0, zl - nose_z))
+                z2 = min(z3, max(z1, zl))
+            verts.extend([(x, y, z0),
+                        (x, y, z1),
+                        (x, y, z2),
+                        (x, y, z3),
+                        (x, y, z4)])
+
+    def p3d_right(self, verts, p2d, i, t, landing=False):
+        x, y = p2d
+        nose_z = min(self.step_height, self.nose_z)
+        zl = self.z0 + t * self.height
+        zs = self.z0 + i * self.step_height
+        if self.z_mode == 'LINEAR':
+            z0 = max(0, zl)
+            z1 = z0 - self.bottom_z
+            verts.extend([(x, y, z1), (x, y, z0)])
+        else:
+            if "FULL" in self.steps_type:
+                z0 = 0
+            else:
+                z0 = max(0, zl - nose_z - self.bottom_z)
+            z3 = zs + max(0, self.step_height - nose_z)
+            z4 = zs + self.step_height
+            if landing:
+                if "FULL" in self.steps_type:
+                    z2 = 0
+                    z1 = 0
+                else:
+                    z2 = max(0, min(z3, z3 - self.bottom_z))
+                    z1 = z2
+            else:
+                z1 = min(z3, max(z0, zl - nose_z))
+                z2 = min(z3, max(z1, zl))
+            verts.extend([(x, y, z4),
+                          (x, y, z3),
+                          (x, y, z2),
+                          (x, y, z1),
+                          (x, y, z0)])
+
+    def p3d_cstep_left(self, verts, p2d, i, t):
+        x, y = p2d
+        nose_z = min(self.step_height, self.nose_z)
+        zs = self.z0 + i * self.step_height
+        z3 = zs + max(0, self.step_height - nose_z)
+        z1 = min(z3, zs - nose_z)
+        verts.append((x, y, z1))
+        verts.append((x, y, z3))
+
+    def p3d_cstep_right(self, verts, p2d, i, t):
+        x, y = p2d
+        nose_z = min(self.step_height, self.nose_z)
+        zs = self.z0 + i * self.step_height
+        z3 = zs + max(0, self.step_height - nose_z)
+        z1 = min(z3, zs - nose_z)
+        verts.append((x, y, z3))
+        verts.append((x, y, z1))
+
+    def straight_stair(self, length):
+        self.next_type = 'STAIR'
+        s = self.straight(length)
+        return StraightStair(s.p, s.v, self.left_offset, self.right_offset, self.steps_type,
+                self.nose_type, self.z_mode, self.nose_z, self.bottom_z)
+
+    def straight_landing(self, length, last_type='STAIR'):
+        self.next_type = 'LANDING'
+        s = self.straight(length)
+        return StraightLanding(s.p, s.v, self.left_offset, self.right_offset, self.steps_type,
+                self.nose_type, self.z_mode, self.nose_z, self.bottom_z, last_type=last_type)
+
+    def curved_stair(self, da, radius, left_shape, right_shape, double_limit=pi):
+        self.next_type = 'STAIR'
+        n = self.normal(1)
+        n.v = radius * n.v.normalized()
+        if da < 0:
+            n.v = -n.v
+        a0 = n.angle
+        c = n.p - n.v
+        return CurvedStair(c, radius, a0, da, self.left_offset, self.right_offset,
+                self.steps_type, self.nose_type, self.z_mode, self.nose_z, self.bottom_z,
+                left_shape, right_shape, double_limit=double_limit)
+
+    def curved_landing(self, da, radius, left_shape, right_shape, double_limit=pi, last_type='STAIR'):
+        self.next_type = 'LANDING'
+        n = self.normal(1)
+        n.v = radius * n.v.normalized()
+        if da < 0:
+            n.v = -n.v
+        a0 = n.angle
+        c = n.p - n.v
+        return CurvedLanding(c, radius, a0, da, self.left_offset, self.right_offset,
+                self.steps_type, self.nose_type, self.z_mode, self.nose_z, self.bottom_z,
+                left_shape, right_shape, double_limit=double_limit, last_type=last_type)
+
+    def get_z(self, t, mode):
+        if mode == 'LINEAR':
+            return self.z0 + t * self.height
+        else:
+            step = 1 + floor(t / self.t_step)
+            return self.z0 + step * self.step_height
+
+    def make_profile(self, t, side, profile, verts, faces, matids, next=None, tnext=0):
+        z0 = self.get_z(t, 'LINEAR')
+        dz1 = 0
+        t, part, dz0, shape = self.get_part(t, side)
+        if next is not None:
+            tnext, next, dz1, shape1 = next.get_part(tnext, side)
+        xy, s = part.proj_xy(t, next)
+        v_xy = s * xy.to_3d()
+        z, s = part.proj_z(t, dz0, next, dz1)
+        v_z = s * Vector((-xy.y * z.x, xy.x * z.x, z.y))
+        x, y = part.lerp(t)
+        verts += [Vector((x, y, z0)) + v.x * v_xy + v.y * v_z for v in profile]
+
+    def project_uv(self, rM, uvs, verts, indexes, up_axis='Z'):
+        if up_axis == 'Z':
+            uvs.append([(rM * Vector(verts[i])).to_2d() for i in indexes])
+        elif up_axis == 'Y':
+            uvs.append([(x, z) for x, y, z in [(rM * Vector(verts[i])) for i in indexes]])
+        else:
+            uvs.append([(y, z) for x, y, z in [(rM * Vector(verts[i])) for i in indexes]])
+
+    def get_proj_matrix(self, part, t, nose_y):
+        # a matrix to project verts
+        # into uv space for horizontal parts of this step
+        # so uv = (rM * vertex).to_2d()
+        tl = t - nose_y / self.get_length("LEFT")
+        tr = t - nose_y / self.get_length("RIGHT")
+        t2, part, dz, shape = self.get_part(tl, "LEFT")
+        p0 = part.lerp(t2)
+        t2, part, dz, shape = self.get_part(tr, "RIGHT")
+        p1 = part.lerp(t2)
+        v = (p1 - p0).normalized()
+        return Matrix([
+            [-v.y, v.x, 0, p0.x],
+            [v.x, v.y, 0, p0.y],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        ]).inverted()
+
+    def _make_nose(self, i, s, verts, faces, matids, uvs, nose_y):
+
+        t = self.t_step * i
+
+        # a matrix to project verts
+        # into uv space for horizontal parts of this step
+        # so uv = (rM * vertex).to_2d()
+        rM = self.get_proj_matrix(self, t, nose_y)
+
+        if self.z_mode == 'LINEAR':
+            return rM
+
+        f = len(verts)
+
+        tl = t - nose_y / self.get_length("LEFT")
+        tr = t - nose_y / self.get_length("RIGHT")
+
+        t2, part, dz, shape = self.get_part(tl, "LEFT")
+        p0 = part.lerp(t2)
+        self.p3d_left(verts, p0, s, t2)
+
+        t2, part, dz, shape = self.get_part(tr, "RIGHT")
+        p1 = part.lerp(t2)
+        self.p3d_right(verts, p1, s, t2)
+
+        start = 3
+        end = 6
+        offset = 10
+
+        # left, top, right
+        matids.extend([self.idmat_step_side,
+             self.idmat_top,
+             self.idmat_step_side])
+
+        faces += [(f + j, f + j + 1, f + j + offset + 1, f + j + offset) for j in range(start, end)]
+
+        u = nose_y
+        v = (p1 - p0).length
+        w = verts[f + 2][2] - verts[f + 3][2]
+        s = int((end - start) / 2)
+
+        uvs += [[(u, verts[f + j][2]), (u, verts[f + j + 1][2]),
+            (0, verts[f + j + 1][2]), (0, verts[f + j][2])] for j in range(start, start + s)]
+
+        uvs.append([(0, 0), (0, v), (u, v), (u, 0)])
+
+        uvs += [[(u, verts[f + j][2]), (u, verts[f + j + 1][2]),
+            (0, verts[f + j + 1][2]), (0, verts[f + j][2])] for j in range(start + s + 1, end)]
+
+        if 'STRAIGHT' in self.nose_type or 'OPEN' in self.steps_type:
+            # face bottom
+            matids.append(self.idmat_bottom)
+            faces.append((f + end, f + start, f + offset + start, f + offset + end))
+            uvs.append([(u, v), (u, 0), (0, 0), (0, v)])
+
+        if self.steps_type != 'OPEN':
+            if 'STRAIGHT' in self.nose_type:
+                # front face bottom straight
+                matids.append(self.idmat_raise)
+                faces.append((f + 12, f + 17, f + 16, f + 13))
+                uvs.append([(0, w), (v, w), (v, 0), (0, 0)])
+
+            elif 'OBLIQUE' in self.nose_type:
+                # front face bottom oblique
+                matids.append(self.idmat_raise)
+                faces.append((f + 12, f + 17, f + 6, f + 3))
+
+                uvs.append([(0, w), (v, w), (v, 0), (0, 0)])
+
+                matids.append(self.idmat_side)
+                faces.append((f + 3, f + 13, f + 12))
+                uvs.append([(0, 0), (u, 0), (u, w)])
+
+                matids.append(self.idmat_side)
+                faces.append((f + 6, f + 17, f + 16))
+                uvs.append([(0, 0), (u, w), (u, 0)])
+
+        # front face top
+        w = verts[f + 3][2] - verts[f + 4][2]
+        matids.append(self.idmat_step_front)
+        faces.append((f + 4, f + 3, f + 6, f + 5))
+        uvs.append([(0, 0), (0, w), (v, w), (v, 0)])
+        return rM
+
+    def make_faces(self, f, rM, verts, faces, matids, uvs):
+
+        if self.z_mode == 'LINEAR':
+            start = 0
+            end = 3
+            offset = 4
+            matids.extend([self.idmat_side,
+                 self.idmat_top,
+                 self.idmat_side,
+                 self.idmat_bottom])
+        elif "OPEN" in self.steps_type:
+            # faces dessus-dessous-lateral marches fermees
+            start = 3
+            end = 6
+            offset = 10
+            matids.extend([self.idmat_step_side,
+                 self.idmat_top,
+                 self.idmat_step_side,
+                 self.idmat_bottom])
+        else:
+            # faces dessus-dessous-lateral marches fermees
+            start = 0
+            end = 9
+            offset = 10
+            matids.extend([self.idmat_side,
+                 self.idmat_side,
+                 self.idmat_side,
+                 self.idmat_step_side,
+                 self.idmat_top,
+                 self.idmat_step_side,
+                 self.idmat_side,
+                 self.idmat_side,
+                 self.idmat_side,
+                 self.idmat_bottom])
+
+        u_l0 = 0
+        u_l1 = self.t_step * self.left_length
+        u_r0 = 0
+        u_r1 = self.t_step * self.right_length
+
+        s = int((end - start) / 2)
+        uvs += [[(u_l0, verts[f + j][2]), (u_l0, verts[f + j + 1][2]),
+            (u_l1, verts[f + j + offset + 1][2]), (u_l1, verts[f + j + offset][2])] for j in range(start, start + s)]
+
+        self.project_uv(rM, uvs, verts, [f + start + s, f + start + s + 1,
+            f + start + s + offset + 1, f + start + s + offset])
+
+        uvs += [[(u_r0, verts[f + j][2]), (u_r0, verts[f + j + 1][2]),
+            (u_r1, verts[f + j + offset + 1][2]), (u_r1, verts[f + j + offset][2])] for j in range(start + s + 1, end)]
+
+        self.project_uv(rM, uvs, verts, [f + end, f + start, f + offset + start, f + offset + end])
+
+        faces += [(f + j, f + j + 1, f + j + offset + 1, f + j + offset) for j in range(start, end)]
+        faces.append((f + end, f + start, f + offset + start, f + offset + end))
+
+
+class StraightStair(Stair, Line):
+    def __init__(self, p, v, left_offset, right_offset, steps_type, nose_type, z_mode, nose_z, bottom_z):
+        Stair.__init__(self, left_offset, right_offset, steps_type, nose_type, z_mode, nose_z, bottom_z)
+        Line.__init__(self, p, v)
+        self.l_line = self.offset(-left_offset)
+        self.r_line = self.offset(right_offset)
+
+    def make_step(self, i, verts, faces, matids, uvs, nose_y=0):
+
+        rM = self._make_nose(i, i, verts, faces, matids, uvs, nose_y)
+
+        t0 = self.t_step * i
+
+        f = len(verts)
+
+        p = self.l_line.lerp(t0)
+        self.p3d_left(verts, p, i, t0)
+        p = self.r_line.lerp(t0)
+        self.p3d_right(verts, p, i, t0)
+
+        t1 = t0 + self.t_step
+
+        p = self.l_line.lerp(t1)
+        self.p3d_left(verts, p, i, t1)
+        p = self.r_line.lerp(t1)
+        self.p3d_right(verts, p, i, t1)
+
+        self.make_faces(f, rM, verts, faces, matids, uvs)
+
+        if "OPEN" in self.steps_type:
+            faces.append((f + 13, f + 14, f + 15, f + 16))
+            matids.append(self.idmat_step_front)
+            uvs.append([(0, 0), (0, 1), (1, 1), (1, 0)])
+
+    def get_length(self, side):
+        return self.length
+
+    def get_lerp_vect(self, posts, side, i, t_step, respect_edges, z_offset=0, t0_abs=None):
+        if t0_abs is not None:
+            t0 = t0_abs
+        else:
+            t0 = i * t_step
+        t, part, dz, shape = self.get_part(t0, side)
+        dz /= part.length
+        n = part.normal(t)
+        z0 = self.get_z(t0, 'STEP')
+        z1 = self.get_z(t0, 'LINEAR')
+        posts.append((n, dz, z0, z1 + t0 * z_offset))
+        return [t0]
+
+    def n_posts(self, post_spacing, side, respect_edges):
+        return self.steps(post_spacing)
+
+    def get_part(self, t, side):
+        if side == 'LEFT':
+            part = self.l_line
+        else:
+            part = self.r_line
+        return t, part, self.height, 'LINE'
+
+
+class CurvedStair(Stair, Arc):
+    def __init__(self, c, radius, a0, da, left_offset, right_offset, steps_type, nose_type,
+        z_mode, nose_z, bottom_z, left_shape, right_shape, double_limit=pi):
+
+        Stair.__init__(self, left_offset, right_offset, steps_type, nose_type, z_mode, nose_z, bottom_z)
+        Arc.__init__(self, c, radius, a0, da)
+        self.l_shape = left_shape
+        self.r_shape = right_shape
+        self.edges_multiples = round(abs(da), 6) > double_limit
+        # left arc, tangeant at start and end
+        self.l_arc, self.l_t0, self.l_t1, self.l_tc = self.set_offset(-left_offset, left_shape)
+        self.r_arc, self.r_t0, self.r_t1, self.r_tc = self.set_offset(right_offset, right_shape)
+
+    def set_offset(self, offset, shape):
+        arc = self.offset(offset)
+        t0 = arc.tangeant(0, 1)
+        t1 = arc.tangeant(1, 1)
+        tc = arc.tangeant(0.5, 1)
+        if self.edges_multiples:
+            i, p, t = t0.intersect(tc)
+            tc.v *= 2 * t
+            tc.p = p
+            i, p, t2 = tc.intersect(t1)
+        else:
+            i, p, t = t0.intersect(t1)
+        t0.v *= t
+        t1.p = p
+        t1.v *= t
+        return arc, t0, t1, tc
+
+    def get_length(self, side):
+        if side == 'RIGHT':
+            arc = self.r_arc
+            shape = self.r_shape
+            t0 = self.r_t0
+        else:
+            arc = self.l_arc
+            shape = self.l_shape
+            t0 = self.l_t0
+        if shape == 'CIRCLE':
+            return arc.length
+        else:
+            if self.edges_multiples:
+                # two edges
+                return t0.length * 4
+            else:
+                return t0.length * 2
+
+    def _make_step(self, t_step, i, s, verts, landing=False):
+
+        tb = t_step * i
+
+        f = len(verts)
+
+        t, part, dz, shape = self.get_part(tb, "LEFT")
+        p = part.lerp(t)
+        self.p3d_left(verts, p, s, tb, landing)
+
+        t, part, dz, shape = self.get_part(tb, "RIGHT")
+        p = part.lerp(t)
+        self.p3d_right(verts, p, s, tb, landing)
+        return f
+
+    def _make_edge(self, t_step, i, j, f, rM, verts, faces, matids, uvs):
+        tb = t_step * i
+        # make edges verts after regular ones
+        if self.l_shape != 'CIRCLE' or self.r_shape != 'CIRCLE':
+            if self.edges_multiples:
+                # edge 1
+                if tb < 0.25 and tb + t_step > 0.25:
+                    f0 = f
+                    f = len(verts)
+                    if self.l_shape == 'CIRCLE':
+                        self.p3d_left(verts, self.l_arc.lerp(0.25), j, 0.25)
+                    else:
+                        self.p3d_left(verts, self.l_tc.p, j, 0.25)
+                    if self.r_shape == 'CIRCLE':
+                        self.p3d_right(verts, self.r_arc.lerp(0.25), j, 0.25)
+                    else:
+                        self.p3d_right(verts, self.r_tc.p, j, 0.25)
+                    self.make_faces(f0, rM, verts, faces, matids, uvs)
+                # edge 2
+                if tb < 0.75 and tb + t_step > 0.75:
+                    f0 = f
+                    f = len(verts)
+                    if self.l_shape == 'CIRCLE':
+                        self.p3d_left(verts, self.l_arc.lerp(0.75), j, 0.75)
+                    else:
+                        self.p3d_left(verts, self.l_t1.p, j, 0.75)
+                    if self.r_shape == 'CIRCLE':
+                        self.p3d_right(verts, self.r_arc.lerp(0.75), j, 0.75)
+                    else:
+                        self.p3d_right(verts, self.r_t1.p, j, 0.75)
+                    self.make_faces(f0, rM, verts, faces, matids, uvs)
+            else:
+                if tb < 0.5 and tb + t_step > 0.5:
+                    f0 = f
+                    f = len(verts)
+                    # the step goes through the edge
+                    if self.l_shape == 'CIRCLE':
+                        self.p3d_left(verts, self.l_arc.lerp(0.5), j, 0.5)
+                    else:
+                        self.p3d_left(verts, self.l_t1.p, j, 0.5)
+                    if self.r_shape == 'CIRCLE':
+                        self.p3d_right(verts, self.r_arc.lerp(0.5), j, 0.5)
+                    else:
+                        self.p3d_right(verts, self.r_t1.p, j, 0.5)
+                    self.make_faces(f0, rM, verts, faces, matids, uvs)
+        return f
+
+    def make_step(self, i, verts, faces, matids, uvs, nose_y=0):
+
+        # open stair with closed face
+
+        # step nose
+        rM = self._make_nose(i, i, verts, faces, matids, uvs, nose_y)
+        f = 0
+        if self.l_shape == 'CIRCLE' or self.r_shape == 'CIRCLE':
+            # every 6 degree
+            n_subs = max(1, int(abs(self.da) / pi * 30 / self.n_step))
+            t_step = self.t_step / n_subs
+            for j in range(n_subs):
+                f0 = f
+                f = self._make_step(t_step, n_subs * i + j, i, verts)
+                if j > 0:
+                    self.make_faces(f0, rM, verts, faces, matids, uvs)
+                f = self._make_edge(t_step, n_subs * i + j, i, f, rM, verts, faces, matids, uvs)
+        else:
+            f = self._make_step(self.t_step, i, i, verts)
+            f = self._make_edge(self.t_step, i, i, f, rM, verts, faces, matids, uvs)
+
+        self._make_step(self.t_step, i + 1, i, verts)
+        self.make_faces(f, rM, verts, faces, matids, uvs)
+
+        if "OPEN" in self.steps_type and self.z_mode != 'LINEAR':
+            # back face top
+            faces.append((f + 13, f + 14, f + 15, f + 16))
+            matids.append(self.idmat_step_front)
+            uvs.append([(0, 0), (0, 1), (1, 1), (1, 0)])
+
+    def get_part(self, t, side):
+        if side == 'RIGHT':
+            arc = self.r_arc
+            shape = self.r_shape
+            t0, t1, tc = self.r_t0, self.r_t1, self.r_tc
+        else:
+            arc = self.l_arc
+            shape = self.l_shape
+            t0, t1, tc = self.l_t0, self.l_t1, self.l_tc
+        if shape == 'CIRCLE':
+            return t, arc, self.height, shape
+        else:
+            if self.edges_multiples:
+                # two edges
+                if t <= 0.25:
+                    return 4 * t, t0, 0.25 * self.height, shape
+                elif t <= 0.75:
+                    return 2 * (t - 0.25), tc, 0.5 * self.height, shape
+                else:
+                    return 4 * (t - 0.75), t1, 0.25 * self.height, shape
+            else:
+                if t <= 0.5:
+                    return 2 * t, t0, 0.5 * self.height, shape
+                else:
+                    return 2 * (t - 0.5), t1, 0.5 * self.height, shape
+
+    def get_lerp_vect(self, posts, side, i, t_step, respect_edges, z_offset=0, t0_abs=None):
+        if t0_abs is not None:
+            t0 = t0_abs
+        else:
+            t0 = i * t_step
+        res = [t0]
+        t1 = t0 + t_step
+        zs = self.get_z(t0, 'STEP')
+        zl = self.get_z(t0, 'LINEAR')
+
+        # vect normal
+        t, part, dz, shape = self.get_part(t0, side)
+        n = part.normal(t)
+        dz /= part.length
+        posts.append((n, dz, zs, zl + t0 * z_offset))
+
+        if shape != 'CIRCLE' and respect_edges:
+            if self.edges_multiples:
+                if t0 < 0.25 and t1 > 0.25:
+                    zs = self.get_z(0.25, 'STEP')
+                    zl = self.get_z(0.25, 'LINEAR')
+                    t, part, dz, shape = self.get_part(0.25, side)
+                    n = part.normal(1)
+                    posts.append((n, dz, zs, zl + 0.25 * z_offset))
+                    res.append(0.25)
+                if t0 < 0.75 and t1 > 0.75:
+                    zs = self.get_z(0.75, 'STEP')
+                    zl = self.get_z(0.75, 'LINEAR')
+                    t, part, dz, shape = self.get_part(0.75, side)
+                    n = part.normal(1)
+                    posts.append((n, dz, zs, zl + 0.75 * z_offset))
+                    res.append(0.75)
+            elif t0 < 0.5 and t1 > 0.5:
+                    zs = self.get_z(0.5, 'STEP')
+                    zl = self.get_z(0.5, 'LINEAR')
+                    t, part, dz, shape = self.get_part(0.5, side)
+                    n = part.normal(1)
+                    posts.append((n, dz, zs, zl + 0.5 * z_offset))
+                    res.append(0.5)
+        return res
+
+    def n_posts(self, post_spacing, side, respect_edges):
+        if side == 'LEFT':
+            arc, t0, shape = self.l_arc, self.l_t0, self.l_shape
+        else:
+            arc, t0, shape = self.r_arc, self.r_t0, self.r_shape
+        step_factor = 1
+        if shape == 'CIRCLE':
+            length = arc.length
+        else:
+            if self.edges_multiples:
+                if respect_edges:
+                    step_factor = 2
+                length = 4 * t0.length
+            else:
+                length = 2 * t0.length
+        steps = step_factor * max(1, round(length / post_spacing, 0))
+        # print("respect_edges:%s t_step:%s n_step:%s" % (respect_edges, 1.0 / steps, int(steps)))
+        return 1.0 / steps, int(steps)
+
+
+class StraightLanding(StraightStair):
+    def __init__(self, p, v, left_offset, right_offset, steps_type,
+            nose_type, z_mode, nose_z, bottom_z, last_type='STAIR'):
+
+        StraightStair.__init__(self, p, v, left_offset, right_offset, steps_type,
+            nose_type, z_mode, nose_z, bottom_z)
+
+        self.last_type = last_type
+
+    @property
+    def height(self):
+        return 0
+
+    @property
+    def top_offset(self):
+        return self.t_step / self.v.length
+
+    @property
+    def top(self):
+        if self.next_type == 'LANDING':
+            return self.z0
+        else:
+            return self.z0 + self.step_height
+
+    def step_size(self, step_depth):
+        self.n_step = 1
+        self.t_step = 1
+        self.step_depth = step_depth
+        if self.last_type == 'LANDING':
+            return 0
+        else:
+            return 1
+
+    def make_step(self, i, verts, faces, matids, uvs, nose_y=0):
+
+        if i == 0 and self.last_type != 'LANDING':
+            rM = self._make_nose(i, 0, verts, faces, matids, uvs, nose_y)
+        else:
+            rM = self.get_proj_matrix(self.l_line, self.t_step * i, nose_y)
+
+        f = len(verts)
+        j = 0
+        t0 = self.t_step * i
+
+        p = self.l_line.lerp(t0)
+        self.p3d_left(verts, p, j, t0)
+
+        p = self.r_line.lerp(t0)
+        self.p3d_right(verts, p, j, t0)
+
+        t1 = t0 + self.t_step
+        p = self.l_line.lerp(t1)
+        self.p3d_left(verts, p, j, t1, self.next_type != 'LANDING')
+
+        p = self.r_line.lerp(t1)
+        self.p3d_right(verts, p, j, t1, self.next_type != 'LANDING')
+
+        self.make_faces(f, rM, verts, faces, matids, uvs)
+
+        if "OPEN" in self.steps_type and self.next_type != 'LANDING':
+            faces.append((f + 13, f + 14, f + 15, f + 16))
+            matids.append(self.idmat_step_front)
+            uvs.append([(0, 0), (0, 1), (1, 1), (1, 0)])
+
+    def straight_landing(self, length):
+        return Stair.straight_landing(self, length, last_type='LANDING')
+
+    def curved_landing(self, da, radius, left_shape, right_shape, double_limit=pi):
+        return Stair.curved_landing(self, da, radius, left_shape,
+            right_shape, double_limit=double_limit, last_type='LANDING')
+
+    def get_z(self, t, mode):
+        if mode == 'STEP':
+            return self.z0 + self.step_height
+        else:
+            return self.z0
+
+
+class CurvedLanding(CurvedStair):
+    def __init__(self, c, radius, a0, da, left_offset, right_offset, steps_type,
+        nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape, double_limit=pi, last_type='STAIR'):
+
+        CurvedStair.__init__(self, c, radius, a0, da, left_offset, right_offset, steps_type,
+            nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape, double_limit=double_limit)
+
+        self.last_type = last_type
+
+    @property
+    def top_offset(self):
+        if self.l_shape == 'CIRCLE' or self.r_shape == 'CIRCLE':
+            return self.t_step / self.step_depth
+        else:
+            if self.edges_multiples:
+                return 0.5 / self.length
+            else:
+                return 1 / self.length
+
+    @property
+    def height(self):
+        return 0
+
+    @property
+    def top(self):
+        if self.next_type == 'LANDING':
+            return self.z0
+        else:
+            return self.z0 + self.step_height
+
+    def step_size(self, step_depth):
+        if self.l_shape == 'CIRCLE' or self.r_shape == 'CIRCLE':
+            t_step, n_step = self.steps(step_depth)
+        else:
+            if self.edges_multiples:
+                t_step, n_step = 0.5, 2
+            else:
+                t_step, n_step = 1, 1
+        self.n_step = n_step
+        self.t_step = t_step
+        self.step_depth = step_depth
+        if self.last_type == 'LANDING':
+            return 0
+        else:
+            return 1
+
+    def make_step(self, i, verts, faces, matids, uvs, nose_y=0):
+
+        if i == 0 and 'LANDING' not in self.last_type:
+            rM = self._make_nose(i, 0, verts, faces, matids, uvs, nose_y)
+        else:
+            rM = self.get_proj_matrix(self.l_arc, self.t_step * i, nose_y)
+
+        f = len(verts)
+
+        if self.l_shape == 'CIRCLE' or self.r_shape == 'CIRCLE':
+            n_subs = max(1, int(abs(self.da / pi * 30 / self.n_step)))
+            t_step = self.t_step / n_subs
+            for j in range(n_subs):
+                f0 = f
+                f = self._make_step(t_step, n_subs * i + j, 0, verts)
+                if j > 0:
+                    self.make_faces(f0, rM, verts, faces, matids, uvs)
+                f = self._make_edge(t_step, n_subs * i + j, 0, f, rM, verts, faces, matids, uvs)
+        else:
+            f = self._make_step(self.t_step, i, 0, verts)
+            f = self._make_edge(self.t_step, i, 0, f, rM, verts, faces, matids, uvs)
+
+        self._make_step(self.t_step, i + 1, 0, verts, i == self.n_step - 1 and 'LANDING' not in self.next_type)
+        self.make_faces(f, rM, verts, faces, matids, uvs)
+
+        if "OPEN" in self.steps_type and 'LANDING' not in self.next_type:
+            faces.append((f + 13, f + 14, f + 15, f + 16))
+            matids.append(self.idmat_step_front)
+            uvs.append([(0, 0), (0, 1), (1, 1), (1, 0)])
+
+    def straight_landing(self, length):
+        return Stair.straight_landing(self, length, last_type='LANDING')
+
+    def curved_landing(self, da, radius, left_shape, right_shape, double_limit=pi):
+        return Stair.curved_landing(self, da, radius, left_shape,
+            right_shape, double_limit=double_limit, last_type='LANDING')
+
+    def get_z(self, t, mode):
+        if mode == 'STEP':
+            return self.z0 + self.step_height
+        else:
+            return self.z0
+
+
+class StairGenerator():
+    def __init__(self, parts):
+        self.parts = parts
+        self.last_type = 'NONE'
+        self.stairs = []
+        self.steps_type = 'NONE'
+        self.sum_da = 0
+        self.user_defined_post = None
+        self.user_defined_uvs = None
+        self.user_defined_mat = None
+
+    def add_part(self, type, steps_type, nose_type, z_mode, nose_z, bottom_z, center,
+            radius, da, width_left, width_right, length, left_shape, right_shape):
+
+        self.steps_type = steps_type
+        if len(self.stairs) < 1:
+            s = None
+        else:
+            s = self.stairs[-1]
+
+        if "S_" not in type:
+            self.sum_da += da
+
+        # start a new stair
+        if s is None:
+            if type == 'S_STAIR':
+                p = Vector((0, 0))
+                v = Vector((0, length))
+                s = StraightStair(p, v, width_left, width_right, steps_type, nose_type, z_mode, nose_z, bottom_z)
+            elif type == 'C_STAIR':
+                if da < 0:
+                    c = Vector((radius, 0))
+                else:
+                    c = Vector((-radius, 0))
+                s = CurvedStair(c, radius, 0, da, width_left, width_right, steps_type,
+                        nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape)
+            elif type == 'D_STAIR':
+                if da < 0:
+                    c = Vector((radius, 0))
+                else:
+                    c = Vector((-radius, 0))
+                s = CurvedStair(c, radius, 0, da, width_left, width_right, steps_type,
+                        nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape, double_limit=0)
+            elif type == 'S_LANDING':
+                p = Vector((0, 0))
+                v = Vector((0, length))
+                s = StraightLanding(p, v, width_left, width_right, steps_type, nose_type, z_mode, nose_z, bottom_z)
+            elif type == 'C_LANDING':
+                if da < 0:
+                    c = Vector((radius, 0))
+                else:
+                    c = Vector((-radius, 0))
+                s = CurvedLanding(c, radius, 0, da, width_left, width_right, steps_type,
+                        nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape)
+            elif type == 'D_LANDING':
+                if da < 0:
+                    c = Vector((radius, 0))
+                else:
+                    c = Vector((-radius, 0))
+                s = CurvedLanding(c, radius, 0, da, width_left, width_right, steps_type,
+                        nose_type, z_mode, nose_z, bottom_z, left_shape, right_shape, double_limit=0)
+        else:
+            if type == 'S_STAIR':
+                s = s.straight_stair(length)
+            elif type == 'C_STAIR':
+                s = s.curved_stair(da, radius, left_shape, right_shape)
+            elif type == 'D_STAIR':
+                s = s.curved_stair(da, radius, left_shape, right_shape, double_limit=0)
+            elif type == 'S_LANDING':
+                s = s.straight_landing(length)
+            elif type == 'C_LANDING':
+                s = s.curved_landing(da, radius, left_shape, right_shape)
+            elif type == 'D_LANDING':
+                s = s.curved_landing(da, radius, left_shape, right_shape, double_limit=0)
+        self.stairs.append(s)
+        self.last_type = type
+
+    def n_steps(self, step_depth):
+        n_steps = 0
+        for stair in self.stairs:
+            n_steps += stair.step_size(step_depth)
+        return n_steps
+
+    def set_height(self, step_height):
+        z = 0
+        for stair in self.stairs:
+            stair.set_height(step_height, z)
+            z = stair.top
+
+    def make_stair(self, height, step_depth, verts, faces, matids, uvs, nose_y=0):
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+        
+        for s, stair in enumerate(self.stairs):
+            if s < len(self.parts):
+                manipulator = self.parts[s].manipulators[0]
+                # Store Gl Points for manipulators
+                if 'Curved' in type(stair).__name__:
+                    c = stair.c
+                    p0 = (stair.p0 - c).to_3d()
+                    p1 = (stair.p1 - c).to_3d()
+                    manipulator.set_pts([(c.x, c.y, stair.top), p0, p1])
+                    manipulator.type_key = 'ARC_ANGLE_RADIUS'
+                    manipulator.prop1_name = 'da'
+                    manipulator.prop2_name = 'radius'
+                else:
+                    if self.sum_da > 0:
+                        side = 1
+                    else:
+                        side = -1
+                    v0 = stair.p0
+                    v1 = stair.p1
+                    manipulator.set_pts([(v0.x, v0.y, stair.top), (v1.x, v1.y, stair.top), (side, 0, 0)])
+                    manipulator.type_key = 'SIZE'
+                    manipulator.prop1_name = 'length'
+
+            for i in range(stair.n_step):
+                stair.make_step(i, verts, faces, matids, uvs, nose_y=nose_y)
+                if s < len(self.stairs) - 1 and self.steps_type != 'OPEN' and \
+                        'Landing' in type(stair).__name__ and stair.next_type != "LANDING":
+                    f = len(verts) - 10
+                    faces.append((f, f + 1, f + 8, f + 9))
+                    matids.append(self.stairs[-1].idmat_bottom)
+                    u = verts[f + 1][2] - verts[f][2]
+                    v = (Vector(verts[f]) - Vector(verts[f + 9])).length
+                    uvs.append([(0, 0), (0, u), (v, u), (v, 0)])
+
+        if self.steps_type != 'OPEN' and len(self.stairs) > 0:
+            f = len(verts) - 10
+            faces.append((f, f + 1, f + 2, f + 3, f + 4, f + 5, f + 6, f + 7, f + 8, f + 9))
+            matids.append(self.stairs[-1].idmat_bottom)
+            uvs.append([(0, 0), (.1, 0), (.2, 0), (.3, 0), (.4, 0), (.4, 1), (.3, 1), (.2, 1), (.1, 1), (0, 1)])
+
+    def setup_user_defined_post(self, o, post_x, post_y, post_z):
+        self.user_defined_post = o
+        x = o.bound_box[6][0] - o.bound_box[0][0]
+        y = o.bound_box[6][1] - o.bound_box[0][1]
+        z = o.bound_box[6][2] - o.bound_box[0][2]
+        self.user_defined_post_scale = Vector((post_x / x, post_y / -y, post_z / z))
+        m = o.data
+        # create vertex group lookup dictionary for names
+        vgroup_names = {vgroup.index: vgroup.name for vgroup in o.vertex_groups}
+        # create dictionary of vertex group assignments per vertex
+        self.vertex_groups = [[vgroup_names[g.group] for g in v.groups] for v in m.vertices]
+        # uvs
+        uv_act = m.uv_layers.active
+        if uv_act is not None:
+            uv_layer = uv_act.data
+            self.user_defined_uvs = [[uv_layer[li].uv for li in p.loop_indices] for p in m.polygons]
+        else:
+            self.user_defined_uvs = [[(0, 0) for i in p.vertices] for p in m.polygons]
+        # material ids
+        self.user_defined_mat = [p.material_index for p in m.polygons]
+
+    def get_user_defined_post(self, tM, z0, z1, z2, slope, post_z, verts, faces, matids, uvs):
+        f = len(verts)
+        m = self.user_defined_post.data
+        for i, g in enumerate(self.vertex_groups):
+            co = m.vertices[i].co.copy()
+            co.x *= self.user_defined_post_scale.x
+            co.y *= self.user_defined_post_scale.y
+            co.z *= self.user_defined_post_scale.z
+            if 'Top' in g:
+                co.z += z2
+            elif 'Bottom' in g:
+                co.z += 0
+            else:
+                co.z += z1
+            if 'Slope' in g:
+                co.z += co.y * slope
+            verts.append(tM * co)
+        matids += self.user_defined_mat
+        faces += [tuple([i + f for i in p.vertices]) for p in m.polygons]
+        uvs += self.user_defined_uvs
+
+    def get_post(self, post, post_x, post_y, post_z, post_alt, sub_offset_x,
+            id_mat, verts, faces, matids, uvs, bottom="STEP"):
+
+        n, dz, zs, zl = post
+        slope = dz * post_y
+
+        if self.user_defined_post is not None:
+            if bottom == "STEP":
+                z0 = zs
+            else:
+                z0 = zl
+            z1 = zl - z0
+            z2 = zl - z0
+            x, y = -n.v.normalized()
+            tM = Matrix([
+                [x, y, 0, n.p.x],
+                [y, -x, 0, n.p.y],
+                [0, 0, 1, z0 + post_alt],
+                [0, 0, 0, 1]
+            ])
+            self.get_user_defined_post(tM, z0, z1, z2, dz, post_z, verts, faces, matids, uvs)
+            return
+
+        z3 = zl + post_z + post_alt - slope
+        z4 = zl + post_z + post_alt + slope
+        if bottom == "STEP":
+            z0 = zs + post_alt
+            z1 = zs + post_alt
+        else:
+            z0 = zl + post_alt - slope
+            z1 = zl + post_alt + slope
+        vn = n.v.normalized()
+        dx = post_x * vn
+        dy = post_y * Vector((vn.y, -vn.x))
+        oy = sub_offset_x * vn
+        x0, y0 = n.p - dx + dy + oy
+        x1, y1 = n.p - dx - dy + oy
+        x2, y2 = n.p + dx - dy + oy
+        x3, y3 = n.p + dx + dy + oy
+        f = len(verts)
+        verts.extend([(x0, y0, z0), (x0, y0, z3),
+                    (x1, y1, z1), (x1, y1, z4),
+                    (x2, y2, z1), (x2, y2, z4),
+                    (x3, y3, z0), (x3, y3, z3)])
+        faces.extend([(f, f + 1, f + 3, f + 2),
+                    (f + 2, f + 3, f + 5, f + 4),
+                    (f + 4, f + 5, f + 7, f + 6),
+                    (f + 6, f + 7, f + 1, f),
+                    (f, f + 2, f + 4, f + 6),
+                    (f + 7, f + 5, f + 3, f + 1)])
+        matids.extend([id_mat, id_mat, id_mat, id_mat, id_mat, id_mat])
+        x = [(0, 0), (0, post_z), (post_x, post_z), (post_x, 0)]
+        y = [(0, 0), (0, post_z), (post_y, post_z), (post_y, 0)]
+        z = [(0, 0), (post_x, 0), (post_x, post_y), (0, post_y)]
+        uvs.extend([x, y, x, y, z, z])
+
+    def get_panel(self, subs, altitude, panel_x, panel_z, sub_offset_x, idmat, verts, faces, matids, uvs):
+        n_subs = len(subs)
+        if n_subs < 1:
+            return
+        f = len(verts)
+        x0 = sub_offset_x - 0.5 * panel_x
+        x1 = sub_offset_x + 0.5 * panel_x
+        z0 = 0
+        z1 = panel_z
+        profile = [Vector((x0, z0)), Vector((x1, z0)), Vector((x1, z1)), Vector((x0, z1))]
+        user_path_uv_v = []
+        n_sections = n_subs - 1
+        n, dz, zs, zl = subs[0]
+        p0 = n.p
+        v0 = n.v.normalized()
+        for s, section in enumerate(subs):
+            n, dz, zs, zl = section
+            p1 = n.p
+            if s < n_sections:
+                v1 = subs[s + 1][0].v.normalized()
+            dir = (v0 + v1).normalized()
+            scale = 1 / cos(0.5 * acos(min(1, max(-1, v0 * v1))))
+            for p in profile:
+                x, y = n.p + scale * p.x * dir
+                z = zl + p.y + altitude
+                verts.append((x, y, z))
+            if s > 0:
+                user_path_uv_v.append((p1 - p0).length)
+            p0 = p1
+            v0 = v1
+
+        # build faces using Panel
+        lofter = Lofter(
+            # closed_shape, index, x, y, idmat
+            True,
+            [i for i in range(len(profile))],
+            [p.x for p in profile],
+            [p.y for p in profile],
+            [idmat for i in range(len(profile))],
+            closed_path=False,
+            user_path_uv_v=user_path_uv_v,
+            user_path_verts=n_subs
+            )
+        faces += lofter.faces(16, offset=f, path_type='USER_DEFINED')
+        matids += lofter.mat(16, idmat, idmat, path_type='USER_DEFINED')
+        v = Vector((0, 0))
+        uvs += lofter.uv(16, v, v, v, v, 0, v, 0, 0, path_type='USER_DEFINED')
+
+    def reset_shapes(self):
+        for s, stair in enumerate(self.stairs):
+            if 'Curved' in type(stair).__name__:
+                stair.l_shape = self.parts[s].left_shape
+                stair.r_shape = self.parts[s].right_shape
+
+    def make_subs(self, height, step_depth, x, y, z, post_y, altitude, bottom, side, slice,
+            post_spacing, sub_spacing, respect_edges, move_x, x_offset, sub_offset_x, mat,
+            verts, faces, matids, uvs):
+
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+        n_stairs = len(self.stairs) - 1
+        subs = []
+
+        if side == "LEFT":
+            offset = move_x - x_offset
+            # offset_sub = offset - sub_offset_x
+        else:
+            offset = move_x + x_offset
+            # offset_sub = offset + sub_offset_x
+
+        for s, stair in enumerate(self.stairs):
+            if 'Curved' in type(stair).__name__:
+                if side == "LEFT":
+                    part = stair.l_arc
+                    shape = stair.l_shape
+                else:
+                    part = stair.r_arc
+                    shape = stair.r_shape
+                # Note: use left part as reference for post distances
+                # use right part as reference for panels
+                stair.l_arc, stair.l_t0, stair.l_t1, stair.l_tc = stair.set_offset(offset, shape)
+                stair.r_arc, stair.r_t0, stair.r_t1, stair.r_tc = stair.set_offset(offset, shape)
+            else:
+                stair.l_line = stair.offset(offset)
+                stair.r_line = stair.offset(offset)
+                part = stair.l_line
+
+            lerp_z = 0
+            edge_t = 1
+            edge_size = 0
+            # interpolate z near end landing
+            if 'Landing' in type(stair).__name__ and stair.next_type == 'STAIR':
+                if not slice:
+                    line = stair.normal(1).offset(self.stairs[s + 1].step_depth)
+                    res, p, t_part = part.intersect(line)
+                    # does perpendicular line intersects circle ?
+                    if res:
+                        edge_size = self.stairs[s + 1].step_depth / stair.get_length(side)
+                        edge_t = 1 - edge_size
+                    else:
+                        # in this case, lerp z over one step
+                        lerp_z = stair.step_height
+
+            t_step, n_step = stair.n_posts(post_spacing, side, respect_edges)
+
+            # space between posts
+            sp = stair.get_length(side)
+            # post size
+            t_post = post_y / sp
+
+            if s == n_stairs:
+                n_step += 1
+            for i in range(n_step):
+                res_t = stair.get_lerp_vect([], side, i, t_step, respect_edges)
+                # subs
+                if s < n_stairs or i < n_step - 1:
+                    res_t.append((i + 1) * t_step)
+                for j in range(len(res_t) - 1):
+                    t0 = res_t[j] + t_post
+                    t1 = res_t[j + 1] - t_post
+                    dt = t1 - t0
+                    n_subs = int(sp * dt / sub_spacing)
+                    if n_subs > 0:
+                        t_subs = dt / n_subs
+                        for k in range(1, n_subs):
+                            t = t0 + k * t_subs
+                            stair.get_lerp_vect(subs, side, 1, t0 + k * t_subs, False)
+                            if t > edge_t:
+                                n, dz, z0, z1 = subs[-1]
+                                subs[-1] = n, dz, z0, z1 + (t - edge_t) / edge_size * stair.step_height
+                            if lerp_z > 0:
+                                n, dz, z0, z1 = subs[-1]
+                                subs[-1] = n, dz, z0, z1 + t * stair.step_height
+
+        for i, post in enumerate(subs):
+            self.get_post(post, x, y, z, altitude, sub_offset_x, mat, verts, faces, matids, uvs, bottom=bottom)
+
+    def make_post(self, height, step_depth, x, y, z, altitude, side, post_spacing, respect_edges, move_x, x_offset, mat,
+        verts, faces, matids, uvs):
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+        l_posts = []
+        n_stairs = len(self.stairs) - 1
+
+        for s, stair in enumerate(self.stairs):
+            if type(stair).__name__ in ['CurvedStair', 'CurvedLanding']:
+                stair.l_arc, stair.l_t0, stair.l_t1, stair.l_tc = stair.set_offset(move_x - x_offset, stair.l_shape)
+                stair.r_arc, stair.r_t0, stair.r_t1, stair.r_tc = stair.set_offset(move_x + x_offset, stair.r_shape)
+            else:
+                stair.l_line = stair.offset(move_x - x_offset)
+                stair.r_line = stair.offset(move_x + x_offset)
+
+            t_step, n_step = stair.n_posts(post_spacing, side, respect_edges)
+
+            if s == n_stairs:
+                n_step += 1
+            for i in range(n_step):
+                stair.get_lerp_vect(l_posts, side, i, t_step, respect_edges)
+
+                if s == n_stairs and i == n_step - 1:
+                    n, dz, z0, z1 = l_posts[-1]
+                    l_posts[-1] = (n, dz, z0 - stair.step_height, z1)
+
+        for i, post in enumerate(l_posts):
+            self.get_post(post, x, y, z, altitude, 0, mat, verts, faces, matids, uvs)
+
+    def make_panels(self, height, step_depth, x, z, post_y, altitude, side, post_spacing,
+            panel_dist, respect_edges, move_x, x_offset, sub_offset_x, mat, verts, faces, matids, uvs):
+
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+        subs = []
+        n_stairs = len(self.stairs) - 1
+
+        if side == "LEFT":
+            offset = move_x - x_offset
+        else:
+            offset = move_x + x_offset
+
+        for s, stair in enumerate(self.stairs):
+
+            is_circle = False
+            if 'Curved' in type(stair).__name__:
+                if side == "LEFT":
+                    is_circle = stair.l_shape == "CIRCLE"
+                    shape = stair.l_shape
+                else:
+                    is_circle = stair.r_shape == "CIRCLE"
+                    shape = stair.r_shape
+                stair.l_arc, stair.l_t0, stair.l_t1, stair.l_tc = stair.set_offset(offset, shape)
+                stair.r_arc, stair.r_t0, stair.r_t1, stair.r_tc = stair.set_offset(offset, shape)
+            else:
+                stair.l_line = stair.offset(offset)
+                stair.r_line = stair.offset(offset)
+
+            # space between posts
+            sp = stair.get_length(side)
+
+            t_step, n_step = stair.n_posts(post_spacing, side, respect_edges)
+
+            if is_circle and 'Curved' in type(stair).__name__:
+                panel_da = abs(stair.da) / pi * 180 / n_step
+                panel_step = max(1, int(panel_da / 6))
+            else:
+                panel_step = 1
+
+            # post size
+            t_post = (post_y + panel_dist) / sp
+
+            if s == n_stairs:
+                n_step += 1
+            for i in range(n_step):
+                res_t = stair.get_lerp_vect([], side, i, t_step, respect_edges)
+                # subs
+                if s < n_stairs or i < n_step - 1:
+                    res_t.append((i + 1) * t_step)
+                for j in range(len(res_t) - 1):
+                    t0 = res_t[j] + t_post
+                    t1 = res_t[j + 1] - t_post
+                    dt = t1 - t0
+                    t_curve = dt / panel_step
+                    if dt > 0:
+                        panel = []
+                        for k in range(panel_step):
+                            stair.get_lerp_vect(panel, side, 1, t_curve, True, t0_abs=t0 + k * t_curve)
+                        stair.get_lerp_vect(panel, side, 1, t1, False)
+                        subs.append(panel)
+        for sub in subs:
+            self.get_panel(sub, altitude, x, z, sub_offset_x, mat, verts, faces, matids, uvs)
+
+    def make_part(self, height, step_depth, part_x, part_z, x_move, x_offset,
+            z_offset, z_mode, steps_type, verts, faces, matids, uvs):
+
+        params = [(stair.z_mode, stair.l_shape, stair.r_shape,
+            stair.bottom_z, stair.steps_type) for stair in self.stairs]
+
+        for stair in self.stairs:
+            if x_offset > 0:
+                stair.l_shape = stair.r_shape
+            else:
+                stair.r_shape = stair.l_shape
+            stair.steps_type = steps_type
+            stair.z_mode = "LINEAR"
+            stair.bottom_z = part_z
+            if 'Curved' in type(stair).__name__:
+                stair.l_arc, stair.l_t0, stair.l_t1, stair.l_tc = \
+                    stair.set_offset(x_move + x_offset + 0.5 * part_x, stair.l_shape)
+                stair.r_arc, stair.r_t0, stair.r_t1, stair.r_tc = \
+                    stair.set_offset(x_move + x_offset - 0.5 * part_x, stair.r_shape)
+            else:
+                stair.l_line = stair.offset(x_move + x_offset + 0.5 * part_x)
+                stair.r_line = stair.offset(x_move + x_offset - 0.5 * part_x)
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+        for j, stair in enumerate(self.stairs):
+            stair.z0 += z_offset + part_z
+            stair.n_step *= 2
+            stair.t_step /= 2
+            stair.step_height /= 2
+            for i in range(stair.n_step):
+                stair.make_step(i, verts, faces, matids, uvs, nose_y=0)
+            stair.n_step /= 2
+            stair.t_step *= 2
+            stair.step_height *= 2
+            stair.z_mode = params[j][0]
+            stair.l_shape = params[j][1]
+            stair.r_shape = params[j][2]
+            stair.bottom_z = params[j][3]
+            stair.steps_type = params[j][4]
+            stair.z0 -= z_offset + part_z
+
+    def make_profile(self, profile, idmat, side, slice, height, step_depth,
+            x_offset, z_offset, extend, verts, faces, matids, uvs):
+
+        for stair in self.stairs:
+            if 'Curved' in type(stair).__name__:
+                stair.l_arc, stair.l_t0, stair.l_t1, stair.l_tc = stair.set_offset(-x_offset, stair.l_shape)
+                stair.r_arc, stair.r_t0, stair.r_t1, stair.r_tc = stair.set_offset(x_offset, stair.r_shape)
+            else:
+                stair.l_line = stair.offset(-x_offset)
+                stair.r_line = stair.offset(x_offset)
+
+        n_steps = self.n_steps(step_depth)
+        self.set_height(height / n_steps)
+
+        n_stairs = len(self.stairs) - 1
+
+        if n_stairs < 0:
+            return
+
+        sections = []
+        sections.append([])
+
+        # first step
+        if extend != 0:
+            t = -extend / self.stairs[0].length
+            self.stairs[0].get_lerp_vect(sections[-1], side, 1, t, True)
+
+        for s, stair in enumerate(self.stairs):
+            n_step = 1
+            is_circle = False
+
+            if 'Curved' in type(stair).__name__:
+                if side == "LEFT":
+                    part = stair.l_arc
+                    is_circle = stair.l_shape == "CIRCLE"
+                else:
+                    part = stair.r_arc
+                    is_circle = stair.r_shape == "CIRCLE"
+            else:
+                if side == "LEFT":
+                    part = stair.l_line
+                else:
+                    part = stair.r_line
+
+            if is_circle:
+                n_step = 3 * stair.n_step
+
+            t_step = 1 / n_step
+
+            last_t = 1.0
+            do_last = True
+            lerp_z = 0
+            # last section 1 step before stair
+            if 'Landing' in type(stair).__name__ and stair.next_type == 'STAIR':
+                if not slice:
+                    line = stair.normal(1).offset(self.stairs[s + 1].step_depth)
+                    res, p, t_part = part.intersect(line)
+                    # does perpendicular line intersects circle ?
+                    if res:
+                        last_t = 1 - self.stairs[s + 1].step_depth / stair.get_length(side)
+                        if last_t < 0:
+                            do_last = False
+                    else:
+                        # in this case, lerp z over one step
+                        do_last = False
+                        lerp_z = stair.step_height
+
+            if s == n_stairs:
+                n_step += 1
+
+            for i in range(n_step):
+                res_t = stair.get_lerp_vect(sections[-1], side, i, t_step, True, z_offset=lerp_z)
+                # remove corner section
+                for cur_t in res_t:
+                    if cur_t > 0 and cur_t > last_t:
+                        sections[-1] = sections[-1][:-1]
+
+            # last section 1 step before next stair start
+            if 'Landing' in type(stair).__name__ and stair.next_type == 'STAIR':
+                if do_last:
+                    stair.get_lerp_vect(sections[-1], side, 1, last_t, False)
+                if slice:
+                    sections.append([])
+                    if extend > 0:
+                        t = -extend / self.stairs[s + 1].length
+                        self.stairs[s + 1].get_lerp_vect(sections[-1], side, 1, t, True)
+
+        t = 1 + extend / self.stairs[-1].length
+        self.stairs[-1].get_lerp_vect(sections[-1], side, 1, t, True)
+
+        for cur_sect in sections:
+            user_path_verts = len(cur_sect)
+            f = len(verts)
+            if user_path_verts > 0:
+                user_path_uv_v = []
+                n, dz, z0, z1 = cur_sect[-1]
+                cur_sect[-1] = (n, dz, z0 - stair.step_height, z1)
+                n_sections = user_path_verts - 1
+                n, dz, zs, zl = cur_sect[0]
+                p0 = n.p
+                v0 = n.v.normalized()
+                for s, section in enumerate(cur_sect):
+                    n, dz, zs, zl = section
+                    p1 = n.p
+                    if s < n_sections:
+                        v1 = cur_sect[s + 1][0].v.normalized()
+                    dir = (v0 + v1).normalized()
+                    scale = 1 / cos(0.5 * acos(min(1, max(-1, v0 * v1))))
+                    for p in profile:
+                        x, y = n.p + scale * p.x * dir
+                        z = zl + p.y + z_offset
+                        verts.append((x, y, z))
+                    if s > 0:
+                        user_path_uv_v.append((p1 - p0).length)
+                    p0 = p1
+                    v0 = v1
+
+                # build faces using Panel
+                lofter = Lofter(
+                    # closed_shape, index, x, y, idmat
+                    True,
+                    [i for i in range(len(profile))],
+                    [p.x for p in profile],
+                    [p.y for p in profile],
+                    [idmat for i in range(len(profile))],
+                    closed_path=False,
+                    user_path_uv_v=user_path_uv_v,
+                    user_path_verts=user_path_verts
+                    )
+                faces += lofter.faces(16, offset=f, path_type='USER_DEFINED')
+                matids += lofter.mat(16, idmat, idmat, path_type='USER_DEFINED')
+                v = Vector((0, 0))
+                uvs += lofter.uv(16, v, v, v, v, 0, v, 0, 0, path_type='USER_DEFINED')
+
+    def set_matids(self, id_materials):
+        for stair in self.stairs:
+            stair.set_matids(id_materials)
+
+
+def update(self, context):
+    self.update(context)
+
+
+def update_manipulators(self, context):
+    self.update(context, manipulable_refresh=True)
+
+
+def update_preset(self, context):
+    auto_update = self.auto_update
+    self.auto_update = False
+    if self.presets == 'STAIR_I':
+        self.n_parts = 1
+        self.update_parts()
+        self.parts[0].type = 'S_STAIR'
+    elif self.presets == 'STAIR_L':
+        self.n_parts = 3
+        self.update_parts()
+        self.parts[0].type = 'S_STAIR'
+        self.parts[1].type = 'C_STAIR'
+        self.parts[2].type = 'S_STAIR'
+        self.da = pi / 2
+    elif self.presets == 'STAIR_U':
+        self.n_parts = 3
+        self.update_parts()
+        self.parts[0].type = 'S_STAIR'
+        self.parts[1].type = 'D_STAIR'
+        self.parts[2].type = 'S_STAIR'
+        self.da = pi
+    elif self.presets == 'STAIR_O':
+        self.n_parts = 2
+        self.update_parts()
+        self.parts[0].type = 'D_STAIR'
+        self.parts[1].type = 'D_STAIR'
+        self.da = pi
+    # keep auto_update state same
+    # prevent unwanted load_preset update
+    self.auto_update = auto_update
+
+
+materials_enum = (
+            ('0', 'Ceiling', '', 0),
+            ('1', 'White', '', 1),
+            ('2', 'Concrete', '', 2),
+            ('3', 'Wood', '', 3),
+            ('4', 'Metal', '', 4),
+            ('5', 'Glass', '', 5)
+            )
+
+
+class archipack_stair_material(PropertyGroup):
+    index = EnumProperty(
+        items=materials_enum,
+        default='4',
+        update=update
+        )
+
+    def find_datablock_in_selection(self, context):
+        """
+            find witch selected object this instance belongs to
+            provide support for "copy to selected"
+        """
+        selected = [o for o in context.selected_objects]
+        for o in selected:
+            props = archipack_stair.datablock(o)
+            if props:
+                for part in props.rail_mat:
+                    if part == self:
+                        return props
+        return None
+
+    def update(self, context):
+        props = self.find_datablock_in_selection(context)
+        if props is not None:
+            props.update(context)
+
+
+class archipack_stair_part(PropertyGroup):
+    type = EnumProperty(
+            items=(
+                ('S_STAIR', 'Straight stair', '', 0),
+                ('C_STAIR', 'Curved stair', '', 1),
+                ('D_STAIR', 'Dual Curved stair', '', 2),
+                ('S_LANDING', 'Straight landing', '', 3),
+                ('C_LANDING', 'Curved landing', '', 4),
+                ('D_LANDING', 'Dual Curved landing', '', 5)
+                ),
+            default='S_STAIR',
+            update=update_manipulators
+            )
+    length = FloatProperty(
+            name="length",
+            min=0.5,
+            default=2.0,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    radius = FloatProperty(
+            name="radius",
+            min=0.5,
+            default=0.7,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    da = FloatProperty(
+            name="angle",
+            min=-pi,
+            max=pi,
+            default=pi / 2,
+            subtype='ANGLE', unit='ROTATION',
+            update=update
+            )
+    left_shape = EnumProperty(
+            items=(
+                ('RECTANGLE', 'Straight', '', 0),
+                ('CIRCLE', 'Curved ', '', 1)
+                ),
+            default='RECTANGLE',
+            update=update
+            )
+    right_shape = EnumProperty(
+            items=(
+                ('RECTANGLE', 'Straight', '', 0),
+                ('CIRCLE', 'Curved ', '', 1)
+                ),
+            default='RECTANGLE',
+            update=update
+            )
+    manipulators = CollectionProperty(type=archipack_manipulator)
+
+    def find_datablock_in_selection(self, context):
+        """
+            find witch selected object this instance belongs to
+            provide support for "copy to selected"
+        """
+        selected = [o for o in context.selected_objects]
+        for o in selected:
+            props = archipack_stair.datablock(o)
+            if props:
+                for part in props.parts:
+                    if part == self:
+                        return props
+        return None
+
+    def update(self, context, manipulable_refresh=False):
+        props = self.find_datablock_in_selection(context)
+        if props is not None:
+            props.update(context, manipulable_refresh)
+
+    def draw(self, layout, context, index, user_mode):
+        if user_mode:
+            box = layout.box()
+            row = box.row()
+            row.prop(self, "type", text=str(index + 1))
+            if self.type in ['C_STAIR', 'C_LANDING', 'D_STAIR', 'D_LANDING']:
+                row = box.row()
+                row.prop(self, "radius")
+                row = box.row()
+                row.prop(self, "da")
+            else:
+                row = box.row()
+                row.prop(self, "length")
+            if self.type in ['C_STAIR', 'C_LANDING', 'D_STAIR', 'D_LANDING']:
+                row = box.row(align=True)
+                row.prop(self, "left_shape", text="")
+                row.prop(self, "right_shape", text="")
+        else:
+            if self.type in ['S_STAIR', 'S_LANDING']:
+                box = layout.box()
+                row = box.row()
+                row.prop(self, "length")
+
+
+class archipack_stair(ArchipackObject, Manipulable, PropertyGroup):
+
+    parts = CollectionProperty(type=archipack_stair_part)
+    n_parts = IntProperty(
+            name="parts",
+            min=1,
+            max=32,
+            default=1, update=update_manipulators
+            )
+    step_depth = FloatProperty(
+            name="Going",
+            min=0.2,
+            default=0.25,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    width = FloatProperty(
+            name="width",
+            min=0.01,
+            default=1.2,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    height = FloatProperty(
+            name="Height",
+            min=0.1,
+            default=2.4, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    nose_y = FloatProperty(
+            name="Depth",
+            min=0.0,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    x_offset = FloatProperty(
+            name="x offset",
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    nose_z = FloatProperty(
+            name="Height",
+            min=0.001,
+            default=0.03, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    bottom_z = FloatProperty(
+            name="Stair bottom",
+            min=0.001,
+            default=0.03, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    radius = FloatProperty(
+            name="radius",
+            min=0.5,
+            default=0.7,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    da = FloatProperty(
+            name="angle",
+            min=-pi,
+            max=pi,
+            default=pi / 2,
+            subtype='ANGLE', unit='ROTATION',
+            update=update
+            )
+    total_angle = FloatProperty(
+            name="angle",
+            min=-50 * pi,
+            max=50 * pi,
+            default=2 * pi,
+            subtype='ANGLE', unit='ROTATION',
+            update=update
+            )
+    steps_type = EnumProperty(
+            name="Steps",
+            items=(
+                ('CLOSED', 'Closed', '', 0),
+                ('FULL', 'Full height', '', 1),
+                ('OPEN', 'Open ', '', 2)
+                ),
+            default='CLOSED',
+            update=update
+            )
+    nose_type = EnumProperty(
+            name="Nosing",
+            items=(
+                ('STRAIGHT', 'Straight', '', 0),
+                ('OBLIQUE', 'Oblique', '', 1),
+                ),
+            default='STRAIGHT',
+            update=update
+            )
+    left_shape = EnumProperty(
+            items=(
+                ('RECTANGLE', 'Straight', '', 0),
+                ('CIRCLE', 'Curved ', '', 1)
+                ),
+            default='RECTANGLE',
+            update=update
+            )
+    right_shape = EnumProperty(
+            items=(
+                ('RECTANGLE', 'Straight', '', 0),
+                ('CIRCLE', 'Curved ', '', 1)
+                ),
+            default='RECTANGLE',
+            update=update
+            )
+    z_mode = EnumProperty(
+            name="Interp z",
+            items=(
+                ('STANDARD', 'Standard', '', 0),
+                ('LINEAR', 'Bottom Linear', '', 1),
+                ('LINEAR_TOP', 'All Linear', '', 2)
+                ),
+            default='STANDARD',
+            update=update
+            )
+    presets = EnumProperty(
+            items=(
+                ('STAIR_I', 'I stair', '', 0),
+                ('STAIR_L', 'L stair', '', 1),
+                ('STAIR_U', 'U stair', '', 2),
+                ('STAIR_O', 'O stair', '', 3),
+                ('STAIR_USER', 'User defined stair', '', 4),
+                ),
+            default='STAIR_I', update=update_preset
+            )
+    left_post = BoolProperty(
+            name='left',
+            default=True,
+            update=update
+            )
+    right_post = BoolProperty(
+            name='right',
+            default=True,
+            update=update
+            )
+    post_spacing = FloatProperty(
+            name="spacing",
+            min=0.1,
+            default=1.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_x = FloatProperty(
+            name="width",
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_y = FloatProperty(
+            name="length",
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_z = FloatProperty(
+            name="height",
+            min=0.001,
+            default=1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_alt = FloatProperty(
+            name="altitude",
+            min=-100,
+            default=0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_offset_x = FloatProperty(
+            name="offset",
+            min=-100.0, max=100,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    post_corners = BoolProperty(
+            name="only on edges",
+            update=update,
+            default=False
+            )
+    user_defined_post_enable = BoolProperty(
+            name="User",
+            update=update,
+            default=True
+            )
+    user_defined_post = StringProperty(
+            name="user defined",
+            update=update
+            )
+    idmat_post = EnumProperty(
+            name="Post",
+            items=materials_enum,
+            default='4',
+            update=update
+            )
+    left_subs = BoolProperty(
+            name='left',
+            default=False,
+            update=update
+            )
+    right_subs = BoolProperty(
+            name='right',
+            default=False,
+            update=update
+            )
+    subs_spacing = FloatProperty(
+            name="spacing",
+            min=0.05,
+            default=0.10, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_x = FloatProperty(
+            name="width",
+            min=0.001,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_y = FloatProperty(
+            name="length",
+            min=0.001,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_z = FloatProperty(
+            name="height",
+            min=0.001,
+            default=1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_alt = FloatProperty(
+            name="altitude",
+            min=-100,
+            default=0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_offset_x = FloatProperty(
+            name="offset",
+            min=-100.0, max=100,
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_bottom = EnumProperty(
+            name="Bottom",
+            items=(
+                ('STEP', 'Follow step', '', 0),
+                ('LINEAR', 'Linear', '', 1),
+                ),
+            default='STEP',
+            update=update
+            )
+    user_defined_subs_enable = BoolProperty(
+            name="User",
+            update=update,
+            default=True
+            )
+    user_defined_subs = StringProperty(
+            name="user defined",
+            update=update
+            )
+    idmat_subs = EnumProperty(
+            name="Subs",
+            items=materials_enum,
+            default='4',
+            update=update
+            )
+    left_panel = BoolProperty(
+            name='left',
+            default=True,
+            update=update
+            )
+    right_panel = BoolProperty(
+            name='right',
+            default=True,
+            update=update
+            )
+    panel_alt = FloatProperty(
+            name="altitude",
+            default=0.25, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    panel_x = FloatProperty(
+            name="width",
+            min=0.001,
+            default=0.01, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    panel_z = FloatProperty(
+            name="height",
+            min=0.001,
+            default=0.6, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    panel_dist = FloatProperty(
+            name="space",
+            min=0.001,
+            default=0.05, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    panel_offset_x = FloatProperty(
+            name="offset",
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    idmat_panel = EnumProperty(
+            name="Panels",
+            items=materials_enum,
+            default='5',
+            update=update
+            )
+    left_rail = BoolProperty(
+            name="left",
+            update=update,
+            default=False
+            )
+    right_rail = BoolProperty(
+            name="right",
+            update=update,
+            default=False
+            )
+    rail_n = IntProperty(
+            name="number",
+            default=1,
+            min=0,
+            max=31,
+            update=update
+            )
+    rail_x = FloatVectorProperty(
+            name="width",
+            default=[
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05
+            ],
+            size=31,
+            min=0.001,
+            precision=2, step=1,
+            unit='LENGTH',
+            update=update
+            )
+    rail_z = FloatVectorProperty(
+            name="height",
+            default=[
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+                0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05
+            ],
+            size=31,
+            min=0.001,
+            precision=2, step=1,
+            unit='LENGTH',
+            update=update
+            )
+    rail_offset = FloatVectorProperty(
+            name="offset",
+            default=[
+                0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0
+            ],
+            size=31,
+            precision=2, step=1,
+            unit='LENGTH',
+            update=update
+            )
+    rail_alt = FloatVectorProperty(
+            name="altitude",
+            default=[
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
+            ],
+            size=31,
+            precision=2, step=1,
+            unit='LENGTH',
+            update=update
+            )
+    rail_mat = CollectionProperty(type=archipack_stair_material)
+
+    left_handrail = BoolProperty(
+            name="left",
+            update=update,
+            default=True
+            )
+    right_handrail = BoolProperty(
+            name="right",
+            update=update,
+            default=True
+            )
+    handrail_offset = FloatProperty(
+            name="offset",
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_alt = FloatProperty(
+            name="altitude",
+            default=1.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_extend = FloatProperty(
+            name="extend",
+            default=0.1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_slice_left = BoolProperty(
+            name='slice',
+            default=True,
+            update=update
+            )
+    handrail_slice_right = BoolProperty(
+            name='slice',
+            default=True,
+            update=update
+            )
+    handrail_profil = EnumProperty(
+            name="Profil",
+            items=(
+                ('SQUARE', 'Square', '', 0),
+                ('CIRCLE', 'Circle', '', 1),
+                ('COMPLEX', 'Circle over square', '', 2)
+                ),
+            default='SQUARE',
+            update=update
+            )
+    handrail_x = FloatProperty(
+            name="width",
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_y = FloatProperty(
+            name="height",
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_radius = FloatProperty(
+            name="radius",
+            min=0.001,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+
+    left_string = BoolProperty(
+            name="left",
+            update=update,
+            default=False
+            )
+    right_string = BoolProperty(
+            name="right",
+            update=update,
+            default=False
+            )
+    string_x = FloatProperty(
+            name="width",
+            min=-100.0,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    string_z = FloatProperty(
+            name="height",
+            default=0.3, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    string_offset = FloatProperty(
+            name="offset",
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    string_alt = FloatProperty(
+            name="altitude",
+            default=-0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+
+    idmat_bottom = EnumProperty(
+            name="Bottom",
+            items=materials_enum,
+            default='1',
+            update=update
+            )
+    idmat_raise = EnumProperty(
+            name="Raise",
+            items=materials_enum,
+            default='1',
+            update=update
+            )
+    idmat_step_front = EnumProperty(
+            name="Step front",
+            items=materials_enum,
+            default='3',
+            update=update
+            )
+    idmat_top = EnumProperty(
+            name="Top",
+            items=materials_enum,
+            default='3',
+            update=update
+            )
+    idmat_side = EnumProperty(
+            name="Side",
+            items=materials_enum,
+            default='1',
+            update=update
+            )
+    idmat_step_side = EnumProperty(
+            name="Step Side",
+            items=materials_enum,
+            default='3',
+            update=update
+            )
+    idmat_handrail = EnumProperty(
+            name="Handrail",
+            items=materials_enum,
+            default='3',
+            update=update
+            )
+    idmat_string = EnumProperty(
+            name="String",
+            items=materials_enum,
+            default='3',
+            update=update
+            )
+
+    # UI layout related
+    parts_expand = BoolProperty(
+            default=False
+            )
+    steps_expand = BoolProperty(
+            default=False
+            )
+    rail_expand = BoolProperty(
+            default=False
+            )
+    idmats_expand = BoolProperty(
+            default=False
+            )
+    handrail_expand = BoolProperty(
+            default=False
+            )
+    string_expand = BoolProperty(
+            default=False
+            )
+    post_expand = BoolProperty(
+            default=False
+            )
+    panel_expand = BoolProperty(
+            default=False
+            )
+    subs_expand = BoolProperty(
+            default=False
+            )
+
+    auto_update = BoolProperty(
+            options={'SKIP_SAVE'},
+            default=True,
+            update=update_manipulators
+            )
+
+    def setup_manipulators(self):
+
+        if len(self.manipulators) == 0:
+            s = self.manipulators.add()
+            s.prop1_name = "width"
+            s = self.manipulators.add()
+            s.prop1_name = "height"
+            s.normal = Vector((0, 1, 0))
+
+        for i in range(self.n_parts):
+            p = self.parts[i]
+            n_manips = len(p.manipulators)
+            if n_manips < 1:
+                m = p.manipulators.add()
+                m.type_key = 'SIZE'
+                m.prop1_name = 'length'
+
+    def update_parts(self):
+
+        # remove rails materials
+        for i in range(len(self.rail_mat), self.rail_n, -1):
+            self.rail_mat.remove(i - 1)
+
+        # add rails
+        for i in range(len(self.rail_mat), self.rail_n):
+            self.rail_mat.add()
+
+        # remove parts
+        for i in range(len(self.parts), self.n_parts, -1):
+            self.parts.remove(i - 1)
+
+        # add parts
+        for i in range(len(self.parts), self.n_parts):
+            self.parts.add()
+
+        self.setup_manipulators()
+
+    def update(self, context, manipulable_refresh=False):
+
+        o = self.find_in_selection(context, self.auto_update)
+
+        if o is None:
+            return
+
+        # clean up manipulators before any data model change
+        if manipulable_refresh:
+            self.manipulable_disable(context)
+
+        self.update_parts()
+
+        center = Vector((0, 0))
+        verts = []
+        faces = []
+        matids = []
+        uvs = []
+        id_materials = [int(self.idmat_top), int(self.idmat_step_front), int(self.idmat_raise),
+                        int(self.idmat_side), int(self.idmat_bottom), int(self.idmat_step_side)]
+
+        # depth at bottom
+        bottom_z = self.bottom_z
+        if self.steps_type == 'OPEN':
+            # depth at front
+            bottom_z = self.nose_z
+
+        width_left = 0.5 * self.width - self.x_offset
+        width_right = 0.5 * self.width + self.x_offset
+
+        self.manipulators[0].set_pts([(-width_left, 0, 0), (width_right, 0, 0), (1, 0, 0)])
+        self.manipulators[1].set_pts([(0, 0, 0), (0, 0, self.height), (1, 0, 0)])
+
+        g = StairGenerator(self.parts)
+        if self.presets == 'STAIR_USER':
+            for part in self.parts:
+                g.add_part(part.type, self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                        bottom_z, center, max(width_left + 0.01, width_right + 0.01, part.radius), part.da,
+                        width_left, width_right, part.length, part.left_shape, part.right_shape)
+
+        elif self.presets == 'STAIR_O':
+            n_parts = max(1, int(round(abs(self.total_angle) / pi, 0)))
+            if self.total_angle > 0:
+                dir = 1
+            else:
+                dir = -1
+            last_da = self.total_angle - dir * (n_parts - 1) * pi
+            if dir * last_da > pi:
+                n_parts += 1
+                last_da -= dir * pi
+            abs_last = dir * last_da
+
+            for part in range(n_parts - 1):
+                g.add_part('D_STAIR', self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                            bottom_z, center, max(width_left + 0.01, width_right + 0.01, self.radius), dir * pi,
+                            width_left, width_right, 1.0, self.left_shape, self.right_shape)
+            if round(abs_last, 2) > 0:
+                if abs_last > pi / 2:
+                    g.add_part('C_STAIR', self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                            bottom_z, center, max(width_left + 0.01, width_right + 0.01, self.radius),
+                            dir * pi / 2,
+                            width_left, width_right, 1.0, self.left_shape, self.right_shape)
+                    g.add_part('C_STAIR', self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                            bottom_z, center, max(width_left + 0.01, width_right + 0.01, self.radius),
+                            last_da - dir * pi / 2,
+                            width_left, width_right, 1.0, self.left_shape, self.right_shape)
+                else:
+                    g.add_part('C_STAIR', self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                            bottom_z, center, max(width_left + 0.01, width_right + 0.01, self.radius), last_da,
+                            width_left, width_right, 1.0, self.left_shape, self.right_shape)
+        else:
+            # STAIR_L STAIR_I STAIR_U
+            for part in self.parts:
+                g.add_part(part.type, self.steps_type, self.nose_type, self.z_mode, self.nose_z,
+                            bottom_z, center, max(width_left + 0.01, width_right + 0.01, self.radius), self.da,
+                            width_left, width_right, part.length, self.left_shape, self.right_shape)
+
+        # Stair basis
+        g.set_matids(id_materials)
+        g.make_stair(self.height, self.step_depth, verts, faces, matids, uvs, nose_y=self.nose_y)
+
+        # Ladder
+        offset_x = 0.5 * self.width - self.post_offset_x
+        post_spacing = self.post_spacing
+        if self.post_corners:
+            post_spacing = 10000
+
+        if self.user_defined_post_enable:
+            # user defined posts
+            user_def_post = context.scene.objects.get(self.user_defined_post)
+            if user_def_post is not None and user_def_post.type == 'MESH':
+                g.setup_user_defined_post(user_def_post, self.post_x, self.post_y, self.post_z)
+
+        if self.left_post:
+            g.make_post(self.height, self.step_depth, 0.5 * self.post_x, 0.5 * self.post_y,
+                    self.post_z, self.post_alt, 'LEFT', post_spacing, self.post_corners,
+                    self.x_offset, offset_x, int(self.idmat_post), verts, faces, matids, uvs)
+
+        if self.right_post:
+            g.make_post(self.height, self.step_depth, 0.5 * self.post_x, 0.5 * self.post_y,
+                    self.post_z, self.post_alt, 'RIGHT', post_spacing, self.post_corners,
+                    self.x_offset, offset_x, int(self.idmat_post), verts, faces, matids, uvs)
+
+        # reset user def posts
+        g.user_defined_post = None
+
+        # user defined subs
+        if self.user_defined_subs_enable:
+            user_def_subs = context.scene.objects.get(self.user_defined_subs)
+            if user_def_subs is not None and user_def_subs.type == 'MESH':
+                g.setup_user_defined_post(user_def_subs, self.subs_x, self.subs_y, self.subs_z)
+
+        if self.left_subs:
+            g.make_subs(self.height, self.step_depth, 0.5 * self.subs_x, 0.5 * self.subs_y,
+                    self.subs_z, 0.5 * self.post_y, self.subs_alt, self.subs_bottom, 'LEFT',
+                    self.handrail_slice_left, post_spacing, self.subs_spacing, self.post_corners,
+                    self.x_offset, offset_x, -self.subs_offset_x, int(self.idmat_subs), verts, faces, matids, uvs)
+
+        if self.right_subs:
+            g.make_subs(self.height, self.step_depth, 0.5 * self.subs_x, 0.5 * self.subs_y,
+                    self.subs_z, 0.5 * self.post_y, self.subs_alt, self.subs_bottom, 'RIGHT',
+                    self.handrail_slice_right, post_spacing, self.subs_spacing, self.post_corners,
+                    self.x_offset, offset_x, self.subs_offset_x, int(self.idmat_subs), verts, faces, matids, uvs)
+
+        g.user_defined_post = None
+
+        if self.left_panel:
+            g.make_panels(self.height, self.step_depth, 0.5 * self.panel_x, self.panel_z, 0.5 * self.post_y,
+                    self.panel_alt, 'LEFT', post_spacing, self.panel_dist, self.post_corners,
+                    self.x_offset, offset_x, -self.panel_offset_x, int(self.idmat_panel), verts, faces, matids, uvs)
+
+        if self.right_panel:
+            g.make_panels(self.height, self.step_depth, 0.5 * self.panel_x, self.panel_z, 0.5 * self.post_y,
+                    self.panel_alt, 'RIGHT', post_spacing, self.panel_dist, self.post_corners,
+                    self.x_offset, offset_x, self.panel_offset_x, int(self.idmat_panel), verts, faces, matids, uvs)
+
+        if self.right_rail:
+            for i in range(self.rail_n):
+                id_materials = [int(self.rail_mat[i].index) for j in range(6)]
+                g.set_matids(id_materials)
+                g.make_part(self.height, self.step_depth, self.rail_x[i], self.rail_z[i],
+                        self.x_offset, offset_x + self.rail_offset[i],
+                        self.rail_alt[i], 'LINEAR', 'CLOSED', verts, faces, matids, uvs)
+
+        if self.left_rail:
+            for i in range(self.rail_n):
+                id_materials = [int(self.rail_mat[i].index) for j in range(6)]
+                g.set_matids(id_materials)
+                g.make_part(self.height, self.step_depth, self.rail_x[i], self.rail_z[i],
+                        self.x_offset, -offset_x - self.rail_offset[i],
+                        self.rail_alt[i], 'LINEAR', 'CLOSED', verts, faces, matids, uvs)
+
+        if self.handrail_profil == 'COMPLEX':
+            sx = self.handrail_x
+            sy = self.handrail_y
+            handrail = [Vector((sx * x, sy * y)) for x, y in [
+            (-0.28, 1.83), (-0.355, 1.77), (-0.415, 1.695), (-0.46, 1.605), (-0.49, 1.51), (-0.5, 1.415),
+            (-0.49, 1.315), (-0.46, 1.225), (-0.415, 1.135), (-0.355, 1.06), (-0.28, 1.0), (-0.255, 0.925),
+            (-0.33, 0.855), (-0.5, 0.855), (-0.5, 0.0), (0.5, 0.0), (0.5, 0.855), (0.33, 0.855), (0.255, 0.925),
+            (0.28, 1.0), (0.355, 1.06), (0.415, 1.135), (0.46, 1.225), (0.49, 1.315), (0.5, 1.415),
+            (0.49, 1.51), (0.46, 1.605), (0.415, 1.695), (0.355, 1.77), (0.28, 1.83), (0.19, 1.875),
+            (0.1, 1.905), (0.0, 1.915), (-0.095, 1.905), (-0.19, 1.875)]]
+
+        elif self.handrail_profil == 'SQUARE':
+            x = 0.5 * self.handrail_x
+            y = self.handrail_y
+            handrail = [Vector((-x, y)), Vector((-x, 0)), Vector((x, 0)), Vector((x, y))]
+        elif self.handrail_profil == 'CIRCLE':
+            r = self.handrail_radius
+            handrail = [Vector((r * sin(0.1 * -a * pi), r * (0.5 + cos(0.1 * -a * pi)))) for a in range(0, 20)]
+
+        if self.right_handrail:
+            g.make_profile(handrail, int(self.idmat_handrail), "RIGHT", self.handrail_slice_right,
+                self.height, self.step_depth, self.x_offset + offset_x + self.handrail_offset,
+                self.handrail_alt, self.handrail_extend, verts, faces, matids, uvs)
+
+        if self.left_handrail:
+            g.make_profile(handrail, int(self.idmat_handrail), "LEFT", self.handrail_slice_left,
+                self.height, self.step_depth, -self.x_offset + offset_x + self.handrail_offset,
+                self.handrail_alt, self.handrail_extend, verts, faces, matids, uvs)
+
+        w = 0.5 * self.string_x
+        h = self.string_z
+        string = [Vector((-w, 0)), Vector((w, 0)), Vector((w, h)), Vector((-w, h))]
+
+        if self.right_string:
+            g.make_profile(string, int(self.idmat_string), "RIGHT", False, self.height, self.step_depth,
+                self.x_offset + 0.5 * self.width + self.string_offset,
+                self.string_alt, 0, verts, faces, matids, uvs)
+
+        if self.left_string:
+            g.make_profile(string, int(self.idmat_string), "LEFT", False, self.height, self.step_depth,
+                -self.x_offset + 0.5 * self.width + self.string_offset,
+                self.string_alt, 0, verts, faces, matids, uvs)
+
+        bmed.buildmesh(context, o, verts, faces, matids=matids, uvs=uvs, weld=True, clean=True)
+
+        # enable manipulators rebuild
+        if manipulable_refresh:
+            self.manipulable_refresh = True
+
+        self.restore_context(context)
+
+    def manipulable_setup(self, context):
+        """
+            TODO: Implement the setup part as per parent object basis
+
+            self.manipulable_disable(context)
+            o = context.active_object
+            for m in self.manipulators:
+                self.manip_stack.append(m.setup(context, o, self))
+
+        """
+        self.manipulable_disable(context)
+        o = context.active_object
+
+        self.setup_manipulators()
+
+        if self.presets is not 'STAIR_O':
+            for i, part in enumerate(self.parts):
+                if i >= self.n_parts:
+                    break
+                if "S_" in part.type or self.presets in ['STAIR_USER']:
+                    for j, m in enumerate(part.manipulators):
+                        self.manip_stack.append(m.setup(context, o, part))
+
+        if self.presets in ['STAIR_U', 'STAIR_L']:
+            self.manip_stack.append(self.parts[1].manipulators[0].setup(context, o, self))
+
+        for m in self.manipulators:
+            self.manip_stack.append(m.setup(context, o, self))
+
+
+class ARCHIPACK_PT_stair(Panel):
+    bl_idname = "ARCHIPACK_PT_stair"
+    bl_label = "Stair"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    # bl_context = 'object'
+    bl_category = 'ArchiPack'
+
+    @classmethod
+    def poll(cls, context):
+        return archipack_stair.filter(context.active_object)
+
+    def draw(self, context):
+        prop = archipack_stair.datablock(context.active_object)
+        if prop is None:
+            return
+        scene = context.scene
+        layout = self.layout
+        row = layout.row(align=True)
+        row.operator('archipack.stair_manipulate', icon='HAND')
+        row = layout.row(align=True)
+        row.prop(prop, 'presets', text="")
+        box = layout.box()
+        # box.label(text="Styles")
+        row = box.row(align=True)
+        # row.menu("ARCHIPACK_MT_stair_preset", text=bpy.types.ARCHIPACK_MT_stair_preset.bl_label)
+        row.operator("archipack.stair_preset_menu", text=bpy.types.ARCHIPACK_OT_stair_preset_menu.bl_label)
+        row.operator("archipack.stair_preset", text="", icon='ZOOMIN')
+        row.operator("archipack.stair_preset", text="", icon='ZOOMOUT').remove_active = True
+        box = layout.box()
+        box.prop(prop, 'width')
+        box.prop(prop, 'height')
+        box.prop(prop, 'bottom_z')
+        box.prop(prop, 'x_offset')
+        # box.prop(prop, 'z_mode')
+        box = layout.box()
+        row = box.row()
+        if prop.parts_expand:
+            row.prop(prop, 'parts_expand', icon="TRIA_DOWN", icon_only=True, text="Parts", emboss=False)
+            if prop.presets == 'STAIR_USER':
+                box.prop(prop, 'n_parts')
+            if prop.presets != 'STAIR_USER':
+                row = box.row(align=True)
+                row.prop(prop, "left_shape", text="")
+                row.prop(prop, "right_shape", text="")
+                row = box.row()
+                row.prop(prop, "radius")
+                row = box.row()
+                if prop.presets == 'STAIR_O':
+                    row.prop(prop, 'total_angle')
+                else:
+                    row.prop(prop, 'da')
+            if prop.presets != 'STAIR_O':
+                for i, part in enumerate(prop.parts):
+                    part.draw(layout, context, i, prop.presets == 'STAIR_USER')
+        else:
+            row.prop(prop, 'parts_expand', icon="TRIA_RIGHT", icon_only=True, text="Parts", emboss=False)
+
+        box = layout.box()
+        row = box.row()
+        if prop.steps_expand:
+            row.prop(prop, 'steps_expand', icon="TRIA_DOWN", icon_only=True, text="Steps", emboss=False)
+            box.prop(prop, 'steps_type')
+            box.prop(prop, 'step_depth')
+            box.prop(prop, 'nose_type')
+            box.prop(prop, 'nose_z')
+            box.prop(prop, 'nose_y')
+        else:
+            row.prop(prop, 'steps_expand', icon="TRIA_RIGHT", icon_only=True, text="Steps", emboss=False)
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.handrail_expand:
+            row.prop(prop, 'handrail_expand', icon="TRIA_DOWN", icon_only=True, text="Handrail", emboss=False)
+        else:
+            row.prop(prop, 'handrail_expand', icon="TRIA_RIGHT", icon_only=True, text="Handrail", emboss=False)
+
+        row.prop(prop, 'left_handrail')
+        row.prop(prop, 'right_handrail')
+
+        if prop.handrail_expand:
+            box.prop(prop, 'handrail_alt')
+            box.prop(prop, 'handrail_offset')
+            box.prop(prop, 'handrail_extend')
+            box.prop(prop, 'handrail_profil')
+            if prop.handrail_profil != 'CIRCLE':
+                box.prop(prop, 'handrail_x')
+                box.prop(prop, 'handrail_y')
+            else:
+                box.prop(prop, 'handrail_radius')
+            row = box.row(align=True)
+            row.prop(prop, 'handrail_slice_left')
+            row.prop(prop, 'handrail_slice_right')
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.string_expand:
+            row.prop(prop, 'string_expand', icon="TRIA_DOWN", icon_only=True, text="String", emboss=False)
+        else:
+            row.prop(prop, 'string_expand', icon="TRIA_RIGHT", icon_only=True, text="String", emboss=False)
+        row.prop(prop, 'left_string')
+        row.prop(prop, 'right_string')
+        if prop.string_expand:
+            box.prop(prop, 'string_x')
+            box.prop(prop, 'string_z')
+            box.prop(prop, 'string_alt')
+            box.prop(prop, 'string_offset')
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.post_expand:
+            row.prop(prop, 'post_expand', icon="TRIA_DOWN", icon_only=True, text="Post", emboss=False)
+        else:
+            row.prop(prop, 'post_expand', icon="TRIA_RIGHT", icon_only=True, text="Post", emboss=False)
+        row.prop(prop, 'left_post')
+        row.prop(prop, 'right_post')
+        if prop.post_expand:
+            box.prop(prop, 'post_corners')
+            if not prop.post_corners:
+                box.prop(prop, 'post_spacing')
+            box.prop(prop, 'post_x')
+            box.prop(prop, 'post_y')
+            box.prop(prop, 'post_z')
+            box.prop(prop, 'post_alt')
+            box.prop(prop, 'post_offset_x')
+            row = box.row(align=True)
+            row.prop(prop, 'user_defined_post_enable', text="")
+            row.prop_search(prop, "user_defined_post", scene, "objects", text="")
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.subs_expand:
+            row.prop(prop, 'subs_expand', icon="TRIA_DOWN", icon_only=True, text="Subs", emboss=False)
+        else:
+            row.prop(prop, 'subs_expand', icon="TRIA_RIGHT", icon_only=True, text="Subs", emboss=False)
+
+        row.prop(prop, 'left_subs')
+        row.prop(prop, 'right_subs')
+        if prop.subs_expand:
+            box.prop(prop, 'subs_spacing')
+            box.prop(prop, 'subs_x')
+            box.prop(prop, 'subs_y')
+            box.prop(prop, 'subs_z')
+            box.prop(prop, 'subs_alt')
+            box.prop(prop, 'subs_offset_x')
+            box.prop(prop, 'subs_bottom')
+            row = box.row(align=True)
+            row.prop(prop, 'user_defined_subs_enable', text="")
+            row.prop_search(prop, "user_defined_subs", scene, "objects", text="")
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.panel_expand:
+            row.prop(prop, 'panel_expand', icon="TRIA_DOWN", icon_only=True, text="Panels", emboss=False)
+        else:
+            row.prop(prop, 'panel_expand', icon="TRIA_RIGHT", icon_only=True, text="Panels", emboss=False)
+        row.prop(prop, 'left_panel')
+        row.prop(prop, 'right_panel')
+        if prop.panel_expand:
+            box.prop(prop, 'panel_dist')
+            box.prop(prop, 'panel_x')
+            box.prop(prop, 'panel_z')
+            box.prop(prop, 'panel_alt')
+            box.prop(prop, 'panel_offset_x')
+
+        box = layout.box()
+        row = box.row(align=True)
+        if prop.rail_expand:
+            row.prop(prop, 'rail_expand', icon="TRIA_DOWN", icon_only=True, text="Rails", emboss=False)
+        else:
+            row.prop(prop, 'rail_expand', icon="TRIA_RIGHT", icon_only=True, text="Rails", emboss=False)
+        row.prop(prop, 'left_rail')
+        row.prop(prop, 'right_rail')
+        if prop.rail_expand:
+            box.prop(prop, 'rail_n')
+            for i in range(prop.rail_n):
+                box = layout.box()
+                box.label(text="Rail " + str(i + 1))
+                box.prop(prop, 'rail_x', index=i)
+                box.prop(prop, 'rail_z', index=i)
+                box.prop(prop, 'rail_alt', index=i)
+                box.prop(prop, 'rail_offset', index=i)
+                box.prop(prop.rail_mat[i], 'index', text="")
+
+        box = layout.box()
+        row = box.row()
+
+        if prop.idmats_expand:
+            row.prop(prop, 'idmats_expand', icon="TRIA_DOWN", icon_only=True, text="Materials", emboss=False)
+            box.prop(prop, 'idmat_top')
+            box.prop(prop, 'idmat_side')
+            box.prop(prop, 'idmat_bottom')
+            box.prop(prop, 'idmat_step_side')
+            box.prop(prop, 'idmat_step_front')
+            box.prop(prop, 'idmat_raise')
+            box.prop(prop, 'idmat_handrail')
+            box.prop(prop, 'idmat_panel')
+            box.prop(prop, 'idmat_post')
+            box.prop(prop, 'idmat_subs')
+            box.prop(prop, 'idmat_string')
+        else:
+            row.prop(prop, 'idmats_expand', icon="TRIA_RIGHT", icon_only=True, text="Materials", emboss=False)
+
+
+# ------------------------------------------------------------------
+# Define operator class to create object
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_stair(ArchipackCreateTool, Operator):
+    bl_idname = "archipack.stair"
+    bl_label = "Stair"
+    bl_description = "Create a Stair"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    def create(self, context):
+        m = bpy.data.meshes.new("Stair")
+        o = bpy.data.objects.new("Stair", m)
+        d = m.archipack_stair.add()
+        context.scene.objects.link(o)
+        o.select = True
+        context.scene.objects.active = o
+        self.load_preset(d)
+        self.add_material(o)
+        m.auto_smooth_angle = 0.20944
+        return o
+
+    # -----------------------------------------------------
+    # Execute
+    # -----------------------------------------------------
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            bpy.ops.object.select_all(action="DESELECT")
+            o = self.create(context)
+            o.location = context.scene.cursor_location
+            o.select = True
+            context.scene.objects.active = o
+            self.manipulate()
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+# ------------------------------------------------------------------
+# Define operator class to manipulate object
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_stair_manipulate(Operator):
+    bl_idname = "archipack.stair_manipulate"
+    bl_label = "Manipulate"
+    bl_description = "Manipulate"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    @classmethod
+    def poll(self, context):
+        return archipack_stair.filter(context.active_object)
+
+    def invoke(self, context, event):
+        d = archipack_stair.datablock(context.active_object)
+        d.manipulable_invoke(context)
+        return {'FINISHED'}
+
+
+# ------------------------------------------------------------------
+# Define operator class to load / save presets
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_stair_preset_menu(PresetMenuOperator, Operator):
+    bl_idname = "archipack.stair_preset_menu"
+    bl_label = "Stair style"
+    preset_subdir = "archipack_stair"
+
+
+class ARCHIPACK_OT_stair_preset(ArchipackPreset, Operator):
+    """Add a Stair Preset"""
+    bl_idname = "archipack.stair_preset"
+    bl_label = "Add Stair Style"
+    preset_menu = "ARCHIPACK_OT_stair_preset_menu"
+
+    @property
+    def blacklist(self):
+        return ['manipulators']
+
+        """
+        'presets', 'n_parts', 'parts', 'width', 'height', 'radius',
+            'total_angle', 'da',
+        """
+
+
+def register():
+    bpy.utils.register_class(archipack_stair_material)
+    bpy.utils.register_class(archipack_stair_part)
+    bpy.utils.register_class(archipack_stair)
+    Mesh.archipack_stair = CollectionProperty(type=archipack_stair)
+    bpy.utils.register_class(ARCHIPACK_PT_stair)
+    bpy.utils.register_class(ARCHIPACK_OT_stair)
+    bpy.utils.register_class(ARCHIPACK_OT_stair_preset_menu)
+    bpy.utils.register_class(ARCHIPACK_OT_stair_preset)
+    bpy.utils.register_class(ARCHIPACK_OT_stair_manipulate)
+
+
+def unregister():
+    bpy.utils.unregister_class(archipack_stair_material)
+    bpy.utils.unregister_class(archipack_stair_part)
+    bpy.utils.unregister_class(archipack_stair)
+    del Mesh.archipack_stair
+    bpy.utils.unregister_class(ARCHIPACK_PT_stair)
+    bpy.utils.unregister_class(ARCHIPACK_OT_stair)
+    bpy.utils.unregister_class(ARCHIPACK_OT_stair_preset_menu)
+    bpy.utils.unregister_class(ARCHIPACK_OT_stair_preset)
+    bpy.utils.unregister_class(ARCHIPACK_OT_stair_manipulate)