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