table.insert(lines, i, {y=y, h=256/2, shapes={}, pending={}})

                     table.insert(lines, i, {y=y, h=256/2, points={}, shapes={}, pending={}})

        if on_shape(mx,my, shape) then

        if on_shape(mx,my, line, shape) then

        draw_shape(16,line.y, shape)

        draw_shape(16,line.y, line, shape)
      end
      for _,p in ipairs(line.points) do
        if p.x == mx and p.y == my then
          love.graphics.setColor(1,0,0)
        else
          love.graphics.setColor(0,0,0)
        end
        love.graphics.circle('line', pixels(p.x)+16,pixels(p.y)+line.y, 4)

      draw_pending_shape(16,line.y, line.pending)

      draw_pending_shape(16,line.y, line)

        lines.current.pending.x2 = coord(x-16)
        lines.current.pending.y2 = coord(y-lines.current.y)

        local j = insert_point(lines.current.points, coord(x-16), coord(y-lines.current.y))
        lines.current.pending.p2 = j

          drawing.pending = {mode='line', x1=coord(x-16), y1=coord(y-drawing.y)}

          local j = insert_point(drawing.points, coord(x-16), coord(y-drawing.y))
          drawing.pending = {mode='line', p1=j}

function draw_shape(left,top, shape)

function insert_point(points, x,y)
  for i,point in ipairs(points) do
    if point.x == x and point.y == y then
      return i
    end
  end
  table.insert(points, {x=x, y=y})
  return #points
end
function draw_shape(left,top, drawing, shape)

    love.graphics.line(pixels(shape.x1)+left,pixels(shape.y1)+top, pixels(shape.x2)+left,pixels(shape.y2)+top)

    local p1 = drawing.points[shape.p1]
    local p2 = drawing.points[shape.p2]
    love.graphics.line(pixels(p1.x)+left,pixels(p1.y)+top, pixels(p2.x)+left,pixels(p2.y)+top)

function draw_pending_shape(left,top, shape)

function draw_pending_shape(left,top, drawing)
  local shape = drawing.pending

    draw_shape(left,top, shape)

    draw_shape(left,top, drawing, shape)

    love.graphics.line(pixels(shape.x1)+left,pixels(shape.y1)+top, love.mouse.getX(),love.mouse.getY())

    local p1 = drawing.points[shape.p1]
    love.graphics.line(pixels(p1.x)+left,pixels(p1.y)+top, love.mouse.getX(),love.mouse.getY())

function on_shape(x,y, shape)

function on_shape(x,y, drawing, shape)

    return on_freehand(x,y, shape)

    return on_freehand(x,y, drawing, shape)

    return on_line(x,y, shape)

    return on_line(x,y, drawing, shape)

function on_freehand(x,y, shape)

function on_freehand(x,y, drawing, shape)

      if on_line(x,y, {x1=prev.x,y1=prev.y, x2=p.x,y2=p.y}) then

      if on_line(x,y, drawing, {p1=prev, p2=p}) then

function on_line(x,y, shape)
  if shape.x1 == shape.x2 then
    if math.abs(shape.x1-x) > 5 then

function on_line(x,y, drawing, shape)
  local p1,p2
  if type(shape.p1) == 'number' then
    p1 = drawing.points[shape.p1]
    p2 = drawing.points[shape.p2]
  else
    p1 = shape.p1
    p2 = shape.p2
  end
  if p1.x == p2.x then
    if math.abs(p1.x-x) > 5 then

    local y1,y2 = shape.y1,shape.y2

    local y1,y2 = p1.y,p2.y

  local m = (shape.y2 - shape.y1) / (shape.x2 - shape.x1)
  local yp = shape.y1 + m*(x-shape.x1)

  local m = (p2.y - p1.y) / (p2.x - p1.x)
  local yp = p1.y + m*(x-p1.x)

  local k = (x-shape.x1) / (shape.x2-shape.x1)

  local k = (x-p1.x) / (p2.x-p1.x)

    drawing.pending.x1 = drawing.pending.points[1].x
    drawing.pending.y1 = drawing.pending.points[1].y

    drawing.pending.p1 = insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y)

      convert_line(shape)

      convert_line(drawing, shape)

      convert_horvert(shape)

      convert_horvert(drawing, shape)

function convert_line(shape)

function convert_line(drawing, shape)

  shape.x1 = shape.points[1].x
  shape.y1 = shape.points[1].y
  shape.x2 = shape.points[#shape.points].x
  shape.y2 = shape.points[#shape.points].y

  shape.p1 = insert_point(drawing.points, shape.points[1].x, shape.points[1].y)
  local n = #shape.points
  shape.p2 = insert_point(drawing.points, shape.points[n].x, shape.points[n].y)

function convert_horvert(shape)

function convert_horvert(drawing, shape)

  if math.abs(shape.x1-shape.x2) > math.abs(shape.y1-shape.y2) then
    shape.y2 = shape.y1

  local p1 = drawing.points[shape.p1]
  local p2 = drawing.points[shape.p2]
  if math.abs(p1.x-p2.x) > math.abs(p1.y-p2.y) then
    p2.y = p1.y

    shape.x2 = shape.x1

    p2.x = p1.x