parchment.lua

--[[ parchment.lua (text editing application that feels like parchment)
Copyright © 2024–2026 Victoria Lacroix

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>. ]]--

-- SECTION: Support library

local lib = require "parchmentlib"

function lib.get_home_directory()
	return os.getenv "HOME"
end

-- Replaces the home directory in the given path with a tilde.
function lib.encode_path(path)
	local pattern = "^" .. lib.get_home_directory()
	return path:gsub(pattern, "~", 1)
end

-- Replaces a tilde at the start of the path with the user's home directory.
function lib.decode_path(path)
	return path:gsub("^~", lib.get_home_directory(), 1)
end

function lib.absolute_path(file_path)
	file_path = lib.decode_path(file_path)
	local full_path = file_path
	local dir
	if full_path:sub(1, 1) ~= "/" then dir = lib.get_home_directory() end
	if dir then
		local up_pattern = "^%.%./"
		local only_up_pattern = "^..$"
		local cur_dir_pattern = "/[^/]+$"
		while file_path:find(up_pattern) do
			file_path = file_path:gsub(up_pattern, "")
			dir = dir:gsub(cur_dir_pattern, "")
		end
		while file_path:find(only_up_pattern) do
			file_path = ""
			dir = dir:gsub(cur_dir_pattern, "")
		end
		full_path = dir .. "/" .. file_path
	end
	return full_path
end

-- Takes the given file path (relative or absolute) and returns the directory and the file name.
function lib.dir_and_file(file_path)
	file_path = lib.absolute_path(file_path)
	local last = 1
	while file_path:sub(last + 1):find "/" do
		last = last + (file_path:sub(last + 1):find "/")
	end
	return file_path:sub(1, last - 1), file_path:sub(last + 1)
end

function lib.file_exists(file_name)
	file_name = lib.absolute_path(file_name)
	local ok, err, code = os.rename(file_name, file_name)
	if not ok then
		-- In Linux, error code 13 when moving a file means that it failed because the directory cannot be made its own child. Any other error means the file does not exist.
		if code == 13 then
			return true
		end
	end
	return ok
end

function lib.is_dir(file_name)
	file_name = lib.absolute_path(file_name)
	if file_name == "/" then return true end
	return lib.file_exists(file_name .. "/")
end

-- Iterates all lines in a file handle, returning true if the file contains any NUL characters and false otherwise. The file handle is then seeked back to the beginning for further reading.
function lib.file_is_binary(hdl)
	local is_binary = false
	for line in hdl:lines() do
		if line:match "\0" then
			is_binary = true
			break
		end
	end
	hdl:seek "set"
	return is_binary
end

function lib.escapepattern(str)
	-- Lua's string.gmatch function does not have a plain option. This takes input strings and returns their pattern equivalent, allowing string.gmatch to work as though it didn't match patterns.
	return str:gsub("[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%1")
end

function lib.escaperepl(str)
	-- In order to prevent replacement strings from being treated like replacement patterns, all % characters simply need to be escaped by doubling them.
	return str:gsub("%%", "%%%%")
end

-- Simple class implementation without inheritance.
local function newclass(init)
	local c = {}
	local mt = {}
	c.__index = c
	function mt:__call(...)
		local obj = setmetatable({}, c)
		init(obj, ...)
		return obj
	end
	function c:isa(klass)
		return getmetatable(self) == klass
	end
	return setmetatable(c, mt)
end

-- SECTION: Main application

-- This app runs in Flatpak, which puts Lua libraries outside of the standard paths. These lines tell Lua to look for libraries where Flatpak has put them.
package.cpath = "/app/lib/lua/5.4/?.so;" .. package.cpath
package.path = "/app/share/lua/5.4/?.lua;" .. package.path

local lfs = require "lfs"
local LuaGObject = require "LuaGObject"

local GLib = LuaGObject.require "GLib"
local Gio = LuaGObject.require "Gio"
local Adw = LuaGObject.require "Adw"
local Gtk = LuaGObject.require "Gtk"
local Gdk = LuaGObject.require "Gdk"
local Pango = LuaGObject.require "Pango"

local Parchment = LuaGObject.package "Parchment"

local app_id = lib.get_app_id()
local is_standalone = lib.get_is_standalone()
local app_flags = is_standalone and { "HANDLES_OPEN", "HANDLES_COMMAND_LINE", "NON_UNIQUE" } or { "HANDLES_OPEN", "HANDLES_COMMAND_LINE" }
local is_devel = lib.get_is_devel()
local app_title = "Parchment"
local app_version = lib.get_app_ver()
local app  = Adw.Application {
	application_id = app_id,
	resource_base_path = "/ca/vtrlx/Parchment", -- Needs to be hardcoded.
	flags = app_flags,
}

app:add_main_option("new-window", string.byte "n", "IN_MAIN", "NONE", "Create a new window.")
app:add_main_option("standalone", string.byte "s", "IN_MAIN", "NONE", "Run Parchment standalone. Suitable for use as an $EDITOR.")

-- Shortcuts from the GNOME HIG (https://developer.gnome.org/hig/reference/keyboard.html)
local accels = {
	["app.zoom-out"] = { "<Ctrl>minus" },
	["app.zoom-reset"] = { "<Ctrl>equal" },
	["app.zoom-in"] = { "<Ctrl><Shift>plus" },
	["win.new-file"] = { "<Ctrl>T" },
	["win.open-file"] = { "<Ctrl>O" },
	["win.new-window"] = {"<Ctrl>N" },
	["win.shortcuts"] = { "<Ctrl><Shift>question" },
	["win.open-folder"] = { "<Ctrl>D" },
	["win.close-tab"] = { "<Ctrl>W" },
	["win.save-file"] = { "<Ctrl>S" },
	["win.save-file-as"] = { "<Ctrl><Shift>S" },
	["win.search"] = { "<Ctrl>F" },
	["win.goto"] = { "<Ctrl>I" },
}
for k, v in pairs(accels) do
	app:set_accels_for_action(k, v)
end

local lerror = error
local function error(...)
	local msg = table.concat({ ... }, "	")
	local dlg = Adw.AlertDialog.new("Error", msg)
	dlg:add_response("cancel", "Continue")
	dlg:choose()
	-- Call Lua's builtin error() function so this new one has the same semantics of unwinding the call stack.
	lerror(...)
end

-- SECTION: GResources

do -- Load and register GResource.
	local resource, err = Gio.Resource.load "/app/data/parchment.gresource"
	if resource then
		Gio.resources_register(resource)
	else
		print("Failed to load resource", err)
	end
end -- Load and register GResource.

-- SECTION: Critically important global variables
local editors = {}
local window_widgets = {}

-- SECTION: Layout management

local zoomlevels = {
	current = 3,
	-- The use of fractions for the factor ensures total precision.
	{ label = "75%", factor = 3/4 },
	{ label = "90%", factor = 9/10 },
	{ label = "100%", factor = 1 },
	{ label = "110%", factor = 11/10 },
	{ label = "125%", factor = 5/4 },
	{ label = "133%", factor = 4/3 },
	{ label = "150%", factor = 3/2 },
	{ label = "166%", factor = 5/3 },
	{ label = "180%", factor = 9/5 },
	{ label = "200%", factor = 2 },
}

local function get_zoom_dimensions(level, fontsize)
	assert(type(level) == "number" and level % 1 == 0)
	assert(level >= 1 and level <= #zoomlevels)
	local factor = zoomlevels[level].factor
	local points = (fontsize or 11) * factor / 1024
	local pixels = 8 * factor
	local width = 640 * factor
	local margin = 24 * factor
	return points, pixels, width, margin
end

local css_template = [[
textview.parchment {
	font-family: %s;
	font-size: %f%s;
}

/* The Gtk.Image class always becomes more opaque when hovered, which suggests that it is actionable even when not. This CSS prevents that from occurring. */
image.parchment:hover {
	opacity: 0.7;
}
]]

local styleman = Adw.StyleManager.get_default()

local css_providers = {}
for i = 1, #zoomlevels do table.insert(css_providers, Gtk.CssProvider()) end

function build_css_providers()
	local docfontname = styleman.document_font_name
	local fontdesc = Pango.FontDescription.from_string(docfontname)
	local fontfam, fontsize = fontdesc:get_family(), fontdesc:get_size()
	local fontunit = fontdesc:get_size_is_absolute() and "px" or "pt"
	for i = 1, #zoomlevels do
		local points = get_zoom_dimensions(i, fontsize)
		local css = css_template:format(fontfam, points, fontunit)
		css_providers[i]:load_from_string(css)
	end
end

local function refresh_zoom(previous)
	local display = Gdk.Display.get_default()
	if previous and css_providers[previous] then
		local oldprovider = css_providers[previous]
		Gtk.StyleContext.remove_provider_for_display(display, oldprovider)
	end
	build_css_providers()
	local currentzoom = zoomlevels.current
	local newprovider = css_providers[currentzoom]
	Gtk.StyleContext.add_provider_for_display(display, newprovider, 1000000)
	local _, pixels = get_zoom_dimensions(currentzoom)
	local above, below = math.floor(pixels / 2), math.ceil(pixels / 2)
	for _, e in pairs(editors) do
		e.tv.pixels_above_lines = above
		e.tv.pixels_below_lines = below
	end
end

styleman.on_notify["document-font-name"] = refresh_zoom

-- Ensure that the default zoom level is active when starting up.
refresh_zoom()

local function zoom_out()
	local previous = zoomlevels.current
	if previous == 1 then return end
	zoomlevels.current = previous - 1
	refresh_zoom(previous)
end

local function zoom_in()
	local previous = zoomlevels.current
	if previous == #zoomlevels then return end
	zoomlevels.current = previous + 1
	refresh_zoom(previous)
end

local function zoom_reset()
	local previous = zoomlevels.current
	if previous == 3 then return end
	zoomlevels.current = 3
	refresh_zoom(previous)
end

-- GTK widgets do not provide signals for when they've resized. Instead, one is supposed to use a Layout Manager to handle this. Because the Layout Manager needs to be of a specific class, this will subclass it.
Parchment:class("EditorLayoutManager", Gtk.LayoutManager)

function Parchment.EditorLayoutManager:do_allocate(widget, width, height, baseline)
	local _, _, maxwidth, minmargin = get_zoom_dimensions(zoomlevels.current)
	local maxinner = maxwidth - minmargin * 2
	local totalmargin = math.max(minmargin, (width - maxinner) / 2)
	-- In case of the margin space being an odd number, the extra pixel gets assigned to the right side.
	widget.left_margin = math.floor(totalmargin)
	widget.right_margin = math.ceil(totalmargin)
	-- Allow some overscroll at the bottom of the file, but never enough such that all text can be scrolled out of view.
	widget.bottom_margin = math.floor(height * 0.6)
	Gtk.TextView.do_size_allocate(widget, width, height, baseline)
end

-- SECTION: Text editor context menu

local function editormenu()
	local menu = Gio.Menu()
	menu:append("Go to Line…", "win.goto")
	return menu
end

-- SECTION: Text editor

local editor = newclass(function(self)
	self.indenttags = {}
	local search_entry = Gtk.Text {
		placeholder_text = "Find in file…",
		hexpand = true,
	}
	local search_clear = Gtk.Button {
		css_name = "image",
		icon_name = "entry-clear-symbolic",
		margin_start = 12,
		visible = false,
		on_clicked = function()
			search_entry.text = ""
			search_entry:grab_focus()
		end,
	}
	local matchnum_label = Gtk.Label {
		css_classes = { "numeric" },
		halign = "END",
		hexpand = false,
		margin_start = 6,
		margin_end = 6,
	}
	function matchnum_label.on_notify.text()
		matchnum_label.visible = #matchnum_label.text > 0
	end
	local sbox = Gtk.Box {
		orientation = "HORIZONTAL",
		css_name = "entry",
		Gtk.Image {
			css_classes = { "parchment" },
			icon_name = "find-symbolic",
		},
		search_entry,
		search_clear,
		matchnum_label,
	}
	local prev_match = Gtk.Button {
		icon_name = "prev-symbolic",
		tooltip_text = "Go to previous match",
	}
	local next_match = Gtk.Button {
		icon_name = "next-symbolic",
		tooltip_text = "Go to next match",
	}
	local search_box = Gtk.Box {
		orientation = "HORIZONTAL",
		css_classes = { "linked" },
		sbox,
		prev_match,
		next_match,
	}
	local replace_image = Gtk.Image {
		css_classes = { "parchment" },
		icon_name = "find-replace-symbolic",
	}
	local replace_entry = Gtk.Text {
		placeholder_text = "Replace with…",
		hexpand = true,
	}
	local replace_clear = Gtk.Button {
		css_name = "image",
		icon_name = "entry-clear-symbolic",
		margin_start = 12,
		margin_end = 6,
		visible = false,
		on_clicked = function()
			replace_entry.text = ""
			replace_entry:grab_focus()
		end,
	}
	local rbox = Gtk.Box {
		css_name = "entry",
		orientation = "HORIZONTAL",
		replace_image,
		replace_entry,
		replace_clear,
	}
	local replace_button = Gtk.Button {
		label = "Replace",
		tooltip_text = "Replaces selected text",
		sensitive = false,
	}
	local replace_in_sel_button = Gtk.Button {
		label = "Replace in selection",
		tooltip_text = "Replace all matches in the selection",
		visible = false,
	}
	local replace_all_button = Gtk.Button {
		label = "Replace all",
		tooltip_text = "Replaces all matches in file",
		sensitive = false,
	}
	local replace_box = Gtk.Box {
		orientation = "HORIZONTAL",
		css_classes = { "linked" },
		rbox,
		replace_button,
		replace_in_sel_button,
		replace_all_button,
	}
	local search_bar_box = Gtk.Box {
		orientation = "VERTICAL",
		spacing = 6,
		search_box,
		replace_box,
	}
	local search_bar_clamp = Adw.Clamp {
		orientation = "HORIZONTAL",
		child = search_bar_box,
		maximum_size = 480,
	}
	local search_bar = Gtk.SearchBar {
		child = search_bar_clamp,
		search_mode_enabled = false,
		show_close_button = true,
	}
	search_bar:connect_entry(search_entry)
	local currentzoom = zoomlevels.current
	local _, pixels = get_zoom_dimensions(currentzoom)
	local above, below = math.floor(pixels / 2), math.ceil(pixels / 2)
	local text_view = Gtk.TextView {
		css_classes = { "parchment", "numeric", "view" },
		top_margin = 12,
		bottom_margin = 400,
		left_margin = 24,
		right_margin = 30,
		pixels_above_lines = above,
		pixels_below_lines = below,
		pixels_inside_wrap = 0,
		layout_manager = Parchment.EditorLayoutManager(),
		wrap_mode = Gtk.WrapMode.WORD_CHAR,
		extra_menu = editormenu(),
	}
	text_view.buffer:set_max_undo_levels(0)
	local scrolled_win = Gtk.ScrolledWindow {
		hscrollbar_policy = "NEVER",
		child = text_view,
		vexpand = true,
	}
	local box = Gtk.Box {
		orientation = "VERTICAL",
		search_bar,
		scrolled_win,
	}
	self.matches = {}
	self.search = {
		entry = search_entry,
		replentry = replace_entry,
		bar = search_bar,
		matchnum = matchnum_label,
	}
	self.tv = text_view
	function self.tv.buffer.on_modified_changed()
		self:update_title()
	end
	self.scroll = scrolled_win
	self.widget = box
	local function refresh_repl_buttons()
		if self:selection_has_match() and not self:match_selected() then
			replace_button.visible = false
			replace_in_sel_button.visible = true
			replace_all_button.visible = false
		else
			replace_button.visible = true
			replace_in_sel_button.visible = false
			replace_all_button.visible = true
		end
		replace_button.sensitive = self:match_selected()
		replace_in_sel_button.sensitive = not self:match_selected() and
			self:selection_has_match()
		replace_all_button.sensitive = #self.matches > 0
		if search_entry.text == replace_entry.text then
			replace_button.sensitive = false
			replace_in_sel_button.sensitive = false
			replace_all_button.sensitive = false
		end
	end
	function replchanged()
		refresh_repl_buttons()
		replace_clear.visible = #replace_entry.text > 0
	end
	function self.tv.buffer.on_mark_set(iter, mark)
		refresh_repl_buttons()
	end
	local function dosearch()
		if not search_bar.search_mode_enabled then return end
		if #search_entry.text == 0 then
			matchnum_label.label = ""
			search_clear.visible = false
			return
		end
		matchnum_label.label = self:findall(search_entry.text)
		search_clear.visible = true
		refresh_repl_buttons()
	end
	local function prev()
		matchnum_label.label = self:prev_match(search_entry.text)
		refresh_repl_buttons()
	end
	local function next()
		matchnum_label.label = self:next_match(search_entry.text)
		refresh_repl_buttons()
	end
	local function repl()
		if not replace_button.sensitive then return end
		self:replace(replace_entry.text)
		matchnum_label.label = self:next_match(search_entry.text)
		refresh_repl_buttons()
	end
	local function replsel()
		self:replace_in_selection(search_entry.text, replace_entry.text)
		dosearch()
	end
	local function replall()
		matchnum_label.label = ""
		self:replace_all(search_entry.text, replace_entry.text)
		refresh_repl_buttons()
	end
--[[
	This next line in particular may be the single most expensive operation in the entire application. It performs a search every single time the file's contents change while the search bar is visible. This is the single factor that hamper's Parchment's performance when dealing with large files.
	As a benchmark, on a Core i7 laptop using a balanced power profile, in a file with 200,000 lines of text, I had no problem typing text with the search mode turned off. With search enabled, and with an active query, Parchment would sometimes take a fraction of a second to show newly-typed text—but never dropped any keyboard inputs. This is a use case that is far, far beyond what Parchment is expected to support, and this code still works acceptably well. In fact, GtkTextView appears to have a harder time coping with large amounts of text than the find function does.
	It's believed that the reason for the find function's excellent performance is that it uses Lua's string search functions, which are optimized to work especially well for long strings of text.
]]--
	self.tv.buffer.on_changed = dosearch
--[[
	self.tv.buffer.on_insert_text:connect(function(buffer, location, text, len)
		local count = 0
		for _ in text:gmatch "[^\n]*" do count = count + 1 end
		local endline = location:get_line() + 1
		local startline = endline - count + 1
		for i = startline, endline do self:markindent(i) end
	end, nil, true)
	self.tv.on_map = function()
		if self.did_first_indent then return end
		GLib.timeout_add(GLib.PRIORITY_DEFAULT, 40, function()
			self:markallindents()
		end)
		self.did_first_indent = true
	end
]]--
	search_entry.buffer.on_notify.text = dosearch
	replace_entry.buffer.on_notify.text = replchanged
	prev_match.on_clicked = prev
	next_match.on_clicked = next
	search_entry.on_activate = next
	replace_button.on_clicked = repl
	replace_in_sel_button.on_clicked = replsel
	replace_all_button.on_clicked = replall
end)

local function open_file(path)
	assert(app.active_window)
	local tab_view = window_widgets[app.active_window].tab_view
	assert(tab_view)
	if type(path) == "string" then
		path = lib.absolute_path(path)
		local e = editors[path]
		if e then
			e:grab_focus()
			return
		end
	end
	local e = editor()
	if type(path) == "string" then
		if not e:edit_file(path) then return end
		local iter = e.tv.buffer:get_start_iter()
		e.tv.buffer:select_range(iter, iter)
	end
	editors[e.widget] = e
	if path then editors[path] = e end
	local page = tab_view:add_page(e.widget)
	tab_view:set_selected_page(page)
end

local function get_focused_editor()
	assert(app.active_window)
	local tab_view = window_widgets[app.active_window].tab_view
	assert(tab_view)
	local page = tab_view.selected_page
	if not page then return nil end
	return editors[page.child]
end

-- SECTION: File Management

local file_dialog_path = lib.get_home_directory()
local filefilters = Gio.ListStore.new(Gtk.FileFilter)
filefilters:append(Gtk.FileFilter {
	name = "Text files",
	mime_types = { "text/*" },
})

local function open_file_dialog(window)
	local e = get_focused_editor()
	local dir = file_dialog_path
	if e and e:has_file() then
		local _, newdir, _ = e:get_path_info()
		dir = newdir
	end
	local file_dialog = Gtk.FileDialog {
		initial_folder = Gio.File.new_for_path(dir),
		filters = filefilters,
	}
	Gio.Async.start(function()
		local list = file_dialog:async_open_multiple(window)
		if not list then return end
		for i = 1, list.n_items do
			-- Gio's API documents say that ListModel's :get_item() method is not available to language bindings and to use :get_object() instead. That's not the case for LuaGObject, which binds :get_item() and returns the object itself instead of a pointer.
			local file = list:get_item(i - 1)
			if i == 1 then
				file_dialog_path = file:get_parent():get_path()
			end
			open_file(file:get_path())
		end
	end)() -- Calls wrapped async
end

local function save_file_dialog(window, e)
	local dir = file_dialog_path
	if e:has_file() then
		local _, newdir, _ = e:get_path_info()
		dir = newdir
	end
	local file_dialog = Gtk.FileDialog {
		initial_folder = Gio.File.new_for_path(dir),
		filters = filefilters,
	}
	Gio.Async.start(function()
		local file = file_dialog:async_save(window)
		if not file then return end
		local path = file:get_path()
		local dir, _ = lib.dir_and_file(path)
		file_dialog_path = dir
		e:save(path)
	end)() -- Calls wrapped async
end

-- SECTION: Application menus

local burger_menu = Gio.Menu()
local zoom_item = Gio.MenuItem.new()
local zoom_custom_value = GLib.Variant("s", "zoom_section")
zoom_item:set_attribute_value("custom", zoom_custom_value)
burger_menu:append_item(zoom_item)

if not is_standalone then
	local file_menu = Gio.Menu()
	file_menu:append("Save As…", "win.save-file-as")
	burger_menu:append_section(nil, file_menu)
end

local nav_menu = Gio.Menu()
nav_menu:append("Show in Files", "win.open-folder")
nav_menu:append("Find/Replace", "win.search")
nav_menu:append("Go to Line", "win.goto")
burger_menu:append_section(nil, nav_menu)

local app_menu = Gio.Menu()
if not is_standalone then
	app_menu:append("New Window", "win.new-window")
end
app_menu:append("Keyboard Shortcuts", "win.shortcuts")
app_menu:append("About " .. app_title, "win.about")
burger_menu:append_section(nil, app_menu)

local shortcutsdialog = Adw.ShortcutsDialog {
	Adw.ShortcutsSection {
		title = "Parchment",
		table.unpack(not is_standalone and {
			Adw.ShortcutsItem.new_from_action("Open a file", "win.open-file"),
			Adw.ShortcutsItem.new_from_action("New file", "win.new-file"),
			Adw.ShortcutsItem.new_from_action("New window", "win.new-window"),
			--Adw.ShortcutsItem.new_from_action("Open/close overview", "win.overview"),
			Adw.ShortcutsItem.new_from_action("Show keyboard shortcuts", "win.shortcuts"),
		} or {
			--Adw.ShortcutsItem.new_from_action("Open/close overview", "win.overview"),
			Adw.ShortcutsItem.new_from_action("Show keyboard shortcuts", "win.shortcuts"),
		}),
	},
	Adw.ShortcutsSection {
		title = "Editor",
		table.unpack(not is_standalone and {
			Adw.ShortcutsItem.new_from_action("Show in Files", "win.open-folder"),
			Adw.ShortcutsItem.new_from_action("Save file", "win.save-file"),
			Adw.ShortcutsItem.new_from_action("Save file as", "win.save-file-as"),
			Adw.ShortcutsItem.new_from_action("Search in file", "win.search"),
			Adw.ShortcutsItem.new_from_action("Go to line", "win.goto"),
			Adw.ShortcutsItem.new_from_action("Close tab", "win.close-tab"),
		} or {
			Adw.ShortcutsItem.new_from_action("Show in Files", "win.open-folder"),
			Adw.ShortcutsItem.new_from_action("Save file", "win.save-file"),
			Adw.ShortcutsItem.new_from_action("Search in file", "win.search"),
			Adw.ShortcutsItem.new_from_action("Go to line", "win.goto"),

		}),
	},
	Adw.ShortcutsSection {
		title = "Zoom",
		Adw.ShortcutsItem.new_from_action("Zoom out", "app.zoom-out"),
		Adw.ShortcutsItem.new_from_action("Zoom in", "app.zoom-in"),
		Adw.ShortcutsItem.new_from_action("Reset zoom", "app.zoom-reset"),
	},
}

local function about(parent)
	local aboutdlg = Adw.AboutDialog {
		application_icon = app_id,
		application_name = app_title,
		copyright = "© 2025 Victoria Lacroix",
		developer_name = "Victoria Lacroix",
		issue_url = "https://github.com/vtrlx/parchment/issues/new",
		license_type = "GPL_3_0",
		version = lib.get_app_ver(),
		website = "https://www.vtrlx.ca/apps/parchment/",
	}

	aboutdlg:add_link("Contact the Developer", "mailto:victoria@vtrlx.ca?subject=Parchment App")

	aboutdlg:add_acknowledgement_section("Application Name", {
		"Brage Fuglseth https://bragefuglseth.dev",
	})
	aboutdlg:add_acknowledgement_section("3rd Party Libraries", {
		"LuaFileSystem https://lunarmodules.github.io/luafilesystem/index.html",
	})

	aboutdlg:present(parent)
end

-- SECTION: Main application window

local disabled_in_standalone = {
	["new-window"] = true,
	["new-file"] = true,
	["open-file"]= true,
	["save-file-as"] = true,
	["close-tab"] = true,
}

local function add_new_action(map, name, cb)
	if is_standalone and disabled_in_standalone[name] then return end
	local action = Gio.SimpleAction.new(name)
	action.enabled = true
	action.on_activate = cb
	map:add_action(action)
	return action
end

-- Creates a new window and presents it, returning the inner tab view.
local function new_window()
	local new_tab_button = Gtk.Button {
		action_name = "win.new-file",
		halign = "START",
		icon_name = "file-new-symbolic",
		tooltip_text = "New file",
	}

	local open_file_button = Gtk.Button {
		action_name = "win.open-file",
		icon_name = "file-open-symbolic",
		tooltip_text = "Open a file",
	}

	local zoom_out_button = Gtk.Button {
		action_name = "app.zoom-out",
		icon_name = "zoom-minus-symbolic",
		tooltip_text = "Zoom out",
	}

	local zoom_in_button = Gtk.Button {
		action_name = "app.zoom-in",
		icon_name = "zoom-plus-symbolic",
		tooltip_text = "Zoom in",
	}

	local currentzoom = zoomlevels.current
	local zoompercent = zoomlevels[currentzoom].label
	local zoom_reset_button = Gtk.Button {
		action_name = "app.zoom-reset",
		css_classes = { "numeric" },
		hexpand = true,
		label = zoompercent,
		tooltip_text = "Reset zoom to 100%",
		width_request = 100,
	}

	local zoom_box = Gtk.Box {
		orientation = "HORIZONTAL",
		hexpand = true,
		Gtk.Label {
			label = "Zoom",
			margin_start = 12,
		},
		Gtk.Box {
			orientation = "HORIZONTAL",
			halign = "END",
			margin_start = 64,
			css_classes = { "linked" },
			zoom_out_button,
			zoom_reset_button,
			zoom_in_button,
		},
	}

	local burger_popover = Gtk.PopoverMenu.new_from_model(burger_menu)
	burger_popover.halign = "END"
	burger_popover:add_child(zoom_box, "zoom_section")
	local menu_button = Gtk.MenuButton {
		direction = "DOWN",
		icon_name = "menu-symbolic",
		popover = burger_popover,
	}

	local tab_view = Adw.TabView {
		vexpand = true,
	}
	function tab_view:on_create_window()
		return new_window()
	end

--[[
	local tab_button = Adw.TabButton {
		action_name = "overview.open",
		tooltip_text = "View all tabs",
		view = tab_view,
	}
]]--

	local save_button = Gtk.Button {
		action_name = "win.save-file",
		icon_name = "file-save-symbolic",
		tooltip_text = "Save file",
		visible = false,
	}

	local file_properties_button = Gtk.Button {
		icon_name = "modify-formatting-symbolic",
		tooltip_text = "Modify formatting…",
		visible = false,
		on_clicked = function()
			local e = get_focused_editor()
			if not e then return end
			e:show_properties()
		end,
	}

	local window_title = Adw.WindowTitle.new(app_title, "")

	local content_header = Adw.HeaderBar {
		title_widget = window_title,
		show_start_title_buttons = false,
		valign = "START",
		start_packs = not is_standalone and { new_tab_button, open_file_button, save_button } or { save_button },
		end_packs = { menu_button, file_properties_button },
		-- end_packs = { menu_button, tab_button, file_properties_button },
	}

	local tab_bar = Adw.TabBar {
		autohide = true,
		view = tab_view,
	}

	local content = Adw.ToolbarView {
		content = tab_view,
		top_bar_style = "FLAT",
		top_bars = { content_header, tab_bar },
	}

	-- This is disabled as it is currently broken by Gtk.TextView causing resize events during its snapshot phase, which when used as a child of Adw.TabOverview leads to the entire tab contents visually freezing until switching to a new tab. Worse still, to fix this requires a breaking change in Gtk and Gtk.SourceView, so the fix must be coordinated downstream with distros.
--[[
	local tab_overview = Adw.TabOverview {
		child = content,
		view = tab_view,
	}
]]--

	local window = Adw.ApplicationWindow {
		application = app,
--		content = tab_overview,
		content = content,
		title = app_title,
		width_request = 480,
		height_request = 240,
	}
	window:set_default_size(640, 720)

	function tab_view:on_page_attached(page)
		file_properties_button.visible = true
		local e = editors[page.child]
		if not e then return end
		content.top_bar_style = "RAISED_BORDER"
		function e:set_title(title, subtitle, icon)
			page.title = title
			if icon then
				local iname = "pencil-symbolic"
				page.indicator_icon = Gio.Icon.new_for_string(iname)
			else
				page.indicator_icon = nil
			end
			if tab_view.selected_page == page then
				window.title = not is_standalone and title or (title .. " (standalone)")
				window_title:set_title(title)
				window_title:set_subtitle(subtitle)
				save_button.tooltip_text = "Save " .. title
				save_button.visible = icon
				if window_widgets[window] and self:has_file() then
					window_widgets[window].open_folder_action.enabled = true
				end
			end
		end
		function e:set_search_mode()
		end
		function e:grab_focus()
			window:activate()
			tab_view:set_selected_page(page)
			e.tv:grab_focus()
		end
		-- Force set here, because the tab view's selected_page won't be set in time for this call.
		local title, subtitle = e:get_title()
		page.title = name
		window.title = not is_standalone and title or (title .. " (standalone)")
		window_title:set_title(title)
		window_title:set_subtitle(subtitle)
		window_widgets[window].open_folder_action.enabled = e:has_file()
		window_widgets[window].search_action.enabled = true
		window_widgets[window].goto_action.enabled = true
	end
	function tab_view:on_page_detached(page)
		local e = editors[page.child]
		if not e then return end
		-- This will be reset once the page is reattached.
		function e:set_title() end
	end
	function tab_view:on_notify(spec)
		if spec.name == "selected-page" and self.selected_page then
			local e = editors[self.selected_page.child]
			e:update_title()
			e.tv:grab_focus()
		end
	end
	function tab_view:on_close_page(page)
		local e = editors[page.child]
		local do_close = true
		local reason
		if type(e.can_close) == "function" then
			do_close, reason = e:can_close()
		end
		self:close_page_finish(page, do_close)
		if not do_close then
			local body = "The file %q has unsaved changes."
			local _, _, name = e:get_path_info()
			body = body:format(name)
			if not e:has_file() then
				body = "This file has unsaved changes."
			end
			local dlg = Adw.AlertDialog.new("Save changes?", body)
			dlg:add_response("close", "Keep open")
			dlg:set_response_appearance("close", "DEFAULT")
			dlg:add_response("discard", "Close without saving")
			dlg:set_response_appearance("discard", "DESTRUCTIVE")
			dlg:add_response("save", "Save and close")
			dlg:set_response_appearance("save", "SUGGESTED")
			function dlg:on_response(response)
				if response == "discard" then
					e.tv.buffer:set_modified(false)
					tab_view:close_page(page)
				elseif response == "save" then
					e:save()
					tab_view:close_page(page)
				end
			end
			dlg:choose(app.active_window)
		else
			editors[page.child] = nil
			local path = e:get_path_info()
			if path then editors[path] = nil end
			if self:get_n_pages() == 0 then
				window.title = app_title
				window_title:set_title(app_title)
				window_title:set_subtitle ""
				save_button.visible = false
				file_properties_button.visible = false
				content.top_bar_style = "FLAT"
				if window_widgets[window] then
					window_widgets[window].open_folder_action.enabled = false
					window_widgets[window].search_action.enabled = false
					window_widgets[window].goto_action.enabled = false
				end
			end
		end
		return true
	end

	window_widgets[window] = {
		tab_view = tab_view,
		in_handle = in_handle,
		zoom_reset_button = zoom_reset_button,
	}
	function window:on_close_request()
		local n_pages = tab_view:get_n_pages()
		local unsaved = {}
		for i = 1, n_pages do
			local page = tab_view:get_nth_page(n_pages - i)
			local e = editors[page.child]
			if not e:can_close() then
				table.insert(unsaved, e)
			end
		end
		local function discard()
			for _, e in ipairs(unsaved) do
				e.tv.buffer:set_modified(false)
			end
			self:close()
		end
		if #unsaved > 0 then
			local dlg = Adw.AlertDialog.new("Close window?", "There are unsaved changes.")
			dlg:add_response("cancel", "Keep open")
			dlg:set_response_appearance("cancel", "DEFAULT")
			dlg:add_response("discard", "Discard all changes")
			dlg:set_response_appearance("discard", "DESTRUCTIVE")
			function dlg:on_response(response)
				if response == "discard" then discard() end
			end
			dlg:choose(self)
			return true
		else
			window_widgets[self] = nil
			-- Explicitly close each editor page to free their resources. Better than hooking into __gc or something similar.
			for i = 1, n_pages do
				local page = tab_view:get_nth_page(n_pages - i)
				tab_view:close_page(page)
			end
			return false
		end
	end

	if not is_standalone then
		local file_drop_target = Gtk.DropTarget.new(Gio.File, Gdk.DragAction.COPY)
		function file_drop_target:on_drop(value)
			local file = value:get_object()
			open_file(file:get_path())
		end
		window:add_controller(file_drop_target)
	end

	add_new_action(window, "close-tab", function()
		local page = tab_view.selected_page
		if not page then return true end
		tab_view:close_page(page)
	end)

	add_new_action(window, "open-file", function()
		open_file_dialog(window)
	end)

	window_widgets[window].open_folder_action = add_new_action(window, "open-folder", function()
		local e = get_focused_editor()
		if not e or not e:has_file() then return end
		local path = e:get_path_info()
		local file = Gio.File.new_for_path(path)
		local launcher = Gtk.FileLauncher.new(file)
		Gio.Async.start(function()
			launcher:async_open_containing_folder()
		end)() -- calls wrapped async
	end)
	window_widgets[window].open_folder_action.enabled = false

	add_new_action(window, "new-file", function()
		open_file()
	end)

	add_new_action(window, "save-file", function()
		local e = get_focused_editor()
		if not e then return end
		if e:has_file() then
			e:save()
		else
			save_file_dialog(window, e)
		end
	end)

	add_new_action(window, "save-file-as", function()
		local e = get_focused_editor()
		if not e then return end
		save_file_dialog(window, e)
	end)

	window_widgets[window].search_action = add_new_action(window, "search", function()
		local e = get_focused_editor()
		if not e then return end
		e:begin_search()
	end)
	window_widgets[window].search_action.enabled = false

	window_widgets[window].goto_action = add_new_action(window, "goto", function()
		local e = get_focused_editor()
		if not e then return end
		e:begin_jumpover()
	end)
	window_widgets[window].goto_action.enabled = false

	add_new_action(window, "new-window", function()
		new_window()
	end)

	add_new_action(window, "shortcuts", function()
		shortcutsdialog:present(window)
	end)

	add_new_action(window, "about", function()
		about(window)
	end)

	if is_devel then window:add_css_class "devel" end

	window:present()

	return tab_view
end

-- SECTION: Text editor definitions

local function buffer_read_file(buffer, file_path)
	local dir, name = lib.dir_and_file(file_path)
	assert(lib.is_dir(dir))
	buffer:begin_irreversible_action()
	buffer:delete(buffer:get_start_iter(), buffer:get_end_iter())
	local hdl = io.open(lib.decode_path(file_path), "r")
	if hdl then
		if lib.file_is_binary(hdl) then
			local window = app.active_window
			if not window then return fail end
			local msg = "The file %q is not a text file, so it can't be opened."
			msg = msg:format(lib.encode_path(name))
			local dlg = Adw.AlertDialog.new("Invalid File Type", msg)
			dlg:add_response("cancel", "Continue without opening")
			dlg:choose(window)
			return fail
		end
		for line in hdl:lines() do
			assert(not line:match "\0")
			line = line:gsub("%s*$", "\n")
			buffer:insert(buffer:get_end_iter(), line, #line)
		end
		-- Remove trailing newlines, so the last line of the file is the last line of the buffer.
		buffer.text = (buffer.text:match ".*[^\n]") or ""
	end
	-- utf8.len() returns fail on an invalid UTF-8 sequence.
	local length = utf8.len(buffer.text)
	if length == fail then
		local window = app.active_window
		if not window then return fail end
		local msg = "The encoding of %q is not supported, so it can't be opened."
		msg = msg:format(lib.encode_path(name))
		local dlg = Adw.AlertDialog.new("Invalid File Encoding", msg)
		dlg:add_response("cancel", "Continue without opening")
		dlg:choose(window)
		return fail
	end
	buffer:set_modified(false)
	buffer:end_irreversible_action()
	return true
end

local function buffer_write_file(buffer, file_path)
	local errmsg
	local file = io.open(file_path, "w")
	if not file then return fail end
	local text = buffer.text:match ".*[^\n]" or ""
	for line in text:gmatch "[^\n]*" do
		line = line:gsub("%s*$", "\n")
		file:write(line)
	end
	local success, err = file:flush()
	if success then
		buffer:set_modified(false)
	end
	file:close()
	return success, err
end

function editor:get_insert()
	return self.tv.buffer:get_insert()
end

function editor:get_bound()
	return self.tv.buffer:get_selection_bound()
end

function editor:get_iters()
	local first = self.tv.buffer:get_iter_at_mark(self:get_bound())
	local second = self.tv.buffer:get_iter_at_mark(self:get_insert())
	first:order(second)
	return first, second
end

function editor:set_iters(first, second)
	assert(first, second)
	first:order(second)
	-- Yes, this is how TextBuffer:select_range() works.
	self.tv.buffer:select_range(second, first)
end

function editor:scroll_to_selection()
	self.tv:scroll_to_mark(self:get_bound(), 0.4999, false, 0.0, 0.0)
	self.tv:scroll_to_mark(self:get_insert(), 0.2, false, 0.0, 0.0)
end

function editor:select_range(range_start, range_end)
	assert(type(range_start) == "number")
	assert(type(range_end) == "number")
	local first = self.tv.buffer:get_start_iter()
	first:forward_chars(range_start - 1)
	local second = self.tv.buffer:get_start_iter()
	second:forward_chars(range_end - 1)
	self:set_iters(first, second)
end

function editor:selection_get()
	local first, second = self:get_iters()
	return first:get_slice(second)
end

function editor:selection_replace(str)
	assert(type(str) == "string")
	self.tv.buffer:begin_user_action()
	local first, second = self:get_iters()
	self.tv.buffer:delete(first, second)
	local offset = second:get_offset()
	self.tv.buffer:insert(second, str, #str)
	self.tv.buffer:end_user_action()
	first = self.tv.buffer:get_iter_at_offset(offset)
	self:set_iters(first, second)
end

function editor:selection_rect()
	local first, second = self:get_iters()
	if second:starts_line() and first:get_offset() ~= second:get_offset() then
		second:backward_line()
		first:order(second)
	end
	local rect = self.tv:get_cursor_locations(second)
	rect.x, rect.y = self.tv:buffer_to_window_coords(Gtk.TextWindowType.TEXT, rect.x, rect.y)
	return rect
end

function editor:can_close()
	return not self.tv.buffer:get_modified()
end

function editor:get_title()
	local title = self.file_name or "New File"
	local subtitle = ""
	if self.file_dir then subtitle = lib.encode_path(self.file_dir) end
	local icon = self.tv.buffer:get_modified()
	return title, subtitle, icon
end

function editor:update_title()
	if type(self.set_title) == "function" then
		self:set_title(self:get_title())
	end
end

function editor:get_path_info()
	if not self:has_file() then return end
	return self.file_dir .. "/" .. self.file_name, self.file_dir, self.file_name
end

function editor:update_search_mode()
	self:set_search_mode(self.search.bar.search_mode_enabled)
end

function editor:has_file()
	return self.file_dir and self.file_name
end

function editor:set_file_path(path)
	local oldpath = self:get_path_info()
	if path == oldpath then return end
	assert(path and type(path) == "string")
	assert(not lib.is_dir(path))
	local abspath = lib.absolute_path(path)
	if oldpath == abspath then return end
	if editors[abspath] then return end
	if oldpath then editors[oldpath] = nil end
	local dir, name = lib.dir_and_file(path)
	assert(lib.is_dir(dir))
	self.file_dir = dir; self.file_name = name
	editors[abspath] = self
	self:update_title()
end

function editor:edit_file(path)
	if self.tv.buffer:get_modified() then
		return
	end
	assert(type(path) == "string")
	self:set_file_path(path)
	path = self:get_path_info()
	local attrs = lfs.attributes(path)
	if not attrs then
		print("no file", path)
		return
	end
	self.modtime = attrs.modification
	return buffer_read_file(self.tv.buffer, path)
end

function editor:warn_save_error()
	local reason
	local path, dir, name = self:get_path_info()
	local dir_attrs = lfs.attributes(dir)
	local file_attrs = lfs.attributes(path)
	if not dir_attrs then
		reason = "the destination folder does not exist"
	elseif not dir_attrs.permissions:match "w" then
		reason = "the destination folder is read-only"
	elseif not file_attrs then
		reason = "of an error with the destination folder"
	elseif file_attrs.mode ~= "file" then
		reason = "the destination path is not a file"
	elseif not file_attrs.permissions:match "w" then
		reason = "the destination file is read-only"
	else
		reason = "of an unknown error"
	end
	local template = "The file “%s” could not be saved because %s."
	local body = template:format(name, reason)
	local dlg = Adw.AlertDialog.new("Could not write file", body)
	dlg:add_response("keep", "Don't save")
	dlg:set_response_appearance("keep", "DEFAULT")
	dlg:add_response("save", "Try again")
	dlg:set_response_appearance("save", "DEFAULT")
	dlg:add_response("save-as", "Save as…")
	dlg:set_response_appearance("save-as", "SUGGESTED")
	local window = app.active_window
	function dlg.on_response(dlg, response)
		if response == "save" then self:save(path) end
		if response == "save-as" then
			save_file_dialog(window, self)
		end
	end
	dlg:choose(window)
end

function editor:save(path)
	local oldpath = self:get_path_info()
	if path then self:set_file_path(path) end
	assert(self.file_dir and self.file_name)
	local name, _
	path, _, name = self:get_path_info()
	local samepath = oldpath == path
	local attrs, modtime
	if lib.file_exists(path) then
		attrs = lfs.attributes(path)
		if attrs.mode ~= "file" then
			self:warn_save_error()
			return
		end
		modtime = attrs.modification
	end
	local function dosave()
		local success = buffer_write_file(self.tv.buffer, path)
		if not success then
			self:warn_save_error(path)
			return
		end
		attrs = lfs.attributes(path)
		self.modtime = attrs.modification
		self:update_title()
	end
	if samepath and self.modtime and modtime and modtime > self.modtime then
		local bodyfmt = "The file “%s” has been modified by another application since it was opened. Saving will overwrite those modifications."
		local body = bodyfmt:format(name)
		local dlg = Adw.AlertDialog.new("Overwrite file?", body)
		dlg:add_response("keep", "Don't save")
		dlg:set_response_appearance("keep", "DEFAULT")
		dlg:add_response("save", "Overwrite")
		dlg:set_response_appearance("save", "DESTRUCTIVE")
		dlg:add_response("save-as", "Save as…")
		dlg:set_response_appearance("save-as", "SUGGESTED")
		local window = app.active_window
		function dlg:on_response(response)
			if response == "save" then dosave() end
			if response == "save-as" then
				save_file_dialog(window, e)
			end
		end
		dlg:choose(window)
	else
		dosave()
	end
end

function editor:go_to(line)
	local lines = self.tv.buffer:get_line_count()
	assert(type(line) == "number" and line >= 1 and line <= lines)
	local first = self.tv.buffer:get_iter_at_line(line - 1)
	self:set_iters(first, first)
	self:scroll_to_selection()
end

function editor:begin_search()
	-- Replace the search entry if the current selection doesn't match
	if not self.search.bar.search_mode_enabled then
		if self.tv.buffer:get_has_selection() and not self:match_selected() then
			self.search.entry.text = self:selection_get()
		else
			self.search.entry.text = ""
		end
		self.search.replentry.text = ""
	end
	self.search.bar.search_mode_enabled = true
	self.search.entry:grab_focus()
end

function editor:update_matches(total, match)
	if type(match) == "number" and type(total) == "number" then
		return ("%d of %d"):format(match, total)
	elseif type(total) == "number" then
		return ("%d"):format(total)
	elseif type(total) == "string" then
		return total
	else
		return ""
	end
end

-- Lua is excellent at processing long strings, and in my experience this implementation is fast enough for most use cases.
function editor:findall(pattern)
	if #pattern == 0 then return end
	local byte_indices = {}
	local text = self.tv.buffer.text
	local len = #text
	local init = 1
	while init <= len do
		local i, j = text:find(pattern, init, true)
		if not i or not j then break end
		table.insert(byte_indices, { i, j })
		init = j + 1
	end
	self.matches = {}
	local utf_total = 0
	init = 1
	for _, t in ipairs(byte_indices) do
		local i = t[1]
		local j = t[2]
		local ulen1 = utf8.len(text, init, i, true)
		local ulen2 = utf8.len(text, i, j, true)
		assert(ulen1 and ulen2)
		ulen1 = utf_total + ulen1
		utf_total = ulen1
		ulen2 = utf_total + ulen2
		utf_total = ulen2 - 1
		table.insert(self.matches, { ulen1, ulen2 })
		init = j + 1
	end
	if not #self.matches then
		return self:update_matches "no match"
	end
	return self:update_matches(#self.matches)
end

-- Returns true if the currently selected text is on a match.
function editor:match_selected()
	local first, second = self:get_iters()
	local first_offset = first:get_offset() + 1
	local second_offset = second:get_offset() + 1
	for _, m in ipairs(self.matches) do
		if first_offset == m[1] and second_offset == m[2] then
			return true
		elseif first_offset < m[1] and second_offset < m[2] then
			return false
		end
	end
	return false
end

function editor:selection_has_match()
	if #self.matches == 0 then return false end
	local first, second = self:get_iters()
	local first_offset = first:get_offset() + 1
	local second_offset = second:get_offset() + 1
	for _, m in ipairs(self.matches) do
		if first_offset <= m[1] and second_offset >= m[2] then
			return true
		end
	end
	return false
end

function editor:next_match(...)
	self:findall(...)
	if #self.matches == 0 then return end
	local _, start_iter = self:get_iters()
	local cursor_pos = start_iter:get_offset()
	for i, m in ipairs(self.matches) do
		if m[1] > cursor_pos then
			self:select_range(m[1], m[2])
			self:scroll_to_selection()
			return self:update_matches(#self.matches, i)
		end
	end
	-- Wrap to start
	self:select_range(self.matches[1][1], self.matches[1][2])
	self:scroll_to_selection()
	return self:update_matches(#self.matches, 1)
end

function editor:prev_match(...)
	self:findall(...)
	if #self.matches == 0 then return end
	local first, _ = self:get_iters()
	local cursor_pos = first:get_offset() + 1
	for i = 1, #self.matches do
		local idx = #self.matches - i + 1
		local m = self.matches[idx]
		if cursor_pos >= m[2] then
			self:select_range(m[1], m[2])
			self:scroll_to_selection()
			return self:update_matches(#self.matches, idx)
		end
	end
	local m = self.matches[#self.matches]
	self:select_range(m[1], m[2])
	self:scroll_to_selection()
	return self:update_matches(#self.matches, #self.matches)
end

-- Replaces the matched expression with the given text.
function editor:replace(repl)
	if not self:match_selected() then return end
	self:selection_replace(repl)
end

function editor:replace_in_selection(pattern, repl)
	if #pattern == 0 then return end
	if not self:selection_has_match() then return end
	pattern = lib.escapepattern(pattern)
	repl = lib.escaperepl(repl)
	local text = self:selection_get()
	local vadj = self.scroll.vadjustment
	local ratio = (vadj.value - vadj.lower) / (vadj.upper - vadj.lower)
	self:selection_replace(text:gsub(pattern,repl))
	GLib.timeout_add(GLib.PRIORITY_DEFAULT, 15, function()
		vadj.value = (vadj.upper - vadj.lower) * ratio + vadj.lower
	end)
end

function editor:replace_all(pattern, repl)
	if #pattern == 0 then return end
	pattern = lib.escapepattern(pattern)
	repl = lib.escaperepl(repl)
	local text = self.tv.buffer.text
	local vadj = self.scroll.vadjustment
	local ratio = (vadj.value - vadj.lower) / (vadj.upper - vadj.lower)
	self.tv.buffer:begin_user_action()
	self.tv.buffer.text = text:gsub(pattern, repl)
	self.tv.buffer:end_user_action()
	GLib.timeout_add(GLib.PRIORITY_DEFAULT, 15, function()
		vadj.value = (vadj.upper - vadj.lower) * ratio + vadj.lower
	end)
end

function editor:fixindent(spaces)
	assert(type(spaces) == "number")
	assert(spaces > 0)
	self.tv.buffer:begin_user_action()
	local oldtext = self.tv.buffer.text
	local newtext = ""
	local spacepattern = ""
	for i = 1, spaces do spacepattern = spacepattern .. " " end
	local pattern = "^	*" .. spacepattern
	for line in oldtext:gmatch "[^\n]*" do
		while line:match(pattern) do
			line = line:gsub(spacepattern, "	")
		end
		-- Pattern is a tab character followed by a space.
		while line:match "	 " do
			-- Replace with just a tab character.
			line = line:gsub("	 ", "	")
		end
		newtext = newtext .. line .. "\n"
	end
	newtext = newtext:match ".*[^\n]"
	self.tv.buffer.text = newtext
	self.tv.buffer:end_user_action()
end

function editor:unfixindent(spaces)
	assert(type(spaces) == "number")
	assert(spaces > 0)
	self.tv.buffer:begin_user_action()
	local oldtext = self.tv.buffer.text
	local newtext = ""
	local spacepattern = ""
	for i = 1, spaces do spacepattern = spacepattern .. " " end
	local pattern = "^ *	"
	for line in oldtext:gmatch "[^\n]*" do
		while line:match(pattern) do
			line = line:gsub("	", spacepattern)
		end
		newtext = newtext .. line .. "\n"
	end
	newtext = newtext:match ".*[^\n]"
	self.tv.buffer.text = newtext
	if restoreafter then
		self.indentspaces = spaces
	end
	self.tv.buffer:end_user_action()
end

function editor:show_properties()
	local s2tbox = Gtk.ListBox {
		selection_mode = "NONE",
		extra_css_classes = { "boxed-list-separate" },
	}
	local t2sbox = Gtk.ListBox {
		selection_mode = "NONE",
		extra_css_classes = { "boxed-list-separate" },
	}
	for _, v in ipairs { 2, 3, 4, 8 } do
		s2tbox:append(Adw.ButtonRow {
			title = ("Convert %d spaces → tabs"):format(v),
			on_activated = function() self:fixindent(v) end,
		})
		t2sbox:append(Adw.ButtonRow {
			title = ("Convert tabs → %d spaces"):format(v),
			on_activated = function() self:unfixindent(v) end,
		})
	end
	local prefsdialog = Adw.PreferencesDialog {
		title = "Adjust Document",
		Adw.PreferencesPage {
			Adw.PreferencesGroup {
				title = "Adjust Indentation",
				description = "Convert between leading spaces and tabs.",
				Adw.WrapBox {
					justify = "FILL",
					justify_last_line = true,
					child_spacing = 12,
					line_spacing = 12,
					s2tbox,
					t2sbox,
				},
			},
		},
	}
	prefsdialog:present(self.tv)
end

function editor:begin_jumpover()
	self.scroll.kinetic_scrolling = false
	self:scroll_to_selection()
	local _, second = self:get_iters()
	local lineno = second:get_line() + 1
	local lines = self.tv.buffer:get_line_count()
	local colno = second:get_line_index() + 1
	local labelfmt = "Line #%d/%d, Column #%d"
	local linelabel = Gtk.Label {
		label = labelfmt:format(lineno, lines, colno),
		halign = "START",
	}
	local lineentry = Gtk.Entry {
		placeholder_text = "Go to line…",
		halign = "FILL",
		width_request = 100,
	}
	local box = Gtk.Box {
		orientation = "VERTICAL",
		spacing = 6,
		linelabel,
		lineentry,
	}
	local popover = Gtk.Popover {
		child = box,
		pointing_to = self:selection_rect(),
	}
	function lineentry.on_changed()
		local num = tonumber(lineentry.text)
		if num and num >= 1 and num <= lines then
			lineentry:remove_css_class "error"
		else
			lineentry:add_css_class "error"
		end
	end
	function lineentry.on_activate()
		local num = tonumber(lineentry.text)
		if num and num >= 1 and num <= lines then
			self:go_to(num)
			popover:popdown()
		end
	end
	popover:set_parent(self.tv)
	popover:popup()
	self.scroll.kinetic_scrolling = true
end

local function matchindent(str)
	-- C/C++ comment
	return str:match "^	*/[/%*]%s*"
		-- Lua comment and various Markdown things.
		or str:match "^	*[%>%-%*%#]+%s+"
		-- Just tabs, or the empty string.
		or str:match "^	*"
end

function editor:markindent(line)
	local buffer = self.tv.buffer
	if line < 1 or line > buffer:get_line_count() then return end
	local sol = buffer:get_iter_at_line(line - 1)
	local eol = sol:copy()
	eol:forward_to_line_end()
	buffer:remove_all_tags(sol, eol)
	local indent_level = #matchindent(sol:get_slice(eol))
	if indent_level == 0 then return end
	start_visible = sol:copy()
	start_visible:forward_chars(indent_level)
	local location = self.tv:get_iter_location(start_visible)
	local indent = -(location.x - self.tv.left_margin)
	if not self.indenttags[indent] then
		self.indenttags[indent] = Gtk.TextTag {
			indent = indent,
		}
		buffer.tag_table:add(self.indenttags[indent])
	end
	buffer:apply_tag(self.indenttags[indent], sol, eol)
end

function editor:markallindents(start, finish)
	if not self.tv:get_realized() then return end
	local buffer = self.tv.buffer
	if not start then start = buffer:get_start_iter() end
	if not finish then finish = buffer:get_end_iter() end
	local startline = start:get_line() + 1
	local endline = finish:get_line() + 1
	for i = startline, endline do
		self:markindent(i)
	end
end

-- SECTION: Application callbacks and startup

local function update_zoom_actions()
	local current = zoomlevels.current
	local zoom_out = app:lookup_action "zoom-out"
	zoom_out.enabled = current > 1
	local zoom_in = app:lookup_action "zoom-in"
	zoom_in.enabled = current < #zoomlevels
	local zoom_reset = app:lookup_action "zoom-reset"
	zoom_reset.enabled = current ~= 3
	local label = zoomlevels[current].label
	for _, w in pairs(window_widgets) do
		w.zoom_reset_button.label = label
	end
end

do -- Add app-wide actions.
	add_new_action(app, "zoom-out", function()
		zoom_out()
		update_zoom_actions()
	end)

	add_new_action(app, "zoom-in", function()
		zoom_in()
		update_zoom_actions()
	end)

	-- Because the zoom defaults to 100, there's no need to reset the zoom level.
	local reset_action = add_new_action(app, "zoom-reset", function()
		zoom_reset()
		update_zoom_actions()
	end)
	reset_action.enabled = false
end

function app:on_open(files)
	for _, f in ipairs(files) do
		open_file(f:get_path())
	end
	if app.active_window then app.active_window:present() end
end

function app:on_activate()
	if app.active_window then app.active_window:present() end
end

-- Handles opening a file from the command line, possibly in a new window of an existing Parchment instance.
function app:on_command_line(cli)
	local argv, argc = cli:get_arguments()
	local files = {}
	for i = 2, #argv do
		filename = argv[i]
		if filename == "-" then
			cli:printerr "can't open from stdin"
			cli:set_exit_status(1)
			cli:done()
			return 0
		end
		local file = cli:create_file_for_arg(filename)
		table.insert(files, file)
	end
	local opts = cli:get_options_dict()
	if cli:get_is_remote() and opts:contains "new-window" then
		new_window()
	end
	if #files > 0 then app:open(files, "") end
	if is_standalone and #files ~= 1 then app:quit() end
	-- Signal that command line options have been handled and that the app should continue starting up.
	cli:set_exit_status(0)
	cli:done()
	return -1
end

function app:on_startup()
	new_window()
end

return app:run { lib.get_cli_args() }