diff --git a/luakit/.config/luakit/binds.lua b/luakit/.config/luakit/binds.lua new file mode 100644 index 0000000..2c8604c --- /dev/null +++ b/luakit/.config/luakit/binds.lua @@ -0,0 +1,588 @@ +----------------- +-- Keybindings -- +----------------- + +-- Binding aliases +local key, buf, but = lousy.bind.key, lousy.bind.buf, lousy.bind.but +local cmd, any = lousy.bind.cmd, lousy.bind.any + +-- Util aliases +local match, join = string.match, lousy.util.table.join +local strip, split = lousy.util.string.strip, lousy.util.string.split + +-- Globals or defaults that are used in binds +local scroll_step = globals.scroll_step or 20 +local zoom_step = globals.zoom_step or 0.1 + +-- Add binds to a mode +function add_binds(mode, binds, before) + assert(binds and type(binds) == "table", "invalid binds table type: " .. type(binds)) + mode = type(mode) ~= "table" and {mode} or mode + for _, m in ipairs(mode) do + local mdata = get_mode(m) + if mdata and before then + mdata.binds = join(binds, mdata.binds or {}) + elseif mdata then + mdata.binds = mdata.binds or {} + for _, b in ipairs(binds) do table.insert(mdata.binds, b) end + else + new_mode(m, { binds = binds }) + end + end +end + +-- Add commands to command mode +function add_cmds(cmds, before) + add_binds("command", cmds, before) +end + +-- Adds the default menu widget bindings to a mode +menu_binds = { + -- Navigate items + key({}, "j", function (w) w.menu:move_down() end), + key({}, "k", function (w) w.menu:move_up() end), + key({}, "Down", function (w) w.menu:move_down() end), + key({}, "Up", function (w) w.menu:move_up() end), + key({}, "Tab", function (w) w.menu:move_down() end), + key({"Shift"}, "Tab", function (w) w.menu:move_up() end), +} + +-- Add binds to special mode "all" which adds its binds to all modes. +add_binds("all", { + key({}, "Escape", "Return to `normal` mode.", + function (w) w:set_mode() end), + + key({"Control"}, "[", "Return to `normal` mode.", + function (w) w:set_mode() end), + + -- Mouse bindings + but({}, 8, "Go back.", + function (w) w:back() end), + + but({}, 9, "Go forward.", + function (w) w:forward() end), + + -- Open link in new tab or navigate to selection + but({}, 2, [[Open link under mouse cursor in new tab or navigate to the + contents of `luakit.selection.primary`.]], + function (w, m) + -- Ignore button 2 clicks in form fields + if not m.context.editable then + -- Open hovered uri in new tab + local uri = w.view.hovered_uri + if uri then + w:new_tab(uri, false) + else -- Open selection in current tab + uri = luakit.selection.primary + if uri then w:navigate(w:search_open(uri)) end + end + end + end), + + -- Open link in new tab when Ctrl-clicked. + but({"Control"}, 1, "Open link under mouse cursor in new tab.", + function (w, m) + local uri = w.view.hovered_uri + if uri then + w:new_tab(uri, false) + end + end), + + -- Zoom binds + but({"Control"}, 4, "Increase text zoom level.", + function (w, m) w:zoom_in() end), + + but({"Control"}, 5, "Reduce text zoom level.", + function (w, m) w:zoom_out() end), + + -- Horizontal mouse scroll binds + but({"Shift"}, 4, "Scroll left.", + function (w, m) w:scroll{ xrel = -scroll_step } end), + + but({"Shift"}, 5, "Scroll right.", + function (w, m) w:scroll{ xrel = scroll_step } end), +}) + +add_binds("normal", { + -- Autoparse the `[count]` before a binding and re-call the hit function + -- with the count removed and added to the opts table. + any([[Meta-binding to detect the `^[count]` syntax. The `[count]` is parsed + and stripped from the internal buffer string and the value assigned to + `state.count`. Then `lousy.bind.hit()` is re-called with the modified + buffer string & original modifier state. + + #### Example binding + + lousy.bind.key({}, "%", function (w, state) + w:scroll{ ypct = state.count } + end, { count = 0 }) + + This binding demonstrates several concepts. Firstly that you are able to + specify per-binding default values of `count`. In this case if the user + types `"%"` the document will be scrolled vertically to `0%` (the top). + + If the user types `"100%"` then the document will be scrolled to `100%` + (the bottom). All without the need to use `lousy.bind.buf` bindings + everywhere and or using a `^(%d*)` pattern prefix on every binding which + would like to make use of the `[count]` syntax.]], + function (w, m) + local count, buf + if m.buffer then + count = string.match(m.buffer, "^(%d+)") + end + if count then + buf = string.sub(m.buffer, #count + 1, (m.updated_buf and -2) or -1) + local opts = join(m, {count = tonumber(count)}) + opts.buffer = (#buf > 0 and buf) or nil + if lousy.bind.hit(w, m.binds, m.mods, m.key, opts) then + return true + end + end + return false + end), + + key({}, "i", "Enter `insert` mode.", + function (w) w:set_mode("insert") end), + + key({}, ":", "Enter `command` mode.", + function (w) w:set_mode("command") end), + + -- Scrolling + key({}, "j", "Scroll document down.", + function (w) w:scroll{ yrel = scroll_step } end), + + key({}, "k", "Scroll document up.", + function (w) w:scroll{ yrel = -scroll_step } end), + + key({}, "h", "Go back.", + function (w) w:back() end), + + key({}, "l", "Go forward..", + function (w) w:forward() end), + + key({}, "Down", "Scroll document down.", + function (w) w:scroll{ yrel = scroll_step } end), + + key({}, "Up", "Scroll document up.", + function (w) w:scroll{ yrel = -scroll_step } end), + + key({}, "Left", "Scroll document left.", + function (w) w:scroll{ xrel = -scroll_step } end), + + key({}, "Right", "Scroll document right.", + function (w) w:scroll{ xrel = scroll_step } end), + + key({}, "^", "Scroll to the absolute left of the document.", + function (w) w:scroll{ x = 0 } end), + + key({}, "$", "Scroll to the absolute right of the document.", + function (w) w:scroll{ x = -1 } end), + + key({}, "0", "Scroll to the absolute left of the document.", + function (w, m) + if not m.count then w:scroll{ y = 0 } else return false end + end), + + key({"Control"}, "e", "Scroll document down.", + function (w) w:scroll{ yrel = scroll_step } end), + + key({"Control"}, "y", "Scroll document up.", + function (w) w:scroll{ yrel = -scroll_step } end), + + key({"Control"}, "d", "Scroll half page down.", + function (w) w:scroll{ ypagerel = 0.5 } end), + + key({"Control"}, "u", "Scroll half page up.", + function (w) w:scroll{ ypagerel = -0.5 } end), + + key({"Control"}, "f", "Scroll page down.", + function (w) w:scroll{ ypagerel = 1.0 } end), + + key({"Control"}, "b", "Scroll page up.", + function (w) w:scroll{ ypagerel = -1.0 } end), + + key({}, "space", "Scroll page down.", + function (w) w:scroll{ ypagerel = 1.0 } end), + + key({"Shift"}, "space", "Scroll page up.", + function (w) w:scroll{ ypagerel = -1.0 } end), + + key({}, "BackSpace", "Scroll page up.", + function (w) w:scroll{ ypagerel = -1.0 } end), + + key({}, "Page_Down", "Scroll page down.", + function (w) w:scroll{ ypagerel = 1.0 } end), + + key({}, "Page_Up", "Scroll page up.", + function (w) w:scroll{ ypagerel = -1.0 } end), + + key({}, "Home", "Go to the end of the document.", + function (w) w:scroll{ y = 0 } end), + + key({}, "End", "Go to the top of the document.", + function (w) w:scroll{ y = -1 } end), + + -- Specific scroll + buf("^gg$", "Go to the top of the document.", + function (w, b, m) w:scroll{ ypct = m.count } end, {count=0}), + + buf("^G$", "Go to the bottom of the document.", + function (w, b, m) w:scroll{ ypct = m.count } end, {count=100}), + + buf("^%%$", "Go to `[count]` percent of the document.", + function (w, b, m) w:scroll{ ypct = m.count } end), + + -- Zooming + key({}, "+", "Enlarge text zoom of the current page.", + function (w, m) w:zoom_in(zoom_step * m.count) end, {count=1}), + + key({}, "-", "Reduce text zom of the current page.", + function (w, m) w:zoom_out(zoom_step * m.count) end, {count=1}), + + key({}, "=", "Reset zoom level.", + function (w, m) w:zoom_set() end), + + buf("^z[iI]$", [[Enlarge text zoom of current page with `zi` or `zI` to + reduce full zoom.]], + function (w, b, m) + w:zoom_in(zoom_step * m.count, b == "zI") + end, {count=1}), + + buf("^z[oO]$", [[Reduce text zoom of current page with `zo` or `zO` to + reduce full zoom.]], + function (w, b, m) + w:zoom_out(zoom_step * m.count, b == "zO") + end, {count=1}), + + -- Zoom reset or specific zoom ([count]zZ for full content zoom) + buf("^z[zZ]$", [[Set current page zoom to `[count]` percent with + `[count]zz`, use `[count]zZ` to set full zoom percent.]], + function (w, b, m) + w:zoom_set(m.count/100, b == "zZ") + end, {count=100}), + + -- Fullscreen + key({}, "F11", "Toggle fullscreen mode.", + function (w) w.win.fullscreen = not w.win.fullscreen end), + + -- Clipboard + key({}, "p", [[Open a URL based on the current primary selection contents + in the current tab.]], + function (w) + local uri = luakit.selection.primary + if not uri then w:notify("No primary selection...") return end + w:navigate(w:search_open(uri)) + end), + + key({}, "P", [[Open a URL based on the current primary selection contents + in `[count=1]` new tab(s).]], + function (w, m) + local uri = luakit.selection.primary + if not uri then w:notify("No primary selection...") return end + for i = 1, m.count do w:new_tab(w:search_open(uri)) end + end, {count = 1}), + + -- Yanking + key({}, "y", "Yank current URI to primary selection.", + function (w) + local uri = string.gsub(w.view.uri or "", " ", "%%20") + luakit.selection.primary = uri + w:notify("Yanked uri: " .. uri) + end), + + -- Commands + key({"Control"}, "a", "Increment last number in URL.", + function (w) w:navigate(w:inc_uri(1)) end), + + key({"Control"}, "x", "Decrement last number in URL.", + function (w) w:navigate(w:inc_uri(-1)) end), + + key({}, "o", "Open one or more URLs.", + function (w) w:enter_cmd(":open ") end), + + key({}, "t", "Open one or more URLs in a new tab.", + function (w) w:enter_cmd(":tabopen ") end), + + key({}, "w", "Open one or more URLs in a new window.", + function (w) w:enter_cmd(":winopen ") end), + + key({}, "O", "Open one or more URLs based on current location.", + function (w) w:enter_cmd(":open " .. (w.view.uri or "")) end), + + key({}, "T", + "Open one or more URLs based on current location in a new tab.", + function (w) w:enter_cmd(":tabopen " .. (w.view.uri or "")) end), + + key({}, "W", + "Open one or more URLs based on current locaton in a new window.", + function (w) w:enter_cmd(":winopen " .. (w.view.uri or "")) end), + + -- History + key({}, "H", "Go back in the browser history `[count=1]` items.", + function (w, m) w:back(m.count) end), + + key({}, "L", "Go forward in the browser history `[count=1]` times.", + function (w, m) w:forward(m.count) end), + + key({}, "XF86Back", "Go back in the browser history.", + function (w, m) w:back(m.count) end), + + key({}, "XF86Forward", "Go forward in the browser history.", + function (w, m) w:forward(m.count) end), + + key({"Control"}, "o", "Go back in the browser history.", + function (w, m) w:back(m.count) end), + + key({"Control"}, "i", "Go forward in the browser history.", + function (w, m) w:forward(m.count) end), + + -- Tab + key({"Control"}, "Page_Up", "Go to previous tab.", + function (w) w:prev_tab() end), + + key({"Control"}, "Page_Down", "Go to next tab.", + function (w) w:next_tab() end), + + key({"Control"}, "Tab", "Go to next tab.", + function (w) w:next_tab() end), + + key({"Shift","Control"}, "Tab", "Go to previous tab.", + function (w) w:prev_tab() end), + + buf("^gT$", "Go to previous tab.", + function (w) w:prev_tab() end), + + buf("^gt$", "Go to next tab (or `[count]` nth tab).", + function (w, b, m) + if not w:goto_tab(m.count) then w:next_tab() end + end, {count=0}), + + buf("^g0$", "Go to first tab.", + function (w) w:goto_tab(1) end), + + buf("^g$$", "Go to last tab.", + function (w) w:goto_tab(-1) end), + + key({"Control"}, "t", "Open a new tab.", + function (w) w:new_tab(globals.homepage) end), + + key({"Control"}, "w", "Close current tab.", + function (w) w:close_tab() end), + + key({}, "d", "Close current tab (or `[count]` tabs).", + function (w, m) for i=1,m.count do w:close_tab() end end, {count=1}), + + key({}, "<", "Reorder tab left `[count=1]` positions.", + function (w, m) + w.tabs:reorder(w.view, w.tabs:current() - m.count) + end, {count=1}), + + key({}, ">", "Reorder tab right `[count=1]` positions.", + function (w, m) + w.tabs:reorder(w.view, + (w.tabs:current() + m.count) % w.tabs:count()) + end, {count=1}), + + buf("^gH$", "Open homepage in new tab.", + function (w) w:new_tab(globals.homepage) end), + + buf("^gh$", "Open homepage.", + function (w) w:navigate(globals.homepage) end), + + buf("^gy$", "Duplicate current tab.", + function (w) w:new_tab(w.view.history or "") end), + + key({}, "r", "Reload current tab.", + function (w) w:reload() end), + + key({}, "R", "Reload current tab (skipping cache).", + function (w) w:reload(true) end), + + key({"Control"}, "c", "Stop loading the current tab.", + function (w) w.view:stop() end), + + key({"Control", "Shift"}, "R", "Restart luakit (reloading configs).", + function (w) w:restart() end), + + -- Window + buf("^ZZ$", "Quit and save the session.", + function (w) w:save_session() w:close_win() end), + + buf("^ZQ$", "Quit and don't save the session.", + function (w) w:close_win() end), + + buf("^D$", "Quit and don't save the session.", + function (w) w:close_win() end), + + -- Enter passthrough mode + key({"Control"}, "z", + "Enter `passthrough` mode, ignores all luakit keybindings.", + function (w) w:set_mode("passthrough") end), +}) + +add_binds("insert", { + key({"Control"}, "z", + "Enter `passthrough` mode, ignores all luakit keybindings.", + function (w) w:set_mode("passthrough") end), +}) + +readline_bindings = { + key({"Shift"}, "Insert", + "Insert contents of primary selection at cursor position.", + function (w) w:insert_cmd(luakit.selection.primary) end), + + key({"Control"}, "w", "Delete previous word.", + function (w) w:del_word() end), + + key({"Control"}, "u", "Delete until beginning of current line.", + function (w) w:del_line() end), + + key({"Control"}, "h", "Delete character to the left.", + function (w) w:del_backward_char() end), + + key({"Control"}, "d", "Delete character to the right.", + function (w) w:del_forward_char() end), + + key({"Control"}, "a", "Move cursor to beginning of current line.", + function (w) w:beg_line() end), + + key({"Control"}, "e", "Move cursor to end of current line.", + function (w) w:end_line() end), + + key({"Control"}, "f", "Move cursor forward one character.", + function (w) w:forward_char() end), + + key({"Control"}, "b", "Move cursor backward one character.", + function (w) w:backward_char() end), + + key({"Mod1"}, "f", "Move cursor forward one word.", + function (w) w:forward_word() end), + + key({"Mod1"}, "b", "Move cursor backward one word.", + function (w) w:backward_word() end), +} + +add_binds({"command", "search"}, readline_bindings) + +-- Switching tabs with Mod1+{1,2,3,...} +mod1binds = {} +for i=1,10 do + table.insert(mod1binds, + key({"Mod1"}, tostring(i % 10), "Jump to tab at index "..i..".", + function (w) w.tabs:switch(i) end)) +end +add_binds("normal", mod1binds) + +-- Command bindings which are matched in the "command" mode from text +-- entered into the input bar. +add_cmds({ + buf("^%S+!", + [[Detect bang syntax in `:command!` and recursively calls + `lousy.bind.match_cmd(..)` removing the bang from the command string + and setting `bang = true` in the bind opts table.]], + function (w, cmd, opts) + local cmd, args = string.match(cmd, "^(%S+)!+(.*)") + if cmd then + opts = join(opts, { bang = true }) + return lousy.bind.match_cmd(w, opts.binds, cmd .. args, opts) + end + end), + + cmd("c[lose]", "Close current tab.", + function (w) w:close_tab() end), + + cmd("print", "Print current page.", + function (w) w.view:eval_js("print()") end), + + cmd("stop", "Stop loading.", + function (w) w.view:stop() end), + + cmd("reload", "Reload page", + function (w) w:reload() end), + + cmd("restart", "Restart browser (reload config files).", + function (w) w:restart() end), + + cmd("write", "Save current session.", + function (w) w:save_session() end), + + cmd("noh[lsearch]", "Clear search highlighting.", + function (w) w:clear_search() end), + + cmd("back", "Go back in the browser history `[count=1]` items.", + function (w, a) w:back(tonumber(a) or 1) end), + + cmd("f[orward]", "Go forward in the browser history `[count=1]` items.", + function (w, a) w:forward(tonumber(a) or 1) end), + + cmd("inc[rease]", "Increment last number in URL.", + function (w, a) w:navigate(w:inc_uri(tonumber(a) or 1)) end), + + cmd("o[pen]", "Open one or more URLs.", + function (w, a) w:navigate(w:search_open(a)) end), + + cmd("t[abopen]", "Open one or more URLs in a new tab.", + function (w, a) w:new_tab(w:search_open(a)) end), + + cmd("w[inopen]", "Open one or more URLs in a new window.", + function (w, a) window.new{w:search_open(a)} end), + + cmd({"javascript", "js"}, "Evaluate JavaScript snippet.", + function (w, a) w.view:eval_js(a) end), + + -- Tab manipulation commands + cmd("tab", "Execute command and open result in new tab.", + function (w, a) w:new_tab() w:run_cmd(":" .. a) end), + + cmd("tabd[o]", "Execute command in each tab.", + function (w, a) w:each_tab(function (v) w:run_cmd(":" .. a) end) end), + + cmd("tabdu[plicate]", "Duplicate current tab.", + function (w) w:new_tab(w.view.history) end), + + cmd("tabfir[st]", "Switch to first tab.", + function (w) w:goto_tab(1) end), + + cmd("tabl[ast]", "Switch to last tab.", + function (w) w:goto_tab(-1) end), + + cmd("tabn[ext]", "Switch to the next tab.", + function (w) w:next_tab() end), + + cmd("tabp[revious]", "Switch to the previous tab.", + function (w) w:prev_tab() end), + + cmd("q[uit]", "Close the current window.", + function (w, a, o) w:close_win(o.bang) end), + + cmd({"viewsource", "vs"}, "View the source code of the current document.", + function (w, a, o) w:toggle_source(not o.bang and true or nil) end), + + cmd({"wqall", "wq"}, "Save the session and quit.", + function (w, a, o) w:save_session() w:close_win(o.bang) end), + + cmd("lua", "Evaluate Lua snippet.", function (w, a) + if a then + local ret = assert( + loadstring("return function(w) return "..a.." end"))()(w) + if ret then print(ret) end + else + w:set_mode("lua") + end + end), + + cmd("dump", "Dump current tabs html to file.", + function (w, a) + local fname = string.gsub(w.win.title, '[^%w%.%-]', '_')..'.html' -- sanitize filename + local file = a or luakit.save_file("Save file", w.win, xdg.download_dir or '.', fname) + if file then + local fd = assert(io.open(file, "w"), "failed to open: " .. file) + local html = assert(w.view:eval_js("document.documentElement.outerHTML"), "Unable to get HTML") + assert(fd:write(html), "unable to save html") + io.close(fd) + w:notify("Dumped HTML to: " .. file) + end + end), +}) + +-- vim: et:sw=4:ts=8:sts=4:tw=80 diff --git a/luakit/.config/luakit/globals.lua b/luakit/.config/luakit/globals.lua new file mode 100644 index 0000000..4eb6a7f --- /dev/null +++ b/luakit/.config/luakit/globals.lua @@ -0,0 +1,89 @@ +-- Global variables for luakit +globals = { + homepage = "file:///home/madmaurice/.config/home/index.html", + -- homepage = "http://github.com/mason-larobina/luakit", + scroll_step = 40, + zoom_step = 0.1, + max_cmd_history = 100, + max_srch_history = 100, + -- http_proxy = "http://example.com:3128", + default_window_size = "800x600", + + -- Disables loading of hostnames from /etc/hosts (for large host files) + -- load_etc_hosts = false, + -- Disables checking if a filepath exists in search_open function + -- check_filepath = false, +} + +-- Make useragent +local _, arch = luakit.spawn_sync("uname -sm") +-- Only use the luakit version if in date format (reduces identifiability) +local lkv = string.match(luakit.version, "^(%d+.%d+.%d+)") +globals.useragent = string.format("Mozilla/5.0 (%s) AppleWebKit/%s+ (KHTML, like Gecko) WebKitGTK+/%s luakit%s", +string.sub(arch, 1, -2), luakit.webkit_user_agent_version, +luakit.webkit_version, (lkv and ("/" .. lkv)) or "") + +-- Search common locations for a ca file which is used for ssl connection validation. +local ca_files = { + -- $XDG_DATA_HOME/luakit/ca-certificates.crt + luakit.data_dir .. "/ca-certificates.crt", + "/etc/certs/ca-certificates.crt", + "/etc/ssl/certs/ca-certificates.crt", +} +-- Use the first ca-file found +for _, ca_file in ipairs(ca_files) do + if os.exists(ca_file) then + soup.ssl_ca_file = ca_file + break + end +end + +-- Change to stop navigation sites with invalid or expired ssl certificates +soup.ssl_strict = false + +-- Set cookie acceptance policy +cookie_policy = { always = 0, never = 1, no_third_party = 2 } +soup.accept_policy = cookie_policy.always + +-- List of search engines. Each item must contain a single %s which is +-- replaced by URI encoded search terms. All other occurances of the percent +-- character (%) may need to be escaped by placing another % before or after +-- it to avoid collisions with lua's string.format characters. +-- See: http://www.lua.org/manual/5.1/manual.html#pdf-string.format +search_engines = { + ddg = "https://duckduckgo.com/?q=%s", + github = "https://github.com/search?q=%s", + g = "https://google.com/search?q=%s", + imdb = "http://www.imdb.com/find?s=all&q=%s", + wiki = "https://de.wikipedia.org/wiki/Special:Search?search=%s", + yt = "https://www.youtube.com/results?search_query=%s", + aur = "https://aur.archlinux.org/packages.php?O=0&K=%s&do_Search=Go", + aw = "https://wiki.archlinux.org/index.php/Special:Search?fulltext=Search&search=%s", + +} + +-- Set google as fallback search engine +search_engines.default = search_engines.ddg +-- Use this instead to disable auto-searching +--search_engines.default = "%s" + +-- Per-domain webview properties +-- See http://webkitgtk.org/reference/webkitgtk/stable/WebKitWebSettings.html +domain_props = { --[[ +["all"] = { +enable_scripts = false, +enable_plugins = false, +enable_private_browsing = false, +user_stylesheet_uri = "", +}, +["youtube.com"] = { +enable_scripts = true, +enable_plugins = true, +}, +["bbs.archlinux.org"] = { +user_stylesheet_uri = "file://" .. luakit.data_dir .. "/styles/dark.css", +enable_private_browsing = true, +}, ]] +} + +-- vim: et:sw=4:ts=8:sts=4:tw=80 diff --git a/luakit/.config/luakit/modes.lua b/luakit/.config/luakit/modes.lua new file mode 100644 index 0000000..bd15c67 --- /dev/null +++ b/luakit/.config/luakit/modes.lua @@ -0,0 +1,163 @@ +------------------------------- +-- luakit mode configuration -- +------------------------------- + +-- Table of modes and their callback hooks +local modes = {} +local lousy = require "lousy" +local join = lousy.util.table.join +local order = 0 + +-- Add new mode table (optionally merges with original mode) +function new_mode(name, desc, mode, replace) + assert(string.match(name, "^[%w-_]+$"), "invalid mode name: " .. name) + -- Detect optional description + if type(desc) == "table" then + desc, mode, replace = nil, desc, mode + end + local traceback = debug.traceback("Creation traceback:", 2) + order = order + 1 + modes[name] = join({ order = order, traceback = traceback }, + (not replace and modes[name]) or {}, mode or {}, + { name = name, desc = desc }) +end + +-- Get mode table +function get_mode(name) return modes[name] end + +function get_modes() return lousy.util.table.clone(modes) end + +-- Attach window & input bar signals for mode hooks +window.init_funcs.modes_setup = function (w) + -- Calls the `enter` and `leave` mode hooks. + w:add_signal("mode-changed", function (_, name, ...) + local leave = (w.mode or {}).leave + + -- Get new modes functions/hooks/data + local mode = assert(modes[name], "invalid mode: " .. name) + + -- Call last modes leave hook. + if leave then leave(w) end + + -- Create w.mode object + w.mode = mode + + -- Update window binds + w:update_binds(name) + + -- Call new modes enter hook. + if mode.enter then mode.enter(w, ...) end + + w:emit_signal("mode-entered", mode) + end) + + local input = w.ibar.input + + -- Calls the changed hook on input widget changed. + input:add_signal("changed", function () + local changed = w.mode.changed + if changed then changed(w, input.text) end + end) + + input:add_signal("property::position", function () + local move_cursor = w.mode.move_cursor + if move_cursor then move_cursor(w, input.position) end + end) + + -- Calls the `activate` hook on input widget activate. + input:add_signal("activate", function () + local mode = w.mode + if mode and mode.activate then + local text, hist = input.text, mode.history + if mode.activate(w, text) == false then return end + -- Check if last history item is identical + if hist and hist.items and hist.items[hist.len or -1] ~= text then + table.insert(hist.items, text) + end + end + end) +end + +-- Add mode related window methods +window.methods.set_mode = lousy.mode.set +local mget = lousy.mode.get +window.methods.is_mode = function (w, name) return name == mget(w) end + +-- Setup normal mode +new_mode("normal", [[When luakit first starts you will find yourself in this + mode.]], { + enter = function (w) + w:set_prompt() + w:set_input() + end, +}) + +new_mode("all", [[Special meta-mode in which the bindings for this mode are + present in all modes.]]) + +-- Setup insert mode +new_mode("insert", [[When clicking on form fields luakit will enter the insert + mode which allows you to enter text in form fields without accidentally + triggering normal mode bindings.]], { + enter = function (w) + w:set_prompt("-- INSERT --") + w:set_input() + w.view:focus() + end, + -- Send key events to webview + passthrough = true, +}) + +new_mode("passthrough", [[Luakit will pass every key event to the WebView + until the user presses Escape.]], { + enter = function (w) + w:set_prompt("-- PASS THROUGH --") + w:set_input() + end, + -- Send key events to webview + passthrough = true, + -- Don't exit mode when clicking outside of form fields + reset_on_focus = false, + -- Don't exit mode on navigation + reset_on_navigation = false, +}) + +-- Setup command mode +new_mode("command", [[Enter commands.]], { + enter = function (w) + w:set_prompt() + w:set_input(":") + end, + changed = function (w, text) + -- Auto-exit command mode if user backspaces ":" in the input bar. + if not string.match(text, "^:") then w:set_mode() end + end, + activate = function (w, text) + w:set_mode() + local cmd = string.sub(text, 2) + if not string.find(cmd, "%S") then return end + + local success, match = xpcall( + function () return w:match_cmd(cmd) end, + function (err) w:error(debug.traceback(err, 3)) end) + + if success and not match then + w:error(string.format("Not a browser command: %q", cmd)) + end + end, + history = {maxlen = 50}, +}) + +new_mode("lua", [[Execute arbitrary Lua commands within the luakit + environment.]], { + enter = function (w) + w:set_prompt(">") + w:set_input("") + end, + activate = function (w, text) + w:set_input("") + local ret = assert(loadstring("return function(w) return "..text.." end"))()(w) + if ret then print(ret) end + end, + history = {maxlen = 50}, +}) diff --git a/luakit/.config/luakit/rc.lua b/luakit/.config/luakit/rc.lua new file mode 100644 index 0000000..5f5ab63 --- /dev/null +++ b/luakit/.config/luakit/rc.lua @@ -0,0 +1,187 @@ +----------------------------------------------------------------------- +-- luakit configuration file, more information at http://luakit.org/ -- +----------------------------------------------------------------------- + +require "lfs" + +if unique then + unique.new("org.luakit") + -- Check for a running luakit instance + if unique.is_running() then + if uris[1] then + for _, uri in ipairs(uris) do + if lfs.attributes(uri) then uri = os.abspath(uri) end + unique.send_message("tabopen " .. uri) + end + else + unique.send_message("winopen") + end + luakit.quit() + end +end + +-- Load library of useful functions for luakit +require "lousy" + +-- Small util functions to print output (info prints only when luakit.verbose is true) +function warn(...) io.stderr:write(string.format(...) .. "\n") end +function info(...) if luakit.verbose then io.stdout:write(string.format(...) .. "\n") end end + +-- Load users global config +-- ("$XDG_CONFIG_HOME/luakit/globals.lua" or "/etc/xdg/luakit/globals.lua") +require "globals" + +-- Load users theme +-- ("$XDG_CONFIG_HOME/luakit/theme.lua" or "/etc/xdg/luakit/theme.lua") +lousy.theme.init(lousy.util.find_config("theme.lua")) +theme = assert(lousy.theme.get(), "failed to load theme") + +-- Load users window class +-- ("$XDG_CONFIG_HOME/luakit/window.lua" or "/etc/xdg/luakit/window.lua") +require "window" + +-- Load users webview class +-- ("$XDG_CONFIG_HOME/luakit/webview.lua" or "/etc/xdg/luakit/webview.lua") +require "webview" + +-- Load users mode configuration +-- ("$XDG_CONFIG_HOME/luakit/modes.lua" or "/etc/xdg/luakit/modes.lua") +require "modes" + +-- Load users keybindings +-- ("$XDG_CONFIG_HOME/luakit/binds.lua" or "/etc/xdg/luakit/binds.lua") +require "binds" + +---------------------------------- +-- Optional user script loading -- +---------------------------------- + +require "webinspector" + +-- Add sqlite3 cookiejar +require "cookies" + +-- Cookie blocking by domain (extends cookies module) +-- Add domains to the whitelist at "$XDG_CONFIG_HOME/luakit/cookie.whitelist" +-- and blacklist at "$XDG_CONFIG_HOME/luakit/cookie.blacklist". +-- Each domain must be on it's own line and you may use "*" as a +-- wildcard character (I.e. "*google.com") +--require "cookie_blocking" + +-- Block all cookies by default (unless whitelisted) +--cookies.default_allow = false + +-- Add uzbl-like form filling +require "formfiller" + +-- Add proxy support & manager +require "proxy" + +-- Add quickmarks support & manager +require "quickmarks" + +-- Add session saving/loading support +require "session" + +-- Add command to list closed tabs & bind to open closed tabs +require "undoclose" + +-- Add command to list tab history items +require "tabhistory" + +-- Add greasemonkey-like javascript userscript support +require "userscripts" + +-- Add bookmarks support +require "bookmarks" +require "bookmarks_chrome" + +-- Add download support +require "downloads" +require "downloads_chrome" + +downloads.default_dir = os.getenv("HOME") .. "/Downloads" + +-- Example using xdg-open for opening downloads / showing download folders +--downloads.add_signal("open-file", function (file, mime) +-- luakit.spawn(string.format("xdg-open %q", file)) +-- return true +--end) + +-- Add vimperator-like link hinting & following +require "follow" + +-- Use a custom charater set for hint labels +--local s = follow.label_styles +--follow.label_maker = s.sort(s.reverse(s.charset("asdfqwerzxcv"))) + +-- Match only hint labels +--follow.pattern_maker = follow.pattern_styles.match_label + +-- Add command history +require "cmdhist" + +-- Add search mode & binds +require "search" + +-- Add ordering of new tabs +require "taborder" + +-- Save web history +require "history" +require "history_chrome" + +require "introspector" + +-- Add command completion +require "completion" + +-- NoScript plugin, toggle scripts and or plugins on a per-domain basis. +-- `,ts` to toggle scripts, `,tp` to toggle plugins, `,tr` to reset. +-- Remove all "enable_scripts" & "enable_plugins" lines from your +-- domain_props table (in config/globals.lua) as this module will conflict. +require "noscript" + +require "follow_selected" +require "go_input" +require "go_next_prev" +require "go_up" + +-- More plugins +require "plugins" +plugins.policy = "automatic" + +----------------------------- +-- End user script loading -- +----------------------------- + +-- Restore last saved session +local w = (session and session.restore()) +if w then + for i, uri in ipairs(uris) do + w:new_tab(uri, i == 1) + end +else + -- Or open new window + window.new(uris) +end + +------------------------------------------- +-- Open URIs from other luakit instances -- +------------------------------------------- + +if unique then + unique.add_signal("message", function (msg, screen) + local cmd, arg = string.match(msg, "^(%S+)%s*(.*)") + local w = lousy.util.table.values(window.bywidget)[1] + if cmd == "tabopen" then + w:new_tab(arg) + elseif cmd == "winopen" then + w = window.new((arg ~= "") and { arg } or {}) + end + w.win.screen = screen + w.win.urgency_hint = true + end) +end + +-- vim: et:sw=4:ts=8:sts=4:tw=80 diff --git a/luakit/.config/luakit/theme.lua b/luakit/.config/luakit/theme.lua new file mode 100644 index 0000000..2e06442 --- /dev/null +++ b/luakit/.config/luakit/theme.lua @@ -0,0 +1,74 @@ +-------------------------- +-- Default luakit theme -- +-------------------------- + +local theme = {} + +-- Default settings +theme.font = "Terminus normal 9" +theme.fg = "#fff" +theme.bg = "#1f1f1f" +theme.fg_selected = theme.fg +theme.bg_selected = "#444444" +theme.fg_disabled = "#ccc" +theme.bg_disabled = theme.bg + +-- Genaral colours +theme.success_fg = "#090" +theme.loaded_fg = "#33AADD" +theme.error_fg = "#900" +theme.error_bg = theme.bg + +-- Warning colours +theme.warning_fg = "#990" +theme.warning_bg = theme.bg + +-- Notification colours +theme.notif_fg = theme.fg +theme.notif_bg = theme.bg + +-- Menu colours +theme.menu_fg = theme.fg +theme.menu_bg = theme.bg +theme.menu_selected_fg = theme.fg +theme.menu_selected_bg = theme.bg_selected +theme.menu_title_bg = theme.bg +theme.menu_primary_title_fg = theme.fg +theme.menu_secondary_title_fg = theme.fg + +-- Proxy manager +-- +theme.proxy_active_menu_fg = theme.fg +theme.proxy_active_menu_bg = theme.bg +theme.proxy_inactive_menu_fg = theme.fg_disabled +theme.proxy_inactive_menu_bg = theme.bg_disabled + +-- Statusbar specific +theme.sbar_fg = theme.fg +theme.sbar_bg = theme.bg + +-- Downloadbar specific +theme.dbar_fg = "#fff" +theme.dbar_bg = "#000" +theme.dbar_error_fg = "#F00" + +-- Input bar specific +theme.ibar_fg = theme.fg +theme.ibar_bg = theme.bg + +-- Tab label +theme.tab_fg = theme.fg +theme.tab_bg = theme.bg +theme.tab_ntheme = "#ddd" +theme.selected_fg = theme.fg +theme.selected_bg = theme.bg_selected +theme.selected_ntheme = "#ddd" +theme.loading_fg = theme.fg +theme.loading_bg = theme.bg + +-- Trusted/untrusted ssl colours +theme.trust_fg = "#090" +theme.notrust_fg = "#900" + +return theme +-- vim: et:sw=4:ts=8:sts=4:tw=80 diff --git a/luakit/.config/luakit/webview.lua b/luakit/.config/luakit/webview.lua new file mode 100644 index 0000000..a7a7a59 --- /dev/null +++ b/luakit/.config/luakit/webview.lua @@ -0,0 +1,350 @@ +-------------------------- +-- WebKit WebView class -- +-------------------------- + +-- Webview class table +webview = {} + +-- Table of functions which are called on new webview widgets. +webview.init_funcs = { + -- Set useragent + set_useragent = function (view, w) + view.user_agent = globals.useragent + end, + + -- Check if checking ssl certificates + checking_ssl = function (view, w) + local ca_file = soup.ssl_ca_file + if ca_file and os.exists(ca_file) then + w.checking_ssl = true + end + end, + + -- Update window and tab titles + title_update = function (view, w) + view:add_signal("property::title", function (v) + w:update_tablist() + if w.view == v then + w:update_win_title() + end + end) + end, + + -- Update uri label in statusbar + uri_update = function (view, w) + view:add_signal("property::uri", function (v) + w:update_tablist() + if w.view == v then + w:update_uri() + end + end) + end, + + -- Update history indicator + hist_update = function (view, w) + view:add_signal("load-status", function (v, status) + if w.view == v then + w:update_hist() + end + end) + end, + + -- Update tab titles + tablist_update = function (view, w) + view:add_signal("load-status", function (v, status) + if status == "provisional" or status == "finished" or status == "failed" then + w:update_tablist() + end + end) + end, + + -- Update scroll widget + scroll_update = function (view, w) + view:add_signal("expose", function (v) + if w.view == v then + w:update_scroll() + end + end) + end, + + -- Update progress widget + progress_update = function (view, w) + for _, sig in ipairs({"load-status", "property::progress"}) do + view:add_signal(sig, function (v) + if w.view == v then + w:update_progress() + w:update_ssl() + end + end) + end + end, + + -- Display hovered link in statusbar + link_hover_display = function (view, w) + view:add_signal("link-hover", function (v, link) + if w.view == v and link then + w:update_uri(link) + end + end) + view:add_signal("link-unhover", function (v) + if w.view == v then + w:update_uri() + end + end) + end, + + -- Clicking a form field automatically enters insert mode. + form_insert_mode = function (view, w) + view:add_signal("button-press", function (v, mods, button, context) + -- Clear start search marker + (w.search_state or {}).marker = nil + + if button == 1 and context.editable then + view:emit_signal("form-active") + end + end) + -- Emit root-active event in button release to prevent "missing" + -- buttons or links when the input bar hides. + view:add_signal("button-release", function (v, mods, button, context) + if button == 1 and not context.editable then + view:emit_signal("root-active") + end + end) + view:add_signal("form-active", function () + if not w.mode.passthrough then + w:set_mode("insert") + end + end) + view:add_signal("root-active", function () + if w.mode.reset_on_focus ~= false then + w:set_mode() + end + end) + end, + + -- Catch keys in non-passthrough modes + mode_key_filter = function (view, w) + view:add_signal("key-press", function () + if not w.mode.passthrough then + return true + end + end) + end, + + -- Try to match a button event to a users button binding else let the + -- press hit the webview. + button_bind_match = function (view, w) + view:add_signal("button-release", function (v, mods, button, context) + (w.search_state or {}).marker = nil + if w:hit(mods, button, { context = context }) then + return true + end + end) + end, + + -- Reset the mode on navigation + mode_reset_on_nav = function (view, w) + view:add_signal("load-status", function (v, status) + if status == "provisional" and w.view == v then + if w.mode.reset_on_navigation ~= false then + w:set_mode() + end + end + end) + end, + + -- Domain properties + domain_properties = function (view, w) + view:add_signal("load-status", function (v, status) + if status ~= "committed" or v.uri == "about:blank" then return end + -- Get domain + local domain = lousy.uri.parse(v.uri).host + -- Strip leading www. + domain = string.match(domain or "", "^www%.(.+)") or domain or "all" + -- Build list of domain props tables to join & load. + -- I.e. for luakit.org load .luakit.org, luakit.org, .org + local props = {domain_props.all or {}, domain_props[domain] or {}} + repeat + table.insert(props, 2, domain_props["."..domain] or {}) + domain = string.match(domain, "%.(.+)") + until not domain + -- Join all property tables + for k, v in pairs(lousy.util.table.join(unpack(props))) do + info("Domain prop: %s = %s (%s)", k, tostring(v), domain) + view[k] = v + end + end) + end, + + -- Action to take on mime type decision request. + mime_decision = function (view, w) + -- Return true to accept or false to reject from this signal. + view:add_signal("mime-type-decision", function (v, uri, mime) + info("Requested link: %s (%s)", uri, mime) + -- i.e. block binary files like *.exe + --if mime == "application/octet-stream" then + -- return false + --end + end) + end, + + -- Action to take on window open request. + --window_decision = function (view, w) + -- view:add_signal("new-window-decision", function (v, uri, reason) + -- if reason == "link-clicked" then + -- window.new({uri}) + -- else + -- w:new_tab(uri) + -- end + -- return true + -- end) + --end, + + create_webview = function (view, w) + -- Return a newly created webview in a new tab + view:add_signal("create-web-view", function (v) + return w:new_tab() + end) + end, + + -- Creates context menu popup from table (and nested tables). + -- Use `true` for menu separators. + --populate_popup = function (view, w) + -- view:add_signal("populate-popup", function (v) + -- return { + -- true, + -- { "_Toggle Source", function () w:toggle_source() end }, + -- { "_Zoom", { + -- { "Zoom _In", function () w:zoom_in() end }, + -- { "Zoom _Out", function () w:zoom_out() end }, + -- true, + -- { "Zoom _Reset", function () w:zoom_set() end }, }, }, + -- } + -- end) + --end, + + -- Action to take on resource request. + resource_request_decision = function (view, w) + view:add_signal("resource-request-starting", function(v, uri) + info("Requesting: %s", uri) + -- Return false to cancel the request. + end) + end, +} + +-- These methods are present when you index a window instance and no window +-- method is found in `window.methods`. The window then checks if there is an +-- active webview and calls the following methods with the given view instance +-- as the first argument. All methods must take `view` & `w` as the first two +-- arguments. +webview.methods = { + -- Reload with or without ignoring cache + reload = function (view, w, bypass_cache) + if bypass_cache then + view:reload_bypass_cache() + else + view:reload() + end + end, + + -- Toggle source view + toggle_source = function (view, w, show) + if show == nil then + view.view_source = not view.view_source + else + view.view_source = show + end + view:reload() + end, + + -- Zoom functions + zoom_in = function (view, w, step, full_zoom) + view.full_content_zoom = not not full_zoom + step = step or globals.zoom_step or 0.1 + view.zoom_level = view.zoom_level + step + end, + + zoom_out = function (view, w, step, full_zoom) + view.full_content_zoom = not not full_zoom + step = step or globals.zoom_step or 0.1 + view.zoom_level = math.max(0.01, view.zoom_level) - step + end, + + zoom_set = function (view, w, level, full_zoom) + view.full_content_zoom = not not full_zoom + view.zoom_level = level or 1.0 + end, + + -- History traversing functions + back = function (view, w, n) + view:go_back(n or 1) + end, + + forward = function (view, w, n) + view:go_forward(n or 1) + end, +} + +function webview.methods.scroll(view, w, new) + local s = view.scroll + for _, axis in ipairs{ "x", "y" } do + -- Relative px movement + if rawget(new, axis.."rel") then + s[axis] = s[axis] + new[axis.."rel"] + + -- Relative page movement + elseif rawget(new, axis .. "pagerel") then + s[axis] = s[axis] + math.ceil(s[axis.."page_size"] * new[axis.."pagerel"]) + + -- Absolute px movement + elseif rawget(new, axis) then + local n = new[axis] + if n == -1 then + s[axis] = s[axis.."max"] + else + s[axis] = n + end + + -- Absolute page movement + elseif rawget(new, axis.."page") then + s[axis] = math.ceil(s[axis.."page_size"] * new[axis.."page"]) + + -- Absolute percent movement + elseif rawget(new, axis .. "pct") then + s[axis] = math.ceil(s[axis.."max"] * (new[axis.."pct"]/100)) + end + end +end + +function webview.new(w) + local view = widget{type = "webview"} + + view.show_scrollbars = false + view.enforce_96_dpi = false + + -- Call webview init functions + for k, func in pairs(webview.init_funcs) do + func(view, w) + end + return view +end + +-- Insert webview method lookup on window structure +table.insert(window.indexes, 1, function (w, k) + if k == "view" then + local view = w.tabs[w.tabs:current()] + if view and type(view) == "widget" and view.type == "webview" then + w.view = view + return view + end + end + -- Lookup webview method + local func = webview.methods[k] + if not func then return end + local view = w.view + if view then + return function (_, ...) return func(view, w, ...) end + end +end) + +-- vim: et:sw=4:ts=8:sts=4:tw=80 diff --git a/luakit/.config/luakit/window.lua b/luakit/.config/luakit/window.lua new file mode 100644 index 0000000..5e921d6 --- /dev/null +++ b/luakit/.config/luakit/window.lua @@ -0,0 +1,859 @@ +------------------ +-- Window class -- +------------------ + +require "lfs" + +-- Window class table +window = {} + +-- List of active windows by window widget +window.bywidget = setmetatable({}, { __mode = "k" }) + +-- Widget construction aliases +local function entry() return widget{type="entry"} end +local function eventbox() return widget{type="eventbox"} end +local function hbox() return widget{type="hbox"} end +local function label() return widget{type="label"} end +local function notebook() return widget{type="notebook"} end +local function vbox() return widget{type="vbox"} end + +-- Build and pack window widgets +function window.build() + -- Create a table for widgets and state variables for a window + local w = { + win = widget{type="window"}, + ebox = eventbox(), + layout = vbox(), + paned = widget{type="vpaned"}, + tabs = notebook(), + -- Tablist widget + tablist = lousy.widget.tablist(), + -- Status bar widgets + sbar = { + layout = hbox(), + ebox = eventbox(), + -- Left aligned widgets + l = { + layout = hbox(), + ebox = eventbox(), + uri = label(), + hist = label(), + loaded = label(), + }, + -- Fills space between the left and right aligned widgets + sep = eventbox(), + -- Right aligned widgets + r = { + layout = hbox(), + ebox = eventbox(), + buf = label(), + ssl = label(), + tabi = label(), + scroll = label(), + }, + }, + + -- Vertical menu window widget (completion results, bookmarks, qmarks, ..) + menu = lousy.widget.menu(), + + -- Input bar widgets + ibar = { + layout = hbox(), + ebox = eventbox(), + prompt = label(), + input = entry(), + }, + closed_tabs = {} + } + + -- Assemble window + w.ebox.child = w.paned + w.paned:pack1(w.layout) + w.win.child = w.ebox + + -- Pack tablist + w.layout:pack(w.tablist.widget) + + -- Pack notebook + w.layout:pack(w.tabs, { expand = true, fill = true }) + + -- Pack left-aligned statusbar elements + local l = w.sbar.l + l.layout:pack(l.uri) + l.layout:pack(l.hist) + l.layout:pack(l.loaded) + l.ebox.child = l.layout + + -- Pack right-aligned statusbar elements + local r = w.sbar.r + r.layout:pack(r.buf) + r.layout:pack(r.ssl) + r.layout:pack(r.tabi) + r.layout:pack(r.scroll) + r.ebox.child = r.layout + + -- Pack status bar elements + local s = w.sbar + s.layout:pack(l.ebox) + s.layout:pack(s.sep, { expand = true, fill = true }) + s.layout:pack(r.ebox) + s.ebox.child = s.layout + w.layout:pack(s.ebox) + + -- Pack menu widget + w.layout:pack(w.menu.widget) + w.menu:hide() + + -- Pack input bar + local i = w.ibar + i.layout:pack(i.prompt) + i.layout:pack(i.input, { expand = true, fill = true }) + i.ebox.child = i.layout + w.layout:pack(i.ebox) + + -- Other settings + i.input.show_frame = false + w.tabs.show_tabs = false + l.loaded:hide() + l.hist:hide() + l.uri.selectable = true + r.ssl:hide() + + -- Allows indexing of window struct by window widget + window.bywidget[w.win] = w + + return w +end + +-- Table of functions to call on window creation. Normally used to add signal +-- handlers to the new windows widgets. +window.init_funcs = { + -- Attach notebook widget signals + notebook_signals = function (w) + w.tabs:add_signal("page-added", function (nbook, view, idx) + luakit.idle_add(function () + w:update_tab_count() + w:update_tablist() + return false + end) + end) + w.tabs:add_signal("switch-page", function (nbook, view, idx) + w.view = nil + w:set_mode() + -- Update widgets after tab switch + luakit.idle_add(function () + w:update_tab_count() + w:update_win_title() + w:update_uri() + w:update_progress() + w:update_tablist() + w:update_buf() + w:update_ssl() + w:update_hist() + return false + end) + end) + w.tabs:add_signal("page-reordered", function (nbook, view, idx) + w:update_tab_count() + w:update_tablist() + end) + end, + + last_win_check = function (w) + w.win:add_signal("destroy", function () + -- call the quit function if this was the last window left + if #luakit.windows == 0 then luakit.quit() end + if w.close_win then w:close_win() end + end) + end, + + key_press_match = function (w) + w.win:add_signal("key-press", function (_, mods, key) + -- Match & exec a bind + local success, match = xpcall( + function () return w:hit(mods, key) end, + function (err) w:error(debug.traceback(err, 3)) end) + + if success and match then + return true + end + end) + end, + + tablist_tab_click = function (w) + w.tablist:add_signal("tab-clicked", function (_, index, mods, button) + if button == 1 then + w.tabs:switch(index) + return true + elseif button == 2 then + w:close_tab(w.tabs[index]) + return true + end + end) + end, + + apply_window_theme = function (w) + local s, i = w.sbar, w.ibar + + -- Set foregrounds + for wi, v in pairs({ + [s.l.uri] = theme.uri_sbar_fg, + [s.l.hist] = theme.hist_sbar_fg, + [s.l.loaded] = theme.sbar_loaded_fg, + [s.r.buf] = theme.buf_sbar_fg, + [s.r.tabi] = theme.tabi_sbar_fg, + [s.r.scroll] = theme.scroll_sbar_fg, + [i.prompt] = theme.prompt_ibar_fg, + [i.input] = theme.input_ibar_fg, + }) do wi.fg = v end + + -- Set backgrounds + for wi, v in pairs({ + [s.l.ebox] = theme.sbar_bg, + [s.r.ebox] = theme.sbar_bg, + [s.sep] = theme.sbar_bg, + [s.ebox] = theme.sbar_bg, + [i.ebox] = theme.ibar_bg, + [i.input] = theme.input_ibar_bg, + }) do wi.bg = v end + + -- Set fonts + for wi, v in pairs({ + [s.l.uri] = theme.uri_sbar_font, + [s.l.hist] = theme.hist_sbar_font, + [s.l.loaded] = theme.sbar_loaded_font, + [s.r.buf] = theme.buf_sbar_font, + [s.r.ssl] = theme.ssl_sbar_font, + [s.r.tabi] = theme.tabi_sbar_font, + [s.r.scroll] = theme.scroll_sbar_font, + [i.prompt] = theme.prompt_ibar_font, + [i.input] = theme.input_ibar_font, + }) do wi.font = v end + end, + + set_default_size = function (w) + local size = globals.default_window_size or "800x600" + if string.match(size, "^%d+x%d+$") then + w.win:set_default_size(string.match(size, "^(%d+)x(%d+)$")) + else + warn("E: window.lua: invalid window size: %q", size) + end + end, + + set_window_icon = function (w) + local path = (luakit.dev_paths and os.exists("./extras/luakit.png")) or + os.exists("/usr/share/pixmaps/luakit.png") + if path then w.win.icon = path end + end, + + clear_urgency_hint = function (w) + w.win:add_signal("focus", function () + w.win.urgency_hint = false + end) + end, +} + +-- Helper functions which operate on the window widgets or structure. +window.methods = { + -- Wrapper around the bind plugin's hit method + hit = function (w, mods, key, opts) + local opts = lousy.util.table.join(opts or {}, { + enable_buffer = w:is_mode("normal"), + buffer = w.buffer, + }) + + local caught, newbuf = lousy.bind.hit(w, w.binds, mods, key, opts) + if w.win then -- Check binding didn't cause window to exit + w.buffer = newbuf + w:update_buf() + end + return caught + end, + + -- Wrapper around the bind plugin's match_cmd method + match_cmd = function (w, buffer) + return lousy.bind.match_cmd(w, get_mode("command").binds, buffer) + end, + + -- enter command or characters into command line + enter_cmd = function (w, cmd, opts) + w:set_mode("command") + w:set_input(cmd, opts) + end, + + -- run command as if typed into the command line + run_cmd = function (w, cmd, opts) + w:enter_cmd(cmd, opts) + w:activate() + end, + + -- insert a string into the command line at the current cursor position + insert_cmd = function (w, str) + if not str then return end + local i = w.ibar.input + local text = i.text + local pos = i.position + local left, right = string.sub(text, 1, pos), string.sub(text, pos+1) + i.text = left .. str .. right + i.position = pos + #str + end, + + -- Emulates pressing the Return key in input field + activate = function (w) + w.ibar.input:emit_signal("activate") + end, + + del_word = function (w) + local i = w.ibar.input + local text = i.text + local pos = i.position + if text and #text > 1 and pos > 1 then + local left, right = string.sub(text, 2, pos), string.sub(text, pos+1) + if not string.find(left, "%s") then + left = "" + elseif string.find(left, "%w+%s*$") then + left = string.sub(left, 0, string.find(left, "%w+%s*$") - 1) + elseif string.find(left, "%W+%s*$") then + left = string.sub(left, 0, string.find(left, "%W+%s*$") - 1) + end + i.text = string.sub(text, 1, 1) .. left .. right + i.position = #left + 1 + end + end, + + del_line = function (w) + local i = w.ibar.input + if not string.match(i.text, "^[:/?]$") then + i.text = string.sub(i.text, 1, 1) + i.position = -1 + end + end, + + del_backward_char = function (w) + local i = w.ibar.input + local text = i.text + local pos = i.position + + if pos > 1 then + i.text = string.sub(text, 0, pos - 1) .. string.sub(text, pos + 1) + i.position = pos - 1 + end + end, + + del_forward_char = function (w) + local i = w.ibar.input + local text = i.text + local pos = i.position + + i.text = string.sub(text, 0, pos) .. string.sub(text, pos + 2) + i.position = pos + end, + + beg_line = function (w) + local i = w.ibar.input + i.position = 1 + end, + + end_line = function (w) + local i = w.ibar.input + i.position = -1 + end, + + forward_char = function (w) + local i = w.ibar.input + i.position = i.position + 1 + end, + + backward_char = function (w) + local i = w.ibar.input + local pos = i.position + if pos > 1 then + i.position = pos - 1 + end + end, + + forward_word = function (w) + local i = w.ibar.input + local text = i.text + local pos = i.position + if text and #text > 1 then + local right = string.sub(text, pos+1) + if string.find(right, "%w+") then + local _, move = string.find(right, "%w+") + i.position = pos + move + end + end + end, + + backward_word = function (w) + local i = w.ibar.input + local text = i.text + local pos = i.position + if text and #text > 1 and pos > 1 then + local left = string.reverse(string.sub(text, 2, pos)) + if string.find(left, "%w+") then + local _, move = string.find(left, "%w+") + i.position = pos - move + end + end + end, + + -- Shows a notification until the next keypress of the user. + notify = function (w, msg, set_mode) + if set_mode ~= false then w:set_mode() end + w:set_prompt(msg, { fg = theme.notif_fg, bg = theme.notif_bg }) + end, + + warning = function (w, msg, set_mode) + if set_mode ~= false then w:set_mode() end + w:set_prompt(msg, { fg = theme.warning_fg, bg = theme.warning_bg }) + end, + + error = function (w, msg, set_mode) + if set_mode ~= false then w:set_mode() end + w:set_prompt("Error: "..msg, { fg = theme.error_fg, bg = theme.error_bg }) + end, + + -- Set and display the prompt + set_prompt = function (w, text, opts) + local prompt, ebox, opts = w.ibar.prompt, w.ibar.ebox, opts or {} + prompt:hide() + -- Set theme + fg, bg = opts.fg or theme.ibar_fg, opts.bg or theme.ibar_bg + if prompt.fg ~= fg then prompt.fg = fg end + if ebox.bg ~= bg then ebox.bg = bg end + -- Set text or remain hidden + if text then + prompt.text = lousy.util.escape(text) + prompt:show() + end + end, + + -- Set display and focus the input bar + set_input = function (w, text, opts) + local input, opts = w.ibar.input, opts or {} + input:hide() + -- Set theme + fg, bg = opts.fg or theme.ibar_fg, opts.bg or theme.ibar_bg + if input.fg ~= fg then input.fg = fg end + if input.bg ~= bg then input.bg = bg end + -- Set text or remain hidden + if text then + input.text = "" + input:show() + input:focus() + input.text = text + input.position = opts.pos or -1 + end + end, + + -- GUI content update functions + update_tab_count = function (w) + w.sbar.r.tabi.text = string.format("[%d/%d]", w.tabs:current(), w.tabs:count()) + end, + + update_win_title = function (w) + local uri, title = w.view.uri, w.view.title + title = (title or "luakit") .. ((uri and " - " .. uri) or "") + local max = globals.max_title_len or 80 + if #title > max then title = string.sub(title, 1, max) .. "..." end + w.win.title = title + end, + + update_uri = function (w, link) + w.sbar.l.uri.text = lousy.util.escape((link and "Link: " .. link) + or (w.view and w.view.uri) or "about:blank") + end, + + update_progress = function (w) + local p = w.view.progress + local loaded = w.sbar.l.loaded + if not w.view:loading() or p == 1 then + loaded:hide() + else + loaded:show() + loaded.text = string.format("(%d%%)", p * 100) + end + end, + + update_scroll = function (w) + local scroll, label = w.view.scroll, w.sbar.r.scroll + local y, max, text = scroll.y, scroll.ymax + if max == 0 then text = "All" + elseif y == 0 then text = "Top" + elseif y == max then text = "Bot" + else text = string.format("%2d%%", (y / max) * 100) + end + if label.text ~= text then label.text = text end + end, + + update_ssl = function (w) + local trusted = w.view:ssl_trusted() + local ssl = w.sbar.r.ssl + if trusted ~= nil and not w.checking_ssl then + ssl.fg = theme.notrust_fg + ssl.text = "(nocheck)" + ssl:show() + elseif trusted == true then + ssl.fg = theme.trust_fg + ssl.text = "(trust)" + ssl:show() + elseif trusted == false then + ssl.fg = theme.notrust_fg + ssl.text = "(notrust)" + ssl:show() + else + ssl:hide() + end + end, + + update_hist = function (w) + local hist = w.sbar.l.hist + local back, forward = w.view:can_go_back(), w.view:can_go_forward() + local s = (back and "+" or "") .. (forward and "-" or "") + if s ~= "" then + hist.text = '['..s..']' + hist:show() + else + hist:hide() + end + end, + + update_buf = function (w) + local buf = w.sbar.r.buf + if w.buffer then + buf.text = lousy.util.escape(string.format(" %-3s", w.buffer)) + buf:show() + else + buf:hide() + end + end, + + update_binds = function (w, mode) + -- Generate the list of active key & buffer binds for this mode + w.binds = lousy.util.table.join((get_mode(mode) or {}).binds or {}, get_mode('all').binds or {}) + -- Clear & hide buffer + w.buffer = nil + w:update_buf() + end, + + update_tablist = function (w) + local current = w.tabs:current() + local fg, bg, nfg, snfg = theme.tab_fg, theme.tab_bg, theme.tab_ntheme, theme.selected_ntheme + local lfg, bfg, gfg = theme.tab_loading_fg, theme.tab_notrust_fg, theme.tab_trust_fg + local escape = lousy.util.escape + local tabs, tfmt = {}, ' %s %s' + + for i, view in ipairs(w.tabs.children) do + -- Get tab number theme + local ntheme = nfg + if view:loading() then -- Show loading on all tabs + ntheme = lfg + elseif current == i then -- Show ssl trusted/untrusted on current tab + local trusted = view:ssl_trusted() + ntheme = snfg + if trusted == false or (trusted ~= nil and not w.checking_ssl) then + ntheme = bfg + elseif trusted then + ntheme = gfg + end + end + local title = view.title or view.uri or "(Untitled)" + tabs[i] = { + title = string.format(tfmt, ntheme or fg, i, escape(title)), + fg = (current == i and theme.tab_selected_fg) or fg, + bg = (current == i and theme.tab_selected_bg) or bg, + } + end + + if #tabs < 2 then tabs, current = {}, 0 end + w.tablist:update(tabs, current) + end, + + new_tab = function (w, arg, switch, order) + local view + -- Use blank tab first + if w.has_blank and w.tabs:count() == 1 and w.tabs[1].uri == "about:blank" then + view = w.tabs[1] + end + w.has_blank = nil + -- Make new webview widget + if not view then + view = webview.new(w) + -- Get tab order function + if not order and taborder then + order = (switch == false and taborder.default_bg) + or taborder.default + end + pos = w.tabs:insert((order and order(w, view)) or -1, view) + if switch ~= false then w.tabs:switch(pos) end + end + -- Load uri or webview history table + if type(arg) == "string" then view.uri = arg + elseif type(arg) == "table" then view.history = arg end + -- Update statusbar widgets + w:update_tab_count() + w:update_tablist() + return view + end, + + -- close the current tab + close_tab = function (w, view, blank_last) + view = view or w.view + -- Treat a blank last tab as an empty notebook (if blank_last=true) + if blank_last ~= false and w.tabs:count() == 1 then + if not view:loading() and view.uri == "about:blank" then return end + w:new_tab("about:blank", false) + w.has_blank = true + end + -- Save tab history + local tab = {hist = view.history,} + -- And relative location + local index = w.tabs:indexof(view) + if index ~= 1 then tab.after = w.tabs[index-1] end + table.insert(w.closed_tabs, tab) + view:destroy() + w:update_tab_count() + w:update_tablist() + end, + + close_win = function (w, force) + -- Ask plugins if it's OK to close last window + if not force and (#luakit.windows == 1) then + local emsg = luakit.emit_signal("can-close", w) + if emsg then + assert(type(emsg) == "string", "invalid exit error message") + w:error(string.format("Can't close luakit: %s (force close " + .. "with :q! or :wq!)", emsg)) + return false + end + end + + w:emit_signal("close") + + -- Close all tabs + while w.tabs:count() ~= 0 do + w:close_tab(nil, false) + end + + -- Destroy tablist + w.tablist:destroy() + + -- Remove from window index + window.bywidget[w.win] = nil + + -- Clear window struct + w = setmetatable(w, {}) + + -- Recursively remove widgets from window + local children = lousy.util.recursive_remove(w.win) + -- Destroy all widgets + for i, c in ipairs(lousy.util.table.join(children, {w.win})) do + if c.hide then c:hide() end + c:destroy() + end + + -- Remove all window table vars + for k, _ in pairs(w) do w[k] = nil end + + -- Quit if closed last window + if #luakit.windows == 0 then luakit.quit() end + end, + + -- Navigate current view or open new tab + navigate = function (w, uri, view) + view = view or w.view + if view then + local js = string.match(uri, "^javascript:(.+)$") + if js then + return view:eval_js(luakit.uri_decode(js)) + end + view.uri = uri + else + return w:new_tab(uri) + end + end, + + -- Save, restart luakit and reload session. + restart = function (w) + -- Generate luakit launch command. + local args = {({string.gsub(luakit.execpath, " ", "\\ ")})[1]} + if luakit.verbose then table.insert(args, "-v") end + -- Relaunch without libunique bindings? + if luakit.nounique then table.insert(args, "-U") end + + -- Get new config path + local conf + if luakit.confpath ~= "/etc/xdg/luakit/rc.lua" and os.exists(luakit.confpath) then + conf = luakit.confpath + table.insert(args, string.format("-c %q", conf)) + end + + -- Check config has valid syntax + local cmd = table.concat(args, " ") + if luakit.spawn_sync(cmd .. " -k") ~= 0 then + return w:error("Cannot restart, syntax error in configuration file"..((conf and ": "..conf) or ".")) + end + + -- Save session. + local wins = {} + for _, w in pairs(window.bywidget) do table.insert(wins, w) end + session.save(wins) + + -- Replace current process with new luakit instance. + luakit.exec(cmd) + end, + + -- Intelligent open command which can detect a uri or search argument. + search_open = function (w, arg) + local lstring = lousy.util.string + local match, find = string.match, string.find + + -- Detect blank uris + if not arg or match(arg, "^%s*$") then return "about:blank" end + + -- Strip whitespace and split by whitespace into args table + local args = lstring.split(lstring.strip(arg)) + + -- Guess if first argument is an address, search engine, file + if #args == 1 then + local uri = args[1] + if uri == "about:blank" then return uri end + + -- Check if search engine name + if search_engines[uri] then + return string.format(search_engines[uri], "") + end + + -- Navigate if . or / in uri (I.e. domains, IP's, scheme://) + if find(uri, "%.") or find(uri, "/") then return uri end + + -- Navigate if this is a javascript-uri + if find(uri, "^javascript:") then return uri end + + -- Valid hostnames to check + local hosts = { "localhost" } + if globals.load_etc_hosts ~= false then + hosts = lousy.util.get_etc_hosts() + end + + -- Check hostnames + for _, h in pairs(hosts) do + if h == uri or match(uri, "^"..h..":%d+$") then return uri end + end + + -- Check for file in filesystem + if globals.check_filepath ~= false then + if lfs.attributes(uri) then return "file://" .. uri end + end + end + + -- Find search engine (or use search_engines.default) + local engine = "default" + if args[1] and search_engines[args[1]] then + engine = args[1] + table.remove(args, 1) + end + + -- URI encode search terms + local terms = luakit.uri_encode(table.concat(args, " ")) + return string.format(search_engines[engine], terms) + end, + + -- Increase (or decrease) the last found number in the current uri + inc_uri = function (w, arg) + local uri = string.gsub(w.view.uri, "(%d+)([^0-9]*)$", function (num, rest) + return string.format("%0"..#num.."d", tonumber(num) + (arg or 1)) .. rest + end) + return uri + end, + + -- Tab traversing functions + next_tab = function (w, n) + w.tabs:switch((((n or 1) + w.tabs:current() -1) % w.tabs:count()) + 1) + end, + + prev_tab = function (w, n) + w.tabs:switch(((w.tabs:current() - (n or 1) -1) % w.tabs:count()) + 1) + end, + + goto_tab = function (w, n) + if n and (n == -1 or n > 0) then + return w.tabs:switch((n <= w.tabs:count() and n) or -1) + end + end, + + -- For each tab, switches to that tab and calls the given function passing + -- it the view contained in the tab. + each_tab = function (w, fn) + for index = 1, w.tabs:count() do + w:goto_tab(index) + fn(w.tabs[index]) + end + end, + + -- If argument is form-active or root-active, emits signal. Ignores all + -- other signals. + emit_form_root_active_signal = function (w, s) + if s == "form-active" then + w.view:emit_signal("form-active") + elseif s == "root-active" then + w.view:emit_signal("root-active") + end + end, +} + +-- Ordered list of class index functions. Other classes (E.g. webview) are able +-- to add their own index functions to this list. +window.indexes = { + -- Find function in window.methods first + function (w, k) return window.methods[k] end +} + +-- Create new window +function window.new(uris) + local w = window.build() + + -- Set window metatable + setmetatable(w, { + __index = function (_, k) + -- Check widget structure first + local v = rawget(w, k) + if v then return v end + -- Call each window index function + for _, index in ipairs(window.indexes) do + v = index(w, k) + if v then return v end + end + end, + }) + + -- Setup window widget for signals + lousy.signal.setup(w) + + -- Call window init functions + for _, func in pairs(window.init_funcs) do + func(w) + end + + -- Populate notebook with tabs + for _, uri in ipairs(uris or {}) do + w:new_tab(w:search_open(uri), false) + end + + -- Make sure something is loaded + if w.tabs:count() == 0 then + w:new_tab(w:search_open(globals.homepage), false) + end + + -- Set initial mode + w:set_mode() + + -- Show window + w.win:show() + + return w +end + +-- vim: et:sw=4:ts=8:sts=4:tw=80