archipack: T52120 release to official

1 files changed, 2098 insertions, 0 deletions

diff --git a/archipack/archipack_window.py b/archipack/archipack_window.py
new file mode 100644
index 00000000..2be55947
--- /dev/null
+++ b/archipack/archipack_window.py
@@ -0,0 +1,2098 @@
+# -*- 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, IntProperty, BoolProperty, BoolVectorProperty,
+    CollectionProperty, FloatVectorProperty, EnumProperty, StringProperty
+)
+from mathutils import Vector
+from math import tan, sqrt
+from .bmesh_utils import BmeshEdit as bmed
+from .panel import Panel as WindowPanel
+from .materialutils import MaterialUtils
+from .archipack_handle import create_handle, window_handle_vertical_01, window_handle_vertical_02
+# from .archipack_door_panel import ARCHIPACK_OT_select_parent
+from .archipack_manipulator import Manipulable
+from .archipack_preset import ArchipackPreset, PresetMenuOperator
+from .archipack_gl import FeedbackPanel
+from .archipack_object import ArchipackObject, ArchipackCreateTool, ArchpackDrawTool
+from .archipack_keymaps import Keymaps
+
+
+def update(self, context):
+    self.update(context)
+
+
+def update_childs(self, context):
+    self.update(context, childs_only=True)
+
+
+def set_cols(self, value):
+    if self.n_cols != value:
+        self.auto_update = False
+        self._set_width(value)
+        self.auto_update = True
+        self.n_cols = value
+    return None
+
+
+def get_cols(self):
+    return self.n_cols
+
+
+class archipack_window_panelrow(PropertyGroup):
+    width = FloatVectorProperty(
+            name="width",
+            min=0.5,
+            max=100.0,
+            default=[
+                50, 50, 50, 50, 50, 50, 50, 50,
+                50, 50, 50, 50, 50, 50, 50, 50,
+                50, 50, 50, 50, 50, 50, 50, 50,
+                50, 50, 50, 50, 50, 50, 50
+            ],
+            size=31,
+            update=update
+            )
+    fixed = BoolVectorProperty(
+            name="Fixed",
+            default=[
+                False, False, False, False, False, False, False, False,
+                False, False, False, False, False, False, False, False,
+                False, False, False, False, False, False, False, False,
+                False, False, False, False, False, False, False, False
+            ],
+            size=32,
+            update=update
+            )
+    cols = IntProperty(
+            name="panels",
+            description="number of panels getter and setter, to avoid infinite recursion",
+            min=1,
+            max=32,
+            default=2,
+            get=get_cols, set=set_cols
+            )
+    n_cols = IntProperty(
+            name="panels",
+            description="store number of panels, internal use only to avoid infinite recursion",
+            min=1,
+            max=32,
+            default=2,
+            update=update
+            )
+    height = FloatProperty(
+            name="Height",
+            min=0.1,
+            default=1.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            update=update
+            )
+    auto_update = BoolProperty(
+            options={'SKIP_SAVE'},
+            name="auto_update",
+            description="disable auto update to avoid infinite recursion",
+            default=True
+            )
+
+    def get_row(self, x, y):
+        size = [Vector((x * self.width[w] / 100, y, 0)) for w in range(self.cols - 1)]
+        sum_x = sum([s.x for s in size])
+        size.append(Vector((x - sum_x, y, 0)))
+        origin = []
+        pivot = []
+        ttl = 0
+        xh = x / 2
+        n_center = len(size) / 2
+        for i, sx in enumerate(size):
+            ttl += sx.x
+            if i < n_center:
+                # pivot left
+                origin.append(Vector((ttl - xh - sx.x, 0)))
+                pivot.append(1)
+            else:
+                # pivot right
+                origin.append(Vector((ttl - xh, 0)))
+                pivot.append(-1)
+        return size, origin, pivot
+
+    def _set_width(self, cols):
+        width = 100 / cols
+        for i in range(cols - 1):
+            self.width[i] = width
+
+    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_window.datablock(o)
+            if props:
+                for row in props.rows:
+                    if row == self:
+                        return props
+        return None
+
+    def update(self, context):
+        if self.auto_update:
+            props = self.find_datablock_in_selection(context)
+            if props is not None:
+                props.update(context, childs_only=False)
+
+    def draw(self, layout, context, last_row):
+        # store parent at runtime to trigger update on parent
+        row = layout.row()
+        row.prop(self, "cols")
+        row = layout.row()
+        if not last_row:
+            row.prop(self, "height")
+        for i in range(self.cols - 1):
+            row = layout.row()
+            row.prop(self, "width", text="col " + str(i + 1), index=i)
+            row.prop(self, "fixed", text="fixed", index=i)
+        row = layout.row()
+        row.label(text="col " + str(self.cols))
+        row.prop(self, "fixed", text="fixed", index=(self.cols - 1))
+
+
+class archipack_window_panel(ArchipackObject, PropertyGroup):
+    center = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    origin = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    size = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    radius = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    angle_y = FloatProperty(
+            name='angle',
+            unit='ROTATION',
+            subtype='ANGLE',
+            min=-1.5, max=1.5,
+            default=0, precision=2,
+            description='angle'
+            )
+    frame_y = FloatProperty(
+            name='Depth',
+            min=0,
+            default=0.06, precision=2,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame depth'
+            )
+    frame_x = FloatProperty(
+            name='Width',
+            min=0,
+            default=0.06, precision=2,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame width'
+            )
+    curve_steps = IntProperty(
+            name="curve steps",
+            min=1,
+            max=128,
+            default=1
+            )
+    shape = EnumProperty(
+            name='Shape',
+            items=(
+                ('RECTANGLE', 'Rectangle', '', 0),
+                ('ROUND', 'Top Round', '', 1),
+                ('ELLIPSIS', 'Top elliptic', '', 2),
+                ('QUADRI', 'Top oblique', '', 3),
+                ('CIRCLE', 'Full circle', '', 4)
+                ),
+            default='RECTANGLE'
+            )
+    pivot = FloatProperty(
+            name='pivot',
+            min=-1, max=1,
+            default=-1, precision=2,
+            description='pivot'
+            )
+    side_material = IntProperty(
+            name="side material",
+            min=0,
+            max=2,
+            default=0
+            )
+    handle = EnumProperty(
+            name='Shape',
+            items=(
+                ('NONE', 'No handle', '', 0),
+                ('INSIDE', 'Inside', '', 1),
+                ('BOTH', 'Inside and outside', '', 2)
+                ),
+            default='NONE'
+            )
+    handle_model = IntProperty(
+            name="handle model",
+            default=1,
+            min=1,
+            max=2
+            )
+    handle_altitude = FloatProperty(
+            name='handle altitude',
+            min=0,
+            default=0.2, precision=2,
+            unit='LENGTH', subtype='DISTANCE',
+            description='handle altitude'
+            )
+    fixed = BoolProperty(
+            name="Fixed",
+            default=False
+            )
+
+    @property
+    def window(self):
+        verre = 0.005
+        chanfer = 0.004
+        x0 = 0
+        x1 = self.frame_x
+        x2 = 0.75 * self.frame_x
+        x3 = chanfer
+        y0 = -self.frame_y
+        y1 = 0
+        y2 = -0.5 * self.frame_y
+        y3 = -chanfer
+        y4 = chanfer - self.frame_y
+
+        if self.fixed:
+            # profil carre avec support pour verre
+            # p ______       y1
+            # / |      y3
+            # |       |___
+            # x       |___   y2  verre
+            # |       |      y4
+            #  \______|      y0
+            # x0 x3   x1
+            #
+            x1 = 0.5 * self.frame_x
+            y1 = -0.45 * self.frame_y
+            y3 = y1 - chanfer
+            y4 = chanfer + y0
+            y2 = (y0 + y2) / 2
+            return WindowPanel(
+                True,  # closed
+                [1, 0, 0, 0, 1, 2, 2, 2, 2],  # x index
+                [x0, x3, x1],
+                [y0, y4, y2, y3, y1, y1, y2 + verre, y2 - verre, y0],
+                [0, 0, 1, 1, 1, 1, 0, 0, 0],  # materials
+                side_cap_front=6,
+                side_cap_back=7      # cap index
+                )
+        else:
+            # profil avec chanfrein et joint et support pour verre
+            # p ____         y1    inside
+            # / |_       y3
+            # |       |___
+            # x       |___   y2  verre
+            # |      _|      y4
+            #  \____|        y0
+            # x0 x3 x2 x1          outside
+            if self.side_material == 0:
+                materials = [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
+            elif self.side_material == 1:
+                # rail window exterior
+                materials = [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
+            else:
+                # rail window interior
+                materials = [0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
+            return WindowPanel(
+                True,            # closed shape
+                [1, 0, 0, 0, 1, 2, 2, 3, 3, 3, 3, 2, 2],     # x index
+                [x0, x3, x2, x1],     # unique x positions
+                [y0, y4, y2, y3, y1, y1, y3, y3, y2 + verre, y2 - verre, y4, y4, y0],
+                materials,     # materials
+                side_cap_front=8,
+                side_cap_back=9                  # cap index
+                )
+
+    @property
+    def verts(self):
+        offset = Vector((0, 0, 0))
+        return self.window.vertices(self.curve_steps, offset, self.center, self.origin, self.size,
+            self.radius, self.angle_y, self.pivot, shape_z=None, path_type=self.shape)
+
+    @property
+    def faces(self):
+        return self.window.faces(self.curve_steps, path_type=self.shape)
+
+    @property
+    def matids(self):
+        return self.window.mat(self.curve_steps, 2, 2, path_type=self.shape)
+
+    @property
+    def uvs(self):
+        return self.window.uv(self.curve_steps, self.center, self.origin, self.size,
+            self.radius, self.angle_y, self.pivot, 0, self.frame_x, path_type=self.shape)
+
+    def find_handle(self, o):
+        for child in o.children:
+            if 'archipack_handle' in child:
+                return child
+        return None
+
+    def update_handle(self, context, o):
+        handle = self.find_handle(o)
+        if handle is None:
+            m = bpy.data.meshes.new("Handle")
+            handle = create_handle(context, o, m)
+            MaterialUtils.add_handle_materials(handle)
+        if self.handle_model == 1:
+            verts, faces = window_handle_vertical_01(1)
+        else:
+            verts, faces = window_handle_vertical_02(1)
+        handle.location = (self.pivot * (self.size.x - 0.4 * self.frame_x), 0, self.handle_altitude)
+        bmed.buildmesh(context, handle, verts, faces)
+
+    def remove_handle(self, context, o):
+        handle = self.find_handle(o)
+        if handle is not None:
+            context.scene.objects.unlink(handle)
+            bpy.data.objects.remove(handle, do_unlink=True)
+
+    def update(self, context):
+
+        o = self.find_in_selection(context)
+
+        if o is None:
+            return
+
+        # update handle, dosent care of instances as window will do
+        if self.handle == 'NONE':
+            self.remove_handle(context, o)
+        else:
+            self.update_handle(context, o)
+
+        bmed.buildmesh(context, o, self.verts, self.faces, self.matids, self.uvs)
+
+        self.restore_context(context)
+
+
+class archipack_window(ArchipackObject, Manipulable, PropertyGroup):
+    x = FloatProperty(
+            name='width',
+            min=0.25,
+            default=100.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='Width', update=update
+            )
+    y = FloatProperty(
+            name='depth',
+            min=0.1,
+            default=0.20, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='Depth', update=update,
+            )
+    z = FloatProperty(
+            name='height',
+            min=0.1,
+            default=1.2, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='height', update=update,
+            )
+    angle_y = FloatProperty(
+            name='angle',
+            unit='ROTATION',
+            subtype='ANGLE',
+            min=-1.5, max=1.5,
+            default=0, precision=2,
+            description='angle', update=update,
+            )
+    radius = FloatProperty(
+            name='radius',
+            min=0.1,
+            default=2.5, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='radius', update=update,
+            )
+    elipsis_b = FloatProperty(
+            name='ellipsis',
+            min=0.1,
+            default=0.5, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='ellipsis vertical size', update=update,
+            )
+    altitude = FloatProperty(
+            name='altitude',
+            default=1.0, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='altitude', update=update,
+            )
+    offset = FloatProperty(
+            name='offset',
+            default=0.1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='offset', update=update,
+            )
+    frame_y = FloatProperty(
+            name='Depth',
+            min=0,
+            default=0.06, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame depth', update=update,
+            )
+    frame_x = FloatProperty(
+            name='Width',
+            min=0,
+            default=0.06, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame width', update=update,
+            )
+    out_frame = BoolProperty(
+            name="Out frame",
+            default=False, update=update,
+            )
+    out_frame_y = FloatProperty(
+            name='Side depth',
+            min=0.001,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame side depth', update=update,
+            )
+    out_frame_y2 = FloatProperty(
+            name='Front depth',
+            min=0.001,
+            default=0.02, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame front depth', update=update,
+            )
+    out_frame_x = FloatProperty(
+            name='Front Width',
+            min=0.0,
+            default=0.1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame width set to 0 disable front frame', update=update,
+            )
+    out_frame_offset = FloatProperty(
+            name='offset',
+            min=0.0,
+            default=0.0, precision=3, step=0.1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='frame offset', update=update,
+            )
+    out_tablet_enable = BoolProperty(
+            name="Out tablet",
+            default=True, update=update,
+            )
+    out_tablet_x = FloatProperty(
+            name='Width',
+            min=0.0,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet width', update=update,
+            )
+    out_tablet_y = FloatProperty(
+            name='Depth',
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet depth', update=update,
+            )
+    out_tablet_z = FloatProperty(
+            name='Height',
+            min=0.001,
+            default=0.03, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet height', update=update,
+            )
+    in_tablet_enable = BoolProperty(
+            name="In tablet",
+            default=True, update=update,
+            )
+    in_tablet_x = FloatProperty(
+            name='Width',
+            min=0.0,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet width', update=update,
+            )
+    in_tablet_y = FloatProperty(
+            name='Depth',
+            min=0.001,
+            default=0.04, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet depth', update=update,
+            )
+    in_tablet_z = FloatProperty(
+            name='Height',
+            min=0.001,
+            default=0.03, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='tablet height', update=update,
+            )
+    blind_enable = BoolProperty(
+            name="Blind",
+            default=False, update=update,
+            )
+    blind_y = FloatProperty(
+            name='Depth',
+            min=0.001,
+            default=0.002, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='Store depth', update=update,
+            )
+    blind_z = FloatProperty(
+            name='Height',
+            min=0.001,
+            default=0.03, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='Store height', update=update,
+            )
+    blind_open = FloatProperty(
+            name='Open',
+            min=0.0, max=100,
+            default=80, precision=1,
+            subtype='PERCENTAGE',
+            description='Store open', update=update,
+            )
+    rows = CollectionProperty(type=archipack_window_panelrow)
+    n_rows = IntProperty(
+            name="number of rows",
+            min=1,
+            max=32,
+            default=1, update=update,
+            )
+    curve_steps = IntProperty(
+            name="curve steps",
+            min=6,
+            max=128,
+            default=16, update=update,
+            )
+    hole_outside_mat = IntProperty(
+            name="Outside",
+            min=0,
+            max=128,
+            default=0, update=update,
+            )
+    hole_inside_mat = IntProperty(
+            name="Inside",
+            min=0,
+            max=128,
+            default=1, update=update,
+            )
+    window_shape = EnumProperty(
+            name='Shape',
+            items=(
+                ('RECTANGLE', 'Rectangle', '', 0),
+                ('ROUND', 'Top Round', '', 1),
+                ('ELLIPSIS', 'Top elliptic', '', 2),
+                ('QUADRI', 'Top oblique', '', 3),
+                ('CIRCLE', 'Full circle', '', 4)
+                ),
+            default='RECTANGLE', update=update,
+            )
+    window_type = EnumProperty(
+            name='Type',
+            items=(
+                ('FLAT', 'Flat window', '', 0),
+                ('RAIL', 'Rail window', '', 1)
+                ),
+            default='FLAT', update=update,
+            )
+    warning = BoolProperty(
+            name="warning",
+            default=False
+            )
+    handle_enable = BoolProperty(
+            name='handle',
+            default=True, update=update_childs,
+            )
+    handle_altitude = FloatProperty(
+            name="altitude",
+            min=0,
+            default=1.4, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='handle altitude', update=update_childs,
+            )
+    hole_margin = FloatProperty(
+            name='hole margin',
+            min=0.0,
+            default=0.1, precision=2, step=1,
+            unit='LENGTH', subtype='DISTANCE',
+            description='how much hole surround wall'
+            )
+    flip = BoolProperty(
+            default=False,
+            update=update,
+            description='flip outside and outside material of hole'
+            )
+    # layout related
+    display_detail = BoolProperty(
+            options={'SKIP_SAVE'},
+            default=False
+            )
+    display_panels = BoolProperty(
+            options={'SKIP_SAVE'},
+            default=True
+            )
+    display_materials = BoolProperty(
+            options={'SKIP_SAVE'},
+            default=True
+            )
+
+    auto_update = BoolProperty(
+            options={'SKIP_SAVE'},
+            default=True,
+            update=update
+            )
+
+    @property
+    def shape(self):
+        if self.window_type == 'RAIL':
+            return 'RECTANGLE'
+        else:
+            return self.window_shape
+
+    @property
+    def window(self):
+        # Flat window frame profil
+        #  ___        y1
+        # |   |__
+        # |      |    y2
+        # |______|    y0
+        #
+        x0 = 0
+        x1 = -x0 - self.frame_x
+        x2 = x0 + 0.5 * self.frame_x
+        y0 = 0.5 * self.y - self.offset
+        y2 = y0 + 0.5 * self.frame_y
+
+        if self.window_type == 'FLAT':
+            y1 = y0 + self.frame_y
+            return WindowPanel(
+                True,     # closed
+                [0, 0, 1, 1, 2, 2],     # x index
+                [x1, x0, x2],
+                [y0, y1, y1, y2, y2, y0],
+                [1, 1, 1, 1, 0, 0]  # material index
+                )
+        else:
+            # Rail window frame profil
+            #  ________       y1
+            # |      __|      y5
+            # |     |__       y4
+            # |      __|      y3
+            # |     |____
+            # |          |    y2
+            # |__________|    y0
+            # -x1   0 x3 x2
+            x2 = x0 + 0.35 * self.frame_y
+            x3 = x0 + 0.2 * self.frame_x
+            y1 = y0 + 2.55 * self.frame_y
+            y3 = y0 + 1.45 * self.frame_y
+            y4 = y0 + 1.55 * self.frame_y
+            y5 = y0 + 2.45 * self.frame_y
+
+            return WindowPanel(
+                True,     # closed
+                [0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 3, 3],     # x index
+                [x1, x0, x3, x2],
+                [y0, y1, y1, y5, y5, y4, y4, y3, y3, y2, y2, y0],
+                [1, 1, 1, 3, 1, 3, 3, 3, 0, 3, 0, 0]  # material index
+                )
+
+    @property
+    def hole(self):
+        # profil percement                          ____
+        #   _____  y_inside          vertical ___|      x1
+        #  |
+        #  |__     y0                outside   ___
+        #     |___ y_outside                       |____ x1-shape_z     inside
+        # -x1 x0
+        y0 = 0.5 * self.y - self.offset
+        x1 = self.frame_x     # sur-largeur percement interieur
+        y_inside = 0.5 * self.y + self.hole_margin     # outside wall
+
+        if self.out_frame is False:
+            x0 = 0
+        else:
+            x0 = -min(self.frame_x - 0.001, self.out_frame_y + self.out_frame_offset)
+
+        outside_mat = self.hole_outside_mat
+        inside_mat = self.hole_inside_mat
+        # if self.flip:
+        #    outside_mat, inside_mat = inside_mat, outside_mat
+
+        y_outside = -y_inside           # inside wall
+
+        return WindowPanel(
+            False,     # closed
+            [1, 1, 0, 0],     # x index
+            [-x1, x0],
+            [y_outside, y0, y0, y_inside],
+            [outside_mat, outside_mat, inside_mat],     # material index
+            side_cap_front=3,     # cap index
+            side_cap_back=0
+            )
+
+    @property
+    def frame(self):
+        # profil cadre
+        #     ___     y0
+        #  __|   |
+        # |      |    y2
+        # |______|    y1
+        # x1 x2  x0
+        y2 = -0.5 * self.y
+        y0 = 0.5 * self.y - self.offset
+        y1 = y2 - self.out_frame_y2
+        x0 = 0   # -min(self.frame_x - 0.001, self.out_frame_offset)
+        x1 = x0 - self.out_frame_x
+        x2 = x0 - self.out_frame_y
+        # y = depth
+        # x = width
+        if self.out_frame_x <= self.out_frame_y:
+            if self.out_frame_x == 0:
+                pts_y = [y2, y0, y0, y2]
+            else:
+                pts_y = [y1, y0, y0, y1]
+            return WindowPanel(
+                True,     # closed profil
+                [0, 0, 1, 1],     # x index
+                [x2, x0],
+                pts_y,
+                [0, 0, 0, 0],     # material index
+                closed_path=bool(self.shape == 'CIRCLE')  # closed path
+                )
+        else:
+            return WindowPanel(
+                True,     # closed profil
+                [0, 0, 1, 1, 2, 2],     # x index
+                [x1, x2, x0],
+                [y1, y2, y2, y0, y0, y1],
+                [0, 0, 0, 0, 0, 0],     # material index
+                closed_path=bool(self.shape == 'CIRCLE')   # closed path
+                )
+
+    @property
+    def out_tablet(self):
+        # profil tablette
+        #  __  y0
+        # |  | y2
+        # | / y3
+        # |_| y1
+        # x0 x2 x1
+        y0 = 0.001 + 0.5 * self.y - self.offset
+        y1 = -0.5 * self.y - self.out_tablet_y
+        y2 = y0 - 0.01
+        y3 = y2 - 0.04
+        x2 = 0
+        x0 = x2 - self.out_tablet_z
+        x1 = 0.3 * self.frame_x
+        # y = depth
+        # x = width1
+        return WindowPanel(
+            True,     # closed profil
+            [1, 1, 2, 2, 0, 0],     # x index
+            [x0, x2, x1],
+            [y1, y3, y2, y0, y0, y1],
+            [4, 3, 3, 4, 4, 4],     # material index
+            closed_path=False           # closed path
+            )
+
+    @property
+    def in_tablet(self):
+        # profil tablette
+        #  __  y0
+        # |  |
+        # |  |
+        # |__| y1
+        # x0  x1
+        y0 = 0.5 * self.y + self.frame_y - self.offset
+        y1 = 0.5 * self.y + self.in_tablet_y
+        if self.window_type == 'RAIL':
+            y0 += 1.55 * self.frame_y
+            y1 += 1.55 * self.frame_y
+        x0 = -self.frame_x
+        x1 = min(x0 + self.in_tablet_z, x0 + self.frame_x - 0.001)
+        # y = depth
+        # x = width1
+        return WindowPanel(
+            True,     # closed profil
+            [0, 0, 1, 1],     # x index
+            [x0, x1],
+            [y1, y0, y0, y1],
+            [1, 1, 1, 1],     # material index
+            closed_path=False           # closed path
+            )
+
+    @property
+    def blind(self):
+        # profil blind
+        #  y0
+        #  | / | / | /
+        #  y1
+        # xn x1 x0
+        dx = self.z / self.blind_z
+        nx = int(self.z / dx)
+        y0 = -0.5 * self.offset
+        # -0.5 * self.y + 0.5 * (0.5 * self.y - self.offset)
+        # 0.5 * (-0.5 * self.y-0.5 * self.offset)
+        y1 = y0 + self.blind_y
+        nx = int(self.z / self.blind_z)
+        dx = self.z / nx
+        open = 1.0 - self.blind_open / 100
+        return WindowPanel(
+            False,                      # profil closed
+            [int((i + (i % 2)) / 2) for i in range(2 * nx)],     # x index
+            [self.z - (dx * i * open) for i in range(nx + 1)],     # x
+            [[y1, y0][i % 2] for i in range(2 * nx)],     #
+            [5 for i in range(2 * nx - 1)],     # material index
+            closed_path=False                           #
+            )
+
+    @property
+    def verts(self):
+        center, origin, size, radius = self.get_radius()
+        is_not_circle = self.shape != 'CIRCLE'
+        offset = Vector((0, self.altitude, 0))
+        verts = self.window.vertices(self.curve_steps, offset, center, origin,
+            size, radius, self.angle_y, 0, shape_z=None, path_type=self.shape)
+        if self.out_frame:
+            verts += self.frame.vertices(self.curve_steps, offset, center, origin,
+                size, radius, self.angle_y, 0, shape_z=None, path_type=self.shape)
+        if is_not_circle and self.out_tablet_enable:
+            verts += self.out_tablet.vertices(self.curve_steps, offset, center, origin,
+                Vector((size.x + 2 * self.out_tablet_x, size.y, size.z)),
+                radius, self.angle_y, 0, shape_z=None, path_type='HORIZONTAL')
+        if is_not_circle and self.in_tablet_enable:
+            verts += self.in_tablet.vertices(self.curve_steps, offset, center, origin,
+                Vector((size.x + 2 * (self.frame_x + self.in_tablet_x), size.y, size.z)),
+                radius, self.angle_y, 0, shape_z=None, path_type='HORIZONTAL')
+        if is_not_circle and self.blind_enable:
+            verts += self.blind.vertices(self.curve_steps, offset, center, origin,
+                Vector((-size.x, 0, 0)), radius, 0, 0, shape_z=None, path_type='HORIZONTAL')
+        return verts
+
+    @property
+    def faces(self):
+        window = self.window
+        faces = window.faces(self.curve_steps, path_type=self.shape)
+        verts_offset = window.n_verts(self.curve_steps, path_type=self.shape)
+        is_not_circle = self.shape != 'CIRCLE'
+        if self.out_frame:
+            frame = self.frame
+            faces += frame.faces(self.curve_steps, path_type=self.shape, offset=verts_offset)
+            verts_offset += frame.n_verts(self.curve_steps, path_type=self.shape)
+        if is_not_circle and self.out_tablet_enable:
+            tablet = self.out_tablet
+            faces += tablet.faces(self.curve_steps, path_type='HORIZONTAL', offset=verts_offset)
+            verts_offset += tablet.n_verts(self.curve_steps, path_type='HORIZONTAL')
+        if is_not_circle and self.in_tablet_enable:
+            tablet = self.in_tablet
+            faces += tablet.faces(self.curve_steps, path_type='HORIZONTAL', offset=verts_offset)
+            verts_offset += tablet.n_verts(self.curve_steps, path_type='HORIZONTAL')
+        if is_not_circle and self.blind_enable:
+            blind = self.blind
+            faces += blind.faces(self.curve_steps, path_type='HORIZONTAL', offset=verts_offset)
+            verts_offset += blind.n_verts(self.curve_steps, path_type='HORIZONTAL')
+
+        return faces
+
+    @property
+    def matids(self):
+        mat = self.window.mat(self.curve_steps, 2, 2, path_type=self.shape)
+        is_not_circle = self.shape != 'CIRCLE'
+        if self.out_frame:
+            mat += self.frame.mat(self.curve_steps, 0, 0, path_type=self.shape)
+        if is_not_circle and self.out_tablet_enable:
+            mat += self.out_tablet.mat(self.curve_steps, 0, 0, path_type='HORIZONTAL')
+        if is_not_circle and self.in_tablet_enable:
+            mat += self.in_tablet.mat(self.curve_steps, 0, 0, path_type='HORIZONTAL')
+        if is_not_circle and self.blind_enable:
+            mat += self.blind.mat(self.curve_steps, 0, 0, path_type='HORIZONTAL')
+        return mat
+
+    @property
+    def uvs(self):
+        center, origin, size, radius = self.get_radius()
+        uvs = self.window.uv(self.curve_steps, center, origin, size, radius,
+            self.angle_y, 0, 0, self.frame_x, path_type=self.shape)
+        is_not_circle = self.shape != 'CIRCLE'
+        if self.out_frame:
+            uvs += self.frame.uv(self.curve_steps, center, origin, size, radius,
+                self.angle_y, 0, 0, self.frame_x, path_type=self.shape)
+        if is_not_circle and self.out_tablet_enable:
+            uvs += self.out_tablet.uv(self.curve_steps, center, origin, size, radius,
+                self.angle_y, 0, 0, self.frame_x, path_type='HORIZONTAL')
+        if is_not_circle and self.in_tablet_enable:
+            uvs += self.in_tablet.uv(self.curve_steps, center, origin, size, radius,
+                self.angle_y, 0, 0, self.frame_x, path_type='HORIZONTAL')
+        if is_not_circle and self.blind_enable:
+            uvs += self.blind.uv(self.curve_steps, center, origin, size, radius,
+                self.angle_y, 0, 0, self.frame_x, path_type='HORIZONTAL')
+        return uvs
+
+    def setup_manipulators(self):
+        if len(self.manipulators) == 4:
+            return
+        s = self.manipulators.add()
+        s.prop1_name = "x"
+        s.prop2_name = "x"
+        s.type_key = "SNAP_SIZE_LOC"
+        s = self.manipulators.add()
+        s.prop1_name = "y"
+        s.prop2_name = "y"
+        s.type_key = "SNAP_SIZE_LOC"
+        s = self.manipulators.add()
+        s.prop1_name = "z"
+        s.normal = Vector((0, 1, 0))
+        s = self.manipulators.add()
+        s.prop1_name = "altitude"
+        s.normal = Vector((0, 1, 0))
+
+    def remove_childs(self, context, o, to_remove):
+        for child in o.children:
+            if to_remove < 1:
+                return
+            if archipack_window_panel.filter(child):
+                to_remove -= 1
+                self.remove_handle(context, child)
+                context.scene.objects.unlink(child)
+                bpy.data.objects.remove(child, do_unlink=True)
+
+    def remove_handle(self, context, o):
+        handle = self.find_handle(o)
+        if handle is not None:
+            context.scene.objects.unlink(handle)
+            bpy.data.objects.remove(handle, do_unlink=True)
+
+    def update_rows(self, context, o):
+        # remove rows
+        for i in range(len(self.rows), self.n_rows, -1):
+            self.rows.remove(i - 1)
+
+        # add rows
+        for i in range(len(self.rows), self.n_rows):
+            self.rows.add()
+
+        # wanted childs
+        if self.shape == 'CIRCLE':
+            w_childs = 1
+        elif self.window_type == 'RAIL':
+            w_childs = self.rows[0].cols
+        else:
+            w_childs = sum([row.cols for row in self.rows])
+
+        # real childs
+        childs = self.get_childs_panels(context, o)
+        n_childs = len(childs)
+
+        # remove child
+        if n_childs > w_childs:
+            self.remove_childs(context, o, n_childs - w_childs)
+
+    def get_childs_panels(self, context, o):
+        return [child for child in o.children if archipack_window_panel.filter(child)]
+
+    def adjust_size_and_origin(self, size, origin, pivot, materials):
+        if len(size) > 1:
+            size[0].x += 0.5 * self.frame_x
+            size[-1].x += 0.5 * self.frame_x
+        for i in range(1, len(size) - 1):
+            size[i].x += 0.5 * self.frame_x
+            origin[i].x += -0.25 * self.frame_x * pivot[i]
+        for i, o in enumerate(origin):
+            o.y = (1 - (i % 2)) * self.frame_y
+        for i, o in enumerate(origin):
+            materials[i] = (1 - (i % 2)) + 1
+
+    def find_handle(self, o):
+        for handle in o.children:
+            if 'archipack_handle' in handle:
+                return handle
+        return None
+
+    def _synch_childs(self, context, o, linked, childs):
+        """
+            sub synch childs nodes of linked object
+        """
+        # remove childs not found on source
+        l_childs = self.get_childs_panels(context, linked)
+        c_names = [c.data.name for c in childs]
+        for c in l_childs:
+            try:
+                id = c_names.index(c.data.name)
+            except:
+                self.remove_handle(context, c)
+                context.scene.objects.unlink(c)
+                bpy.data.objects.remove(c, do_unlink=True)
+
+        # children ordering may not be the same, so get the right l_childs order
+        l_childs = self.get_childs_panels(context, linked)
+        l_names = [c.data.name for c in l_childs]
+        order = []
+        for c in childs:
+            try:
+                id = l_names.index(c.data.name)
+            except:
+                id = -1
+            order.append(id)
+
+        # add missing childs and update other ones
+        for i, child in enumerate(childs):
+            if order[i] < 0:
+                p = bpy.data.objects.new("Panel", child.data)
+                context.scene.objects.link(p)
+                p.lock_location[0] = True
+                p.lock_location[1] = True
+                p.lock_location[2] = True
+                p.lock_rotation[1] = True
+                p.lock_scale[0] = True
+                p.lock_scale[1] = True
+                p.lock_scale[2] = True
+                p.parent = linked
+                p.matrix_world = linked.matrix_world.copy()
+
+            else:
+                p = l_childs[order[i]]
+
+            # update handle
+            handle = self.find_handle(child)
+            h = self.find_handle(p)
+            if handle is not None:
+                if h is None:
+                    h = create_handle(context, p, handle.data)
+                    MaterialUtils.add_handle_materials(h)
+                h.location = handle.location.copy()
+            elif h is not None:
+                context.scene.objects.unlink(h)
+                bpy.data.objects.remove(h, do_unlink=True)
+
+            p.location = child.location.copy()
+
+    def _synch_hole(self, context, linked, hole):
+        l_hole = self.find_hole(linked)
+        if l_hole is None:
+            l_hole = bpy.data.objects.new("hole", hole.data)
+            l_hole['archipack_hole'] = True
+            context.scene.objects.link(l_hole)
+            l_hole.parent = linked
+            l_hole.matrix_world = linked.matrix_world.copy()
+            l_hole.location = hole.location.copy()
+        else:
+            l_hole.data = hole.data
+
+    def synch_childs(self, context, o):
+        """
+            synch childs nodes of linked objects
+        """
+        bpy.ops.object.select_all(action='DESELECT')
+        o.select = True
+        context.scene.objects.active = o
+        childs = self.get_childs_panels(context, o)
+        hole = self.find_hole(o)
+        bpy.ops.object.select_linked(type='OBDATA')
+        for linked in context.selected_objects:
+            if linked != o:
+                self._synch_childs(context, o, linked, childs)
+                if hole is not None:
+                    self._synch_hole(context, linked, hole)
+
+    def update_childs(self, context, o):
+        """
+            pass params to childrens
+        """
+        self.update_rows(context, o)
+        childs = self.get_childs_panels(context, o)
+        n_childs = len(childs)
+        child_n = 0
+        row_n = 0
+        location_y = 0.5 * self.y - self.offset + 0.5 * self.frame_y
+        center, origin, size, radius = self.get_radius()
+        offset = Vector((0, 0))
+        handle = 'NONE'
+        if self.shape != 'CIRCLE':
+            if self.handle_enable:
+                if self.z > 1.8:
+                    handle = 'BOTH'
+                else:
+                    handle = 'INSIDE'
+            is_circle = False
+        else:
+            is_circle = True
+
+        if self.window_type == 'RAIL':
+            handle_model = 2
+        else:
+            handle_model = 1
+
+        for row in self.rows:
+            row_n += 1
+            if row_n < self.n_rows and not is_circle and self.window_type != 'RAIL':
+                z = row.height
+                shape = 'RECTANGLE'
+            else:
+                z = max(2 * self.frame_x + 0.001, self.z - offset.y)
+                shape = self.shape
+
+            self.warning = bool(z > self.z - offset.y)
+            if self.warning:
+                break
+            size, origin, pivot = row.get_row(self.x, z)
+            # side materials
+            materials = [0 for i in range(row.cols)]
+
+            handle_altitude = min(
+                max(4 * self.frame_x, self.handle_altitude - offset.y - self.altitude),
+                z - 4 * self.frame_x
+                )
+
+            if self.window_type == 'RAIL':
+                self.adjust_size_and_origin(size, origin, pivot, materials)
+
+            for panel in range(row.cols):
+                child_n += 1
+
+                if row.fixed[panel]:
+                    enable_handle = 'NONE'
+                else:
+                    enable_handle = handle
+
+                if child_n > n_childs:
+                    bpy.ops.archipack.window_panel(
+                        center=center,
+                        origin=Vector((origin[panel].x, offset.y, 0)),
+                        size=size[panel],
+                        radius=radius,
+                        pivot=pivot[panel],
+                        shape=shape,
+                        fixed=row.fixed[panel],
+                        handle=enable_handle,
+                        handle_model=handle_model,
+                        handle_altitude=handle_altitude,
+                        curve_steps=self.curve_steps,
+                        side_material=materials[panel],
+                        frame_x=self.frame_x,
+                        frame_y=self.frame_y,
+                        angle_y=self.angle_y,
+                    )
+                    child = context.active_object
+                    # parenting at 0, 0, 0 before set object matrix_world
+                    # so location remains local from frame
+                    child.parent = o
+                    child.matrix_world = o.matrix_world.copy()
+                else:
+                    child = childs[child_n - 1]
+                    child.select = True
+                    context.scene.objects.active = child
+                    props = archipack_window_panel.datablock(child)
+                    if props is not None:
+                        props.origin = Vector((origin[panel].x, offset.y, 0))
+                        props.center = center
+                        props.radius = radius
+                        props.size = size[panel]
+                        props.pivot = pivot[panel]
+                        props.shape = shape
+                        props.fixed = row.fixed[panel]
+                        props.handle = enable_handle
+                        props.handle_model = handle_model
+                        props.handle_altitude = handle_altitude
+                        props.side_material = materials[panel]
+                        props.curve_steps = self.curve_steps
+                        props.frame_x = self.frame_x
+                        props.frame_y = self.frame_y
+                        props.angle_y = self.angle_y
+                        props.update(context)
+                # location y + frame width. frame depends on choosen profile (fixed or not)
+                # update linked childs location too
+                child.location = Vector((origin[panel].x, origin[panel].y + location_y + self.frame_y,
+                    self.altitude + offset.y))
+
+                if not row.fixed[panel]:
+                    handle = 'NONE'
+
+                # only one single panel allowed for circle
+                if is_circle:
+                    return
+
+            # only one single row allowed for rail window
+            if self.window_type == 'RAIL':
+                return
+            offset.y += row.height
+
+    def _get_tri_radius(self):
+        return Vector((0, self.y, 0)), Vector((0, 0, 0)), \
+            Vector((self.x, self.z, 0)), Vector((self.x, 0, 0))
+
+    def _get_quad_radius(self):
+        fx_z = self.z / self.x
+        center_y = min(self.x / (self.x - self.frame_x) * self.z - self.frame_x * (1 + sqrt(1 + fx_z * fx_z)),
+            abs(tan(self.angle_y) * (self.x)))
+        if self.angle_y < 0:
+            center_x = 0.5 * self.x
+        else:
+            center_x = -0.5 * self.x
+        return Vector((center_x, center_y, 0)), Vector((0, 0, 0)), \
+            Vector((self.x, self.z, 0)), Vector((self.x, 0, 0))
+
+    def _get_round_radius(self):
+        """
+            bound radius to available space
+            return center, origin, size, radius
+        """
+        x = 0.5 * self.x - self.frame_x
+        # minimum space available
+        y = self.z - sum([row.height for row in self.rows[:self.n_rows - 1]]) - 2 * self.frame_x
+        y = min(y, x)
+        # minimum radius inside
+        r = y + x * (x - (y * y / x)) / (2 * y)
+        radius = max(self.radius, 0.001 + self.frame_x + r)
+        return Vector((0, self.z - radius, 0)), Vector((0, 0, 0)), \
+            Vector((self.x, self.z, 0)), Vector((radius, 0, 0))
+
+    def _get_circle_radius(self):
+        """
+            return center, origin, size, radius
+        """
+        return Vector((0, 0.5 * self.x, 0)), Vector((0, 0, 0)), \
+            Vector((self.x, self.z, 0)), Vector((0.5 * self.x, 0, 0))
+
+    def _get_ellipsis_radius(self):
+        """
+            return center, origin, size, radius
+        """
+        y = self.z - sum([row.height for row in self.rows[:self.n_rows - 1]])
+        radius_b = max(0, 0.001 - 2 * self.frame_x + min(y, self.elipsis_b))
+        return Vector((0, self.z - radius_b, 0)), Vector((0, 0, 0)), \
+            Vector((self.x, self.z, 0)), Vector((self.x / 2, radius_b, 0))
+
+    def get_radius(self):
+        """
+            return center, origin, size, radius
+        """
+        if self.shape == 'ROUND':
+            return self._get_round_radius()
+        elif self.shape == 'ELLIPSIS':
+            return self._get_ellipsis_radius()
+        elif self.shape == 'CIRCLE':
+            return self._get_circle_radius()
+        elif self.shape == 'QUADRI':
+            return self._get_quad_radius()
+        elif self.shape in ['TRIANGLE', 'PENTAGON']:
+            return self._get_tri_radius()
+        else:
+            return Vector((0, 0, 0)), Vector((0, 0, 0)), \
+                Vector((self.x, self.z, 0)), Vector((0, 0, 0))
+
+    def update(self, context, childs_only=False):
+        # support for "copy to selected"
+        o = self.find_in_selection(context, self.auto_update)
+
+        if o is None:
+            return
+
+        self.setup_manipulators()
+
+        if childs_only is False:
+            bmed.buildmesh(context, o, self.verts, self.faces, self.matids, self.uvs)
+
+        self.update_childs(context, o)
+
+        # update hole
+        if childs_only is False and self.find_hole(o) is not None:
+            self.interactive_hole(context, o)
+
+        # support for instances childs, update at object level
+        self.synch_childs(context, o)
+
+        # store 3d points for gl manipulators
+        x, y = 0.5 * self.x, 0.5 * self.y
+        self.manipulators[0].set_pts([(-x, -y, 0), (x, -y, 0), (1, 0, 0)])
+        self.manipulators[1].set_pts([(-x, -y, 0), (-x, y, 0), (-1, 0, 0)])
+        self.manipulators[2].set_pts([(x, -y, self.altitude), (x, -y, self.altitude + self.z), (-1, 0, 0)])
+        self.manipulators[3].set_pts([(x, -y, 0), (x, -y, self.altitude), (-1, 0, 0)])
+
+        # restore context
+        self.restore_context(context)
+
+    def find_hole(self, o):
+        for child in o.children:
+            if 'archipack_hole' in child:
+                return child
+        return None
+
+    def interactive_hole(self, context, o):
+        hole_obj = self.find_hole(o)
+
+        if hole_obj is None:
+            m = bpy.data.meshes.new("hole")
+            hole_obj = bpy.data.objects.new("hole", m)
+            context.scene.objects.link(hole_obj)
+            hole_obj['archipack_hole'] = True
+            hole_obj.parent = o
+            hole_obj.matrix_world = o.matrix_world.copy()
+            MaterialUtils.add_wall2_materials(hole_obj)
+
+        hole = self.hole
+        center, origin, size, radius = self.get_radius()
+
+        if self.out_frame is False:
+            x0 = 0
+        else:
+            x0 = min(self.frame_x - 0.001, self.out_frame_y + self.out_frame_offset)
+
+        if self.out_tablet_enable:
+            x0 -= min(self.frame_x - 0.001, self.out_tablet_z)
+        shape_z = [0, x0]
+
+        verts = hole.vertices(self.curve_steps, Vector((0, self.altitude, 0)), center, origin, size, radius,
+            self.angle_y, 0, shape_z=shape_z, path_type=self.shape)
+
+        faces = hole.faces(self.curve_steps, path_type=self.shape)
+
+        matids = hole.mat(self.curve_steps, 2, 2, path_type=self.shape)
+
+        uvs = hole.uv(self.curve_steps, center, origin, size, radius,
+            self.angle_y, 0, 0, self.frame_x, path_type=self.shape)
+
+        bmed.buildmesh(context, hole_obj, verts, faces, matids=matids, uvs=uvs)
+        return hole_obj
+
+    def robust_hole(self, context, tM):
+        hole = self.hole
+        center, origin, size, radius = self.get_radius()
+
+        if self.out_frame is False:
+            x0 = 0
+        else:
+            x0 = min(self.frame_x - 0.001, self.out_frame_y + self.out_frame_offset)
+
+        if self.out_tablet_enable:
+            x0 -= min(self.frame_x - 0.001, self.out_tablet_z)
+        shape_z = [0, x0]
+
+        m = bpy.data.meshes.new("hole")
+        o = bpy.data.objects.new("hole", m)
+        o['archipack_robusthole'] = True
+        context.scene.objects.link(o)
+        verts = hole.vertices(self.curve_steps, Vector((0, self.altitude, 0)), center, origin, size, radius,
+            self.angle_y, 0, shape_z=shape_z, path_type=self.shape)
+
+        verts = [tM * Vector(v) for v in verts]
+
+        faces = hole.faces(self.curve_steps, path_type=self.shape)
+
+        matids = hole.mat(self.curve_steps, 2, 2, path_type=self.shape)
+
+        uvs = hole.uv(self.curve_steps, center, origin, size, radius,
+            self.angle_y, 0, 0, self.frame_x, path_type=self.shape)
+
+        bmed.buildmesh(context, o, verts, faces, matids=matids, uvs=uvs)
+        MaterialUtils.add_wall2_materials(o)
+        o.select = True
+        context.scene.objects.active = o
+        return o
+
+
+class ARCHIPACK_PT_window(Panel):
+    bl_idname = "ARCHIPACK_PT_window"
+    bl_label = "Window"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    # bl_context = 'object'
+    bl_category = 'ArchiPack'
+
+    # layout related
+    display_detail = BoolProperty(
+        default=False
+    )
+    display_panels = BoolProperty(
+        default=True
+    )
+
+    @classmethod
+    def poll(cls, context):
+        return archipack_window.filter(context.active_object)
+
+    def draw(self, context):
+        o = context.active_object
+        prop = archipack_window.datablock(o)
+        if prop is None:
+            return
+        layout = self.layout
+        layout.operator('archipack.window_manipulate', icon='HAND')
+        row = layout.row(align=True)
+        row.operator('archipack.window', text="Refresh", icon='FILE_REFRESH').mode = 'REFRESH'
+        if o.data.users > 1:
+            row.operator('archipack.window', text="Make unique", icon='UNLINKED').mode = 'UNIQUE'
+        row.operator('archipack.window', text="Delete", icon='ERROR').mode = 'DELETE'
+        box = layout.box()
+        # box.label(text="Styles")
+        row = box.row(align=True)
+        row.operator("archipack.window_preset_menu", text=bpy.types.ARCHIPACK_OT_window_preset_menu.bl_label)
+        row.operator("archipack.window_preset", text="", icon='ZOOMIN')
+        row.operator("archipack.window_preset", text="", icon='ZOOMOUT').remove_active = True
+        box = layout.box()
+        box.prop(prop, 'window_type')
+        box.prop(prop, 'x')
+        box.prop(prop, 'y')
+        if prop.window_shape != 'CIRCLE':
+            box.prop(prop, 'z')
+            if prop.warning:
+                box.label(text="Insufficient height", icon='ERROR')
+        box.prop(prop, 'altitude')
+        box.prop(prop, 'offset')
+
+        if prop.window_type == 'FLAT':
+            box = layout.box()
+            box.prop(prop, 'window_shape')
+            if prop.window_shape in ['ROUND', 'CIRCLE', 'ELLIPSIS']:
+                box.prop(prop, 'curve_steps')
+            if prop.window_shape in ['ROUND']:
+                box.prop(prop, 'radius')
+            elif prop.window_shape == 'ELLIPSIS':
+                box.prop(prop, 'elipsis_b')
+            elif prop.window_shape == 'QUADRI':
+                box.prop(prop, 'angle_y')
+
+        row = layout.row(align=True)
+        if prop.display_detail:
+            row.prop(prop, "display_detail", icon="TRIA_DOWN", icon_only=True, text="Components", emboss=False)
+        else:
+            row.prop(prop, "display_detail", icon="TRIA_RIGHT", icon_only=True, text="Components", emboss=False)
+
+        if prop.display_detail:
+            box = layout.box()
+            box.label("Frame")
+            box.prop(prop, 'frame_x')
+            box.prop(prop, 'frame_y')
+            if prop.window_shape != 'CIRCLE':
+                box = layout.box()
+                row = box.row(align=True)
+                row.prop(prop, 'handle_enable')
+                if prop.handle_enable:
+                    box.prop(prop, 'handle_altitude')
+            box = layout.box()
+            row = box.row(align=True)
+            row.prop(prop, 'out_frame')
+            if prop.out_frame:
+                box.prop(prop, 'out_frame_x')
+                box.prop(prop, 'out_frame_y2')
+                box.prop(prop, 'out_frame_y')
+                box.prop(prop, 'out_frame_offset')
+            if prop.window_shape != 'CIRCLE':
+                box = layout.box()
+                row = box.row(align=True)
+                row.prop(prop, 'out_tablet_enable')
+                if prop.out_tablet_enable:
+                    box.prop(prop, 'out_tablet_x')
+                    box.prop(prop, 'out_tablet_y')
+                    box.prop(prop, 'out_tablet_z')
+                box = layout.box()
+                row = box.row(align=True)
+                row.prop(prop, 'in_tablet_enable')
+                if prop.in_tablet_enable:
+                    box.prop(prop, 'in_tablet_x')
+                    box.prop(prop, 'in_tablet_y')
+                    box.prop(prop, 'in_tablet_z')
+                box = layout.box()
+                row = box.row(align=True)
+                row.prop(prop, 'blind_enable')
+                if prop.blind_enable:
+                    box.prop(prop, 'blind_open')
+                    box.prop(prop, 'blind_y')
+                    box.prop(prop, 'blind_z')
+        if prop.window_shape != 'CIRCLE':
+            row = layout.row()
+            if prop.display_panels:
+                row.prop(prop, "display_panels", icon="TRIA_DOWN", icon_only=True, text="Rows", emboss=False)
+            else:
+                row.prop(prop, "display_panels", icon="TRIA_RIGHT", icon_only=True, text="Rows", emboss=False)
+
+            if prop.display_panels:
+                if prop.window_type != 'RAIL':
+                    row = layout.row()
+                    row.prop(prop, 'n_rows')
+                    last_row = prop.n_rows - 1
+                    for i, row in enumerate(prop.rows):
+                        box = layout.box()
+                        box.label(text="Row " + str(i + 1))
+                        row.draw(box, context, i == last_row)
+                else:
+                    box = layout.box()
+                    row = prop.rows[0]
+                    row.draw(box, context, True)
+
+        row = layout.row(align=True)
+        if prop.display_materials:
+            row.prop(prop, "display_materials", icon="TRIA_DOWN", icon_only=True, text="Materials", emboss=False)
+        else:
+            row.prop(prop, "display_materials", icon="TRIA_RIGHT", icon_only=True, text="Materials", emboss=False)
+        if prop.display_materials:
+            box = layout.box()
+            box.label("Hole")
+            box.prop(prop, 'hole_inside_mat')
+            box.prop(prop, 'hole_outside_mat')
+
+
+class ARCHIPACK_PT_window_panel(Panel):
+    bl_idname = "ARCHIPACK_PT_window_panel"
+    bl_label = "Window panel"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = 'ArchiPack'
+
+    @classmethod
+    def poll(cls, context):
+        return archipack_window_panel.filter(context.active_object)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.operator("archipack.select_parent")
+
+
+# ------------------------------------------------------------------
+# Define operator class to create object
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_window(ArchipackCreateTool, Operator):
+    bl_idname = "archipack.window"
+    bl_label = "Window"
+    bl_description = "Window"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+    x = FloatProperty(
+        name='width',
+        min=0.1, max=10000,
+        default=2.0, precision=2,
+        description='Width'
+        )
+    y = FloatProperty(
+        name='depth',
+        min=0.1, max=10000,
+        default=0.20, precision=2,
+        description='Depth'
+        )
+    z = FloatProperty(
+        name='height',
+        min=0.1, max=10000,
+        default=1.2, precision=2,
+        description='height'
+        )
+    altitude = FloatProperty(
+        name='altitude',
+        min=0.0, max=10000,
+        default=1.0, precision=2,
+        description='altitude'
+        )
+    mode = EnumProperty(
+        items=(
+        ('CREATE', 'Create', '', 0),
+        ('DELETE', 'Delete', '', 1),
+        ('REFRESH', 'Refresh', '', 2),
+        ('UNIQUE', 'Make unique', '', 3),
+        ),
+        default='CREATE'
+        )
+    # auto_manipulate = BoolProperty(default=True)
+
+    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):
+        m = bpy.data.meshes.new("Window")
+        o = bpy.data.objects.new("Window", m)
+        d = m.archipack_window.add()
+        d.x = self.x
+        d.y = self.y
+        d.z = self.z
+        d.altitude = self.altitude
+        context.scene.objects.link(o)
+        o.select = True
+        context.scene.objects.active = o
+        self.load_preset(d)
+        self.add_material(o)
+        # select frame
+        o.select = True
+        context.scene.objects.active = o
+        return o
+
+    def delete(self, context):
+        o = context.active_object
+        if archipack_window.filter(o):
+            bpy.ops.archipack.disable_manipulate()
+            for child in o.children:
+                if 'archipack_hole' in child:
+                    context.scene.objects.unlink(child)
+                    bpy.data.objects.remove(child, do_unlink=True)
+                elif child.data is not None and 'archipack_window_panel' in child.data:
+                    for handle in child.children:
+                        if 'archipack_handle' in handle:
+                            context.scene.objects.unlink(handle)
+                            bpy.data.objects.remove(handle, do_unlink=True)
+                    context.scene.objects.unlink(child)
+                    bpy.data.objects.remove(child, do_unlink=True)
+            context.scene.objects.unlink(o)
+            bpy.data.objects.remove(o, do_unlink=True)
+
+    def update(self, context):
+        o = context.active_object
+        d = archipack_window.datablock(o)
+        if d is not None:
+            d.update(context)
+            bpy.ops.object.select_linked(type='OBDATA')
+            for linked in context.selected_objects:
+                if linked != o:
+                    archipack_window.datablock(linked).update(context)
+        bpy.ops.object.select_all(action="DESELECT")
+        o.select = True
+        context.scene.objects.active = o
+
+    def unique(self, context):
+        act = context.active_object
+        sel = [o for o in context.selected_objects]
+        bpy.ops.object.select_all(action="DESELECT")
+        for o in sel:
+            if archipack_window.filter(o):
+                o.select = True
+                for child in o.children:
+                    if 'archipack_hole' in child or (
+                            child.data is not None and
+                            'archipack_window_panel' in child.data):
+                        child.hide_select = False
+                        child.select = True
+        if len(context.selected_objects) > 0:
+            bpy.ops.object.make_single_user(type='SELECTED_OBJECTS', object=True,
+                obdata=True, material=False, texture=False, animation=False)
+            for child in context.selected_objects:
+                if 'archipack_hole' in child:
+                    child.hide_select = True
+        bpy.ops.object.select_all(action="DESELECT")
+        context.scene.objects.active = act
+        for o in sel:
+            o.select = True
+
+    # -----------------------------------------------------
+    # Execute
+    # -----------------------------------------------------
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            if self.mode == 'CREATE':
+                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()
+            elif self.mode == 'DELETE':
+                self.delete(context)
+            elif self.mode == 'REFRESH':
+                self.update(context)
+            elif self.mode == 'UNIQUE':
+                self.unique(context)
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+class ARCHIPACK_OT_window_draw(ArchpackDrawTool, Operator):
+    bl_idname = "archipack.window_draw"
+    bl_label = "Draw Windows"
+    bl_description = "Draw Windows over walls"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    filepath = StringProperty(default="")
+    feedback = None
+    stack = []
+
+    @classmethod
+    def poll(cls, context):
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        row = layout.row()
+        row.label("Use Properties panel (N) to define parms", icon='INFO')
+
+    def draw_callback(self, _self, context):
+        self.feedback.draw(context)
+
+    def add_object(self, context, event):
+        o = context.active_object
+        bpy.ops.object.select_all(action="DESELECT")
+
+        if archipack_window.filter(o):
+
+            o.select = True
+            context.scene.objects.active = o
+
+            if event.shift:
+                bpy.ops.archipack.window(mode="UNIQUE")
+
+            new_w = o.copy()
+            new_w.data = o.data
+            context.scene.objects.link(new_w)
+
+            o = new_w
+            o.select = True
+            context.scene.objects.active = o
+
+            # synch subs from parent instance
+            bpy.ops.archipack.window(mode="REFRESH")
+
+        else:
+            bpy.ops.archipack.window(auto_manipulate=False, filepath=self.filepath)
+            o = context.active_object
+
+        bpy.ops.archipack.generate_hole('INVOKE_DEFAULT')
+        o.select = True
+        context.scene.objects.active = o
+
+    def modal(self, context, event):
+
+        context.area.tag_redraw()
+        o = context.active_object
+        d = archipack_window.datablock(o)
+        hole = None
+        if d is not None:
+            hole = d.find_hole(o)
+
+        # hide hole from raycast
+        if hole is not None:
+            o.hide = True
+            hole.hide = True
+
+        res, tM, wall, y = self.mouse_hover_wall(context, event)
+
+        if hole is not None:
+            o.hide = False
+            hole.hide = False
+
+        if res and d is not None:
+            o.matrix_world = tM
+            if d.y != wall.data.archipack_wall2[0].width:
+                d.y = wall.data.archipack_wall2[0].width
+
+        if event.value == 'PRESS':
+            if event.type in {'LEFTMOUSE', 'RET', 'NUMPAD_ENTER', 'SPACE'}:
+                if wall is not None:
+                    context.scene.objects.active = wall
+                    wall.select = True
+                    if bpy.ops.archipack.single_boolean.poll():
+                        bpy.ops.archipack.single_boolean()
+                    wall.select = False
+                    # o must be a window here
+                    if d is not None:
+                        context.scene.objects.active = o
+                        self.stack.append(o)
+                        self.add_object(context, event)
+                        context.active_object.matrix_world = tM
+                    return {'RUNNING_MODAL'}
+            # prevent selection of other object
+            if event.type in {'RIGHTMOUSE'}:
+                return {'RUNNING_MODAL'}
+
+        if self.keymap.check(event, self.keymap.undo) or (
+                event.type in {'BACK_SPACE'} and event.value == 'RELEASE'
+                ):
+            if len(self.stack) > 0:
+                last = self.stack.pop()
+                context.scene.objects.active = last
+                bpy.ops.archipack.window(mode="DELETE")
+                context.scene.objects.active = o
+            return {'RUNNING_MODAL'}
+
+        if event.value == 'RELEASE':
+
+            if event.type in {'ESC', 'RIGHTMOUSE'}:
+                bpy.ops.archipack.window(mode='DELETE')
+                self.feedback.disable()
+                bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
+                return {'FINISHED'}
+
+        return {'PASS_THROUGH'}
+
+    def invoke(self, context, event):
+
+        if context.mode == "OBJECT":
+            o = None
+            self.stack = []
+            self.keymap = Keymaps(context)
+            # exit manipulate_mode if any
+            bpy.ops.archipack.disable_manipulate()
+            # invoke with shift pressed will use current object as basis for linked copy
+            if self.filepath == '' and archipack_window.filter(context.active_object):
+                o = context.active_object
+            context.scene.objects.active = None
+            bpy.ops.object.select_all(action="DESELECT")
+            if o is not None:
+                o.select = True
+                context.scene.objects.active = o
+            self.add_object(context, event)
+            self.feedback = FeedbackPanel()
+            self.feedback.instructions(context, "Draw a window", "Click & Drag over a wall", [
+                ('LEFTCLICK, RET, SPACE, ENTER', 'Create a window'),
+                ('BACKSPACE, CTRL+Z', 'undo last'),
+                ('SHIFT', 'Make independant copy'),
+                ('RIGHTCLICK or ESC', 'exit')
+                ])
+            self.feedback.enable()
+            args = (self, context)
+
+            self._handle = bpy.types.SpaceView3D.draw_handler_add(self.draw_callback, args, 'WINDOW', 'POST_PIXEL')
+            context.window_manager.modal_handler_add(self)
+            return {'RUNNING_MODAL'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+# ------------------------------------------------------------------
+# Define operator class to create object
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_window_panel(Operator):
+    bl_idname = "archipack.window_panel"
+    bl_label = "Window panel"
+    bl_description = "Window panel"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+    center = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    origin = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    size = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    radius = FloatVectorProperty(
+            subtype='XYZ'
+            )
+    angle_y = FloatProperty(
+            name='angle',
+            unit='ROTATION',
+            subtype='ANGLE',
+            min=-1.5, max=1.5,
+            default=0, precision=2,
+            description='angle'
+            )
+    frame_y = FloatProperty(
+            name='Depth',
+            min=0, max=100,
+            default=0.06, precision=2,
+            description='frame depth'
+            )
+    frame_x = FloatProperty(
+            name='Width',
+            min=0, max=100,
+            default=0.06, precision=2,
+            description='frame width'
+            )
+    curve_steps = IntProperty(
+            name="curve steps",
+            min=1,
+            max=128,
+            default=16
+            )
+    shape = EnumProperty(
+            name='Shape',
+            items=(
+                ('RECTANGLE', 'Rectangle', '', 0),
+                ('ROUND', 'Top Round', '', 1),
+                ('ELLIPSIS', 'Top Elliptic', '', 2),
+                ('QUADRI', 'Top oblique', '', 3),
+                ('CIRCLE', 'Full circle', '', 4)
+                ),
+            default='RECTANGLE'
+            )
+    pivot = FloatProperty(
+            name='pivot',
+            min=-1, max=1,
+            default=-1, precision=2,
+            description='pivot'
+            )
+    side_material = IntProperty(
+            name="side material",
+            min=0,
+            max=2,
+            default=0
+            )
+    handle = EnumProperty(
+            name='Handle',
+            items=(
+                ('NONE', 'No handle', '', 0),
+                ('INSIDE', 'Inside', '', 1),
+                ('BOTH', 'Inside and outside', '', 2)
+                ),
+            default='NONE'
+            )
+    handle_model = IntProperty(
+            name="handle model",
+            default=1,
+            min=1,
+            max=2
+            )
+    handle_altitude = FloatProperty(
+            name='handle altitude',
+            min=0, max=1000,
+            default=0.2, precision=2,
+            description='handle altitude'
+            )
+    fixed = BoolProperty(
+            name="Fixed",
+            default=False
+            )
+
+    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):
+        m = bpy.data.meshes.new("Window Panel")
+        o = bpy.data.objects.new("Window Panel", m)
+        d = m.archipack_window_panel.add()
+        d.center = self.center
+        d.origin = self.origin
+        d.size = self.size
+        d.radius = self.radius
+        d.frame_y = self.frame_y
+        d.frame_x = self.frame_x
+        d.curve_steps = self.curve_steps
+        d.shape = self.shape
+        d.fixed = self.fixed
+        d.pivot = self.pivot
+        d.angle_y = self.angle_y
+        d.side_material = self.side_material
+        d.handle = self.handle
+        d.handle_model = self.handle_model
+        d.handle_altitude = self.handle_altitude
+        context.scene.objects.link(o)
+        o.select = True
+        context.scene.objects.active = o
+        o.lock_location[0] = True
+        o.lock_location[1] = True
+        o.lock_location[2] = True
+        o.lock_rotation[1] = True
+        o.lock_scale[0] = True
+        o.lock_scale[1] = True
+        o.lock_scale[2] = True
+        d.update(context)
+        MaterialUtils.add_window_materials(o)
+        return o
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            o = self.create(context)
+            o.select = True
+            context.scene.objects.active = o
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+# ------------------------------------------------------------------
+# Define operator class to manipulate object
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_window_manipulate(Operator):
+    bl_idname = "archipack.window_manipulate"
+    bl_label = "Manipulate"
+    bl_description = "Manipulate"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    @classmethod
+    def poll(self, context):
+        return archipack_window.filter(context.active_object)
+
+    def invoke(self, context, event):
+        d = archipack_window.datablock(context.active_object)
+        d.manipulable_invoke(context)
+        return {'FINISHED'}
+
+# ------------------------------------------------------------------
+# Define operator class to load / save presets
+# ------------------------------------------------------------------
+
+
+class ARCHIPACK_OT_window_preset_menu(PresetMenuOperator, Operator):
+    bl_idname = "archipack.window_preset_menu"
+    bl_label = "Window Presets"
+    preset_subdir = "archipack_window"
+
+
+class ARCHIPACK_OT_window_preset(ArchipackPreset, Operator):
+    """Add a Window Preset"""
+    bl_idname = "archipack.window_preset"
+    bl_label = "Add Window Preset"
+    preset_menu = "ARCHIPACK_OT_window_preset_menu"
+
+    @property
+    def blacklist(self):
+        # 'x', 'y', 'z', 'altitude', 'window_shape'
+        return ['manipulators']
+
+
+def register():
+    bpy.utils.register_class(archipack_window_panelrow)
+    bpy.utils.register_class(archipack_window_panel)
+    Mesh.archipack_window_panel = CollectionProperty(type=archipack_window_panel)
+    bpy.utils.register_class(ARCHIPACK_PT_window_panel)
+    bpy.utils.register_class(ARCHIPACK_OT_window_panel)
+    bpy.utils.register_class(archipack_window)
+    Mesh.archipack_window = CollectionProperty(type=archipack_window)
+    bpy.utils.register_class(ARCHIPACK_OT_window_preset_menu)
+    bpy.utils.register_class(ARCHIPACK_PT_window)
+    bpy.utils.register_class(ARCHIPACK_OT_window)
+    bpy.utils.register_class(ARCHIPACK_OT_window_preset)
+    bpy.utils.register_class(ARCHIPACK_OT_window_draw)
+    bpy.utils.register_class(ARCHIPACK_OT_window_manipulate)
+
+
+def unregister():
+    bpy.utils.unregister_class(archipack_window_panelrow)
+    bpy.utils.unregister_class(archipack_window_panel)
+    bpy.utils.unregister_class(ARCHIPACK_PT_window_panel)
+    del Mesh.archipack_window_panel
+    bpy.utils.unregister_class(ARCHIPACK_OT_window_panel)
+    bpy.utils.unregister_class(archipack_window)
+    del Mesh.archipack_window
+    bpy.utils.unregister_class(ARCHIPACK_OT_window_preset_menu)
+    bpy.utils.unregister_class(ARCHIPACK_PT_window)
+    bpy.utils.unregister_class(ARCHIPACK_OT_window)
+    bpy.utils.unregister_class(ARCHIPACK_OT_window_preset)
+    bpy.utils.unregister_class(ARCHIPACK_OT_window_draw)
+    bpy.utils.unregister_class(ARCHIPACK_OT_window_manipulate)