update_editor_box = function(node, preserve_screen_top_of_cursor_node)
	if node.editor == nil then return end
	if node.y > Viewport.y then
		if not preserve_screen_top_of_cursor_node or node ~= Cursor_node then
			node.editor.screen_top1.line = 1
			node.editor.screen_top1.pos = 1
		end
		node.editor.top = vy(node.y)
	else
		node.editor.screen_top1, node.editor.top = schema1_of_y(node.editor, Viewport.y - node.y)
	end
	node.editor.left = math.floor(vx(node.x))
	node.editor.right = math.ceil(vx(node.x+node.w))
	edit.update_font_settings(node.editor, scale(20))
	Text.redraw_all(node.editor)
end

Page2 = {
	x=500, y=300,
    -- page
		type='text',
        data={
"Call me Ishmael.  Some years ago--never mind how long precisely--having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.  It is a way I have of driving off the spleen and regulating the circulation.  Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off--then, I account it high time to get to sea as soon as I can.  This is my substitute for pistol and ball.  With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship.  There is nothing surprising in this.  If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me."
		},
        width=400, bg={r=0,g=0.8,b=0}
}

A = function(preserve_screen_top_of_cursor_node)
	-- translate Page to Surface
	while #Surface > 3 do table.remove(Surface) end  -- HACK
	local red = false
	for x=-1000,2000,300 do
		for y=-10000,10000,200 do
			add_thick_line({type='line', data={x,y, x+200,y+200, x,y+400}, r=red and 1 or 0,g=red and 0 or 0.5,b=0}, 10)
			red = not red
		end
	end
	compute_layout(Page, Page.x,Page.y, Surface, preserve_screen_top_of_cursor_node)
	compute_layout(Page2, Page2.x,Page2.y, Surface, preserve_screen_top_of_cursor_node)
	-- continue the pipeline
	B(preserve_screen_top_of_cursor_node)
	-- TODO: ugly that we're manipulating editor objects twice
end

add_thick_line = function(s, thickness)
	-- increase the thickness of a horizontal-ish line
	table.insert(Surface, s)
	for i=1,thickness-1 do
		s = copy_shape(s)
		for j=2,#s.data, 2 do
			s.data[j] = s.data[j]+1
		end
		table.insert(Surface, s)
	end
end

copy_shape = function(s)
	local result = {}
	for k,v in pairs(s) do
		result[k] = v
	end
	result.data = {}
	for _,d in ipairs(s.data) do
		table.insert(result.data, d)
	end
	return result
end

on.keychord_press = function(chord, key)
	if chord == 'C-=' then
		-- zoom in
		Viewport.zoom = Viewport.zoom+0.1
		B()
	elseif chord == 'C--' then
		-- zoom out
		Viewport.zoom = Viewport.zoom-0.1
		B()
	elseif chord == 'C-0' then
		-- reset zoom
		Viewport.zoom = 1.0
		B()
	elseif Cursor_node then
		local old_top = {line=Cursor_node.editor.screen_top1.line, pos=Cursor_node.editor.screen_top1.pos}
		edit.keychord_press(Cursor_node.editor, chord, key)
		if not eq(Cursor_node.editor.screen_top1, old_top) then
			Viewport.y = Cursor_node.y + y_of_schema1(Cursor_node.editor, Cursor_node.editor.screen_top1)
		end
		A(--[[preserve screen_top of cursor node]] true)
	else
		if chord == 'up' then
			Viewport.y = Viewport.y - scale(20)
			B()
		elseif chord == 'down' then
			Viewport.y = Viewport.y + scale(20)
			B()
		elseif chord == 'left' then
			Viewport.x = Viewport.x - scale(50)
			B()
		elseif chord == 'right' then
			Viewport.x = Viewport.x + scale(50)
			B()
		elseif chord == 'pageup' then
			Viewport.y = Viewport.y - App.screen.height/Viewport.zoom
			B()
		elseif chord == 'S-up' then
			Viewport.y = Viewport.y - App.screen.height/Viewport.zoom
			B()
		elseif chord == 'pagedown' then
			Viewport.y = Viewport.y + App.screen.height/Viewport.zoom
			B()
		elseif chord == 'S-down' then
			Viewport.y = Viewport.y + App.screen.height/Viewport.zoom
			B()
		elseif chord == 'S-left' then
			Viewport.x = Viewport.x - App.screen.width/Viewport.zoom
			B()
		elseif chord == 'S-right' then
			Viewport.x = Viewport.x + App.screen.width/Viewport.zoom
			B()
		end
	end
end

on.text_input = function(t)
	if Cursor_node then
		local old_top = {line=Cursor_node.editor.screen_top1.line, pos=Cursor_node.editor.screen_top1.pos}
		edit.text_input(Cursor_node.editor, t)
		if not eq(Cursor_node.editor.screen_top1, old_top) then
			Viewport.y = Cursor_node.y + y_of_schema1(Cursor_node.editor, Cursor_node.editor.screen_top1)
		end
		A(--[[preserve screen_top of cursor node]] true)
	end
end

        data={
			"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.",
			'1',
			'2',
			'3',
			'mno',
			'Acb',
			'g',
			'hij',
			'klm',
			'nop',
		},
        width=400, bg={r=1,g=1,b=0}
      },
      -- a table on the right
      { type='rows', name='searches', margin=50, data={
        { type='text', data={''},},
        { type='cols', data={
          { type='text', data={'search:'},},
          { type='text', name='search', bg={r=0.8,g=0.8,b=0.8}, data={''}, width=90,},
        }},
		{ type='text', data={'table:'},},
        { type='cols', bg={r=0.8,g=0.8,b=0.8}, data={
            { type='rows', width=90, data={
              {type='text', data={'abc'},},
              {type='text', data={'abc'},},
            }},
            { type='rows', width=90, data={
              {type='text', data={'def'},},
              {type='text', data={'def'},},
            }},
        }},
      }},
    },
}

B = function(preserve_screen_top_of_cursor_node)
	-- recompute various aspects based on the current viewport settings
	love.graphics.setFont(love.graphics.newFont(scale(20)))  -- editor objects implicitly depend on current font so update it
	for _,obj in ipairs(Surface) do
		if obj.type == 'line' then
			obj.zdata = {}
			for i=1,#obj.data,2 do
				table.insert(obj.zdata, vx(obj.data[i]))
				table.insert(obj.zdata, vy(obj.data[i+1]))
			end
		elseif obj.type == 'bezier' then
			zdata = {}
			for i=1,#obj.data,2 do
				table.insert(zdata, vx(obj.data[i]))
				table.insert(zdata, vy(obj.data[i+1]))
			end
			obj.zdata = love.math.newBezierCurve(zdata):render()
		elseif obj.type == 'text' then
			if obj.w then
				update_editor_box(obj, preserve_screen_top_of_cursor_node)
			else
				obj.text = love.graphics.newText(love.graphics.getFont(), obj.data)
			end
		end
	end
end

schema1_of_y = function(editor, y)
	-- return line/pos of screen line starting near a given y offset,
	-- and the (negative) offset remaining after the calculation
	-- invariants:
	-- 	- 0 >= y_offset >= -Line_height
	-- 	- let loc, y_offset = schema1_of_y(pane, y)
	-- 		y + y_offset == y_of_schema1(pane, loc)
	assert(y >= 0)
	local y_offset = y
	for i=1,#editor.lines do
		Text.populate_screen_line_starting_pos(editor, i)
		local height = line_height(editor, i)
		if y_offset < height then
			local line = editor.lines[i]
			local nlines = math.floor(y_offset/editor.line_height)
			assert(nlines >= 0 and nlines < #editor.line_cache[i].screen_line_starting_pos)
			local pos = editor.line_cache[i].screen_line_starting_pos[nlines+1]  -- switch to 1-indexing
			y_offset = y_offset - nlines*editor.line_height
			return {line=i, pos=pos}, -y_offset
		end
		y_offset = y_offset - height
	end
	-- y is below the pane
	return {line=#editor.lines+1, pos=1}, y_offset  -- positive value
end

line_height = function(editor, line_index)
	local line = editor.lines[line_index]
	local line_cache = editor.line_cache[line_index]
	return editor.line_height*#line_cache.screen_line_starting_pos
end

y_of_schema1 = function(editor, loc)
	local result = 0
	if loc.line == 1 and loc.pos == 1 then
		return result
	end
	for i=1,loc.line-1 do
		Text.populate_screen_line_starting_pos(editor, i)
		result = result + line_height(editor, i)
	end
	Text.populate_screen_line_starting_pos(editor, loc.line)
	for i,screen_line_starting_pos in ipairs(editor.line_cache[loc.line].screen_line_starting_pos) do
		if screen_line_starting_pos >= loc.pos then
			break
		end
		result = result + editor.line_height
	end
	return result
end

on.initialize = function()
	A()
end

Viewport = {x=-50, y=-50, w=800,h=600, zoom=1.0}

to_text = function(x,y)
	for _,node in ipairs(Surface) do
		if node.type == 'text' then
			if x >= vx(node.x) and node.w and x < vx(node.x + node.w) then
				if y >= vy(node.y) and node.h and y < vy(node.y + node.h) then
					return node
				end
			end
		end
	end
end

on.mouse_press = function(x,y, mouse_button)
	if Cursor_node then
		Cursor_node.show_cursor = nil
		Cursor_node = nil
	end
	local node = to_text(x,y)
	if node then
		Cursor_node = node
		edit.mouse_press(node.editor, x,y, mouse_button)
	else
		Pan = {x=Viewport.x+x/Viewport.zoom,y=Viewport.y+y/Viewport.zoom}
	end
end

Cursor_node = nil

end

end

  {type='line', data={0,-1000, 0,1000}},
  {type='line', data={-10000,0, 10000,0}},
  {type='text', data={'0'}, x=-20,y=-30},
  {type='rectangle', x=50,y=50, w=20,h=80, r=1,g=0,b=0},

	love.graphics.setColor(1,0,0)

			love.graphics.rectangle(obj.drawmode or 'fill', vx(obj.x),vy(obj.y), scale(obj.w),scale(obj.h))

			love.graphics.line(unpack(obj.zdata))

			if obj.w == nil then
				love.graphics.draw(obj.text, vx(obj.x), vy(obj.y))
			else
				edit.draw(obj.editor, obj.fg or {r=0,g=0,b=0}, not obj.show_cursor)

compute_layout = function(node, x,y, nodes_to_render, preserve_screen_top_of_cursor_node)

			for i,s in ipairs(node.data) do
				local text = love.graphics.newText(font(20), node.data)

		if node.editor == nil then
			initialize_editor(node)
		else
			update_editor_box(node, preserve_screen_top_of_cursor_node)
		end

			if not child.width then
				child.width = node.width  -- HACK: should we set child.w or child.width? Neither is quite satisfactory.
			end

}

}

		Viewport.x = Pan.x - App.mouse_x()/Viewport.zoom
		Viewport.y = Pan.y - App.mouse_y()/Viewport.zoom
		B()

end

	if Pan then
		Pan = nil
	elseif Cursor_node then
		Cursor_node.show_cursor = true
		edit.mouse_release(Cursor_node.editor, x,y, mouse_button)
	end
end

font = function(fontsize)

	-- return the height of a node. The result is scaled.

		local scaled_fontsize = scale(20)
		local scaled_lineheight = math.floor(scaled_fontsize*1.3)
		obj.editor = edit.initialize_state(vy(obj.y), math.floor(vx(obj.x)), math.ceil(vx(obj.x+obj.w)), scaled_fontsize, scaled_lineheight)

	print('code changed')
	A()  -- just in case we edited Page

This file contains no definition, but is used as a marker in the save dir to indicate all definitions have been copied from the repo to the save dir.