archipack: T52120 release to official

1 files changed, 1782 insertions, 0 deletions

diff --git a/archipack/archipack_fence.py b/archipack/archipack_fence.py
new file mode 100644
index 00000000..961b516e
--- /dev/null
+++ b/archipack/archipack_fence.py
@@ -0,0 +1,1782 @@
+# -*- 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 mathutils.geometry import interpolate_bezier
+from math import sin, cos, pi, acos, atan2
+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 Fence():
+
+    def __init__(self):
+        # total distance from start
+        self.dist = 0
+        self.t_start = 0
+        self.t_end = 0
+        self.dz = 0
+        self.z0 = 0
+        self.a0 = 0
+
+    def set_offset(self, offset, last=None):
+        """
+            Offset line and compute intersection point
+            between segments
+        """
+        self.line = self.make_offset(offset, last)
+
+    @property
+    def t_diff(self):
+        return self.t_end - self.t_start
+
+    def straight_fence(self, a0, length):
+        s = self.straight(length).rotate(a0)
+        return StraightFence(s.p, s.v)
+
+    def curved_fence(self, a0, da, radius):
+        n = self.normal(1).rotate(a0).scale(radius)
+        if da < 0:
+            n.v = -n.v
+        a0 = n.angle
+        c = n.p - n.v
+        return CurvedFence(c, radius, a0, da)
+
+
+class StraightFence(Fence, Line):
+    def __str__(self):
+        return "t_start:{} t_end:{} dist:{}".format(self.t_start, self.t_end, self.dist)
+
+    def __init__(self, p, v):
+        Fence.__init__(self)
+        Line.__init__(self, p, v)
+
+
+class CurvedFence(Fence, Arc):
+    def __str__(self):
+        return "t_start:{} t_end:{} dist:{}".format(self.t_start, self.t_end, self.dist)
+
+    def __init__(self, c, radius, a0, da):
+        Fence.__init__(self)
+        Arc.__init__(self, c, radius, a0, da)
+
+
+class FenceSegment():
+    def __str__(self):
+        return "t_start:{} t_end:{} n_step:{}  t_step:{} i_start:{} i_end:{}".format(
+            self.t_start, self.t_end, self.n_step, self.t_step, self.i_start, self.i_end)
+
+    def __init__(self, t_start, t_end, n_step, t_step, i_start, i_end):
+        self.t_start = t_start
+        self.t_end = t_end
+        self.n_step = n_step
+        self.t_step = t_step
+        self.i_start = i_start
+        self.i_end = i_end
+
+
+class FenceGenerator():
+
+    def __init__(self, parts):
+        self.parts = parts
+        self.segs = []
+        self.length = 0
+        self.user_defined_post = None
+        self.user_defined_uvs = None
+        self.user_defined_mat = None
+
+    def add_part(self, part):
+
+        if len(self.segs) < 1:
+            s = None
+        else:
+            s = self.segs[-1]
+
+        # start a new fence
+        if s is None:
+            if part.type == 'S_FENCE':
+                p = Vector((0, 0))
+                v = part.length * Vector((cos(part.a0), sin(part.a0)))
+                s = StraightFence(p, v)
+            elif part.type == 'C_FENCE':
+                c = -part.radius * Vector((cos(part.a0), sin(part.a0)))
+                s = CurvedFence(c, part.radius, part.a0, part.da)
+        else:
+            if part.type == 'S_FENCE':
+                s = s.straight_fence(part.a0, part.length)
+            elif part.type == 'C_FENCE':
+                s = s.curved_fence(part.a0, part.da, part.radius)
+
+        # s.dist = self.length
+        # self.length += s.length
+        self.segs.append(s)
+        self.last_type = type
+
+    def set_offset(self, offset):
+        # @TODO:
+        # re-evaluate length of offset line here
+        last = None
+        for seg in self.segs:
+            seg.set_offset(offset, last)
+            last = seg.line
+
+    def param_t(self, angle_limit, post_spacing):
+        """
+            setup corners and fences dz
+            compute index of fences wich belong to each group of fences between corners
+            compute t of each fence
+        """
+        # segments are group of parts separated by limit angle
+        self.segments = []
+        i_start = 0
+        t_start = 0
+        dist_0 = 0
+        z = 0
+        self.length = 0
+        n_parts = len(self.parts) - 1
+        for i, f in enumerate(self.segs):
+            f.dist = self.length
+            self.length += f.line.length
+
+        vz0 = Vector((1, 0))
+        angle_z = 0
+        for i, f in enumerate(self.segs):
+            dz = self.parts[i].dz
+            if f.dist > 0:
+                f.t_start = f.dist / self.length
+            else:
+                f.t_start = 0
+
+            f.t_end = (f.dist + f.line.length) / self.length
+            f.z0 = z
+            f.dz = dz
+            z += dz
+
+            if i < n_parts:
+
+                vz1 = Vector((self.segs[i + 1].length, self.parts[i + 1].dz))
+                angle_z = abs(vz0.angle_signed(vz1))
+                vz0 = vz1
+
+                if (abs(self.parts[i + 1].a0) >= angle_limit or angle_z >= angle_limit):
+                    l_seg = f.dist + f.line.length - dist_0
+                    t_seg = f.t_end - t_start
+                    n_fences = max(1, int(l_seg / post_spacing))
+                    t_fence = t_seg / n_fences
+                    segment = FenceSegment(t_start, f.t_end, n_fences, t_fence, i_start, i)
+                    dist_0 = f.dist + f.line.length
+                    t_start = f.t_end
+                    i_start = i
+                    self.segments.append(segment)
+
+            manipulators = self.parts[i].manipulators
+            p0 = f.line.p0.to_3d()
+            p1 = f.line.p1.to_3d()
+            # angle from last to current segment
+            if i > 0:
+                v0 = self.segs[i - 1].line.straight(-1, 1).v.to_3d()
+                v1 = f.line.straight(1, 0).v.to_3d()
+                manipulators[0].set_pts([p0, v0, v1])
+
+            if type(f).__name__ == "StraightFence":
+                # segment length
+                manipulators[1].type_key = 'SIZE'
+                manipulators[1].prop1_name = "length"
+                manipulators[1].set_pts([p0, p1, (1, 0, 0)])
+            else:
+                # segment radius + angle
+                v0 = (f.line.p0 - f.c).to_3d()
+                v1 = (f.line.p1 - f.c).to_3d()
+                manipulators[1].type_key = 'ARC_ANGLE_RADIUS'
+                manipulators[1].prop1_name = "da"
+                manipulators[1].prop2_name = "radius"
+                manipulators[1].set_pts([f.c.to_3d(), v0, v1])
+
+            # snap manipulator, dont change index !
+            manipulators[2].set_pts([p0, p1, (1, 0, 0)])
+
+        f = self.segs[-1]
+        l_seg = f.dist + f.line.length - dist_0
+        t_seg = f.t_end - t_start
+        n_fences = max(1, int(l_seg / post_spacing))
+        t_fence = t_seg / n_fences
+        segment = FenceSegment(t_start, f.t_end, n_fences, t_fence, i_start, len(self.segs) - 1)
+        self.segments.append(segment)
+
+    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 '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):
+
+        n, dz, zl = post
+        slope = dz * post_y
+
+        if self.user_defined_post is not None:
+            x, y = -n.v.normalized()
+            p = n.p + sub_offset_x * n.v.normalized()
+            tM = Matrix([
+                [x, y, 0, p.x],
+                [y, -x, 0, p.y],
+                [0, 0, 1, zl + post_alt],
+                [0, 0, 0, 1]
+            ])
+            self.get_user_defined_post(tM, zl, 0, 0, dz, post_z, verts, faces, matids, uvs)
+            return
+
+        z3 = zl + post_z + post_alt - slope
+        z4 = zl + post_z + post_alt + slope
+        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, zl = subs[0]
+        p0 = n.p
+        v0 = n.v.normalized()
+        for s, section in enumerate(subs):
+            n, dz, 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 make_subs(self, x, y, z, post_y, altitude,
+            sub_spacing, offset_x, sub_offset_x, mat, verts, faces, matids, uvs):
+
+        t_post = (0.5 * post_y - y) / self.length
+        t_spacing = (sub_spacing + y) / self.length
+
+        for segment in self.segments:
+            t_step = segment.t_step
+            t_start = segment.t_start + t_post
+            s = 0
+            s_sub = t_step - 2 * t_post
+            n_sub = int(s_sub / t_spacing)
+            if n_sub > 0:
+                t_sub = s_sub / n_sub
+            else:
+                t_sub = 1
+            i = segment.i_start
+            while s < segment.n_step:
+                t_cur = t_start + s * t_step
+                for j in range(1, n_sub):
+                    t_s = t_cur + t_sub * j
+                    while self.segs[i].t_end < t_s:
+                        i += 1
+                    f = self.segs[i]
+                    t = (t_s - f.t_start) / f.t_diff
+                    n = f.line.normal(t)
+                    post = (n, f.dz / f.length, f.z0 + f.dz * t)
+                    self.get_post(post, x, y, z, altitude, sub_offset_x, mat, verts, faces, matids, uvs)
+                s += 1
+
+    def make_post(self, x, y, z, altitude, x_offset, mat, verts, faces, matids, uvs):
+
+        for segment in self.segments:
+            t_step = segment.t_step
+            t_start = segment.t_start
+            s = 0
+            i = segment.i_start
+            while s < segment.n_step:
+                t_cur = t_start + s * t_step
+                while self.segs[i].t_end < t_cur:
+                    i += 1
+                f = self.segs[i]
+                t = (t_cur - f.t_start) / f.t_diff
+                n = f.line.normal(t)
+                post = (n, f.dz / f.line.length, f.z0 + f.dz * t)
+                # self.get_post(post, x, y, z, altitude, x_offset, mat, verts, faces, matids, uvs)
+                self.get_post(post, x, y, z, altitude, 0, mat, verts, faces, matids, uvs)
+                s += 1
+
+            if segment.i_end + 1 == len(self.segs):
+                f = self.segs[segment.i_end]
+                n = f.line.normal(1)
+                post = (n, f.dz / f.line.length, f.z0 + f.dz)
+                # self.get_post(post, x, y, z, altitude, x_offset, mat, verts, faces, matids, uvs)
+                self.get_post(post, x, y, z, altitude, 0, mat, verts, faces, matids, uvs)
+
+    def make_panels(self, x, z, post_y, altitude, panel_dist,
+            offset_x, sub_offset_x, idmat, verts, faces, matids, uvs):
+
+        t_post = (0.5 * post_y + panel_dist) / self.length
+        for segment in self.segments:
+            t_step = segment.t_step
+            t_start = segment.t_start
+            s = 0
+            i = segment.i_start
+            while s < segment.n_step:
+                subs = []
+                t_cur = t_start + s * t_step + t_post
+                t_end = t_start + (s + 1) * t_step - t_post
+                # find first section
+                while self.segs[i].t_end < t_cur and i < segment.i_end:
+                    i += 1
+                f = self.segs[i]
+                # 1st section
+                t = (t_cur - f.t_start) / f.t_diff
+                n = f.line.normal(t)
+                subs.append((n, f.dz / f.line.length, f.z0 + f.dz * t))
+                # crossing sections -> new segment
+                while i < segment.i_end:
+                    f = self.segs[i]
+                    if f.t_end < t_end:
+                        if type(f).__name__ == 'CurvedFence':
+                            # cant end after segment
+                            t0 = max(0, (t_cur - f.t_start) / f.t_diff)
+                            t1 = min(1, (t_end - f.t_start) / f.t_diff)
+                            n_s = int(max(1, abs(f.da) * (5) / pi - 1))
+                            dt = (t1 - t0) / n_s
+                            for j in range(1, n_s + 1):
+                                t = t0 + dt * j
+                                n = f.line.sized_normal(t, 1)
+                                # n.p = f.lerp(x_offset)
+                                subs.append((n, f.dz / f.line.length, f.z0 + f.dz * t))
+                        else:
+                            n = f.line.normal(1)
+                            subs.append((n, f.dz / f.line.length, f.z0 + f.dz))
+                    if f.t_end >= t_end:
+                        break
+                    elif f.t_start < t_end:
+                        i += 1
+
+                f = self.segs[i]
+                # last section
+                if type(f).__name__ == 'CurvedFence':
+                    # cant start before segment
+                    t0 = max(0, (t_cur - f.t_start) / f.t_diff)
+                    t1 = min(1, (t_end - f.t_start) / f.t_diff)
+                    n_s = int(max(1, abs(f.da) * (5) / pi - 1))
+                    dt = (t1 - t0) / n_s
+                    for j in range(1, n_s + 1):
+                        t = t0 + dt * j
+                        n = f.line.sized_normal(t, 1)
+                        # n.p = f.lerp(x_offset)
+                        subs.append((n, f.dz / f.line.length, f.z0 + f.dz * t))
+                else:
+                    t = (t_end - f.t_start) / f.t_diff
+                    n = f.line.normal(t)
+                    subs.append((n, f.dz / f.line.length, f.z0 + f.dz * t))
+
+                # self.get_panel(subs, altitude, x, z, 0, idmat, verts, faces, matids, uvs)
+                self.get_panel(subs, altitude, x, z, sub_offset_x, idmat, verts, faces, matids, uvs)
+                s += 1
+
+    def make_profile(self, profile, idmat,
+            x_offset, z_offset, extend, verts, faces, matids, uvs):
+
+        last = None
+        for seg in self.segs:
+            seg.p_line = seg.make_offset(x_offset, last)
+            last = seg.p_line
+
+        n_fences = len(self.segs) - 1
+
+        if n_fences < 0:
+            return
+
+        sections = []
+
+        f = self.segs[0]
+
+        # first step
+        if extend != 0 and f.p_line.length != 0:
+            t = -extend / self.segs[0].p_line.length
+            n = f.p_line.sized_normal(t, 1)
+            # n.p = f.lerp(x_offset)
+            sections.append((n, f.dz / f.p_line.length, f.z0 + f.dz * t))
+
+        # add first section
+        n = f.p_line.sized_normal(0, 1)
+        # n.p = f.lerp(x_offset)
+        sections.append((n, f.dz / f.p_line.length, f.z0))
+
+        for s, f in enumerate(self.segs):
+            if f.p_line.length == 0:
+                continue
+            if type(f).__name__ == 'CurvedFence':
+                n_s = int(max(1, abs(f.da) * 30 / pi - 1))
+                for i in range(1, n_s + 1):
+                    t = i / n_s
+                    n = f.p_line.sized_normal(t, 1)
+                    # n.p = f.lerp(x_offset)
+                    sections.append((n, f.dz / f.p_line.length, f.z0 + f.dz * t))
+            else:
+                n = f.p_line.sized_normal(1, 1)
+                # n.p = f.lerp(x_offset)
+                sections.append((n, f.dz / f.p_line.length, f.z0 + f.dz))
+
+        if extend != 0 and f.p_line.length != 0:
+            t = 1 + extend / self.segs[-1].p_line.length
+            n = f.p_line.sized_normal(t, 1)
+            # n.p = f.lerp(x_offset)
+            sections.append((n, f.dz / f.p_line.length, f.z0 + f.dz * t))
+
+        user_path_verts = len(sections)
+        offset = len(verts)
+        if user_path_verts > 0:
+            user_path_uv_v = []
+            n, dz, z0 = sections[-1]
+            sections[-1] = (n, dz, z0)
+            n_sections = user_path_verts - 1
+            n, dz, zl = sections[0]
+            p0 = n.p
+            v0 = n.v.normalized()
+            for s, section in enumerate(sections):
+                n, dz, zl = section
+                p1 = n.p
+                if s < n_sections:
+                    v1 = sections[s + 1][0].v.normalized()
+                dir = (v0 + v1).normalized()
+                scale = min(10, 1 / cos(0.5 * acos(min(1, max(-1, v0 * v1)))))
+                for p in profile:
+                    # x, y = n.p + scale * (x_offset + p.x) * dir
+                    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=offset, 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 update(self, context):
+    self.update(context)
+
+
+def update_manipulators(self, context):
+    self.update(context, manipulable_refresh=True)
+
+
+def update_path(self, context):
+    self.update_path(context)
+
+
+def update_type(self, context):
+
+    d = self.find_datablock_in_selection(context)
+
+    if d is not None and d.auto_update:
+
+        d.auto_update = False
+        # find part index
+        idx = 0
+        for i, part in enumerate(d.parts):
+            if part == self:
+                idx = i
+                break
+        part = d.parts[idx]
+        a0 = 0
+        if idx > 0:
+            g = d.get_generator()
+            w0 = g.segs[idx - 1]
+            a0 = w0.straight(1).angle
+            if "C_" in self.type:
+                w = w0.straight_fence(part.a0, part.length)
+            else:
+                w = w0.curved_fence(part.a0, part.da, part.radius)
+        else:
+            g = FenceGenerator(None)
+            g.add_part(self)
+            w = g.segs[0]
+
+        # w0 - w - w1
+        dp = w.p1 - w.p0
+        if "C_" in self.type:
+            part.radius = 0.5 * dp.length
+            part.da = pi
+            a0 = atan2(dp.y, dp.x) - pi / 2 - a0
+        else:
+            part.length = dp.length
+            a0 = atan2(dp.y, dp.x) - a0
+
+        if a0 > pi:
+            a0 -= 2 * pi
+        if a0 < -pi:
+            a0 += 2 * pi
+        part.a0 = a0
+
+        if idx + 1 < d.n_parts:
+            # adjust rotation of next part
+            part1 = d.parts[idx + 1]
+            if "C_" in part.type:
+                a0 = part1.a0 - pi / 2
+            else:
+                a0 = part1.a0 + w.straight(1).angle - atan2(dp.y, dp.x)
+
+            if a0 > pi:
+                a0 -= 2 * pi
+            if a0 < -pi:
+                a0 += 2 * pi
+            part1.a0 = a0
+
+        d.auto_update = True
+
+
+materials_enum = (
+            ('0', 'Wood', '', 0),
+            ('1', 'Metal', '', 1),
+            ('2', 'Glass', '', 2)
+            )
+
+
+class archipack_fence_material(PropertyGroup):
+    index = EnumProperty(
+        items=materials_enum,
+        default='0',
+        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_fence.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_fence_part(PropertyGroup):
+    type = EnumProperty(
+            items=(
+                ('S_FENCE', 'Straight fence', '', 0),
+                ('C_FENCE', 'Curved fence', '', 1),
+                ),
+            default='S_FENCE',
+            update=update_type
+            )
+    length = FloatProperty(
+            name="length",
+            min=0.01,
+            default=2.0,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    radius = FloatProperty(
+            name="radius",
+            min=0.01,
+            default=0.7,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    da = FloatProperty(
+            name="total angle",
+            min=-pi,
+            max=pi,
+            default=pi / 2,
+            subtype='ANGLE', unit='ROTATION',
+            update=update
+            )
+    a0 = FloatProperty(
+            name="angle",
+            min=-2 * pi,
+            max=2 * pi,
+            default=0,
+            subtype='ANGLE', unit='ROTATION',
+            update=update
+            )
+    dz = FloatProperty(
+            name="delta z",
+            default=0,
+            unit='LENGTH', subtype='DISTANCE'
+            )
+
+    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_fence.datablock(o)
+            if props is not None:
+                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):
+        box = layout.box()
+        row = box.row()
+        row.prop(self, "type", text=str(index + 1))
+        if self.type in ['C_FENCE']:
+            row = box.row()
+            row.prop(self, "radius")
+            row = box.row()
+            row.prop(self, "da")
+        else:
+            row = box.row()
+            row.prop(self, "length")
+        row = box.row()
+        row.prop(self, "a0")
+
+
+class archipack_fence(ArchipackObject, Manipulable, PropertyGroup):
+
+    parts = CollectionProperty(type=archipack_fence_part)
+    user_defined_path = StringProperty(
+            name="user defined",
+            update=update_path
+            )
+    user_defined_spline = IntProperty(
+            name="Spline index",
+            min=0,
+            default=0,
+            update=update_path
+            )
+    user_defined_resolution = IntProperty(
+            name="resolution",
+            min=1,
+            max=128,
+            default=12, update=update_path
+            )
+    n_parts = IntProperty(
+            name="parts",
+            min=1,
+            default=1, update=update_manipulators
+            )
+    x_offset = FloatProperty(
+            name="x offset",
+            default=0.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+
+    radius = FloatProperty(
+            name="radius",
+            min=0.01,
+            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
+            )
+    angle_limit = FloatProperty(
+            name="angle",
+            min=0,
+            max=2 * pi,
+            default=pi / 8,
+            subtype='ANGLE', unit='ROTATION',
+            update=update_manipulators
+            )
+    shape = EnumProperty(
+            items=(
+                ('RECTANGLE', 'Straight', '', 0),
+                ('CIRCLE', 'Curved ', '', 1)
+                ),
+            default='RECTANGLE',
+            update=update
+            )
+    post = BoolProperty(
+            name='enable',
+            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, max=1000,
+            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",
+            default=0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    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='1',
+            update=update
+            )
+    subs = BoolProperty(
+            name='enable',
+            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",
+            default=0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    subs_offset_x = FloatProperty(
+            name="offset",
+            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='1',
+            update=update
+            )
+    panel = BoolProperty(
+            name='enable',
+            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='2',
+            update=update
+            )
+    rail = BoolProperty(
+            name="enable",
+            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_fence_material)
+
+    handrail = BoolProperty(
+            name="enable",
+            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",
+            min=0,
+            default=0.1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    handrail_slice = 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
+            )
+    idmat_handrail = EnumProperty(
+            name="Handrail",
+            items=materials_enum,
+            default='0',
+            update=update
+            )
+
+    # UI layout related
+    parts_expand = BoolProperty(
+            default=False
+            )
+    rail_expand = BoolProperty(
+            default=False
+            )
+    idmats_expand = BoolProperty(
+            default=False
+            )
+    handrail_expand = BoolProperty(
+            default=False
+            )
+    post_expand = BoolProperty(
+            default=False
+            )
+    panel_expand = BoolProperty(
+            default=False
+            )
+    subs_expand = BoolProperty(
+            default=False
+            )
+
+    # Flag to prevent mesh update while making bulk changes over variables
+    # use :
+    # .auto_update = False
+    # bulk changes
+    # .auto_update = True
+    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 == 0:
+                s = p.manipulators.add()
+                s.type_key = "ANGLE"
+                s.prop1_name = "a0"
+                s = p.manipulators.add()
+                s.type_key = "SIZE"
+                s.prop1_name = "length"
+                s = p.manipulators.add()
+                # s.type_key = 'SNAP_POINT'
+                s.type_key = 'WALL_SNAP'
+                s.prop1_name = str(i)
+                s.prop2_name = 'post_z'
+
+    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 interpolate_bezier(self, pts, wM, p0, p1, resolution):
+        # straight segment, worth testing here
+        # since this can lower points count by a resolution factor
+        # use normalized to handle non linear t
+        if resolution == 0:
+            pts.append(wM * p0.co.to_3d())
+        else:
+            v = (p1.co - p0.co).normalized()
+            d1 = (p0.handle_right - p0.co).normalized()
+            d2 = (p1.co - p1.handle_left).normalized()
+            if d1 == v and d2 == v:
+                pts.append(wM * p0.co.to_3d())
+            else:
+                seg = interpolate_bezier(wM * p0.co,
+                    wM * p0.handle_right,
+                    wM * p1.handle_left,
+                    wM * p1.co,
+                    resolution + 1)
+                for i in range(resolution):
+                    pts.append(seg[i].to_3d())
+
+    def from_spline(self, context, wM, resolution, spline):
+
+        o = self.find_in_selection(context)
+
+        if o is None:
+            return
+
+        tM = wM.copy()
+        tM.row[0].normalize()
+        tM.row[1].normalize()
+        tM.row[2].normalize()
+        pts = []
+        if spline.type == 'POLY':
+            pt = spline.points[0].co
+            pts = [wM * p.co.to_3d() for p in spline.points]
+            if spline.use_cyclic_u:
+                pts.append(pts[0])
+        elif spline.type == 'BEZIER':
+            pt = spline.bezier_points[0].co
+            points = spline.bezier_points
+            for i in range(1, len(points)):
+                p0 = points[i - 1]
+                p1 = points[i]
+                self.interpolate_bezier(pts, wM, p0, p1, resolution)
+            if spline.use_cyclic_u:
+                p0 = points[-1]
+                p1 = points[0]
+                self.interpolate_bezier(pts, wM, p0, p1, resolution)
+                pts.append(pts[0])
+            else:
+                pts.append(wM * points[-1].co)
+        auto_update = self.auto_update
+        self.auto_update = False
+
+        self.n_parts = len(pts) - 1
+        self.update_parts()
+
+        p0 = pts.pop(0)
+        a0 = 0
+        for i, p1 in enumerate(pts):
+            dp = p1 - p0
+            da = atan2(dp.y, dp.x) - a0
+            if da > pi:
+                da -= 2 * pi
+            if da < -pi:
+                da += 2 * pi
+            p = self.parts[i]
+            p.length = dp.to_2d().length
+            p.dz = dp.z
+            p.a0 = da
+            a0 += da
+            p0 = p1
+
+        self.auto_update = auto_update
+
+        o.matrix_world = tM * Matrix([
+            [1, 0, 0, pt.x],
+            [0, 1, 0, pt.y],
+            [0, 0, 1, pt.z],
+            [0, 0, 0, 1]
+            ])
+
+    def update_path(self, context):
+        path = context.scene.objects.get(self.user_defined_path)
+        if path is not None and path.type == 'CURVE':
+            splines = path.data.splines
+            if len(splines) > self.user_defined_spline:
+                self.from_spline(
+                    context,
+                    path.matrix_world,
+                    self.user_defined_resolution,
+                    splines[self.user_defined_spline])
+
+    def get_generator(self):
+        g = FenceGenerator(self.parts)
+        for part in self.parts:
+            # type, radius, da, length
+            g.add_part(part)
+
+        g.set_offset(self.x_offset)
+        # param_t(da, part_length)
+        g.param_t(self.angle_limit, self.post_spacing)
+        return g
+
+    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()
+
+        verts = []
+        faces = []
+        matids = []
+        uvs = []
+
+        g = self.get_generator()
+
+        # depth at bottom
+        # self.manipulators[1].set_pts([(0, 0, 0), (0, 0, self.height), (1, 0, 0)])
+
+        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.post:
+            g.make_post(0.5 * self.post_x, 0.5 * self.post_y, self.post_z,
+                    self.post_alt, self.x_offset,
+                    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.subs:
+            g.make_subs(0.5 * self.subs_x, 0.5 * self.subs_y, self.subs_z,
+                    self.post_y, self.subs_alt, self.subs_spacing,
+                    self.x_offset, self.subs_offset_x, int(self.idmat_subs), verts, faces, matids, uvs)
+
+        g.user_defined_post = None
+
+        if self.panel:
+            g.make_panels(0.5 * self.panel_x, self.panel_z, self.post_y,
+                    self.panel_alt, self.panel_dist, self.x_offset, self.panel_offset_x,
+                    int(self.idmat_panel), verts, faces, matids, uvs)
+
+        if self.rail:
+            for i in range(self.rail_n):
+                x = 0.5 * self.rail_x[i]
+                y = self.rail_z[i]
+                rail = [Vector((-x, y)), Vector((-x, 0)), Vector((x, 0)), Vector((x, y))]
+                g.make_profile(rail, int(self.rail_mat[i].index), self.x_offset - self.rail_offset[i],
+                        self.rail_alt[i], 0, 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.handrail:
+            g.make_profile(handrail, int(self.idmat_handrail), self.x_offset - self.handrail_offset,
+                self.handrail_alt, self.handrail_extend, 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
+
+        # restore context
+        self.restore_context(context)
+
+    def manipulable_setup(self, context):
+        """
+            NOTE:
+            this one assume context.active_object is the instance this
+            data belongs to, failing to do so will result in wrong
+            manipulators set on active object
+        """
+        self.manipulable_disable(context)
+
+        o = context.active_object
+
+        self.setup_manipulators()
+
+        for i, part in enumerate(self.parts):
+            if i >= self.n_parts:
+                break
+
+            if i > 0:
+                # start angle
+                self.manip_stack.append(part.manipulators[0].setup(context, o, part))
+
+            # length / radius + angle
+            self.manip_stack.append(part.manipulators[1].setup(context, o, part))
+
+            # snap point
+            self.manip_stack.append(part.manipulators[2].setup(context, o, self))
+
+        for m in self.manipulators:
+            self.manip_stack.append(m.setup(context, o, self))
+
+
+class ARCHIPACK_PT_fence(Panel):
+    bl_idname = "ARCHIPACK_PT_fence"
+    bl_label = "Fence"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = 'ArchiPack'
+
+    @classmethod
+    def poll(cls, context):
+        return archipack_fence.filter(context.active_object)
+
+    def draw(self, context):
+        prop = archipack_fence.datablock(context.active_object)
+        if prop is None:
+            return
+        scene = context.scene
+        layout = self.layout
+        row = layout.row(align=True)
+        row.operator('archipack.fence_manipulate', icon='HAND')
+        box = layout.box()
+        # box.label(text="Styles")
+        row = box.row(align=True)
+        row.operator("archipack.fence_preset_menu", text=bpy.types.ARCHIPACK_OT_fence_preset_menu.bl_label)
+        row.operator("archipack.fence_preset", text="", icon='ZOOMIN')
+        row.operator("archipack.fence_preset", text="", icon='ZOOMOUT').remove_active = True
+        box = layout.box()
+        row = box.row(align=True)
+        row.operator("archipack.fence_curve_update", text="", icon='FILE_REFRESH')
+        row.prop_search(prop, "user_defined_path", scene, "objects", text="", icon='OUTLINER_OB_CURVE')
+        if prop.user_defined_path is not "":
+            box.prop(prop, 'user_defined_spline')
+            box.prop(prop, 'user_defined_resolution')
+        box.prop(prop, 'angle_limit')
+        box.prop(prop, 'x_offset')
+        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)
+            box.prop(prop, 'n_parts')
+            for i, part in enumerate(prop.parts):
+                part.draw(layout, context, i)
+        else:
+            row.prop(prop, 'parts_expand', icon="TRIA_RIGHT", icon_only=True, text="Parts", 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, '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')
+
+        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, 'post')
+        if prop.post_expand:
+            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')
+            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, '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')
+            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, '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, '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_handrail')
+            box.prop(prop, 'idmat_panel')
+            box.prop(prop, 'idmat_post')
+            box.prop(prop, 'idmat_subs')
+        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_fence(ArchipackCreateTool, Operator):
+    bl_idname = "archipack.fence"
+    bl_label = "Fence"
+    bl_description = "Fence"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    def create(self, context):
+        m = bpy.data.meshes.new("Fence")
+        o = bpy.data.objects.new("Fence", m)
+        d = m.archipack_fence.add()
+        # make manipulators selectable
+        d.manipulable_selectable = True
+        context.scene.objects.link(o)
+        o.select = True
+        context.scene.objects.active = o
+        self.load_preset(d)
+        self.add_material(o)
+        return o
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            bpy.ops.object.select_all(action="DESELECT")
+            o = self.create(context)
+            o.location = bpy.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 create object
+# ------------------------------------------------------------------
+
+class ARCHIPACK_OT_fence_curve_update(Operator):
+    bl_idname = "archipack.fence_curve_update"
+    bl_label = "Fence curve update"
+    bl_description = "Update fence data from curve"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    @classmethod
+    def poll(self, context):
+        return archipack_fence.filter(context.active_object)
+
+    def draw(self, context):
+        layout = self.layout
+        row = layout.row()
+        row.label("Use Properties panel (N) to define parms", icon='INFO')
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            d = archipack_fence.datablock(context.active_object)
+            d.update_path(context)
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+class ARCHIPACK_OT_fence_from_curve(ArchipackCreateTool, Operator):
+    bl_idname = "archipack.fence_from_curve"
+    bl_label = "Fence curve"
+    bl_description = "Create a fence from a curve"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    @classmethod
+    def poll(self, context):
+        return context.active_object is not None and context.active_object.type == 'CURVE'
+
+    def draw(self, context):
+        layout = self.layout
+        row = layout.row()
+        row.label("Use Properties panel (N) to define parms", icon='INFO')
+
+    def create(self, context):
+        o = None
+        curve = context.active_object
+        for i, spline in enumerate(curve.data.splines):
+            bpy.ops.archipack.fence('INVOKE_DEFAULT', auto_manipulate=False)
+            o = context.active_object
+            d = archipack_fence.datablock(o)
+            d.auto_update = False
+            d.user_defined_spline = i
+            d.user_defined_path = curve.name
+            d.auto_update = True
+        return o
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            bpy.ops.object.select_all(action="DESELECT")
+            o = self.create(context)
+            if o is not None:
+                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_fence_manipulate(Operator):
+    bl_idname = "archipack.fence_manipulate"
+    bl_label = "Manipulate"
+    bl_description = "Manipulate"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    @classmethod
+    def poll(self, context):
+        return archipack_fence.filter(context.active_object)
+
+    def invoke(self, context, event):
+        d = archipack_fence.datablock(context.active_object)
+        d.manipulable_invoke(context)
+        return {'FINISHED'}
+
+
+# ------------------------------------------------------------------
+# Define operator class to load / save presets
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_fence_preset_menu(PresetMenuOperator, Operator):
+    bl_idname = "archipack.fence_preset_menu"
+    bl_label = "Fence Styles"
+    preset_subdir = "archipack_fence"
+
+
+class ARCHIPACK_OT_fence_preset(ArchipackPreset, Operator):
+    """Add a Fence Preset"""
+    bl_idname = "archipack.fence_preset"
+    bl_label = "Add Fence Style"
+    preset_menu = "ARCHIPACK_OT_fence_preset_menu"
+
+    @property
+    def blacklist(self):
+        return ['manipulators', 'n_parts', 'parts', 'user_defined_path', 'user_defined_spline']
+
+
+def register():
+    bpy.utils.register_class(archipack_fence_material)
+    bpy.utils.register_class(archipack_fence_part)
+    bpy.utils.register_class(archipack_fence)
+    Mesh.archipack_fence = CollectionProperty(type=archipack_fence)
+    bpy.utils.register_class(ARCHIPACK_OT_fence_preset_menu)
+    bpy.utils.register_class(ARCHIPACK_PT_fence)
+    bpy.utils.register_class(ARCHIPACK_OT_fence)
+    bpy.utils.register_class(ARCHIPACK_OT_fence_preset)
+    bpy.utils.register_class(ARCHIPACK_OT_fence_manipulate)
+    bpy.utils.register_class(ARCHIPACK_OT_fence_from_curve)
+    bpy.utils.register_class(ARCHIPACK_OT_fence_curve_update)
+
+
+def unregister():
+    bpy.utils.unregister_class(archipack_fence_material)
+    bpy.utils.unregister_class(archipack_fence_part)
+    bpy.utils.unregister_class(archipack_fence)
+    del Mesh.archipack_fence
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence_preset_menu)
+    bpy.utils.unregister_class(ARCHIPACK_PT_fence)
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence)
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence_preset)
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence_manipulate)
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence_from_curve)
+    bpy.utils.unregister_class(ARCHIPACK_OT_fence_curve_update)