edit.update_font_settings(node.editor, scale(20))

	if node.editor.font_height ~= scale(20) then
		edit.update_font_settings(node.editor, scale(20))
		Text.redraw_all(node.editor)
	end

	if node.editor.font_height ~= scale(20) then
		edit.update_font_settings(node.editor, scale(20))
	end

end
	Text.redraw_all(node.editor)

		compute_layout(Global_state.thread, 0,0, Surface)

		compute_layout(Global_state.thread, 0,0, Surface, skip_updating_screen_top_for)

	B()
		compute_layout(node, node.x,node.y, Surface, skip_updating_screen_top_for)

	B(skip_updating_screen_top_for)

	-- continue the pipeline

			love.graphics.rectangle(obj.drawmode or 'fill', vx(obj.x),vy(obj.y), scale(obj.w),scale(obj.h), scale(obj.rx or 0),scale(obj.ry or obj.rx or 0))
			love.graphics.line(unpack(obj.zdata))
			love.graphics.circle(obj.drawmode or 'fill', vx(obj.x), vy(obj.y), scale(obj.radius))
			love.graphics.arc(obj.drawmode or 'line', obj.arctype or 'open', vx(obj.x), vy(obj.y), scale(obj.radius), obj.angle1, obj.angle2, obj.segments)
			love.graphics.ellipse(obj.drawmode or 'fill', vx(obj.x), vy(obj.y), scale(obj.radiusx), scale(obj.radiusy))
			love.graphics.line(unpack(obj.zdata))
				love.graphics.draw(obj.text, vx(obj.x), vy(obj.y))
	end

end

	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
		if chord == 'return' then

		A()
	elseif Cursor_node and Cursor_node.editor.cursor_x then

			-- Most of the time, we update the screen_top of nodes from Viewport.y.
			-- But here we went the other way.
			-- It's very important to avoid creating a recurrence, to avoid running
			-- both sides of this feedback loop in a single frame. These apps are
			-- not very numerically precise (e.g. we force text lines to start at
			-- integer pixels regardless of zoom, because that keeps text crisp),
			-- and the computations of Viewport.y and node.top will almost certainly
			-- not converge. The resulting bugs are extremely difficult to chase
			-- down.
			-- The optional skip_updating_screen_top_for arg ensures we don't run
			-- the other side of the feedback loop.
			A(--[[skip updating screen_top for]] Cursor_node)
			return

		else

		end
	else
		if chord == 'up' then

			B()
		elseif chord == 'down' then

			B()
		elseif chord == 'left' then

			B()
		elseif chord == 'right' then

			B()

			B()

			B()
		elseif chord == 'S-left' then

			B()
		elseif chord == 'S-right' then

			B()

		A()
	elseif chord == 'C-z' then
		dump_state()
	elseif chord == 'C-g' then
		-- special Expose-like 'global zoom' mode
		if Zoomed_out == nil then
			zoom_out()
		else
			undo_zoom_out()
		end
	elseif chord == 'C-q' then
		live.send_to_app('QUIT')
	elseif Manifest_navigator.show then
		keychord_press_on_manifest_navigator(chord, key)
	elseif chord == 'C-n' then
		new_definition()
		A()
	elseif chord == 'C-l' then
		Manifest_navigator.show = true
		Manifest_navigator.for_delete = false
		initialize_manifest_navigator()
	elseif chord == 'C-d' then
		Manifest_navigator.show = true
		Manifest_navigator.for_delete = true
		initialize_manifest_navigator()
			local definition_name = live.get_definition_name_from_buffer(live.definition_to_string(Cursor_node.editor))
			maybe_update_key_in_definitions(old_definition_name, definition_name, Cursor_node)
				-- Most of the time, we update the screen_top of nodes from Viewport.y.
				-- But here we went the other way.
				-- It's very important to avoid creating a recurrence, to avoid running
				-- both sides of this feedback loop in a single frame. These apps are
				-- not very numerically precise (e.g. we force text lines to start at
				-- integer pixels regardless of zoom, because that keeps text crisp),
				-- and the computations of Viewport.y and node.top will almost certainly
				-- not converge. The resulting bugs are extremely difficult to chase
				-- down.
				-- The optional skip_updating_screen_top_for arg ensures we don't run
				-- the other side of the feedback loop.
				A(--[[skip updating screen_top for]] Cursor_node)
				return

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

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

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

		local scaled_fontsize = scale(20)
		local scaled_lineheight = math.floor(scaled_fontsize*1.3)

		-- HACK: modify obj.editor.left after initialization

		obj.editor.left = obj.editor.left + Line_number_width*App.width('m')

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

		if node.type == 'text' and not node.button 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

	Pan = {x=Viewport.x+x/Viewport.zoom,y=Viewport.y+y/Viewport.zoom}

	Pan = {x=Viewport.x+x/Viewport.zoom, y=Viewport.y+y/Viewport.zoom}