archipack: T52120 release to official

1 files changed, 1228 insertions, 0 deletions

diff --git a/archipack/archipack_gl.py b/archipack/archipack_gl.py
new file mode 100644
index 00000000..fc1f8c03
--- /dev/null
+++ b/archipack/archipack_gl.py
@@ -0,0 +1,1228 @@
+# -*- 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)
+#
+# ----------------------------------------------------------
+
+import bgl
+import blf
+import bpy
+from math import sin, cos, atan2, pi
+from mathutils import Vector, Matrix
+from bpy_extras import view3d_utils, object_utils
+
+
+# ------------------------------------------------------------------
+# Define Gl Handle types
+# ------------------------------------------------------------------
+
+
+class DefaultColorScheme:
+    """
+        Font sizes and basic colour scheme
+        default to this when not found in addon prefs
+        Colors are FloatVectorProperty of size 4 and type COLOR_GAMMA
+    """
+    feedback_size_main = 16
+    feedback_size_title = 14
+    feedback_size_shortcut = 11
+    feedback_colour_main = (0.95, 0.95, 0.95, 1.0)
+    feedback_colour_key = (0.67, 0.67, 0.67, 1.0)
+    feedback_colour_shortcut = (0.51, 0.51, 0.51, 1.0)
+    feedback_shortcut_area = (0, 0.4, 0.6, 0.2)
+    feedback_title_area = (0, 0.4, 0.6, 0.5)
+
+
+"""
+    # Addon prefs template
+
+    feedback_size_main = IntProperty(
+            name="Main",
+            description="Main title font size (pixels)",
+            min=2,
+            default=16
+            )
+    feedback_size_title = IntProperty(
+            name="Title",
+            description="Tool name font size (pixels)",
+            min=2,
+            default=14
+            )
+    feedback_size_shortcut = IntProperty(
+            name="Shortcut",
+            description="Shortcuts font size (pixels)",
+            min=2,
+            default=11
+            )
+    feedback_shortcut_area = FloatVectorProperty(
+            name="Background Shortcut",
+            description="Shortcut area background color",
+            subtype='COLOR_GAMMA',
+            default=(0, 0.4, 0.6, 0.2),
+            size=4,
+            min=0, max=1
+            )
+    feedback_title_area = FloatVectorProperty(
+            name="Background Main",
+            description="Title area background color",
+            subtype='COLOR_GAMMA',
+            default=(0, 0.4, 0.6, 0.5),
+            size=4,
+            min=0, max=1
+            )
+    feedback_colour_main = FloatVectorProperty(
+            name="Font Main",
+            description="Title color",
+            subtype='COLOR_GAMMA',
+            default=(0.95, 0.95, 0.95, 1.0),
+            size=4,
+            min=0, max=1
+            )
+    feedback_colour_key = FloatVectorProperty(
+            name="Font Shortcut key",
+            description="KEY label color",
+            subtype='COLOR_GAMMA',
+            default=(0.67, 0.67, 0.67, 1.0),
+            size=4,
+            min=0, max=1
+            )
+    feedback_colour_shortcut = FloatVectorProperty(
+            name="Font Shortcut hint",
+            description="Shortcuts text color",
+            subtype='COLOR_GAMMA',
+            default=(0.51, 0.51, 0.51, 1.0),
+            size=4,
+            min=0, max=1
+            )
+
+    def draw(self, context):
+        layout = self.layout
+        box = layout.box()
+        row = box.row()
+        split = row.split(percentage=0.5)
+        col = split.column()
+        col.label(text="Colors:")
+        row = col.row(align=True)
+        row.prop(self, "feedback_title_area")
+        row = col.row(align=True)
+        row.prop(self, "feedback_shortcut_area")
+        row = col.row(align=True)
+        row.prop(self, "feedback_colour_main")
+        row = col.row(align=True)
+        row.prop(self, "feedback_colour_key")
+        row = col.row(align=True)
+        row.prop(self, "feedback_colour_shortcut")
+        col = split.column()
+        col.label(text="Font size:")
+        col.prop(self, "feedback_size_main")
+        col.prop(self, "feedback_size_title")
+        col.prop(self, "feedback_size_shortcut")
+"""
+
+
+# @TODO:
+# 1 Make a clear separation of 2d (pixel position) and 3d (world position)
+#   modes way to set gl coords
+# 2 Unify methods to set points - currently set_pts, set_pos ...
+# 3 Put all Gl part in a sub module as it may be used by other devs
+#   as gl toolkit abstraction for screen feedback
+# 4 Implement cursor badges (np_station sample)
+# 5 Define a clear color scheme so it is easy to customize
+# 6 Allow different arguments for each classes like
+#   eg: for line p0 p1, p0 and vector (p1-p0)
+#       raising exceptions when incomplete
+# 7 Use correct words, normal is not realy a normal
+#   but a perpendicular
+# May be hard code more shapes ?
+# Fine tuned text styles with shadows and surronding boxes / backgrounds
+# Extending tests to hdr screens, ultra wide ones and so on
+# Circular handle, handle styling (only border, filling ...)
+
+# Keep point 3 in mind while doing this, to keep it simple and easy to use
+# Take inspiration from other's feed back systems, talk to other devs
+# and find who actually work on bgl future for 2.8 release
+
+
+class Gl():
+    """
+        handle 3d -> 2d gl drawing
+        d : dimensions
+            3 to convert pos from 3d
+            2 to keep pos as 2d absolute screen position
+    """
+    def __init__(self,
+            d=3,
+            colour=(0.0, 0.0, 0.0, 1.0)):
+        # nth dimensions of input coords 3=word coords 2=pixel screen coords
+        self.d = d
+        self.pos_2d = Vector((0, 0))
+        self.colour_inactive = colour
+
+    @property
+    def colour(self):
+        return self.colour_inactive
+
+    def position_2d_from_coord(self, context, coord, render=False):
+        """ coord given in local input coordsys
+        """
+        if self.d == 2:
+            return coord
+        if render:
+            return self.get_render_location(context, coord)
+        region = context.region
+        rv3d = context.region_data
+        loc = view3d_utils.location_3d_to_region_2d(region, rv3d, coord, self.pos_2d)
+        return loc
+
+    def get_render_location(self, context, coord):
+        scene = context.scene
+        co_2d = object_utils.world_to_camera_view(scene, scene.camera, coord)
+        # Get pixel coords
+        render_scale = scene.render.resolution_percentage / 100
+        render_size = (int(scene.render.resolution_x * render_scale),
+                       int(scene.render.resolution_y * render_scale))
+        return [round(co_2d.x * render_size[0]), round(co_2d.y * render_size[1])]
+
+    def _end(self):
+        bgl.glEnd()
+        bgl.glPopAttrib()
+        bgl.glLineWidth(1)
+        bgl.glDisable(bgl.GL_BLEND)
+        bgl.glColor4f(0.0, 0.0, 0.0, 1.0)
+
+
+class GlText(Gl):
+
+    def __init__(self,
+            d=3,
+            label="",
+            value=None,
+            precision=2,
+            unit_mode='AUTO',
+            unit_type='SIZE',
+            dimension=1,
+            angle=0,
+            font_size=12,
+            colour=(1, 1, 1, 1),
+            z_axis=Vector((0, 0, 1))):
+        """
+            d: [2|3] coords type: 2 for coords in screen pixels, 3 for 3d world location
+            label : string label
+            value : float value (will add unit according following settings)
+            precision : integer rounding for values
+            dimension : [1 - 3] nth dimension of unit (single, square, cubic)
+            unit_mode : ['AUTO','METER','CENTIMETER','MILIMETER','FEET','INCH','RADIANS','DEGREE']
+                        unit type to use to postfix values
+                        auto use scene units setup
+            unit_type : ['SIZE','ANGLE']
+                        unit type to add to value
+            angle : angle to rotate text
+
+        """
+        self.z_axis = z_axis
+        # text, add as prefix to value
+        self.label = label
+        # value with unit related
+        self.value = value
+        self.precision = precision
+        self.dimension = dimension
+        self.unit_type = unit_type
+        self.unit_mode = unit_mode
+
+        self.font_size = font_size
+        self.angle = angle
+        Gl.__init__(self, d)
+        self.colour_inactive = colour
+        # store text with units
+        self._text = ""
+
+    def text_size(self, context):
+        """
+            overall on-screen size in pixels
+        """
+        dpi, font_id = context.user_preferences.system.dpi, 0
+        if self.angle != 0:
+            blf.enable(font_id, blf.ROTATION)
+            blf.rotation(font_id, self.angle)
+        blf.aspect(font_id, 1.0)
+        blf.size(font_id, self.font_size, dpi)
+        x, y = blf.dimensions(font_id, self.text)
+        if self.angle != 0:
+            blf.disable(font_id, blf.ROTATION)
+        return Vector((x, y))
+
+    @property
+    def pts(self):
+        return [self.pos_3d]
+
+    @property
+    def text(self):
+        s = self.label + self._text
+        return s.strip()
+
+    def add_units(self, context):
+        if self.value is None:
+            return ""
+        if self.unit_type == 'ANGLE':
+            scale = 1
+        else:
+            scale = context.scene.unit_settings.scale_length
+
+        val = self.value * scale
+        mode = self.unit_mode
+        if mode == 'AUTO':
+            if self.unit_type == 'ANGLE':
+                mode = context.scene.unit_settings.system_rotation
+            else:
+                if context.scene.unit_settings.system == "IMPERIAL":
+                    if round(val * (3.2808399 ** self.dimension), 2) >= 1.0:
+                        mode = 'FEET'
+                    else:
+                        mode = 'INCH'
+                elif context.scene.unit_settings.system == "METRIC":
+                    if round(val, 2) >= 1.0:
+                        mode = 'METER'
+                    else:
+                        if round(val, 2) >= 0.01:
+                            mode = 'CENTIMETER'
+                        else:
+                            mode = 'MILIMETER'
+        # convert values
+        if mode == 'METER':
+            unit = "m"
+        elif mode == 'CENTIMETER':
+            val *= (100 ** self.dimension)
+            unit = "cm"
+        elif mode == 'MILIMETER':
+            val *= (1000 ** self.dimension)
+            unit = 'mm'
+        elif mode == 'INCH':
+            val *= (39.3700787 ** self.dimension)
+            unit = "in"
+        elif mode == 'FEET':
+            val *= (3.2808399 ** self.dimension)
+            unit = "ft"
+        elif mode == 'RADIANS':
+            unit = ""
+        elif mode == 'DEGREES':
+            val = self.value / pi * 180
+            unit = "°"
+        else:
+            unit = ""
+        if self.dimension == 2:
+            unit += "\u00b2"  # Superscript two
+        elif self.dimension == 3:
+            unit += "\u00b3"  # Superscript three
+
+        fmt = "%1." + str(self.precision) + "f " + unit
+        return fmt % val
+
+    def set_pos(self, context, value, pos_3d, direction, angle=0, normal=Vector((0, 0, 1))):
+        self.up_axis = direction.normalized()
+        self.c_axis = self.up_axis.cross(normal)
+        self.pos_3d = pos_3d
+        self.value = value
+        self.angle = angle
+        self._text = self.add_units(context)
+
+    def draw(self, context, render=False):
+        self.render = render
+        x, y = self.position_2d_from_coord(context, self.pts[0], render)
+        # dirty fast assignment
+        dpi, font_id = context.user_preferences.system.dpi, 0
+        bgl.glColor4f(*self.colour)
+        if self.angle != 0:
+            blf.enable(font_id, blf.ROTATION)
+            blf.rotation(font_id, self.angle)
+        blf.size(font_id, self.font_size, dpi)
+        blf.position(font_id, x, y, 0)
+        blf.draw(font_id, self.text)
+        if self.angle != 0:
+            blf.disable(font_id, blf.ROTATION)
+
+
+class GlBaseLine(Gl):
+
+    def __init__(self,
+            d=3,
+            width=1,
+            style=bgl.GL_LINE,
+            closed=False):
+        Gl.__init__(self, d)
+        # default line width
+        self.width = width
+        # default line style
+        self.style = style
+        # allow closed lines
+        self.closed = False
+
+    def draw(self, context, render=False):
+        """
+            render flag when rendering
+        """
+        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
+        if self.style == bgl.GL_LINE_STIPPLE:
+            bgl.glLineStipple(1, 0x9999)
+        bgl.glEnable(self.style)
+        bgl.glEnable(bgl.GL_BLEND)
+        if render:
+            # enable anti-alias on lines
+            bgl.glEnable(bgl.GL_LINE_SMOOTH)
+        bgl.glColor4f(*self.colour)
+        bgl.glLineWidth(self.width)
+        if self.closed:
+            bgl.glBegin(bgl.GL_LINE_LOOP)
+        else:
+            bgl.glBegin(bgl.GL_LINE_STRIP)
+
+        for pt in self.pts:
+            x, y = self.position_2d_from_coord(context, pt, render)
+            bgl.glVertex2f(x, y)
+        self._end()
+
+
+class GlLine(GlBaseLine):
+    """
+        2d/3d Line
+    """
+    def __init__(self, d=3, p=None, v=None, p0=None, p1=None, z_axis=None):
+        """
+            d=3 use 3d coords, d=2 use 2d pixels coords
+            Init by either
+            p: Vector or tuple origin
+            v: Vector or tuple size and direction
+            or
+            p0: Vector or tuple 1 point location
+            p1: Vector or tuple 2 point location
+            Will convert any into Vector 3d
+            both optionnals
+        """
+        if p is not None and v is not None:
+            self.p = Vector(p)
+            self.v = Vector(v)
+        elif p0 is not None and p1 is not None:
+            self.p = Vector(p0)
+            self.v = Vector(p1) - self.p
+        else:
+            self.p = Vector((0, 0, 0))
+            self.v = Vector((0, 0, 0))
+        if z_axis is not None:
+            self.z_axis = z_axis
+        else:
+            self.z_axis = Vector((0, 0, 1))
+        GlBaseLine.__init__(self, d)
+
+    @property
+    def p0(self):
+        return self.p
+
+    @property
+    def p1(self):
+        return self.p + self.v
+
+    @p0.setter
+    def p0(self, p0):
+        """
+            Note: setting p0
+            move p0 only
+        """
+        p1 = self.p1
+        self.p = Vector(p0)
+        self.v = p1 - p0
+
+    @p1.setter
+    def p1(self, p1):
+        """
+            Note: setting p1
+            move p1 only
+        """
+        self.v = Vector(p1) - self.p
+
+    @property
+    def length(self):
+        return self.v.length
+
+    @property
+    def angle(self):
+        return atan2(self.v.y, self.v.x)
+
+    @property
+    def cross(self):
+        """
+            Vector perpendicular on plane defined by z_axis
+            lie on the right side
+            p1
+            |--x
+            p0
+        """
+        return self.v.cross(self.z_axis)
+
+    def normal(self, t=0):
+        """
+            Line perpendicular on plane defined by z_axis
+            lie on the right side
+            p1
+            |--x
+            p0
+        """
+        n = GlLine()
+        n.p = self.lerp(t)
+        n.v = self.cross
+        return n
+
+    def sized_normal(self, t, size):
+        """
+            GlLine perpendicular on plane defined by z_axis and of given size
+            positionned at t in current line
+            lie on the right side
+            p1
+            |--x
+            p0
+        """
+        n = GlLine()
+        n.p = self.lerp(t)
+        n.v = size * self.cross.normalized()
+        return n
+
+    def lerp(self, t):
+        """
+            Interpolate along segment
+            t parameter [0, 1] where 0 is start of arc and 1 is end
+        """
+        return self.p + self.v * t
+
+    def offset(self, offset):
+        """
+            offset > 0 on the right part
+        """
+        self.p += offset * self.cross.normalized()
+
+    def point_sur_segment(self, pt):
+        """ point_sur_segment (2d)
+            point: Vector 3d
+            t: param t de l'intersection sur le segment courant
+            d: distance laterale perpendiculaire positif a droite
+        """
+        dp = (pt - self.p).to_2d()
+        v2d = self.v.to_2d()
+        dl = v2d.length
+        d = (self.v.x * dp.y - self.v.y * dp.x) / dl
+        t = (v2d * dp) / (dl * dl)
+        return t > 0 and t < 1, d, t
+
+    @property
+    def pts(self):
+        return [self.p0, self.p1]
+
+
+class GlCircle(GlBaseLine):
+
+    def __init__(self,
+            d=3,
+            radius=0,
+            center=Vector((0, 0, 0)),
+            z_axis=Vector((0, 0, 1))):
+
+        self.r = radius
+        self.c = center
+        z = z_axis
+
+        if z.z < 1:
+            x = z.cross(Vector((0, 0, 1)))
+            y = x.cross(z)
+        else:
+            x = Vector((1, 0, 0))
+            y = Vector((0, 1, 0))
+
+        self.rM = Matrix([
+            Vector((x.x, y.x, z.x)),
+            Vector((x.y, y.y, z.y)),
+            Vector((x.z, y.z, z.z))
+        ])
+        self.z_axis = z
+        self.a0 = 0
+        self.da = 2 * pi
+        GlBaseLine.__init__(self, d)
+
+    def lerp(self, t):
+        """
+            Linear interpolation
+        """
+        a = self.a0 + t * self.da
+        return self.c + self.rM * Vector((self.r * cos(a), self.r * sin(a), 0))
+
+    @property
+    def pts(self):
+        n_pts = max(1, int(round(abs(self.da) / pi * 30, 0)))
+        t_step = 1 / n_pts
+        return [self.lerp(i * t_step) for i in range(n_pts + 1)]
+
+
+class GlArc(GlCircle):
+
+    def __init__(self,
+            d=3,
+            radius=0,
+            center=Vector((0, 0, 0)),
+            z_axis=Vector((0, 0, 1)),
+            a0=0,
+            da=0):
+        """
+            a0 and da arguments are in radians
+            a0 = 0   on the x+ axis side
+            a0 = pi  on the x- axis side
+            da > 0 CCW contrary-clockwise
+            da < 0 CW  clockwise
+        """
+        GlCircle.__init__(self, d, radius, center, z_axis)
+        self.da = da
+        self.a0 = a0
+
+    @property
+    def length(self):
+        return self.r * abs(self.da)
+
+    def normal(self, t=0):
+        """
+            perpendicular line always on the right side
+        """
+        n = GlLine(d=self.d, z_axis=self.z_axis)
+        n.p = self.lerp(t)
+        if self.da < 0:
+            n.v = self.c - n.p
+        else:
+            n.v = n.p - self.c
+        return n
+
+    def sized_normal(self, t, size):
+        n = GlLine(d=self.d, z_axis=self.z_axis)
+        n.p = self.lerp(t)
+        if self.da < 0:
+            n.v = size * (self.c - n.p).normalized()
+        else:
+            n.v = size * (n.p - self.c).normalized()
+        return n
+
+    def tangeant(self, t, length):
+        a = self.a0 + t * self.da
+        ca = cos(a)
+        sa = sin(a)
+        n = GlLine(d=self.d, z_axis=self.z_axis)
+        n.p = self.c + self.rM * Vector((self.r * ca, self.r * sa, 0))
+        n.v = self.rM * Vector((length * sa, -length * ca, 0))
+        if self.da > 0:
+            n.v = -n.v
+        return n
+
+    def offset(self, offset):
+        """
+            offset > 0 on the right part
+        """
+        if self.da > 0:
+            radius = self.r + offset
+        else:
+            radius = self.r - offset
+        return GlArc(d=self.d,
+            radius=radius,
+            center=self.c,
+            a0=self.a0,
+            da=self.da,
+            z_axis=self.z_axis)
+
+
+class GlPolygon(Gl):
+
+    def __init__(self,
+            colour=(0.0, 0.0, 0.0, 1.0),
+            d=3):
+
+        self.pts_3d = []
+        Gl.__init__(self, d, colour)
+
+    def set_pos(self, pts_3d):
+        self.pts_3d = pts_3d
+
+    @property
+    def pts(self):
+        return self.pts_3d
+
+    def draw(self, context, render=False):
+        """
+            render flag when rendering
+        """
+        self.render = render
+        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
+        bgl.glEnable(bgl.GL_BLEND)
+        if render:
+            # enable anti-alias on polygons
+            bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
+        bgl.glColor4f(*self.colour)
+        bgl.glBegin(bgl.GL_POLYGON)
+
+        for pt in self.pts:
+            x, y = self.position_2d_from_coord(context, pt, render)
+            bgl.glVertex2f(x, y)
+        self._end()
+
+
+class GlRect(GlPolygon):
+    def __init__(self,
+            colour=(0.0, 0.0, 0.0, 1.0),
+            d=2):
+        GlPolygon.__init__(self, colour, d)
+
+    def draw(self, context, render=False):
+        self.render = render
+        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
+        bgl.glEnable(bgl.GL_BLEND)
+        if render:
+            # enable anti-alias on polygons
+            bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
+        bgl.glColor4f(*self.colour)
+        p0 = self.pts[0]
+        p1 = self.pts[1]
+        bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
+        self._end()
+
+
+class GlImage(Gl):
+    def __init__(self,
+        d=2,
+        image=None):
+        self.image = image
+        self.colour_inactive = (1, 1, 1, 1)
+        Gl.__init__(self, d)
+        self.pts_2d = [Vector((0, 0)), Vector((10, 10))]
+
+    def set_pos(self, pts):
+        self.pts_2d = pts
+
+    @property
+    def pts(self):
+        return self.pts_2d
+
+    def draw(self, context, render=False):
+        if self.image is None:
+            return
+        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
+        p0 = self.pts[0]
+        p1 = self.pts[1]
+        bgl.glEnable(bgl.GL_BLEND)
+        bgl.glColor4f(*self.colour)
+        bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
+        self.image.gl_load()
+        bgl.glEnable(bgl.GL_BLEND)
+        bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.image.bindcode[0])
+        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST)
+        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST)
+        bgl.glEnable(bgl.GL_TEXTURE_2D)
+        bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
+        # bgl.glColor4f(1, 1, 1, 1)
+        bgl.glBegin(bgl.GL_QUADS)
+        bgl.glTexCoord2d(0, 0)
+        bgl.glVertex2d(p0.x, p0.y)
+        bgl.glTexCoord2d(0, 1)
+        bgl.glVertex2d(p0.x, p1.y)
+        bgl.glTexCoord2d(1, 1)
+        bgl.glVertex2d(p1.x, p1.y)
+        bgl.glTexCoord2d(1, 0)
+        bgl.glVertex2d(p1.x, p0.y)
+        bgl.glEnd()
+        self.image.gl_free()
+        bgl.glDisable(bgl.GL_TEXTURE_2D)
+
+
+class GlPolyline(GlBaseLine):
+    def __init__(self, colour, d=3):
+        self.pts_3d = []
+        GlBaseLine.__init__(self, d)
+        self.colour_inactive = colour
+
+    def set_pos(self, pts_3d):
+        self.pts_3d = pts_3d
+        # self.pts_3d.append(pts_3d[0])
+
+    @property
+    def pts(self):
+        return self.pts_3d
+
+
+class GlHandle(GlPolygon):
+
+    def __init__(self, sensor_size, size, draggable=False, selectable=False, d=3):
+        """
+            sensor_size : 2d size in pixels of sensor area
+            size : 3d size of handle
+        """
+        GlPolygon.__init__(self, d=d)
+        self.colour_active = (1.0, 0.0, 0.0, 1.0)
+        self.colour_hover = (1.0, 1.0, 0.0, 1.0)
+        self.colour_normal = (1.0, 1.0, 1.0, 1.0)
+        self.colour_selected = (0.0, 0.0, 0.7, 1.0)
+        self.size = size
+        self.sensor_width = sensor_size
+        self.sensor_height = sensor_size
+        self.pos_3d = Vector((0, 0, 0))
+        self.up_axis = Vector((0, 0, 0))
+        self.c_axis = Vector((0, 0, 0))
+        self.hover = False
+        self.active = False
+        self.draggable = draggable
+        self.selectable = selectable
+        self.selected = False
+
+    def set_pos(self, context, pos_3d, direction, normal=Vector((0, 0, 1))):
+        self.up_axis = direction.normalized()
+        self.c_axis = self.up_axis.cross(normal)
+        self.pos_3d = pos_3d
+        self.pos_2d = self.position_2d_from_coord(context, self.sensor_center)
+
+    def check_hover(self, pos_2d):
+        if self.draggable:
+            dp = pos_2d - self.pos_2d
+            self.hover = abs(dp.x) < self.sensor_width and abs(dp.y) < self.sensor_height
+
+    @property
+    def sensor_center(self):
+        pts = self.pts
+        n = len(pts)
+        x, y, z = 0, 0, 0
+        for pt in pts:
+            x += pt.x
+            y += pt.y
+            z += pt.z
+        return Vector((x / n, y / n, z / n))
+
+    @property
+    def pts(self):
+        raise NotImplementedError
+
+    @property
+    def colour(self):
+        if self.render:
+            return self.colour_inactive
+        elif self.draggable:
+            if self.active:
+                return self.colour_active
+            elif self.hover:
+                return self.colour_hover
+            elif self.selected:
+                return self.colour_selected
+            return self.colour_normal
+        else:
+            return self.colour_inactive
+
+
+class SquareHandle(GlHandle):
+
+    def __init__(self, sensor_size, size, draggable=False, selectable=False):
+        GlHandle.__init__(self, sensor_size, size, draggable, selectable)
+
+    @property
+    def pts(self):
+        n = self.up_axis
+        c = self.c_axis
+        if self.selected or self.hover or self.active:
+            scale = 1
+        else:
+            scale = 0.5
+        x = n * self.size * scale
+        y = c * self.size * scale
+        return [self.pos_3d - x - y, self.pos_3d + x - y, self.pos_3d + x + y, self.pos_3d - x + y]
+
+
+class TriHandle(GlHandle):
+
+    def __init__(self, sensor_size, size, draggable=False, selectable=False):
+        GlHandle.__init__(self, sensor_size, size, draggable, selectable)
+
+    @property
+    def pts(self):
+        n = self.up_axis
+        c = self.c_axis
+        # does move sensitive area so disable for tri handle
+        # may implement sensor_center property to fix this
+        # if self.selected or self.hover or self.active:
+        scale = 1
+        # else:
+        #    scale = 0.5
+        x = n * self.size * 4 * scale
+        y = c * self.size * scale
+        return [self.pos_3d - x + y, self.pos_3d - x - y, self.pos_3d]
+
+
+class EditableText(GlText, GlHandle):
+    def __init__(self, sensor_size, size, draggable=False, selectable=False):
+        GlHandle.__init__(self, sensor_size, size, draggable, selectable)
+        GlText.__init__(self, colour=(0, 0, 0, 1))
+
+    def set_pos(self, context, value, pos_3d, direction, normal=Vector((0, 0, 1))):
+        self.up_axis = direction.normalized()
+        self.c_axis = self.up_axis.cross(normal)
+        self.pos_3d = pos_3d
+        self.value = value
+        self._text = self.add_units(context)
+        x, y = self.text_size(context)
+        self.pos_2d = self.position_2d_from_coord(context, pos_3d)
+        self.pos_2d.x += 0.5 * x
+        self.sensor_width, self.sensor_height = 0.5 * x, y
+
+    @property
+    def sensor_center(self):
+        return self.pos_3d
+
+
+class ThumbHandle(GlHandle):
+
+    def __init__(self, size_2d, label, image=None, draggable=False, selectable=False, d=2):
+        GlHandle.__init__(self, size_2d, size_2d, draggable, selectable, d)
+        self.image = GlImage(image=image)
+        self.label = GlText(d=2, label=label.replace("_", " ").capitalize())
+        self.frame = GlPolyline((1, 1, 1, 1), d=2)
+        self.frame.closed = True
+        self.size_2d = size_2d
+        self.sensor_width = 0.5 * size_2d.x
+        self.sensor_height = 0.5 * size_2d.y
+        self.colour_normal = (0.715, 0.905, 1, 0.9)
+        self.colour_hover = (1, 1, 1, 1)
+
+    def set_pos(self, context, pos_2d):
+        """
+            pos 2d is center !!
+        """
+        self.pos_2d = pos_2d
+        ts = self.label.text_size(context)
+        self.label.pos_3d = pos_2d + Vector((-0.5 * ts.x, ts.y - 0.5 * self.size_2d.y))
+        p0, p1 = self.pts
+        self.image.set_pos(self.pts)
+        self.frame.set_pos([p0, Vector((p1.x, p0.y)), p1, Vector((p0.x, p1.y))])
+
+    @property
+    def pts(self):
+        s = 0.5 * self.size_2d
+        return [self.pos_2d - s, self.pos_2d + s]
+
+    @property
+    def sensor_center(self):
+        return self.pos_2d + 0.5 * self.size_2d
+
+    def draw(self, context, render=False):
+        self.render = render
+        self.image.colour_inactive = self.colour
+        GlHandle.draw(self, context, render=False)
+        self.image.draw(context, render=False)
+        self.label.draw(context, render=False)
+        self.frame.draw(context, render=False)
+
+
+class Screen():
+    def __init__(self, margin):
+        self.margin = margin
+
+    def size(self, context):
+
+        system = context.user_preferences.system
+        w = context.region.width
+        h = context.region.height
+        y_min = self.margin
+        y_max = h - self.margin
+        x_min = self.margin
+        x_max = w - self.margin
+        if (system.use_region_overlap and
+                system.window_draw_method in {'TRIPLE_BUFFER', 'AUTOMATIC'}):
+            area = context.area
+
+            for r in area.regions:
+                if r.type == 'TOOLS':
+                    x_min += r.width
+                elif r.type == 'UI':
+                    x_max -= r.width
+        return x_min, x_max, y_min, y_max
+
+
+class FeedbackPanel():
+    """
+        Feed-back panel
+        inspired by np_station
+    """
+    def __init__(self, title='Archipack'):
+
+        prefs = self.get_prefs(bpy.context)
+
+        self.main_title = GlText(d=2,
+            label=title + " : ",
+            font_size=prefs.feedback_size_main,
+            colour=prefs.feedback_colour_main
+            )
+        self.title = GlText(d=2,
+            font_size=prefs.feedback_size_title,
+            colour=prefs.feedback_colour_main
+            )
+        self.spacing = Vector((
+            0.5 * prefs.feedback_size_shortcut,
+            0.5 * prefs.feedback_size_shortcut))
+        self.margin = 50
+        self.explanation = GlText(d=2,
+            font_size=prefs.feedback_size_shortcut,
+            colour=prefs.feedback_colour_main
+            )
+        self.shortcut_area = GlPolygon(colour=prefs.feedback_shortcut_area, d=2)
+        self.title_area = GlPolygon(colour=prefs.feedback_title_area, d=2)
+        self.shortcuts = []
+        self.on = False
+        self.show_title = True
+        self.show_main_title = True
+        # read only, when enabled, after draw() the top left coord of info box
+        self.top = Vector((0, 0))
+        self.screen = Screen(self.margin)
+
+    def disable(self):
+        self.on = False
+
+    def enable(self):
+        self.on = True
+
+    def get_prefs(self, context):
+        global __name__
+        try:
+            # retrieve addon name from imports
+            addon_name = __name__.split('.')[0]
+            prefs = context.user_preferences.addons[addon_name].preferences
+        except:
+            prefs = DefaultColorScheme
+            pass
+        return prefs
+
+    def instructions(self, context, title, explanation, shortcuts):
+        """
+            position from bottom to top
+        """
+        prefs = self.get_prefs(context)
+
+        self.explanation.label = explanation
+        self.title.label = title
+
+        self.shortcuts = []
+
+        for key, label in shortcuts:
+            key = GlText(d=2, label=key,
+                font_size=prefs.feedback_size_shortcut,
+                colour=prefs.feedback_colour_key)
+            label = GlText(d=2, label=' : ' + label,
+                font_size=prefs.feedback_size_shortcut,
+                colour=prefs.feedback_colour_shortcut)
+            ks = key.text_size(context)
+            ls = label.text_size(context)
+            self.shortcuts.append([key, ks, label, ls])
+
+    def draw(self, context, render=False):
+        if self.on:
+            """
+                draw from bottom to top
+                so we are able to always fit needs
+            """
+            x_min, x_max, y_min, y_max = self.screen.size(context)
+            available_w = x_max - x_min - 2 * self.spacing.x
+            main_title_size = self.main_title.text_size(context) + Vector((5, 0))
+
+            # h = context.region.height
+            # 0,0 = bottom left
+            pos = Vector((x_min + self.spacing.x, y_min))
+            shortcuts = []
+
+            # sort by lines
+            lines = []
+            line = []
+            space = 0
+            sum_txt = 0
+
+            for key, ks, label, ls in self.shortcuts:
+                space += ks.x + ls.x + self.spacing.x
+                if pos.x + space > available_w:
+                    txt_spacing = (available_w - sum_txt) / (max(1, len(line) - 1))
+                    sum_txt = 0
+                    space = ks.x + ls.x + self.spacing.x
+                    lines.append((txt_spacing, line))
+                    line = []
+                sum_txt += ks.x + ls.x
+                line.append([key, ks, label, ls])
+
+            if len(line) > 0:
+                txt_spacing = (available_w - sum_txt) / (max(1, len(line) - 1))
+                lines.append((txt_spacing, line))
+
+            # reverse lines to draw from bottom to top
+            lines = list(reversed(lines))
+            for spacing, line in lines:
+                pos.y += self.spacing.y
+                pos.x = x_min + self.spacing.x
+                for key, ks, label, ls in line:
+                    key.pos_3d = pos.copy()
+                    pos.x += ks.x
+                    label.pos_3d = pos.copy()
+                    pos.x += ls.x + spacing
+                    shortcuts.extend([key, label])
+                pos.y += ks.y + self.spacing.y
+
+            n_shortcuts = len(shortcuts)
+            # shortcut area
+            self.shortcut_area.pts_3d = [
+                (x_min, self.margin),
+                (x_max, self.margin),
+                (x_max, pos.y),
+                (x_min, pos.y)
+                ]
+
+            # small space between shortcut area and main title bar
+            if n_shortcuts > 0:
+                pos.y += 0.5 * self.spacing.y
+
+            self.title_area.pts_3d = [
+                (x_min, pos.y),
+                (x_max, pos.y),
+                (x_max, pos.y + main_title_size.y + 2 * self.spacing.y),
+                (x_min, pos.y + main_title_size.y + 2 * self.spacing.y)
+                ]
+            pos.y += self.spacing.y
+
+            title_size = self.title.text_size(context)
+            # check for space available:
+            # if explanation + title + main_title are too big
+            # 1 remove main title
+            # 2 remove title
+            explanation_size = self.explanation.text_size(context)
+
+            self.show_title = True
+            self.show_main_title = True
+
+            if title_size.x + explanation_size.x > available_w:
+                # keep only explanation
+                self.show_title = False
+                self.show_main_title = False
+            elif main_title_size.x + title_size.x + explanation_size.x > available_w:
+                # keep title + explanation
+                self.show_main_title = False
+                self.title.pos_3d = (x_min + self.spacing.x, pos.y)
+            else:
+                self.title.pos_3d = (x_min + self.spacing.x + main_title_size.x, pos.y)
+
+            self.explanation.pos_3d = (x_max - self.spacing.x - explanation_size.x, pos.y)
+            self.main_title.pos_3d = (x_min + self.spacing.x, pos.y)
+
+            self.shortcut_area.draw(context)
+            self.title_area.draw(context)
+            if self.show_title:
+                self.title.draw(context)
+            if self.show_main_title:
+                self.main_title.draw(context)
+            self.explanation.draw(context)
+            for s in shortcuts:
+                s.draw(context)
+
+            self.top = Vector((x_min, pos.y + main_title_size.y + self.spacing.y))
+
+
+class GlCursorFence():
+    """
+        Cursor crossing Fence
+    """
+    def __init__(self, width=1, colour=(1.0, 1.0, 1.0, 0.5), style=2852):
+        self.line_x = GlLine(d=2)
+        self.line_x.style = style
+        self.line_x.width = width
+        self.line_x.colour_inactive = colour
+        self.line_y = GlLine(d=2)
+        self.line_y.style = style
+        self.line_y.width = width
+        self.line_y.colour_inactive = colour
+        self.on = True
+
+    def set_location(self, context, location):
+        w = context.region.width
+        h = context.region.height
+        x, y = location
+        self.line_x.p = Vector((0, y))
+        self.line_x.v = Vector((w, 0))
+        self.line_y.p = Vector((x, 0))
+        self.line_y.v = Vector((0, h))
+
+    def enable(self):
+        self.on = True
+
+    def disable(self):
+        self.on = False
+
+    def draw(self, context, render=False):
+        if self.on:
+            self.line_x.draw(context)
+            self.line_y.draw(context)
+
+
+class GlCursorArea():
+    def __init__(self,
+                width=1,
+                bordercolour=(1.0, 1.0, 1.0, 0.5),
+                areacolour=(0.5, 0.5, 0.5, 0.08),
+                style=2852):
+
+        self.border = GlPolyline(bordercolour, d=2)
+        self.border.style = style
+        self.border.width = width
+        self.border.closed = True
+        self.area = GlPolygon(areacolour, d=2)
+        self.min = Vector((0, 0))
+        self.max = Vector((0, 0))
+        self.on = False
+
+    def in_area(self, pt):
+        return (self.min.x <= pt.x and self.max.x >= pt.x and
+            self.min.y <= pt.y and self.max.y >= pt.y)
+
+    def set_location(self, context, p0, p1):
+        x0, y0 = p0
+        x1, y1 = p1
+        if x0 > x1:
+            x1, x0 = x0, x1
+        if y0 > y1:
+            y1, y0 = y0, y1
+        self.min = Vector((x0, y0))
+        self.max = Vector((x1, y1))
+        pos = [
+            Vector((x0, y0)),
+            Vector((x0, y1)),
+            Vector((x1, y1)),
+            Vector((x1, y0))]
+        self.area.set_pos(pos)
+        self.border.set_pos(pos)
+
+    def enable(self):
+        self.on = True
+
+    def disable(self):
+        self.on = False
+
+    def draw(self, context, render=False):
+        if self.on:
+            self.area.draw(context)
+            self.border.draw(context)