source_edit.lua

   1 -- some constants people might like to tweak
   2 Text_color = {r=0, g=0, b=0}
   3 Cursor_color = {r=1, g=0, b=0}
   4 Hyperlink_decoration_color = {r=0.4, g=0.4, b=1}
   5 Stroke_color = {r=0, g=0, b=0}
   6 Current_stroke_color = {r=0.7, g=0.7, b=0.7}  -- in process of being drawn
   7 Current_name_background_color = {r=1, g=0, b=0, a=0.1}  -- name currently being edited
   8 Focus_stroke_color = {r=1, g=0, b=0}  -- what mouse is hovering over
   9 Highlight_color = {r=0.7, g=0.7, b=0.9}  -- selected text
  10 Line_number_color = {r=0.6, g=0.6, b=0.6}
  11 Icon_color = {r=0.7, g=0.7, b=0.7}  -- color of current mode icon in drawings
  12 Help_color = {r=0, g=0.5, b=0}
  13 Help_background_color = {r=0, g=0.5, b=0, a=0.1}
  14
  15 Margin_top = 15
  16 Margin_left = 25
  17 Margin_right = 25
  18
  19 Drawing_padding_top = 10
  20 Drawing_padding_bottom = 10
  21 Drawing_padding_height = Drawing_padding_top + Drawing_padding_bottom
  22
  23 Same_point_distance = 4  -- pixel distance at which two points are considered the same
  24
  25 edit = {}
  26
  27 -- run in both tests and a real run
  28 function edit.initialize_state(top, left, right, font_height, line_height)  -- currently always draws to bottom of screen
  29   local result = {
  30     -- a line is either text or a drawing
  31     -- a text is a table with:
  32     --    mode = 'text',
  33     --    string data,
  34     -- a drawing is a table with:
  35     --    mode = 'drawing'
  36     --    a (y) coord in pixels (updated while painting screen),
  37     --    a (h)eight,
  38     --    an array of points, and
  39     --    an array of shapes
  40     -- a shape is a table containing:
  41     --    a mode
  42     --    an array points for mode 'freehand' (raw x,y coords; freehand drawings don't pollute the points array of a drawing)
  43     --    an array vertices for mode 'polygon', 'rectangle', 'square'
  44     --    p1, p2 for mode 'line'
  45     --    center, radius for mode 'circle'
  46     --    center, radius, start_angle, end_angle for mode 'arc'
  47     -- Unless otherwise specified, coord fields are normalized; a drawing is always 256 units wide
  48     -- The field names are carefully chosen so that switching modes in midstream
  49     -- remembers previously entered points where that makes sense.
  50     lines = {{mode='text', data=''}},  -- array of lines
  51
  52     -- Lines can be too long to fit on screen, in which case they _wrap_ into
  53     -- multiple _screen lines_.
  54
  55     -- rendering wrapped text lines needs some additional short-lived data per line:
  56     --   startpos, the index of data the line starts rendering from, can only be >1 for topmost line on screen
  57     --   starty, the y coord in pixels the line starts rendering from
  58     --   fragments: snippets of the line guaranteed to not straddle screen lines
  59     --   screen_line_starting_pos: optional array of grapheme indices if it wraps over more than one screen line
  60     line_cache = {},
  61
  62     -- Given wrapping, any potential location for the text cursor can be described in two ways:
  63     -- * schema 1: As a combination of line index and position within a line (in utf8 codepoint units)
  64     -- * schema 2: As a combination of line index, screen line index within the line, and a position within the screen line.
  65     --
  66     -- Most of the time we'll only persist positions in schema 1, translating to
  67     -- schema 2 when that's convenient.
  68     --
  69     -- Make sure these coordinates are never aliased, so that changing one causes
  70     -- action at a distance.
  71     screen_top1 = {line=1, pos=1},  -- position of start of screen line at top of screen
  72     cursor1 = {line=1, pos=1},  -- position of cursor
  73     screen_bottom1 = {line=1, pos=1},  -- position of start of screen line at bottom of screen
  74
  75     selection1 = {},
  76     -- some extra state to compute selection between mouse press and release
  77     old_cursor1 = nil,
  78     old_selection1 = nil,
  79     mousepress_shift = nil,
  80
  81     -- cursor coordinates in pixels
  82     cursor_x = 0,
  83     cursor_y = 0,
  84
  85     current_drawing_mode = 'line',
  86     previous_drawing_mode = nil,  -- extra state for some ephemeral modes like moving/deleting/naming points
  87
  88     font_height = font_height,
  89     line_height = line_height,
  90
  91     top = top,
  92     left = math.floor(left),  -- left margin for text; line numbers go to the left of this
  93     right = math.floor(right),
  94     width = right-left,
  95
  96     filename = love.filesystem.getSourceBaseDirectory()..'/lines.txt',  -- '/' should work even on Windows
  97     next_save = nil,
  98
  99     -- undo
 100     history = {},
 101     next_history = 1,
 102
 103     -- search
 104     search_term = nil,
 105     search_backup = nil,  -- stuff to restore when cancelling search
 106   }
 107   return result
 108 end  -- App.initialize_state
 109
 110 function edit.check_locs(State)
 111   -- if State is inconsistent (i.e. file changed by some other program),
 112   --   throw away all cursor state entirely
 113   if edit.invalid1(State, State.screen_top1)
 114       or edit.invalid_cursor1(State)
 115       or not edit.cursor_on_text(State)
 116       or not Text.le1(State.screen_top1, State.cursor1) then
 117     State.screen_top1 = {line=1, pos=1}
 118     State.cursor1 = {line=1, pos=1}
 119     edit.put_cursor_on_next_text_line(State)
 120   end
 121 end
 122
 123 function edit.invalid1(State, loc1)
 124   if loc1.line > #State.lines then return true end
 125   local l = State.lines[loc1.line]
 126   if l.mode ~= 'text' then return false end  -- pos is irrelevant to validity for a drawing line
 127   return loc1.pos > #State.lines[loc1.line].data
 128 end
 129
 130 -- cursor loc in particular differs from other locs in one way:
 131 -- pos might occur just after end of line
 132 function edit.invalid_cursor1(State)
 133   local cursor1 = State.cursor1
 134   if cursor1.line > #State.lines then return true end
 135   local l = State.lines[cursor1.line]
 136   if l.mode ~= 'text' then return false end  -- pos is irrelevant to validity for a drawing line
 137   return cursor1.pos > #State.lines[cursor1.line].data + 1
 138 end
 139
 140 function edit.cursor_on_text(State)
 141   return State.cursor1.line <= #State.lines
 142       and State.lines[State.cursor1.line].mode == 'text'
 143 end
 144
 145 function edit.put_cursor_on_next_text_line(State)
 146   while true do
 147   if State.cursor1.line >= #State.lines then
 148     break
 149   end
 150   if State.lines[State.cursor1.line].mode == 'text' then
 151     break
 152   end
 153   State.cursor1.line = State.cursor1.line+1
 154   State.cursor1.pos = 1
 155   end
 156 end
 157
 158 function edit.draw(State, hide_cursor, show_line_numbers)
 159   State.button_handlers = {}
 160   App.color(Text_color)
 161   if #State.lines ~= #State.line_cache then
 162     print(('line_cache is out of date; %d when it should be %d'):format(#State.line_cache, #State.lines))
 163     assert(false)
 164   end
 165   if not Text.le1(State.screen_top1, State.cursor1) then
 166     print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
 167     assert(false)
 168   end
 169   State.cursor_x = nil
 170   State.cursor_y = nil
 171   local y = State.top
 172   local screen_bottom1 = {line=nil, pos=nil}
 173 --?   print('== draw')
 174   for line_index = State.screen_top1.line,#State.lines do
 175     local line = State.lines[line_index]
 176 --?     print('draw:', y, line_index, line)
 177     if y + State.line_height > App.screen.height then break end
 178     screen_bottom1.line = line_index
 179     if line.mode == 'text' then
 180 --?       print('text.draw', y, line_index)
 181       local startpos = 1
 182       if line_index == State.screen_top1.line then
 183         startpos = State.screen_top1.pos
 184       end
 185       if line.data == '' then
 186         -- button to insert new drawing
 187         local buttonx = State.left-Margin_left+4
 188         if show_line_numbers then
 189           buttonx = 4  -- HACK: position draw buttons at a fixed x on screen
 190         end
 191         button(State, 'draw', {x=buttonx, y=y+4, w=12,h=12, color={1,1,0},
 192           icon = icon.insert_drawing,
 193           onpress1 = function()
 194                        Drawing.before = snapshot(State, line_index-1, line_index)
 195                        table.insert(State.lines, line_index, {mode='drawing', y=y, h=256/2, points={}, shapes={}, pending={}})
 196                        table.insert(State.line_cache, line_index, {})
 197                        if State.cursor1.line >= line_index then
 198                          State.cursor1.line = State.cursor1.line+1
 199                        end
 200                        schedule_save(State)
 201                        record_undo_event(State, {before=Drawing.before, after=snapshot(State, line_index-1, line_index+1)})
 202                      end,
 203         })
 204       end
 205       y, screen_bottom1.pos = Text.draw(State, line_index, y, startpos, hide_cursor, show_line_numbers)
 206 --?       print('=> y', y)
 207     elseif line.mode == 'drawing' then
 208       y = y+Drawing_padding_top
 209       Drawing.draw(State, line_index, y)
 210       y = y + Drawing.pixels(line.h, State.width) + Drawing_padding_bottom
 211     else
 212       print(line.mode)
 213       assert(false)
 214     end
 215   end
 216   State.screen_bottom1 = screen_bottom1
 217   if State.search_term then
 218     Text.draw_search_bar(State)
 219   end
 220 end
 221
 222 function edit.update(State, dt)
 223   Drawing.update(State, dt)
 224   if State.next_save and State.next_save < Current_time then
 225     save_to_disk(State)
 226     State.next_save = nil
 227   end
 228 end
 229
 230 function schedule_save(State)
 231   if State.next_save == nil then
 232     State.next_save = Current_time + 3  -- short enough that you're likely to still remember what you did
 233   end
 234 end
 235
 236 function edit.quit(State)
 237   -- make sure to save before quitting
 238   if State.next_save then
 239     save_to_disk(State)
 240     -- give some time for the OS to flush everything to disk
 241     love.timer.sleep(0.1)
 242   end
 243 end
 244
 245 function edit.mouse_press(State, x,y, mouse_button)
 246   if State.search_term then return end
 247 --?   print_and_log(('edit.mouse_press: cursor at %d,%d'):format(State.cursor1.line, State.cursor1.pos))
 248   if mouse_press_consumed_by_any_button_handler(State, x,y, mouse_button) then
 249     -- press on a button and it returned 'true' to short-circuit
 250     return
 251   end
 252
 253   if y < State.top then
 254     State.old_cursor1 = State.cursor1
 255     State.old_selection1 = State.selection1
 256     State.mousepress_shift = App.shift_down()
 257     State.selection1 = {
 258         line=State.screen_top1.line,
 259         pos=State.screen_top1.pos,
 260     }
 261     return
 262   end
 263
 264   for line_index,line in ipairs(State.lines) do
 265     if line.mode == 'text' then
 266       if Text.in_line(State, line_index, x,y) then
 267         -- delicate dance between cursor, selection and old cursor/selection
 268         -- scenarios:
 269         --  regular press+release: sets cursor, clears selection
 270         --  shift press+release:
 271         --    sets selection to old cursor if not set otherwise leaves it untouched
 272         --    sets cursor
 273         --  press and hold to start a selection: sets selection on press, cursor on release
 274         --  press and hold, then press shift: ignore shift
 275         --    i.e. mouse_release should never look at shift state
 276 --?         print_and_log(('edit.mouse_press: in line %d'):format(line_index))
 277         State.old_cursor1 = State.cursor1
 278         State.old_selection1 = State.selection1
 279         State.mousepress_shift = App.shift_down()
 280         State.selection1 = {
 281             line=line_index,
 282             pos=Text.to_pos_on_line(State, line_index, x, y),
 283         }
 284         return
 285       end
 286     elseif line.mode == 'drawing' then
 287       local line_cache = State.line_cache[line_index]
 288       if Drawing.in_drawing(line, line_cache, x, y, State.left,State.right) then
 289         State.lines.current_drawing_index = line_index
 290         State.lines.current_drawing = line
 291         Drawing.before = snapshot(State, line_index)
 292         Drawing.mouse_press(State, line_index, x,y, mouse_button)
 293         return
 294       end
 295     end
 296   end
 297
 298   -- still here? click is below all screen lines
 299   State.old_cursor1 = State.cursor1
 300   State.old_selection1 = State.selection1
 301   State.mousepress_shift = App.shift_down()
 302   State.selection1 = {
 303       line=State.screen_bottom1.line,
 304       pos=Text.pos_at_end_of_screen_line(State, State.screen_bottom1),
 305   }
 306 end
 307
 308 function edit.mouse_release(State, x,y, mouse_button)
 309   if State.search_term then return end
 310 --?   print_and_log(('edit.mouse_release: cursor at %d,%d'):format(State.cursor1.line, State.cursor1.pos))
 311   if State.lines.current_drawing then
 312     Drawing.mouse_release(State, x,y, mouse_button)
 313     schedule_save(State)
 314     if Drawing.before then
 315       record_undo_event(State, {before=Drawing.before, after=snapshot(State, State.lines.current_drawing_index)})
 316       Drawing.before = nil
 317     end
 318   else
 319 --?     print_and_log('edit.mouse_release: no current drawing')
 320     for line_index,line in ipairs(State.lines) do
 321       if line.mode == 'text' then
 322         if Text.in_line(State, line_index, x,y) then
 323 --?           print_and_log(('edit.mouse_release: in line %d'):format(line_index))
 324           State.cursor1 = {
 325               line=line_index,
 326               pos=Text.to_pos_on_line(State, line_index, x, y),
 327           }
 328 --?           print_and_log(('edit.mouse_release: cursor now %d,%d'):format(State.cursor1.line, State.cursor1.pos))
 329           if State.mousepress_shift then
 330             if State.old_selection1.line == nil then
 331               State.selection1 = State.old_cursor1
 332             else
 333               State.selection1 = State.old_selection1
 334             end
 335           end
 336           State.old_cursor1, State.old_selection1, State.mousepress_shift = nil
 337           if eq(State.cursor1, State.selection1) then
 338             State.selection1 = {}
 339           end
 340           break
 341         end
 342       end
 343     end
 344 --?     print_and_log(('edit.mouse_release: finally selection %s,%s cursor %d,%d'):format(tostring(State.selection1.line), tostring(State.selection1.pos), State.cursor1.line, State.cursor1.pos))
 345   end
 346 end
 347
 348 function edit.mouse_wheel_move(State, dx,dy)
 349   if dy > 0 then
 350     State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
 351     edit.put_cursor_on_next_text_line(State)
 352     for i=1,math.floor(dy) do
 353       Text.up(State)
 354     end
 355   elseif dy < 0 then
 356     State.cursor1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos}
 357     edit.put_cursor_on_next_text_line(State)
 358     for i=1,math.floor(-dy) do
 359       Text.down(State)
 360     end
 361   end
 362 end
 363
 364 function edit.text_input(State, t)
 365 --?   print('text input', t)
 366   if State.search_term then
 367     State.search_term = State.search_term..t
 368     Text.search_next(State)
 369   elseif State.lines.current_drawing and State.current_drawing_mode == 'name' then
 370     local before = snapshot(State, State.lines.current_drawing_index)
 371     local drawing = State.lines.current_drawing
 372     local p = drawing.points[drawing.pending.target_point]
 373     p.name = p.name..t
 374     record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})
 375   else
 376     local drawing_index, drawing = Drawing.current_drawing(State)
 377     if drawing_index == nil then
 378       for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 379       Text.text_input(State, t)
 380     end
 381   end
 382   schedule_save(State)
 383 end
 384
 385 function edit.keychord_press(State, chord, key)
 386   if State.selection1.line and
 387       not State.lines.current_drawing and
 388       -- printable character created using shift key => delete selection
 389       -- (we're not creating any ctrl-shift- or alt-shift- combinations using regular/printable keys)
 390       (not App.shift_down() or utf8.len(key) == 1) and
 391       chord ~= 'C-a' and chord ~= 'C-c' and chord ~= 'C-x' and chord ~= 'backspace' and chord ~= 'delete' and chord ~= 'C-z' and chord ~= 'C-y' and not App.is_cursor_movement(chord) then
 392     Text.delete_selection(State, State.left, State.right)
 393   end
 394   if State.search_term then
 395     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 396     if chord == 'escape' then
 397       State.search_term = nil
 398       State.cursor1 = State.search_backup.cursor
 399       State.screen_top1 = State.search_backup.screen_top
 400       State.search_backup = nil
 401       Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
 402     elseif chord == 'return' then
 403       State.search_term = nil
 404       State.search_backup = nil
 405     elseif chord == 'backspace' then
 406       local len = utf8.len(State.search_term)
 407       local byte_offset = Text.offset(State.search_term, len)
 408       State.search_term = string.sub(State.search_term, 1, byte_offset-1)
 409     elseif chord == 'down' then
 410       State.cursor1.pos = State.cursor1.pos+1
 411       Text.search_next(State)
 412     elseif chord == 'up' then
 413       Text.search_previous(State)
 414     end
 415     return
 416   elseif chord == 'C-f' then
 417     State.search_term = ''
 418     State.search_backup = {
 419       cursor={line=State.cursor1.line, pos=State.cursor1.pos},
 420       screen_top={line=State.screen_top1.line, pos=State.screen_top1.pos},
 421     }
 422   -- zoom
 423   elseif chord == 'C-=' then
 424     edit.update_font_settings(State, State.font_height+2)
 425     Text.redraw_all(State)
 426   elseif chord == 'C--' then
 427     if State.font_height > 2 then
 428       edit.update_font_settings(State, State.font_height-2)
 429       Text.redraw_all(State)
 430     end
 431   elseif chord == 'C-0' then
 432     edit.update_font_settings(State, 20)
 433     Text.redraw_all(State)
 434   -- undo
 435   elseif chord == 'C-z' then
 436     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 437     local event = undo_event(State)
 438     if event then
 439       local src = event.before
 440       State.screen_top1 = deepcopy(src.screen_top)
 441       State.cursor1 = deepcopy(src.cursor)
 442       State.selection1 = deepcopy(src.selection)
 443       patch(State.lines, event.after, event.before)
 444       patch_placeholders(State.line_cache, event.after, event.before)
 445       -- invalidate various cached bits of lines
 446       State.lines.current_drawing = nil
 447       -- if we're scrolling, reclaim all fragments to avoid memory leaks
 448       Text.redraw_all(State)
 449       schedule_save(State)
 450     end
 451   elseif chord == 'C-y' then
 452     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 453     local event = redo_event(State)
 454     if event then
 455       local src = event.after
 456       State.screen_top1 = deepcopy(src.screen_top)
 457       State.cursor1 = deepcopy(src.cursor)
 458       State.selection1 = deepcopy(src.selection)
 459       patch(State.lines, event.before, event.after)
 460       -- invalidate various cached bits of lines
 461       State.lines.current_drawing = nil
 462       -- if we're scrolling, reclaim all fragments to avoid memory leaks
 463       Text.redraw_all(State)
 464       schedule_save(State)
 465     end
 466   -- clipboard
 467   elseif chord == 'C-a' then
 468     State.selection1 = {line=1, pos=1}
 469     State.cursor1 = {line=#State.lines, pos=utf8.len(State.lines[#State.lines].data)+1}
 470   elseif chord == 'C-c' then
 471     local s = Text.selection(State)
 472     if s then
 473       App.set_clipboard(s)
 474     end
 475   elseif chord == 'C-x' then
 476     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 477     local s = Text.cut_selection(State, State.left, State.right)
 478     if s then
 479       App.set_clipboard(s)
 480     end
 481     schedule_save(State)
 482   elseif chord == 'C-v' then
 483     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 484     -- We don't have a good sense of when to scroll, so we'll be conservative
 485     -- and sometimes scroll when we didn't quite need to.
 486     local before_line = State.cursor1.line
 487     local before = snapshot(State, before_line)
 488     local clipboard_data = App.get_clipboard()
 489     for _,code in utf8.codes(clipboard_data) do
 490       local c = utf8.char(code)
 491       if c == '\n' then
 492         Text.insert_return(State)
 493       else
 494         Text.insert_at_cursor(State, c)
 495       end
 496     end
 497     if Text.cursor_out_of_screen(State) then
 498       Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
 499     end
 500     schedule_save(State)
 501     record_undo_event(State, {before=before, after=snapshot(State, before_line, State.cursor1.line)})
 502   -- dispatch to drawing or text
 503   elseif App.mouse_down(1) or chord:sub(1,2) == 'C-' then
 504     -- DON'T reset line_cache.starty here
 505     local drawing_index, drawing = Drawing.current_drawing(State)
 506     if drawing_index then
 507       local before = snapshot(State, drawing_index)
 508       Drawing.keychord_press(State, chord)
 509       record_undo_event(State, {before=before, after=snapshot(State, drawing_index)})
 510       schedule_save(State)
 511     end
 512   elseif chord == 'escape' and not App.mouse_down(1) then
 513     for _,line in ipairs(State.lines) do
 514       if line.mode == 'drawing' then
 515         line.show_help = false
 516       end
 517     end
 518   elseif State.lines.current_drawing and State.current_drawing_mode == 'name' then
 519     if chord == 'return' then
 520       State.current_drawing_mode = State.previous_drawing_mode
 521       State.previous_drawing_mode = nil
 522     else
 523       local before = snapshot(State, State.lines.current_drawing_index)
 524       local drawing = State.lines.current_drawing
 525       local p = drawing.points[drawing.pending.target_point]
 526       if chord == 'escape' then
 527         p.name = nil
 528         record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})
 529       elseif chord == 'backspace' then
 530         local len = utf8.len(p.name)
 531         if len > 0 then
 532           local byte_offset = Text.offset(p.name, len-1)
 533           if len == 1 then byte_offset = 0 end
 534           p.name = string.sub(p.name, 1, byte_offset)
 535           record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})
 536         end
 537       end
 538     end
 539     schedule_save(State)
 540   else
 541     for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
 542     Text.keychord_press(State, chord)
 543   end
 544 end
 545
 546 function edit.key_release(State, key, scancode)
 547 end
 548
 549 function edit.update_font_settings(State, font_height)
 550   State.font_height = font_height
 551   love.graphics.setFont(love.graphics.newFont(State.font_height))
 552   State.line_height = math.floor(font_height*1.3)
 553 end
 554
 555 --== some methods for tests
 556
 557 -- Insulate tests from some key globals so I don't have to change the vast
 558 -- majority of tests when they're modified for the real app.
 559 Test_margin_left = 25
 560 Test_margin_right = 0
 561
 562 function edit.initialize_test_state()
 563   -- if you change these values, tests will start failing
 564   return edit.initialize_state(
 565       15,  -- top margin
 566       Test_margin_left,
 567       App.screen.width - Test_margin_right,
 568       14,  -- font height assuming default LÖVE font
 569       15)  -- line height
 570 end
 571
 572 -- all text_input events are also keypresses
 573 -- TODO: handle chords of multiple keys
 574 function edit.run_after_text_input(State, t)
 575   edit.keychord_press(State, t)
 576   edit.text_input(State, t)
 577   edit.key_release(State, t)
 578   App.screen.contents = {}
 579   edit.update(State, 0)
 580   edit.draw(State)
 581 end
 582
 583 -- not all keys are text_input
 584 function edit.run_after_keychord(State, chord)
 585   edit.keychord_press(State, chord)
 586   edit.key_release(State, chord)
 587   App.screen.contents = {}
 588   edit.update(State, 0)
 589   edit.draw(State)
 590 end
 591
 592 function edit.run_after_mouse_click(State, x,y, mouse_button)
 593   App.fake_mouse_press(x,y, mouse_button)
 594   edit.mouse_press(State, x,y, mouse_button)
 595   App.fake_mouse_release(x,y, mouse_button)
 596   edit.mouse_release(State, x,y, mouse_button)
 597   App.screen.contents = {}
 598   edit.update(State, 0)
 599   edit.draw(State)
 600 end
 601
 602 function edit.run_after_mouse_press(State, x,y, mouse_button)
 603   App.fake_mouse_press(x,y, mouse_button)
 604   edit.mouse_press(State, x,y, mouse_button)
 605   App.screen.contents = {}
 606   edit.update(State, 0)
 607   edit.draw(State)
 608 end
 609
 610 function edit.run_after_mouse_release(State, x,y, mouse_button)
 611   App.fake_mouse_release(x,y, mouse_button)
 612   edit.mouse_release(State, x,y, mouse_button)
 613   App.screen.contents = {}
 614   edit.update(State, 0)
 615   edit.draw(State)
 616 end