greasepencil-addon first push

25 files changed, 1383 insertions, 0 deletions

diff --git a/greasepencil_tools/Official_GP_brush_pack_V1.blend b/greasepencil_tools/Official_GP_brush_pack_V1.blend
new file mode 100644
index 00000000..ca9c4205
--- /dev/null
+++ b/greasepencil_tools/Official_GP_brush_pack_V1.blend
diff --git a/greasepencil_tools/__init__.py b/greasepencil_tools/__init__.py
new file mode 100644
index 00000000..bad7f2e7
--- /dev/null
+++ b/greasepencil_tools/__init__.py
@@ -0,0 +1,63 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+
+bl_info = {
+"name": "Grease Pencil Tools",
+"description": "Pack of tools for Grease pencil drawing",
+"author": "Samuel Bernou, Antonio Vazquez, Daniel Martinez Lara, Matias Mendiola",
+"version": (1, 1, 2),
+"blender": (2, 91, 0),
+"location": "Sidebar > Grease pencil > Grease pencil",
+"warning": "",
+"doc_url": "https://docs.blender.org/manual/en/dev/addons/object/grease_pencil_tools.html",
+"tracker_url": "https://github.com/Pullusb/greasepencil-addon/issues",
+"category": "Object",
+"support": "OFFICIAL",
+}
+
+import bpy
+from .  import (prefs,
+                box_deform,
+                line_reshape,
+                rotate_canvas,
+                import_brush_pack,
+                ui_panels,
+                )
+
+def register():
+    prefs.register()
+    box_deform.register()
+    line_reshape.register()
+    rotate_canvas.register()
+    import_brush_pack.register()
+    ui_panels.register()
+
+    ## update tab name with update in pref file (passing addon_prefs)
+    prefs.update_panel(prefs.get_addon_prefs(), bpy.context)
+
+def unregister():
+    ui_panels.unregister()
+    import_brush_pack.unregister()
+    rotate_canvas.unregister()
+    box_deform.unregister()
+    line_reshape.unregister()
+    prefs.unregister()
+
+if __name__ == "__main__":
+    register()
\ No newline at end of file
diff --git a/greasepencil_tools/box_deform.py b/greasepencil_tools/box_deform.py
new file mode 100644
index 00000000..6354f019
--- /dev/null
+++ b/greasepencil_tools/box_deform.py
@@ -0,0 +1,585 @@
+# ##### 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 #####
+
+'''Based on Box_deform standalone addon - Author: Samuel Bernou'''
+
+from .prefs import get_addon_prefs
+
+import bpy
+import numpy as np
+
+def location_to_region(worldcoords):
+    from bpy_extras import view3d_utils
+    return view3d_utils.location_3d_to_region_2d(bpy.context.region, bpy.context.space_data.region_3d, worldcoords)
+
+def region_to_location(viewcoords, depthcoords):
+    from bpy_extras import view3d_utils
+    return view3d_utils.region_2d_to_location_3d(bpy.context.region, bpy.context.space_data.region_3d, viewcoords, depthcoords)
+
+def assign_vg(obj, vg_name):
+    ## create vertex group
+    vg = obj.vertex_groups.get(vg_name)
+    if vg:
+        # remove to start clean
+        obj.vertex_groups.remove(vg)
+    vg = obj.vertex_groups.new(name=vg_name)
+    bpy.ops.gpencil.vertex_group_assign()
+    return vg
+
+def view_cage(obj):
+    prefs = get_addon_prefs()
+    lattice_interp = prefs.default_deform_type
+
+    gp = obj.data
+    gpl = gp.layers
+
+    coords = []
+    initial_mode = bpy.context.mode
+
+    ## get points
+    if bpy.context.mode == 'EDIT_GPENCIL':
+        for l in gpl:
+            if l.lock or l.hide or not l.active_frame:#or len(l.frames)
+                continue
+            if gp.use_multiedit:
+                target_frames = [f for f in l.frames if f.select]
+            else:
+                target_frames = [l.active_frame]
+            
+            for f in target_frames:
+                for s in f.strokes:
+                    if not s.select:
+                        continue
+                    for p in s.points:
+                        if p.select:
+                            # get real location
+                            coords.append(obj.matrix_world @ p.co)
+
+    elif bpy.context.mode == 'OBJECT':#object mode -> all points
+        for l in gpl:# if l.hide:continue# only visible ? (might break things)
+            if not len(l.frames):
+                continue#skip frameless layer
+            for s in l.active_frame.strokes:
+                for p in s.points:
+                    coords.append(obj.matrix_world @ p.co)
+    
+    elif bpy.context.mode == 'PAINT_GPENCIL':
+        # get last stroke points coordinated
+        if not gpl.active or not gpl.active.active_frame:
+            return 'No frame to deform'
+
+        if not len(gpl.active.active_frame.strokes):
+            return 'No stroke found to deform'
+        
+        paint_id = -1
+        if bpy.context.scene.tool_settings.use_gpencil_draw_onback:
+            paint_id = 0
+        coords = [obj.matrix_world @ p.co for p in gpl.active.active_frame.strokes[paint_id].points]
+    
+    else:
+        return 'Wrong mode!'
+
+    if not coords:
+        ## maybe silent return instead (need special str code to manage errorless return)
+        return 'No points found!'
+
+    if bpy.context.mode in ('EDIT_GPENCIL', 'PAINT_GPENCIL') and len(coords) < 2:
+        # Dont block object mod
+        return 'Less than two point selected'
+
+    vg_name = 'lattice_cage_deform_group'
+
+    if bpy.context.mode == 'EDIT_GPENCIL':
+        vg = assign_vg(obj, vg_name)
+    
+    if bpy.context.mode == 'PAINT_GPENCIL':
+        # points cannot be assign to API yet(ugly and slow workaround but only way)
+        # -> https://developer.blender.org/T56280 so, hop'in'ops !
+        
+        # store selection and deselect all
+        plist = []
+        for s in gpl.active.active_frame.strokes:
+            for p in s.points:
+                plist.append([p, p.select])
+                p.select = False
+        
+        # select
+        ## foreach_set does not update
+        # gpl.active.active_frame.strokes[paint_id].points.foreach_set('select', [True]*len(gpl.active.active_frame.strokes[paint_id].points))
+        for p in gpl.active.active_frame.strokes[paint_id].points:
+            p.select = True
+        
+        # assign
+        bpy.ops.object.mode_set(mode='EDIT_GPENCIL')
+        vg = assign_vg(obj, vg_name)
+
+        # restore
+        for pl in plist:
+            pl[0].select = pl[1]
+        
+
+    ## View axis Mode ---
+
+    ## get view coordinate of all points
+    coords2D = [location_to_region(co) for co in coords]
+
+    # find centroid for depth (or more economic, use obj origin...)
+    centroid = np.mean(coords, axis=0)
+
+    # not a mean ! a mean of extreme ! centroid2d = np.mean(coords2D, axis=0)
+    all_x, all_y = np.array(coords2D)[:, 0], np.array(coords2D)[:, 1]
+    min_x, min_y = np.min(all_x), np.min(all_y)
+    max_x, max_y = np.max(all_x), np.max(all_y)
+
+    width = (max_x - min_x)
+    height = (max_y - min_y)
+    center_x = min_x + (width/2)
+    center_y = min_y + (height/2)
+
+    centroid2d = (center_x,center_y)
+    center = region_to_location(centroid2d, centroid)
+    # bpy.context.scene.cursor.location = center#Dbg
+
+
+    #corner Bottom-left to Bottom-right
+    x0 = region_to_location((min_x, min_y), centroid)
+    x1 = region_to_location((max_x, min_y), centroid)
+    x_worldsize = (x0 - x1).length
+
+    #corner Bottom-left to top-left
+    y0 = region_to_location((min_x, min_y), centroid)
+    y1 = region_to_location((min_x, max_y), centroid)
+    y_worldsize = (y0 - y1).length
+
+    ## in case of 3
+
+    lattice_name = 'lattice_cage_deform'
+    # cleaning
+    cage = bpy.data.objects.get(lattice_name)
+    if cage:
+        bpy.data.objects.remove(cage)
+
+    lattice = bpy.data.lattices.get(lattice_name)
+    if lattice:
+        bpy.data.lattices.remove(lattice)
+
+    # create lattice object
+    lattice = bpy.data.lattices.new(lattice_name)
+    cage = bpy.data.objects.new(lattice_name, lattice)
+    cage.show_in_front = True
+
+    ## Master (root) collection
+    bpy.context.scene.collection.objects.link(cage)
+
+    # spawn cage and align it to view (Again ! align something to a vector !!! argg)
+
+    r3d = bpy.context.space_data.region_3d
+    viewmat = r3d.view_matrix
+
+    cage.matrix_world = viewmat.inverted()
+    cage.scale = (x_worldsize, y_worldsize, 1)
+    ## Z aligned in view direction (need minus X 90 degree to be aligned FRONT)
+    # cage.rotation_euler.x -= radians(90)
+    # cage.scale = (x_worldsize, 1, y_worldsize)
+    cage.location = center
+
+    lattice.points_u = 2
+    lattice.points_v = 2
+    lattice.points_w = 1
+
+    lattice.interpolation_type_u = lattice_interp#'KEY_LINEAR'-'KEY_BSPLINE'
+    lattice.interpolation_type_v = lattice_interp#'KEY_LINEAR'-'KEY_BSPLINE'
+    lattice.interpolation_type_w = lattice_interp#'KEY_LINEAR'-'KEY_BSPLINE'
+
+    mod = obj.grease_pencil_modifiers.new('tmp_lattice', 'GP_LATTICE')
+
+    # move to top if modifiers exists
+    for _ in range(len(obj.grease_pencil_modifiers)):
+        bpy.ops.object.gpencil_modifier_move_up(modifier='tmp_lattice')
+
+    mod.object = cage
+
+    if initial_mode == 'PAINT_GPENCIL':
+        mod.layer = gpl.active.info
+    
+    # note : if initial was Paint, changed to Edit
+    #        so vertex attribution is valid even for paint
+    if bpy.context.mode == 'EDIT_GPENCIL':
+        mod.vertex_group = vg.name
+
+    #Go in object mode if not already
+    if bpy.context.mode != 'OBJECT':
+        bpy.ops.object.mode_set(mode='OBJECT')
+
+    # Store name of deformed object in case of 'revive modal' 
+    cage.vertex_groups.new(name=obj.name)
+
+    ## select and make cage active
+    # cage.select_set(True)
+    bpy.context.view_layer.objects.active = cage
+    obj.select_set(False)#deselect GP object
+    bpy.ops.object.mode_set(mode='EDIT')# go in lattice edit mode
+    bpy.ops.lattice.select_all(action='SELECT')# select all points
+
+    if prefs.use_clic_drag:
+        ## Eventually change tool mode to tweak for direct point editing (reset after before leaving)
+        bpy.ops.wm.tool_set_by_id(name="builtin.select")# Tweaktoolcode
+    return cage
+
+
+def back_to_obj(obj, gp_mode, org_lattice_toolset, context):
+    if context.mode == 'EDIT_LATTICE' and org_lattice_toolset:# Tweaktoolcode - restore the active tool used by lattice edit..
+        bpy.ops.wm.tool_set_by_id(name = org_lattice_toolset)# Tweaktoolcode
+    
+    # gp object active and selected
+    bpy.ops.object.mode_set(mode='OBJECT')
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+
+
+def delete_cage(cage):
+    lattice = cage.data
+    bpy.data.objects.remove(cage)
+    bpy.data.lattices.remove(lattice)
+
+def apply_cage(gp_obj, cage):
+    mod = gp_obj.grease_pencil_modifiers.get('tmp_lattice')
+    if mod:
+        bpy.ops.object.gpencil_modifier_apply(apply_as='DATA', modifier=mod.name)
+    else:
+        print('tmp_lattice modifier not found to apply...')
+
+    delete_cage(cage)
+
+def cancel_cage(gp_obj, cage):
+    #remove modifier
+    mod = gp_obj.grease_pencil_modifiers.get('tmp_lattice')
+    if mod:
+        gp_obj.grease_pencil_modifiers.remove(mod)
+    else:
+        print('tmp_lattice modifier not found to remove...')
+    
+    delete_cage(cage)
+    
+
+class GP_OT_latticeGpDeform(bpy.types.Operator):
+    """Create a lattice to use as quad corner transform"""
+    bl_idname = "gp.latticedeform"
+    bl_label = "Box Deform"
+    bl_description = "Use lattice for free box transforms on grease pencil points (Ctrl+T)"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.object is not None and context.object.type in ('GPENCIL','LATTICE')
+
+    # local variable
+    tab_press_ct = 0
+
+    def modal(self, context, event):
+        display_text = f"Deform Cage size: {self.lat.points_u}x{self.lat.points_v} (1-9 or ctrl + ←→↑↓)  | \
+mode (M) : {'Linear' if self.lat.interpolation_type_u == 'KEY_LINEAR' else 'Spline'} | \
+valid:Spacebar/Enter, cancel:Del/Backspace/Tab/Ctrl+T"
+        context.area.header_text_set(display_text)
+
+
+        ## Handle ctrl+Z
+        if event.type in {'Z'} and event.value == 'PRESS' and event.ctrl:
+            ## Disable (capture key)
+            return {"RUNNING_MODAL"}
+            ## Not found how possible to find modal start point in undo stack to 
+            # print('ops list', context.window_manager.operators.keys())
+            # if context.window_manager.operators:#can be empty
+            #     print('\nlast name', context.window_manager.operators[-1].name)
+
+        # Auto interpo check
+        if self.auto_interp:
+            if event.type in {'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE', 'ZERO',} and event.value == 'PRESS':
+                self.set_lattice_interp('KEY_BSPLINE')
+            if event.type in {'DOWN_ARROW', "UP_ARROW", "RIGHT_ARROW", "LEFT_ARROW"} and event.value == 'PRESS' and event.ctrl:
+                self.set_lattice_interp('KEY_BSPLINE')
+            if event.type in {'ONE'} and event.value == 'PRESS':
+                self.set_lattice_interp('KEY_LINEAR')
+
+        # Single keys
+        if event.type in {'H'} and event.value == 'PRESS':
+            # self.report({'INFO'}, "Can't hide")
+            return {"RUNNING_MODAL"}
+        
+        if event.type in {'ONE'} and event.value == 'PRESS':# , 'NUMPAD_1'
+            self.lat.points_u = self.lat.points_v = 2
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'TWO'} and event.value == 'PRESS':# , 'NUMPAD_2'
+            self.lat.points_u = self.lat.points_v = 3
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'THREE'} and event.value == 'PRESS':# , 'NUMPAD_3'
+            self.lat.points_u = self.lat.points_v = 4
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'FOUR'} and event.value == 'PRESS':# , 'NUMPAD_4'
+            self.lat.points_u = self.lat.points_v = 5
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'FIVE'} and event.value == 'PRESS':# , 'NUMPAD_5'
+            self.lat.points_u = self.lat.points_v = 6
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'SIX'} and event.value == 'PRESS':# , 'NUMPAD_6'
+            self.lat.points_u = self.lat.points_v = 7
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'SEVEN'} and event.value == 'PRESS':# , 'NUMPAD_7'
+            self.lat.points_u = self.lat.points_v = 8
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'EIGHT'} and event.value == 'PRESS':# , 'NUMPAD_8'
+            self.lat.points_u = self.lat.points_v = 9
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'NINE'} and event.value == 'PRESS':# , 'NUMPAD_9'
+            self.lat.points_u = self.lat.points_v = 10
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'ZERO'} and event.value == 'PRESS':# , 'NUMPAD_0'
+            self.lat.points_u = 2
+            self.lat.points_v = 1
+            return {"RUNNING_MODAL"}
+        
+        if event.type in {'RIGHT_ARROW'} and event.value == 'PRESS' and event.ctrl:
+            if self.lat.points_u < 20:
+                self.lat.points_u += 1 
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'LEFT_ARROW'} and event.value == 'PRESS' and event.ctrl:
+            if self.lat.points_u > 1:
+                self.lat.points_u -= 1 
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'UP_ARROW'} and event.value == 'PRESS' and event.ctrl:
+            if self.lat.points_v < 20:
+                self.lat.points_v += 1 
+            return {"RUNNING_MODAL"}
+
+        if event.type in {'DOWN_ARROW'} and event.value == 'PRESS' and event.ctrl:
+            if self.lat.points_v > 1:
+                self.lat.points_v -= 1 
+            return {"RUNNING_MODAL"}
+
+
+        # change modes
+        if event.type in {'M'} and event.value == 'PRESS':
+            self.auto_interp = False
+            interp = 'KEY_BSPLINE' if self.lat.interpolation_type_u == 'KEY_LINEAR' else 'KEY_LINEAR'
+            self.set_lattice_interp(interp)
+            return {"RUNNING_MODAL"}
+
+        # Valid
+        if event.type in {'RET', 'SPACE'}:
+            if event.value == 'PRESS':
+                context.window_manager.boxdeform_running = False
+                self.restore_prefs(context)
+                back_to_obj(self.gp_obj, self.gp_mode, self.org_lattice_toolset, context)
+                apply_cage(self.gp_obj, self.cage)#must be in object mode
+                
+                # back to original mode 
+                if self.gp_mode != 'OBJECT':
+                    bpy.ops.object.mode_set(mode=self.gp_mode)
+
+                context.area.header_text_set(None)#reset header
+
+                return {'FINISHED'}
+        
+        # Abort ---
+        # One Warning for Tab cancellation.
+        if event.type == 'TAB' and event.value == 'PRESS':
+            self.tab_press_ct += 1
+            if self.tab_press_ct < 2:
+                self.report({'WARNING'}, "Pressing TAB again will Cancel")
+                return {"RUNNING_MODAL"}
+
+        if event.type in {'T'} and event.value == 'PRESS' and event.ctrl:# Retyped same shortcut
+            self.cancel(context)
+            return {'CANCELLED'}
+
+        if event.type in {'DEL', 'BACK_SPACE'} or self.tab_press_ct >= 2:#'ESC',
+            self.cancel(context)
+            return {'CANCELLED'}
+
+        return {'PASS_THROUGH'}
+
+    def set_lattice_interp(self, interp):
+        self.lat.interpolation_type_u = self.lat.interpolation_type_v = self.lat.interpolation_type_w = interp
+
+    def cancel(self, context):
+        context.window_manager.boxdeform_running = False
+        self.restore_prefs(context)
+        back_to_obj(self.gp_obj, self.gp_mode, self.org_lattice_toolset, context)
+        cancel_cage(self.gp_obj, self.cage)
+        context.area.header_text_set(None)     
+        if self.gp_mode != 'OBJECT':
+            bpy.ops.object.mode_set(mode=self.gp_mode)
+
+    def store_prefs(self, context):
+        # store_valierables <-< preferences
+        self.use_drag_immediately = context.preferences.inputs.use_drag_immediately 
+        self.drag_threshold_mouse = context.preferences.inputs.drag_threshold_mouse 
+        self.drag_threshold_tablet = context.preferences.inputs.drag_threshold_tablet
+        self.use_overlays = context.space_data.overlay.show_overlays
+        # maybe store in windows manager to keep around in case of modal revival ?
+
+    def restore_prefs(self, context):
+        # preferences <-< store_valierables
+        context.preferences.inputs.use_drag_immediately = self.use_drag_immediately
+        context.preferences.inputs.drag_threshold_mouse = self.drag_threshold_mouse
+        context.preferences.inputs.drag_threshold_tablet = self.drag_threshold_tablet
+        context.space_data.overlay.show_overlays = self.use_overlays
+    
+    def set_prefs(self, context):
+        context.preferences.inputs.use_drag_immediately = True
+        context.preferences.inputs.drag_threshold_mouse = 1
+        context.preferences.inputs.drag_threshold_tablet = 3
+        context.space_data.overlay.show_overlays = True
+
+    def invoke(self, context, event):
+        ## Restrict to 3D view
+        if context.area.type != 'VIEW_3D':
+            self.report({'WARNING'}, "View3D not found, cannot run operator")
+            return {'CANCELLED'}
+
+        if not context.object:#do it in poll ?
+            self.report({'ERROR'}, "No active objects found")
+            return {'CANCELLED'}
+
+        if context.window_manager.boxdeform_running:
+            return {'CANCELLED'}
+
+        self.prefs = get_addon_prefs()#get_prefs
+        self.auto_interp = self.prefs.auto_swap_deform_type
+        self.org_lattice_toolset = None
+        ## usability toggles
+        if self.prefs.use_clic_drag:#Store the active tool since we will change it
+            self.org_lattice_toolset = bpy.context.workspace.tools.from_space_view3d_mode(bpy.context.mode, create=False).idname# Tweaktoolcode    
+        
+        #store (scene properties needed in case of ctrlZ revival)
+        self.store_prefs(context)
+        self.gp_mode = 'EDIT_GPENCIL'
+
+        # --- special Case of lattice revive modal, just after ctrl+Z back into lattice with modal stopped
+        if context.mode == 'EDIT_LATTICE' and context.object.name == 'lattice_cage_deform' and len(context.object.vertex_groups):
+            self.gp_obj = context.scene.objects.get(context.object.vertex_groups[0].name)
+            if not self.gp_obj:
+                self.report({'ERROR'}, "/!\\ Box Deform : Cannot find object to target")
+                return {'CANCELLED'}
+            if not self.gp_obj.grease_pencil_modifiers.get('tmp_lattice'):
+                self.report({'ERROR'}, "/!\\ No 'tmp_lattice' modifiers on GP object")
+                return {'CANCELLED'}
+            self.cage = context.object
+            self.lat = self.cage.data
+            self.set_prefs(context)
+
+            if self.prefs.use_clic_drag:
+                bpy.ops.wm.tool_set_by_id(name="builtin.select")
+            context.window_manager.boxdeform_running = True
+            context.window_manager.modal_handler_add(self)
+            return {'RUNNING_MODAL'}
+
+        if context.object.type != 'GPENCIL':
+            # self.report({'ERROR'}, "Works only on gpencil objects")
+            ## silent return 
+            return {'CANCELLED'}
+
+        #paint need VG workaround. object need good shortcut
+        if context.mode not in ('EDIT_GPENCIL', 'OBJECT', 'PAINT_GPENCIL'):
+            # self.report({'WARNING'}, "Works only in following GPencil modes: edit")# ERROR
+            ## silent return 
+            return {'CANCELLED'}
+
+        # bpy.ops.ed.undo_push(message="Box deform step")#don't work as expected (+ might be obsolete)
+        # https://developer.blender.org/D6147 <- undo forget 
+
+        self.gp_obj = context.object
+        # Clean potential failed previous job (delete tmp lattice)
+        mod = self.gp_obj.grease_pencil_modifiers.get('tmp_lattice')
+        if mod:
+            print('Deleted remaining lattice modifiers')
+            self.gp_obj.grease_pencil_modifiers.remove(mod)
+
+        phantom_obj = context.scene.objects.get('lattice_cage_deform')
+        if phantom_obj:
+            print('Deleted remaining lattice object')
+            delete_cage(phantom_obj)
+
+        if [m for m in self.gp_obj.grease_pencil_modifiers if m.type == 'GP_LATTICE']:
+            self.report({'ERROR'}, "Grease pencil object already has a lattice modifier (can only have one)")
+            return {'CANCELLED'}
+        
+
+        self.gp_mode = context.mode#store mode for restore
+        
+        # All good, create lattice and start modal
+
+        # Create lattice (and switch to lattice edit) ----
+        self.cage = view_cage(self.gp_obj)
+        if isinstance(self.cage, str):#error, cage not created, display error
+            self.report({'ERROR'}, self.cage)
+            return {'CANCELLED'}
+        
+        self.lat = self.cage.data
+
+        self.set_prefs(context)
+        context.window_manager.boxdeform_running = True
+        context.window_manager.modal_handler_add(self)
+        return {'RUNNING_MODAL'}
+
+## --- KEYMAP
+
+addon_keymaps = []
+def register_keymaps():
+    addon = bpy.context.window_manager.keyconfigs.addon
+
+    km = addon.keymaps.new(name = "Grease Pencil", space_type = "EMPTY", region_type='WINDOW')
+    kmi = km.keymap_items.new("gp.latticedeform", type ='T', value = "PRESS", ctrl = True)
+    kmi.repeat = False
+    addon_keymaps.append(km)
+
+def unregister_keymaps():
+    for km in addon_keymaps:
+        for kmi in km.keymap_items:
+            km.keymap_items.remove(kmi)
+    addon_keymaps.clear()
+
+### --- REGISTER ---
+
+def register():
+    if bpy.app.background:
+        return
+    bpy.types.WindowManager.boxdeform_running = bpy.props.BoolProperty(default=False)
+    bpy.utils.register_class(GP_OT_latticeGpDeform)
+    register_keymaps()
+
+def unregister():
+    if bpy.app.background:
+        return
+    unregister_keymaps()
+    bpy.utils.unregister_class(GP_OT_latticeGpDeform)
+    wm = bpy.context.window_manager
+    p = 'boxdeform_running'
+    if p in wm:
+        del wm[p]
\ No newline at end of file
diff --git a/greasepencil_tools/icos/tex_01.jpg b/greasepencil_tools/icos/tex_01.jpg
new file mode 100644
index 00000000..e8f88b25
--- /dev/null
+++ b/greasepencil_tools/icos/tex_01.jpg
diff --git a/greasepencil_tools/icos/tex_02.jpg b/greasepencil_tools/icos/tex_02.jpg
new file mode 100644
index 00000000..61ee7700
--- /dev/null
+++ b/greasepencil_tools/icos/tex_02.jpg
diff --git a/greasepencil_tools/icos/tex_03.jpg b/greasepencil_tools/icos/tex_03.jpg
new file mode 100644
index 00000000..7a091d26
--- /dev/null
+++ b/greasepencil_tools/icos/tex_03.jpg
diff --git a/greasepencil_tools/icos/tex_04.jpg b/greasepencil_tools/icos/tex_04.jpg
new file mode 100644
index 00000000..880814e4
--- /dev/null
+++ b/greasepencil_tools/icos/tex_04.jpg
diff --git a/greasepencil_tools/icos/tex_05.jpg b/greasepencil_tools/icos/tex_05.jpg
new file mode 100644
index 00000000..c7220c6e
--- /dev/null
+++ b/greasepencil_tools/icos/tex_05.jpg
diff --git a/greasepencil_tools/icos/tex_06.jpg b/greasepencil_tools/icos/tex_06.jpg
new file mode 100644
index 00000000..23d37141
--- /dev/null
+++ b/greasepencil_tools/icos/tex_06.jpg
diff --git a/greasepencil_tools/icos/tex_07.jpg b/greasepencil_tools/icos/tex_07.jpg
new file mode 100644
index 00000000..5e1b1cb3
--- /dev/null
+++ b/greasepencil_tools/icos/tex_07.jpg
diff --git a/greasepencil_tools/icos/tex_08.jpg b/greasepencil_tools/icos/tex_08.jpg
new file mode 100644
index 00000000..44376fdd
--- /dev/null
+++ b/greasepencil_tools/icos/tex_08.jpg
diff --git a/greasepencil_tools/icos/tex_09.jpg b/greasepencil_tools/icos/tex_09.jpg
new file mode 100644
index 00000000..45aff490
--- /dev/null
+++ b/greasepencil_tools/icos/tex_09.jpg
diff --git a/greasepencil_tools/icos/tex_10.jpg b/greasepencil_tools/icos/tex_10.jpg
new file mode 100644
index 00000000..952d18d9
--- /dev/null
+++ b/greasepencil_tools/icos/tex_10.jpg
diff --git a/greasepencil_tools/icos/tex_11.jpg b/greasepencil_tools/icos/tex_11.jpg
new file mode 100644
index 00000000..032bcd0c
--- /dev/null
+++ b/greasepencil_tools/icos/tex_11.jpg
diff --git a/greasepencil_tools/icos/tex_12.jpg b/greasepencil_tools/icos/tex_12.jpg
new file mode 100644
index 00000000..9e07a1b5
--- /dev/null
+++ b/greasepencil_tools/icos/tex_12.jpg
diff --git a/greasepencil_tools/icos/tex_13.jpg b/greasepencil_tools/icos/tex_13.jpg
new file mode 100644
index 00000000..05c89ca7
--- /dev/null
+++ b/greasepencil_tools/icos/tex_13.jpg
diff --git a/greasepencil_tools/icos/tex_14.jpg b/greasepencil_tools/icos/tex_14.jpg
new file mode 100644
index 00000000..8d36c530
--- /dev/null
+++ b/greasepencil_tools/icos/tex_14.jpg
diff --git a/greasepencil_tools/icos/tex_15.jpg b/greasepencil_tools/icos/tex_15.jpg
new file mode 100644
index 00000000..b84732d2
--- /dev/null
+++ b/greasepencil_tools/icos/tex_15.jpg
diff --git a/greasepencil_tools/icos/tex_16.jpg b/greasepencil_tools/icos/tex_16.jpg
new file mode 100644
index 00000000..3ba1bc23
--- /dev/null
+++ b/greasepencil_tools/icos/tex_16.jpg
diff --git a/greasepencil_tools/icos/tex_17.jpg b/greasepencil_tools/icos/tex_17.jpg
new file mode 100644
index 00000000..b9751c7c
--- /dev/null
+++ b/greasepencil_tools/icos/tex_17.jpg
diff --git a/greasepencil_tools/import_brush_pack.py b/greasepencil_tools/import_brush_pack.py
new file mode 100644
index 00000000..fbeb25f1
--- /dev/null
+++ b/greasepencil_tools/import_brush_pack.py
@@ -0,0 +1,40 @@
+import bpy
+
+class GP_OT_install_brush_pack(bpy.types.Operator):
+    bl_idname = "gp.import_brush_pack"
+    bl_label = "Import texture brush pack"
+    bl_description = "import Grease Pencil brush pack from Grease Pencil addon"
+    bl_options = {"REGISTER", "INTERNAL"}
+
+    def execute(self, context):
+        from pathlib import Path
+
+        blendname = 'Official_GP_brush_pack_V1.blend'        
+        blend_fp = Path(__file__).parent / blendname
+        print('blend_fp: ', blend_fp)
+
+        cur_brushes = [b.name for b in bpy.data.brushes]
+        with bpy.data.libraries.load(str(blend_fp), link=False) as (data_from, data_to):
+            # load brushes starting with 'tex' prefix if there are not already there
+            data_to.brushes = [b for b in data_from.brushes if b.startswith('tex_') and not b in cur_brushes]
+            # Add holdout
+            if 'z_holdout' in data_from.brushes:
+                data_to.brushes.append('z_holdout')
+
+        brush_count = len(data_to.brushes)
+        ## force fake user for the brushes
+        for b in data_to.brushes:
+            b.use_fake_user = True
+
+        if brush_count:
+            self.report({'INFO'}, f'{brush_count} brushes installed')
+        else:
+            self.report({'WARNING'}, 'Brushes already loaded')
+        return {"FINISHED"}
+
+
+def register():
+    bpy.utils.register_class(GP_OT_install_brush_pack)
+
+def unregister():
+    bpy.utils.unregister_class(GP_OT_install_brush_pack)
\ No newline at end of file
diff --git a/greasepencil_tools/line_reshape.py b/greasepencil_tools/line_reshape.py
new file mode 100644
index 00000000..608b95b2
--- /dev/null
+++ b/greasepencil_tools/line_reshape.py
@@ -0,0 +1,192 @@
+# ##### 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 #####
+ 
+'''Based on GP_refine_stroke 0.2.4 - Author: Samuel Bernou'''
+
+import bpy
+
+### --- Vector utils
+
+def mean(*args):
+    '''
+    return mean of all passed value (multiple)
+    If it's a list or tuple return mean of it (only on first list passed).
+    '''
+    if isinstance(args[0], list) or isinstance(args[0], tuple):
+        return mean(*args[0])#send the first list UNPACKED (else infinite recursion as it always evaluate as list)
+    return sum(args) / len(args)
+
+def vector_len_from_coord(a, b):
+    '''
+    Get two points (that has coordinate 'co' attribute) or Vectors (2D or 3D)
+    Return length as float
+    '''
+    from mathutils import Vector    
+    if type(a) is Vector:
+        return (a - b).length
+    else:   
+        return (a.co - b.co).length
+
+def point_from_dist_in_segment_3d(a, b, ratio):
+    '''return the tuple coords of a point on 3D segment ab according to given ratio (some distance divided by total segment lenght)'''
+    ## ref:https://math.stackexchange.com/questions/175896/finding-a-point-along-a-line-a-certain-distance-away-from-another-point
+    # ratio = dist / seglenght
+    return ( ((1 - ratio) * a[0] + (ratio*b[0])), ((1 - ratio) * a[1] + (ratio*b[1])), ((1 - ratio) * a[2] + (ratio*b[2])) )
+
+def get_stroke_length(s):
+    '''return 3D total length of the stroke'''
+    all_len = 0.0
+    for i in range(0, len(s.points)-1):
+        #print(vector_len_from_coord(s.points[i],s.points[i+1]))
+        all_len += vector_len_from_coord(s.points[i],s.points[i+1])   
+    return (all_len)
+
+### --- Functions
+
+def to_straight_line(s, keep_points=True, influence=100, straight_pressure=True):
+    '''
+    keep points : if false only start and end point stay
+    straight_pressure : (not available with keep point) take the mean pressure of all points and apply to stroke.
+    '''
+    
+    p_len = len(s.points)
+    if p_len <= 2: # 1 or 2 points only, cancel
+        return
+
+    if not keep_points:
+        if straight_pressure: mean_pressure = mean([p.pressure for p in s.points])#can use a foreach_get but might not be faster.
+        for i in range(p_len-2):
+            s.points.pop(index=1)
+        if straight_pressure:
+            for p in s.points:
+                p.pressure = mean_pressure
+
+    else:
+        A = s.points[0].co
+        B = s.points[-1].co
+        # ab_dist = vector_len_from_coord(A,B)
+        full_dist = get_stroke_length(s)
+        dist_from_start = 0.0
+        coord_list = []
+        
+        for i in range(1, p_len-1):#all but first and last
+            dist_from_start += vector_len_from_coord(s.points[i-1],s.points[i])
+            ratio = dist_from_start / full_dist
+            # dont apply directly (change line as we measure it in loop)
+            coord_list.append( point_from_dist_in_segment_3d(A, B, ratio) )
+        
+        # apply change
+        for i in range(1, p_len-1):
+            ## Direct super straight 100%
+            #s.points[i].co = coord_list[i-1]
+            
+            ## With influence
+            s.points[i].co = point_from_dist_in_segment_3d(s.points[i].co, coord_list[i-1], influence / 100)
+    
+    return
+
+def get_last_index(context=None):
+    if not context:
+        context = bpy.context
+    return 0 if context.tool_settings.use_gpencil_draw_onback else -1
+
+### --- OPS
+
+class GP_OT_straightStroke(bpy.types.Operator):
+    bl_idname = "gp.straight_stroke"
+    bl_label = "Straight Stroke"
+    bl_description = "Make stroke a straight line between first and last point, tweak influence in the redo panel\
+        \nshift+click to reset infuence to 100%"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.active_object is not None and context.object.type == 'GPENCIL'
+        #and context.mode in ('PAINT_GPENCIL', 'EDIT_GPENCIL')
+
+    influence_val : bpy.props.FloatProperty(name="Straight force", description="Straight interpolation percentage", 
+    default=100, min=0, max=100, step=2, precision=1, subtype='PERCENTAGE', unit='NONE')
+    
+    def execute(self, context):
+        gp = context.object.data
+        gpl = gp.layers
+        if not gpl:
+            return {"CANCELLED"}
+
+        if context.mode == 'PAINT_GPENCIL':
+            if not gpl.active or not gpl.active.active_frame:
+                self.report({'ERROR'}, 'No Grease pencil frame found') 
+                return {"CANCELLED"}
+
+            if not len(gpl.active.active_frame.strokes):
+                self.report({'ERROR'}, 'No strokes found.') 
+                return {"CANCELLED"}
+
+            s = gpl.active.active_frame.strokes[get_last_index(context)]
+            to_straight_line(s, keep_points=True, influence=self.influence_val)
+        
+        elif context.mode == 'EDIT_GPENCIL':
+            ct = 0
+            for l in gpl:
+                if l.lock or l.hide or not l.active_frame:
+                    # avoid locked, hided, empty layers
+                    continue
+                if gp.use_multiedit:
+                    target_frames = [f for f in l.frames if f.select]
+                else:
+                    target_frames = [l.active_frame]
+                
+                for f in target_frames:
+                    for s in f.strokes:
+                        if s.select:
+                            ct += 1
+                            to_straight_line(s, keep_points=True, influence=self.influence_val)
+            
+            if not ct:
+                self.report({'ERROR'}, 'No selected stroke found.') 
+                return {"CANCELLED"}
+
+        ## filter method
+        # if context.mode == 'PAINT_GPENCIL':
+        #     L, F, S = 'ACTIVE', 'ACTIVE', 'LAST'
+        # elif context.mode == 'EDIT_GPENCIL'
+        #     L, F, S = 'ALL', 'ACTIVE', 'SELECT'
+        #     if gp.use_multiedit: F = 'SELECT'
+        # else : return {"CANCELLED"}
+        # for s in strokelist(t_layer=L, t_frame=F, t_stroke=S):
+        #     to_straight_line(s, keep_points=True, influence = self.influence_val)#, straight_pressure=True
+
+        return {"FINISHED"}
+    
+    def draw(self, context):
+        layout = self.layout
+        layout.prop(self, "influence_val")
+
+    def invoke(self, context, event):
+        if context.mode not in ('PAINT_GPENCIL', 'EDIT_GPENCIL'):
+            return {"CANCELLED"}
+        if event.shift:
+            self.influence_val = 100
+        return self.execute(context)
+
+
+def register():
+    bpy.utils.register_class(GP_OT_straightStroke)
+
+def unregister():
+    bpy.utils.unregister_class(GP_OT_straightStroke)
diff --git a/greasepencil_tools/prefs.py b/greasepencil_tools/prefs.py
new file mode 100644
index 00000000..81434136
--- /dev/null
+++ b/greasepencil_tools/prefs.py
@@ -0,0 +1,250 @@
+# ##### 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 #####
+
+import bpy
+import os
+from bpy.props import (
+        BoolProperty,
+        EnumProperty,
+        StringProperty,
+        # IntProperty,
+        )
+
+from .ui_panels import GP_PT_sidebarPanel
+
+def get_addon_prefs():
+    import os
+    addon_name = os.path.splitext(__name__)[0]
+    addon_prefs = bpy.context.preferences.addons[addon_name].preferences
+    return (addon_prefs)
+
+## Addons Preferences Update Panel
+def update_panel(self, context):
+    try:
+        bpy.utils.unregister_class(GP_PT_sidebarPanel)
+    except:
+        pass
+    GP_PT_sidebarPanel.bl_category = get_addon_prefs().category
+    bpy.utils.register_class(GP_PT_sidebarPanel)
+
+## keymap binder for rotate canvas
+def auto_rebind(self, context):
+    unregister_keymaps()
+    register_keymaps()
+
+class GreasePencilAddonPrefs(bpy.types.AddonPreferences):
+    bl_idname = os.path.splitext(__name__)[0]#'greasepencil-addon' ... __package__ ?
+    # bl_idname = __name__
+
+    category : StringProperty(
+            name="Category",
+            description="Choose a name for the category of the panel",
+            default="Grease pencil",
+            update=update_panel)
+
+    pref_tabs : EnumProperty(
+        items=(('PREF', "Preferences", "Preferences properties of GP"),
+               ('TUTO', "Tutorial", "How to use the tool"),
+               # ('KEYMAP', "Keymap", "customise the default keymap"),
+               ),
+               default='PREF')
+
+    # --- props
+    use_clic_drag : BoolProperty(
+        name='Use click drag directly on points',
+        description="Change the active tool to 'tweak' during modal, Allow to direct clic-drag points of the box",
+        default=True)
+    
+    default_deform_type : EnumProperty(
+        items=(('KEY_LINEAR', "Linear (perspective mode)", "Linear interpolation, like corner deform / perspective tools of classic 2D", 'IPO_LINEAR',0),
+               ('KEY_BSPLINE', "Spline (smooth deform)", "Spline interpolation transformation\nBest when lattice is subdivided", 'IPO_CIRC',1),
+               ),
+        name='Starting interpolation', default='KEY_LINEAR', description='Choose default interpolation when entering mode')
+    
+    # About interpolation : https://docs.blender.org/manual/en/2.83/animation/shape_keys/shape_keys_panel.html#fig-interpolation-type
+
+    auto_swap_deform_type : BoolProperty(
+        name='Auto swap interpolation mode',
+        description="Automatically set interpolation to 'spline' when subdividing lattice\n Back to 'linear' when",
+        default=True)
+
+    ## rotate canvas variables
+
+    ## Use HUD
+    canvas_use_hud: BoolProperty(
+        name = "Use Hud",
+        description = "Display angle lines and angle value as text on viewport",
+        default = False)
+
+    ## Canvas rotate
+    canvas_use_shortcut: BoolProperty(
+        name = "Use Default Shortcut",
+        description = "Use default shortcut: mouse double-click + modifier",
+        default = True,
+        update=auto_rebind)
+
+    mouse_click : EnumProperty(
+        name="Mouse button", description="click on right/left/middle mouse button in combination with a modifier to trigger alignement",
+        default='MIDDLEMOUSE',
+        items=(
+            ('RIGHTMOUSE', 'Right click', 'Use click on Right mouse button', 'MOUSE_RMB', 0),
+            ('LEFTMOUSE', 'Left click', 'Use click on Left mouse button', 'MOUSE_LMB', 1),
+            ('MIDDLEMOUSE', 'Mid click', 'Use click on Mid mouse button', 'MOUSE_MMB', 2),
+            ),
+        update=auto_rebind)
+    
+    use_shift: BoolProperty(
+            name = "combine with shift",
+            description = "add shift",
+            default = False,
+            update=auto_rebind)
+
+    use_alt: BoolProperty(
+            name = "combine with alt",
+            description = "add alt",
+            default = True,
+            update=auto_rebind)
+
+    use_ctrl: BoolProperty(
+            name = "combine with ctrl",
+            description = "add ctrl",
+            default = True,
+            update=auto_rebind)
+
+    def draw(self, context):
+            layout = self.layout
+            # layout.use_property_split = True
+            row= layout.row(align=True)
+            row.prop(self, "pref_tabs", expand=True)
+
+            if self.pref_tabs == 'PREF':
+                
+                ## TAB CATEGORY 
+                box = layout.box()
+                row = box.row(align=True)
+                row.label(text="Panel Category:")
+                row.prop(self, "category", text="")
+
+                ## BOX DEFORM
+                box = layout.box()
+                box.label(text='Box deform:')
+                box.prop(self, "use_clic_drag")
+                # box.separator()
+                box.prop(self, "default_deform_type")
+                box.label(text="Deformer type can be changed during modal with 'M' key, this is for default behavior", icon='INFO')
+                
+                box.prop(self, "auto_swap_deform_type")
+                box.label(text="Once 'M' is hit, auto swap is desactivated to stay in your chosen mode", icon='INFO')
+
+                ## ROTATE CANVAS
+                box = layout.box()
+                box.label(text='Rotate canvas:')
+
+                box.prop(self, "canvas_use_shortcut", text='Bind shortcuts')
+
+                if self.canvas_use_shortcut:
+                    
+                    row = box.row()
+                    row.label(text="(Auto rebind when changing shortcut)")#icon=""
+                    # row.operator("prefs.rebind_shortcut", text='Bind/Rebind shortcuts', icon='FILE_REFRESH')#EVENT_SPACEKEY
+                    row = box.row(align = True)
+                    row.prop(self, "use_ctrl", text='Ctrl')#, expand=True
+                    row.prop(self, "use_alt", text='Alt')#, expand=True
+                    row.prop(self, "use_shift", text='Shift')#, expand=True
+                    row.prop(self, "mouse_click",text='')#expand=True
+
+                    if not self.use_ctrl and not self.use_alt and not self.use_shift:
+                        box.label(text="Choose at least one modifier to combine with click (default: Ctrl+Alt)", icon="ERROR")# INFO
+
+                else:
+                    box.label(text="No hotkey has been set automatically. Following operators needs to be set manually:", icon="ERROR")
+                    box.label(text="view3d.rotate_canvas")
+                box.prop(self, 'canvas_use_hud')
+
+
+            if self.pref_tabs == 'TUTO':
+
+                #**Behavior from context mode**
+                col = layout.column()
+                col.label(text='Box deform tool')
+                col.label(text="Usage:", icon='MOD_LATTICE')
+                col.label(text="Use the shortcut 'Ctrl+T' in available modes (listed below)")
+                col.label(text="The lattice box is generated facing your view (be sure to face canvas if you want to stay on it)")
+                col.label(text="Use shortcuts below to deform (a help will be displayed in the topbar)")
+
+                col.separator()
+                col.label(text="Shortcuts:", icon='HAND')
+                col.label(text="Spacebar / Enter : Confirm")
+                col.label(text="Delete / Backspace / Tab(twice) / Ctrl+T : Cancel")
+                col.label(text="M : Toggle between Linear and Spline mode at any moment")
+                col.label(text="1-9 top row number : Subdivide the box")
+                col.label(text="Ctrl + arrows-keys : Subdivide the box incrementally in individual X/Y axis")
+
+                col.separator()
+                col.label(text="Modes and deformation target:", icon='PIVOT_BOUNDBOX')
+                col.label(text="- Object mode : The whole GP object is deformed (including all frames)")
+                col.label(text="- GPencil Edit mode : Deform Selected points")
+                col.label(text="- Gpencil Paint : Deform last Strokes")
+                # col.label(text="- Lattice edit : Revive the modal after a ctrl+Z")
+
+                col.separator()
+                col.label(text="Notes:", icon='TEXT')
+                col.label(text="- If you return in box deform after applying (with a ctrl+Z), you need to hit 'Ctrl+T' again to revive the modal.")
+                col.label(text="- A cancel warning will be displayed the first time you hit Tab")
+
+
+### rotate canvas keymap
+
+
+addon_keymaps = []
+def register_keymaps():
+    pref = get_addon_prefs()
+    if not pref.canvas_use_shortcut:
+        return
+    addon = bpy.context.window_manager.keyconfigs.addon
+
+    km = bpy.context.window_manager.keyconfigs.addon.keymaps.get("3D View")
+    if not km:
+        km = addon.keymaps.new(name = "3D View", space_type = "VIEW_3D")
+    
+    if 'view3d.rotate_canvas' not in km.keymap_items:
+        km = addon.keymaps.new(name='3D View', space_type='VIEW_3D')
+        kmi = km.keymap_items.new('view3d.rotate_canvas',
+        type=pref.mouse_click, value="PRESS", alt=pref.use_alt, ctrl=pref.use_ctrl, shift=pref.use_shift, any=False)
+
+        addon_keymaps.append(km)
+
+def unregister_keymaps():
+    for km in addon_keymaps:
+        for kmi in km.keymap_items:
+            km.keymap_items.remove(kmi)
+    addon_keymaps.clear()
+
+
+
+### REGISTER ---
+
+def register():
+    bpy.utils.register_class(GreasePencilAddonPrefs)
+    # Force box deform running to false
+    bpy.context.preferences.addons[os.path.splitext(__name__)[0]].preferences.boxdeform_running = False
+    register_keymaps()
+
+def unregister():
+    unregister_keymaps()
+    bpy.utils.unregister_class(GreasePencilAddonPrefs)
diff --git a/greasepencil_tools/rotate_canvas.py b/greasepencil_tools/rotate_canvas.py
new file mode 100644
index 00000000..2ba5ed34
--- /dev/null
+++ b/greasepencil_tools/rotate_canvas.py
@@ -0,0 +1,170 @@
+from .prefs import get_addon_prefs
+
+import bpy
+import math
+import mathutils
+from bpy_extras.view3d_utils import location_3d_to_region_2d
+from bpy.props import BoolProperty, EnumProperty
+## draw utils
+import gpu
+import bgl
+import blf
+from gpu_extras.batch import batch_for_shader
+from gpu_extras.presets import draw_circle_2d
+
+
+def draw_callback_px(self, context):
+    # 50% alpha, 2 pixel width line
+    shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
+    bgl.glEnable(bgl.GL_BLEND)
+    bgl.glLineWidth(2)
+
+    # init
+    batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": [self.center, self.initial_pos]})#self.vector_initial
+    shader.bind()
+    shader.uniform_float("color", (0.5, 0.5, 0.8, 0.6))
+    batch.draw(shader)
+
+    batch = batch_for_shader(shader, 'LINE_STRIP', {"pos": [self.center, self.pos_current]})
+    shader.bind()
+    shader.uniform_float("color", (0.3, 0.7, 0.2, 0.5))
+    batch.draw(shader)
+
+    # restore opengl defaults
+    bgl.glLineWidth(1)
+    bgl.glDisable(bgl.GL_BLEND)
+
+    ## text
+    font_id = 0
+    ## draw text debug infos
+    blf.position(font_id, 15, 30, 0)
+    blf.size(font_id, 20, 72)
+    blf.draw(font_id, f'angle: {math.degrees(self.angle):.1f}')
+
+
+class RC_OT_RotateCanvas(bpy.types.Operator):
+    bl_idname = 'view3d.rotate_canvas'
+    bl_label = 'Rotate Canvas'
+    bl_options = {"REGISTER", "UNDO"}
+
+    def get_center_view(self, context, cam):
+        '''
+        https://blender.stackexchange.com/questions/6377/coordinates-of-corners-of-camera-view-border
+        Thanks to ideasman42
+        '''
+
+        frame = cam.data.view_frame()
+        mat = cam.matrix_world
+        frame = [mat @ v for v in frame]
+        frame_px = [location_3d_to_region_2d(context.region, context.space_data.region_3d, v) for v in frame]
+        center_x = frame_px[2].x + (frame_px[0].x - frame_px[2].x)/2
+        center_y = frame_px[1].y + (frame_px[0].y - frame_px[1].y)/2
+
+        return mathutils.Vector((center_x, center_y))
+
+    def execute(self, context):
+        if self.hud:
+            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
+            context.area.tag_redraw()
+        if self.in_cam:
+                self.cam.rotation_mode = self.org_rotation_mode
+        return {'FINISHED'}
+
+    def modal(self, context, event):
+        if event.type in {'MOUSEMOVE','INBETWEEN_MOUSEMOVE'}:
+            # Get current mouse coordination (region)
+            self.pos_current = mathutils.Vector((event.mouse_region_x, event.mouse_region_y))
+            # Get current vector
+            self.vector_current = (self.pos_current - self.center).normalized()
+            # Calculates the angle between initial and current vectors
+            self.angle = self.vector_initial.angle_signed(self.vector_current)#radian
+            # print (math.degrees(self.angle), self.vector_initial, self.vector_current)
+
+            if self.in_cam:
+                self.cam.matrix_world = self.cam_matrix
+                self.cam.rotation_euler.rotate_axis("Z", self.angle)
+            
+            else:#free view
+                context.space_data.region_3d.view_rotation = self._rotation
+                rot = context.space_data.region_3d.view_rotation
+                rot = rot.to_euler()
+                rot.rotate_axis("Z", self.angle)
+                context.space_data.region_3d.view_rotation = rot.to_quaternion()
+        
+        if event.type in {'RIGHTMOUSE', 'LEFTMOUSE', 'MIDDLEMOUSE'} and event.value == 'RELEASE':
+            if not self.angle:
+                # self.report({'INFO'}, 'Reset')
+                aim = context.space_data.region_3d.view_rotation @ mathutils.Vector((0.0, 0.0, 1.0))#view vector
+                context.space_data.region_3d.view_rotation = aim.to_track_quat('Z','Y')#track Z, up Y
+            self.execute(context)
+            return {'FINISHED'}
+        
+        if event.type == 'ESC':#Cancel
+            self.execute(context)
+            if self.in_cam:
+                self.cam.matrix_world = self.cam_matrix
+            else:
+                context.space_data.region_3d.view_rotation = self._rotation
+            return {'CANCELLED'}
+
+
+        return {'RUNNING_MODAL'}
+
+    def invoke(self, context, event):
+        self.hud = get_addon_prefs().canvas_use_hud
+        self.angle = 0.0
+        self.in_cam = context.region_data.view_perspective == 'CAMERA'
+
+        if self.in_cam:
+            # Get camera from scene
+            self.cam = bpy.context.scene.camera
+            
+            #return if one element is locked (else bypass location)
+            if self.cam.lock_rotation[:] != (False, False, False):
+                self.report({'WARNING'}, 'Camera rotation is locked') 
+                return {'CANCELLED'}
+
+            self.center = self.get_center_view(context, self.cam)
+            # store original rotation mode
+            self.org_rotation_mode = self.cam.rotation_mode
+            # set to euler to works with quaternions, restored at finish
+            self.cam.rotation_mode = 'XYZ'
+            # store camera matrix world
+            self.cam_matrix = self.cam.matrix_world.copy()
+            # self.cam_init_euler = self.cam.rotation_euler.copy()
+
+        else:
+            self.center = mathutils.Vector((context.area.width/2, context.area.height/2))
+            
+            # store current rotation
+            self._rotation = context.space_data.region_3d.view_rotation.copy()
+
+        # Get current mouse coordination
+        self.pos_current = mathutils.Vector((event.mouse_region_x, event.mouse_region_y))
+        
+        self.initial_pos = self.pos_current# for draw debug, else no need
+        # Calculate inital vector
+        self.vector_initial = self.pos_current - self.center
+        self.vector_initial.normalize()
+        
+        # Initializes the current vector with the same initial vector.
+        self.vector_current = self.vector_initial.copy()
+        
+        args = (self, context)
+        if self.hud:
+            self._handle = bpy.types.SpaceView3D.draw_handler_add(draw_callback_px, args, 'WINDOW', 'POST_PIXEL')
+        context.window_manager.modal_handler_add(self)
+        return {'RUNNING_MODAL'}
+
+
+### --- REGISTER
+
+def register():
+    bpy.utils.register_class(RC_OT_RotateCanvas)
+
+
+def unregister():
+    bpy.utils.unregister_class(RC_OT_RotateCanvas)
+
+# if __name__ == "__main__":
+#     register()
\ No newline at end of file
diff --git a/greasepencil_tools/ui_panels.py b/greasepencil_tools/ui_panels.py
new file mode 100644
index 00000000..ecbc9a24
--- /dev/null
+++ b/greasepencil_tools/ui_panels.py
@@ -0,0 +1,83 @@
+# ##### 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 #####
+
+import bpy
+
+class GP_PT_sidebarPanel(bpy.types.Panel):
+    bl_label = "Grease Pencil tools"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "Grease pencil"
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        
+        # Box deform ops
+        self.layout.operator_context = 'INVOKE_DEFAULT'
+        layout.operator('gp.latticedeform', icon ="MOD_MESHDEFORM")# MOD_LATTICE, LATTICE_DATA
+
+        # Straight line ops
+        layout.operator('gp.straight_stroke', icon ="CURVE_PATH")# IPO_LINEAR
+
+
+        # Expose Native view operators
+        # if context.scene.camera:
+        row = layout.row(align=True)
+        row.operator('view3d.zoom_camera_1_to_1', text = 'Zoom 1:1', icon = 'ZOOM_PREVIOUS')# FULLSCREEN_EXIT?
+        row.operator('view3d.view_center_camera', text = 'Zoom Fit', icon = 'FULLSCREEN_ENTER')
+
+
+def menu_boxdeform_entry(self, context):
+    """Transform shortcut to append in existing menu"""
+    layout = self.layout
+    obj = bpy.context.object
+    # {'EDIT_GPENCIL', 'PAINT_GPENCIL','SCULPT_GPENCIL','WEIGHT_GPENCIL', 'VERTEX_GPENCIL'}
+    if obj and obj.type == 'GPENCIL' and context.mode in {'OBJECT', 'EDIT_GPENCIL', 'PAINT_GPENCIL'}:
+        self.layout.operator_context = 'INVOKE_DEFAULT'
+        layout.operator('gp.latticedeform', text='Box Deform')
+
+def menu_stroke_entry(self, context):
+    layout = self.layout
+    # Gpencil modes : {'EDIT_GPENCIL', 'PAINT_GPENCIL','SCULPT_GPENCIL','WEIGHT_GPENCIL', 'VERTEX_GPENCIL'}
+    if context.mode in {'EDIT_GPENCIL', 'PAINT_GPENCIL'}:
+        self.layout.operator_context = 'INVOKE_DEFAULT'
+        layout.operator('gp.straight_stroke', text='Straight Stroke')
+
+def menu_brush_pack(self, context):
+    layout = self.layout
+    # if context.mode in {'EDIT_GPENCIL', 'PAINT_GPENCIL'}:
+    self.layout.operator_context = 'INVOKE_DEFAULT'
+    layout.operator('gp.import_brush_pack')#, text='Import brush pack'
+
+
+def register():
+    bpy.utils.register_class(GP_PT_sidebarPanel)
+    ## VIEW3D_MT_edit_gpencil.append# Grease pencil menu
+    bpy.types.VIEW3D_MT_transform_object.append(menu_boxdeform_entry)
+    bpy.types.VIEW3D_MT_edit_gpencil_transform.append(menu_boxdeform_entry)
+    bpy.types.VIEW3D_MT_edit_gpencil_stroke.append(menu_stroke_entry)
+    bpy.types.VIEW3D_MT_brush_gpencil_context_menu.append(menu_brush_pack)
+
+
+def unregister():
+    bpy.types.VIEW3D_MT_brush_gpencil_context_menu.remove(menu_brush_pack)
+    bpy.types.VIEW3D_MT_transform_object.remove(menu_boxdeform_entry)
+    bpy.types.VIEW3D_MT_edit_gpencil_transform.remove(menu_boxdeform_entry)
+    bpy.types.VIEW3D_MT_edit_gpencil_stroke.remove(menu_stroke_entry)
+    bpy.utils.unregister_class(GP_PT_sidebarPanel)