def hookup_events():
    """
    Handle events for resizing
    - run once
    """
    handle = ltk.find("#handle")
    #print("setting up handle")
    handle.on("mousedown", ltk.proxy(lambda event: resize_draft_start(event)))
    handle.on("mousemove", ltk.proxy(lambda event: resize_draft(event)))
    handle.on("mouseup", ltk.proxy(lambda event: resize_draft_end(event)))
    handle.on("mouseleave", ltk.proxy(lambda event: resize_draft_end(event)))

#globals
g_h_selected = None
g_h_selected_offset = None
g_h_offset = None

def get_mouse_position(event, el):
    """
    Get the screen coords of the mouse
    - for dragging events
    """
    CTM = el.getScreenCTM()
    x = (event.clientX - CTM.e) / CTM.a
    y = (event.clientY - CTM.f) / CTM.d
    return [x,y]

def start_drag(event):
    """
    Used when we want to Drag:
    - calc offsets for simple math adj of moving element
    """
    global g_h_selected, g_h_selected_offset, g_h_offset
    g_h_selected = event.target
    print(event.target)
    g_h_offset = get_mouse_position(event, g_h_selected)
    g_h_selected_offset = get_mouse_position(event, g_h_selected)
    #print("start resize", g_h_offset)
    g_h_selected_offset[0] -= float(g_h_selected.getAttributeNS(None,"x"))
    g_h_selected_offset[1] -= float(g_h_selected.getAttributeNS(None,"y"))

def resize_draft_start(event):
    """
    Setup to start dragging the handle.
    - hide pattern maybe ?
    """
    #event.preventDefault()
    start_drag(event)
    # empty the drawn selection,targets
    if loom.current_selection:
        loom.clear_selection()
    # ignore the cell row detection box (we collide)
    ltk.find("#cells_butside_rect").addClass("ignored")
    #! empty the pattern

def resize_draft(event):
    """
    Active mouse motion while dragging
    - resize the draft_bg etc
    - g_h_selected will be "#handle"
    """
    #event.preventDefault()
    if g_h_selected:
        x,y = get_mouse_position(event, g_h_selected)
        #! check and clamp to max,min size
        #print("resize me", x-g_h_offset[0], y-g_h_offset[1])
        offset = [x - g_h_selected_offset[0], y - g_h_selected_offset[1]]
        #! Maybe Quantize to steps > 5 (would draw less often)
        # reposition handle box
        g_h_selected.setAttributeNS(None, "x", offset[0])
        g_h_selected.setAttributeNS(None, "y", offset[1])
        #
        svg = loom.create_draft_bg(x-g_h_offset[0])
        ltk.find("#draft_bg").html(svg) 
        # resize the baserect box
        grid_bbox = ltk.find("#BG_grid").children()[0].getBBox()
        loom.resize_draftUI_box(grid_bbox)
        # redraw handle box and interior
        # get curr handle w,h for handle redraw
        w = float(g_h_selected.getAttribute("width"))
        h = float(g_h_selected.getAttribute("height"))
        offset.extend([w,h])
        for [id,slot,value] in loom.draft_ui_layer.update_handle(offset):
            ltk.window.document.querySelector(id).setAttribute(slot, value)

def resize_draft_end(event):
    """
    Cleanup when dropping resize handle:
    - set grid size for redraws,
    - redraw handle in correct pos
    """
    global g_h_selected
    if g_h_selected:
        #print("end resize", get_mouse_position(event, g_h_selected))
        # need to reset the handle to proper place
        bbox = ltk.find("#BG_grid").children()[0].getBBox()
        # reset self.draft_width variable etc
        loom.draft_width = bbox.width
        loom.finalise_draft_move()
        g_h_selected = None
        # redraw the drawn selection,highlights
        if loom.current_selection:
            loom.rebuild_selection()
        # reenable cell collision box
        ltk.find("#cells_butside_rect").removeClass("ignored")
        #! redraw the pattern