593 lines
21 KiB
Lua
593 lines
21 KiB
Lua
local machi = {
|
|
layout = require((...):match("(.-)[^%.]+$") .. "layout"),
|
|
engine = require((...):match("(.-)[^%.]+$") .. "engine"),
|
|
}
|
|
|
|
local capi = {
|
|
client = client
|
|
}
|
|
|
|
local beautiful = require("beautiful")
|
|
local wibox = require("wibox")
|
|
local awful = require("awful")
|
|
local gears = require("gears")
|
|
local lgi = require("lgi")
|
|
local dpi = require("beautiful.xresources").apply_dpi
|
|
local gtimer = require("gears.timer")
|
|
|
|
local ERROR = 2
|
|
local WARNING = 1
|
|
local INFO = 0
|
|
local DEBUG = -1
|
|
|
|
local module = {
|
|
log_level = WARNING,
|
|
}
|
|
|
|
local function log(level, msg)
|
|
if level > module.log_level then
|
|
print(msg)
|
|
end
|
|
end
|
|
|
|
local function min(a, b)
|
|
if a < b then return a else return b end
|
|
end
|
|
|
|
local function max(a, b)
|
|
if a < b then return b else return a end
|
|
end
|
|
|
|
local function with_alpha(col, alpha)
|
|
local r, g, b
|
|
_, r, g, b, _ = col:get_rgba()
|
|
return lgi.cairo.SolidPattern.create_rgba(r, g, b, alpha)
|
|
end
|
|
|
|
function module.start(c, exit_keys)
|
|
local tablist_font_desc = beautiful.get_merged_font(
|
|
beautiful.font, dpi(10))
|
|
local font_color = with_alpha(gears.color(beautiful.fg_normal), 1)
|
|
local font_color_hl = with_alpha(gears.color(beautiful.fg_focus), 1)
|
|
local label_size = dpi(30)
|
|
local border_color = with_alpha(
|
|
gears.color(beautiful.machi_switcher_border_color or beautiful.border_focus),
|
|
beautiful.machi_switcher_border_opacity or 0.25)
|
|
local border_color_hl = with_alpha(
|
|
gears.color(beautiful.machi_switcher_border_hl_color or beautiful.border_focus),
|
|
beautiful.machi_switcher_border_hl_opacity or 0.75)
|
|
local fill_color = with_alpha(
|
|
gears.color(beautiful.machi_switcher_fill_color or beautiful.bg_normal),
|
|
beautiful.machi_switcher_fill_opacity or 0.25)
|
|
local box_bg = with_alpha(
|
|
gears.color(beautiful.machi_switcher_box_bg or beautiful.bg_normal),
|
|
beautiful.machi_switcher_box_opacity or 0.85)
|
|
local fill_color_hl = with_alpha(
|
|
gears.color(beautiful.machi_switcher_fill_color_hl or beautiful.bg_focus),
|
|
beautiful.machi_switcher_fill_hl_opacity or 1)
|
|
-- for comparing floats
|
|
local threshold = 0.1
|
|
local traverse_radius = dpi(5)
|
|
|
|
local screen = c and c.screen or awful.screen.focused()
|
|
local tag = screen.selected_tag
|
|
local layout = tag.layout
|
|
local gap = tag.gap
|
|
local start_x = screen.workarea.x
|
|
local start_y = screen.workarea.y
|
|
|
|
if (c ~= nil and c.floating) or layout.machi_get_instance_data == nil then return end
|
|
|
|
local cd, td, areas, _new_placement_cb = layout.machi_get_instance_data(screen, screen.selected_tag)
|
|
if areas == nil or #areas == 0 then
|
|
return
|
|
end
|
|
|
|
local infobox = wibox({
|
|
screen = screen,
|
|
x = screen.workarea.x,
|
|
y = screen.workarea.y,
|
|
width = screen.workarea.width,
|
|
height = screen.workarea.height,
|
|
bg = "#ffffff00",
|
|
opacity = 1,
|
|
ontop = true,
|
|
type = "dock",
|
|
})
|
|
infobox.visible = true
|
|
|
|
local tablist = nil
|
|
local tablist_index = nil
|
|
|
|
local traverse_x, traverse_y
|
|
if c then
|
|
traverse_x = c.x + traverse_radius
|
|
traverse_y = c.y + traverse_radius
|
|
else
|
|
traverse_x = screen.workarea.x + screen.workarea.width / 2
|
|
traverse_y = screen.workarea.y + screen.workarea.height / 2
|
|
end
|
|
|
|
local selected_area_ = nil
|
|
local function set_selected_area(area)
|
|
selected_area_ = area
|
|
if area then
|
|
traverse_x = max(areas[area].x + traverse_radius, min(areas[area].x + areas[area].width - traverse_radius, traverse_x))
|
|
traverse_y = max(areas[area].y + traverse_radius, min(areas[area].y + areas[area].height - traverse_radius, traverse_y))
|
|
end
|
|
end
|
|
|
|
local function selected_area()
|
|
if selected_area_ == nil then
|
|
local min_dis = nil
|
|
for i, a in ipairs(areas) do
|
|
if a.habitable then
|
|
local dis =
|
|
math.abs(a.x + traverse_radius - traverse_x) + math.abs(a.x + a.width - traverse_radius - traverse_x) - a.width +
|
|
math.abs(a.y + traverse_radius - traverse_y) + math.abs(a.y + a.height - traverse_radius - traverse_y) - a.height +
|
|
traverse_radius * 4
|
|
if min_dis == nil or min_dis > dis then
|
|
min_dis = dis
|
|
selected_area_ = i
|
|
end
|
|
end
|
|
end
|
|
|
|
set_selected_area(selected_area_)
|
|
end
|
|
return selected_area_
|
|
end
|
|
|
|
local parent_stack = {}
|
|
|
|
local function maintain_tablist()
|
|
if tablist == nil then
|
|
tablist = {}
|
|
|
|
local active_area = selected_area()
|
|
for _, tc in ipairs(screen.tiled_clients) do
|
|
if not (tc.floating or tc.immobilized)
|
|
then
|
|
if areas[active_area].x <= tc.x + tc.width + tc.border_width * 2 and tc.x <= areas[active_area].x + areas[active_area].width and
|
|
areas[active_area].y <= tc.y + tc.height + tc.border_width * 2 and tc.y <= areas[active_area].y + areas[active_area].height
|
|
then
|
|
tablist[#tablist + 1] = tc
|
|
end
|
|
end
|
|
end
|
|
|
|
tablist_index = 1
|
|
|
|
else
|
|
|
|
local j = 0
|
|
for i = 1, #tablist do
|
|
if tablist[i].valid then
|
|
j = j + 1
|
|
tablist[j] = tablist[i]
|
|
elseif i <= tablist_index and tablist_index > 0 then
|
|
tablist_index = tablist_index - 1
|
|
end
|
|
end
|
|
|
|
for i = #tablist, j + 1, -1 do
|
|
table.remove(tablist, i)
|
|
end
|
|
end
|
|
|
|
if c and not c.valid then c = nil end
|
|
if c == nil and #tablist > 0 then
|
|
c = tablist[tablist_index]
|
|
end
|
|
end
|
|
|
|
local function draw_info(context, cr, width, height)
|
|
maintain_tablist()
|
|
|
|
cr:set_source_rgba(0, 0, 0, 0)
|
|
cr:rectangle(0, 0, width, height)
|
|
cr:fill()
|
|
|
|
local msg, ext
|
|
local active_area = selected_area()
|
|
for i, a in ipairs(areas) do
|
|
if a.habitable or i == active_area then
|
|
cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
|
|
cr:clip()
|
|
cr:set_source(fill_color)
|
|
cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
|
|
cr:fill()
|
|
cr:set_source(i == active_area and border_color_hl or border_color)
|
|
cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
|
|
cr:set_line_width(10.0)
|
|
cr:stroke()
|
|
cr:reset_clip()
|
|
end
|
|
end
|
|
|
|
if #tablist > 0 then
|
|
local a = areas[active_area]
|
|
local pl = lgi.Pango.Layout.create(cr)
|
|
pl:set_font_description(tablist_font_desc)
|
|
|
|
local vpadding = dpi(10)
|
|
local list_height = vpadding
|
|
local list_width = 2 * vpadding
|
|
local exts = {}
|
|
|
|
for index, tc in ipairs(tablist) do
|
|
local label = tc.name or "<unnamed>"
|
|
pl:set_text(label)
|
|
local w, h
|
|
w, h = pl:get_size()
|
|
w = w / lgi.Pango.SCALE
|
|
h = h / lgi.Pango.SCALE
|
|
local ext = { width = w, height = h, x_bearing = 0, y_bearing = 0 }
|
|
exts[#exts + 1] = ext
|
|
list_height = list_height + ext.height + vpadding
|
|
list_width = max(list_width, w + 2 * vpadding)
|
|
end
|
|
|
|
local x_offset = a.x + a.width / 2 - start_x
|
|
local y_offset = a.y + a.height / 2 - list_height / 2 + vpadding - start_y
|
|
|
|
-- cr:rectangle(a.x - start_x, y_offset - vpadding - start_y, a.width, list_height)
|
|
-- cover the entire area
|
|
cr:rectangle(a.x - start_x, a.y - start_y, a.width, a.height)
|
|
cr:set_source(fill_color)
|
|
cr:fill()
|
|
|
|
cr:rectangle(a.x + (a.width - list_width) / 2 - start_x, a.y + (a.height - list_height) / 2 - start_y, list_width, list_height)
|
|
cr:set_source(box_bg)
|
|
cr:fill()
|
|
|
|
for index, tc in ipairs(tablist) do
|
|
local label = tc.name or "<unnamed>"
|
|
local ext = exts[index]
|
|
if index == tablist_index then
|
|
cr:rectangle(x_offset - ext.width / 2 - vpadding / 2, y_offset - vpadding / 2, ext.width + vpadding, ext.height + vpadding)
|
|
cr:set_source(fill_color_hl)
|
|
cr:fill()
|
|
pl:set_text(label)
|
|
cr:move_to(x_offset - ext.width / 2 - ext.x_bearing, y_offset - ext.y_bearing)
|
|
cr:set_source(font_color_hl)
|
|
cr:show_layout(pl)
|
|
else
|
|
pl:set_text(label)
|
|
cr:move_to(x_offset - ext.width / 2 - ext.x_bearing, y_offset - ext.y_bearing)
|
|
cr:set_source(font_color)
|
|
cr:show_layout(pl)
|
|
end
|
|
|
|
y_offset = y_offset + ext.height + vpadding
|
|
end
|
|
end
|
|
|
|
-- show the traverse point
|
|
cr:rectangle(traverse_x - start_x - traverse_radius, traverse_y - start_y - traverse_radius, traverse_radius * 2, traverse_radius * 2)
|
|
cr:set_source_rgba(1, 1, 1, 1)
|
|
cr:fill()
|
|
end
|
|
|
|
infobox.bgimage = draw_info
|
|
|
|
local key_translate_tab = {
|
|
["w"] = "Up",
|
|
["a"] = "Left",
|
|
["s"] = "Down",
|
|
["d"] = "Right",
|
|
}
|
|
|
|
awful.client.focus.history.disable_tracking()
|
|
|
|
local kg
|
|
local function exit()
|
|
awful.client.focus.history.enable_tracking()
|
|
if capi.client.focus then
|
|
capi.client.emit_signal("focus", capi.client.focus)
|
|
end
|
|
infobox.visible = false
|
|
awful.keygrabber.stop(kg)
|
|
end
|
|
|
|
local function handle_key(mod, key, event)
|
|
if event == "release" then
|
|
if exit_keys and exit_keys[key] then
|
|
exit()
|
|
end
|
|
return
|
|
end
|
|
if key_translate_tab[key] ~= nil then
|
|
key = key_translate_tab[key]
|
|
end
|
|
|
|
maintain_tablist()
|
|
assert(tablist ~= nil)
|
|
|
|
local shift = false
|
|
local ctrl = false
|
|
for i, m in ipairs(mod) do
|
|
if m == "Shift" then shift = true
|
|
elseif m == "Control" then ctrl = true
|
|
end
|
|
end
|
|
|
|
if key == "Tab" then
|
|
if #tablist > 0 then
|
|
tablist_index = tablist_index % #tablist + 1
|
|
c = tablist[tablist_index]
|
|
c:emit_signal("request::activate", "mouse.move", {raise=false})
|
|
c:raise()
|
|
|
|
infobox.bgimage = draw_info
|
|
end
|
|
elseif key == "Up" or key == "Down" or key == "Left" or key == "Right" then
|
|
local current_area = selected_area()
|
|
|
|
if c and (shift or ctrl) then
|
|
if shift then
|
|
if current_area == nil or
|
|
areas[current_area].x ~= c.x or
|
|
areas[current_area].y ~= c.y
|
|
then
|
|
traverse_x = c.x + traverse_radius
|
|
traverse_y = c.y + traverse_radius
|
|
set_selected_area(nil)
|
|
end
|
|
elseif ctrl then
|
|
local ex = c.x + c.width + c.border_width * 2
|
|
local ey = c.y + c.height + c.border_width * 2
|
|
if current_area == nil or
|
|
areas[current_area].x + areas[current_area].width ~= ex or
|
|
areas[current_area].y + areas[current_area].height ~= ey
|
|
then
|
|
traverse_x = ex - traverse_radius
|
|
traverse_y = ey - traverse_radius
|
|
set_selected_area(nil)
|
|
end
|
|
end
|
|
end
|
|
|
|
local choice = nil
|
|
local choice_value
|
|
|
|
current_area = selected_area()
|
|
|
|
for i, a in ipairs(areas) do
|
|
if not a.habitable then goto continue end
|
|
|
|
local v
|
|
if key == "Up" then
|
|
if a.x < traverse_x + threshold
|
|
and traverse_x < a.x + a.width + threshold then
|
|
v = traverse_y - a.y - a.height
|
|
else
|
|
v = -1
|
|
end
|
|
elseif key == "Down" then
|
|
if a.x < traverse_x + threshold
|
|
and traverse_x < a.x + a.width + threshold then
|
|
v = a.y - traverse_y
|
|
else
|
|
v = -1
|
|
end
|
|
elseif key == "Left" then
|
|
if a.y < traverse_y + threshold
|
|
and traverse_y < a.y + a.height + threshold then
|
|
v = traverse_x - a.x - a.width
|
|
else
|
|
v = -1
|
|
end
|
|
elseif key == "Right" then
|
|
if a.y < traverse_y + threshold
|
|
and traverse_y < a.y + a.height + threshold then
|
|
v = a.x - traverse_x
|
|
else
|
|
v = -1
|
|
end
|
|
end
|
|
|
|
if (v > threshold) and (choice_value == nil or choice_value > v) then
|
|
choice = i
|
|
choice_value = v
|
|
end
|
|
::continue::
|
|
end
|
|
|
|
if choice == nil then
|
|
choice = current_area
|
|
if key == "Up" then
|
|
traverse_y = screen.workarea.y
|
|
elseif key == "Down" then
|
|
traverse_y = screen.workarea.y + screen.workarea.height
|
|
elseif key == "Left" then
|
|
traverse_x = screen.workarea.x
|
|
else
|
|
traverse_x = screen.workarea.x + screen.workarea.width
|
|
end
|
|
end
|
|
|
|
if choice ~= nil then
|
|
tablist = nil
|
|
set_selected_area(choice)
|
|
|
|
if c and ctrl and cd[c].draft ~= false then
|
|
local lu = cd[c].lu or cd[c].area
|
|
local rd = cd[c].rd or cd[c].area
|
|
|
|
if shift then
|
|
lu = choice
|
|
if areas[rd].x + areas[rd].width <= areas[lu].x or
|
|
areas[rd].y + areas[rd].height <= areas[lu].y
|
|
then
|
|
rd = nil
|
|
end
|
|
else
|
|
rd = choice
|
|
if areas[rd].x + areas[rd].width <= areas[lu].x or
|
|
areas[rd].y + areas[rd].height <= areas[lu].y
|
|
then
|
|
lu = nil
|
|
end
|
|
end
|
|
|
|
if lu ~= nil and rd ~= nil then
|
|
machi.layout.set_geometry(c, areas[lu], areas[rd], 0, c.border_width)
|
|
elseif lu ~= nil then
|
|
machi.layout.set_geometry(c, areas[lu], nil, 0, c.border_width)
|
|
elseif rd ~= nil then
|
|
c.x = min(c.x, areas[rd].x)
|
|
c.y = min(c.y, areas[rd].y)
|
|
machi.layout.set_geometry(c, nil, areas[rd], 0, c.border_width)
|
|
end
|
|
|
|
if lu == rd and cd[c].draft ~= true then
|
|
cd[c].lu = nil
|
|
cd[c].rd = nil
|
|
cd[c].area = lu
|
|
else
|
|
cd[c].lu = lu
|
|
cd[c].rd = rd
|
|
cd[c].area = nil
|
|
end
|
|
|
|
c:emit_signal("request::activate", "mouse.move", {raise=false})
|
|
c:raise()
|
|
awful.layout.arrange(screen)
|
|
elseif c and shift then
|
|
-- move the window
|
|
local in_draft = cd[c].draft
|
|
if cd[c].draft ~= nil then
|
|
in_draft = cd[c].draft
|
|
elseif cd[c].lu then
|
|
in_draft = true
|
|
elseif cd[c].area then
|
|
in_draft = false
|
|
else
|
|
log(ERROR, "Assuming in_draft for unhandled client "..tostring(c))
|
|
in_draft = true
|
|
end
|
|
if in_draft then
|
|
c.x = areas[choice].x
|
|
c.y = areas[choice].y
|
|
else
|
|
machi.layout.set_geometry(c, areas[choice], areas[choice], 0, c.border_width)
|
|
cd[c].lu = nil
|
|
cd[c].rd = nil
|
|
cd[c].area = choice
|
|
end
|
|
c:emit_signal("request::activate", "mouse.move", {raise=false})
|
|
c:raise()
|
|
c.machi_no_sanitize_geometry = true
|
|
awful.layout.arrange(screen)
|
|
|
|
tablist = nil
|
|
else
|
|
maintain_tablist()
|
|
-- move the focus
|
|
if #tablist > 0 and tablist[1] ~= c then
|
|
c = tablist[1]
|
|
capi.client.focus = c
|
|
end
|
|
end
|
|
|
|
infobox.bgimage = draw_info
|
|
end
|
|
elseif (key == "q" or key == "Prior") then
|
|
local current_area = selected_area()
|
|
if areas[current_area].parent_id == nil then
|
|
return
|
|
end
|
|
|
|
tablist = nil
|
|
set_selected_area(areas[current_area].parent_id)
|
|
if #parent_stack == 0 or
|
|
parent_stack[#parent_stack] ~= current_area then
|
|
parent_stack = {current_area}
|
|
end
|
|
parent_stack[#parent_stack + 1] = areas[current_area].parent_id
|
|
current_area = parent_stack[#parent_stack]
|
|
|
|
if c and ctrl and cd[c].draft ~= false then
|
|
if cd[c].area then
|
|
cd[c].lu, cd[c].rd, cd[c].area = cd[c].area, cd[c].area, nil
|
|
end
|
|
machi.layout.set_geometry(c, areas[current_area], areas[current_area], 0, c.border_width)
|
|
awful.layout.arrange(screen)
|
|
end
|
|
|
|
infobox.bgimage = draw_info
|
|
elseif (key =="e" or key == "Next") then
|
|
local current_area = selected_area()
|
|
if #parent_stack <= 1 or parent_stack[#parent_stack] ~= current_area then
|
|
return
|
|
end
|
|
|
|
tablist = nil
|
|
set_selected_area(parent_stack[#parent_stack - 1])
|
|
table.remove(parent_stack, #parent_stack)
|
|
current_area = parent_stack[#parent_stack]
|
|
|
|
if c and ctrl then
|
|
if areas[current_area].habitable and cd[c].draft ~= true then
|
|
cd[c].lu, cd[c].rd, cd[c].area = nil, nil, current_area
|
|
end
|
|
machi.layout.set_geometry(c, areas[current_area], areas[current_area], 0, c.border_width)
|
|
awful.layout.arrange(screen)
|
|
end
|
|
|
|
infobox.bgimage = draw_info
|
|
elseif key == "/" then
|
|
local current_area = selected_area()
|
|
local original_cmd = machi.engine.areas_to_command(areas, true, current_area)
|
|
areas[current_area].hole = true
|
|
local prefix, suffix = machi.engine.areas_to_command(
|
|
areas, false):match("(.*)|(.*)")
|
|
areas[current_area].hole = nil
|
|
|
|
workarea = {
|
|
x = areas[current_area].x - gap * 2,
|
|
y = areas[current_area].y - gap * 2,
|
|
width = areas[current_area].width + gap * 4,
|
|
height = areas[current_area].height + gap * 4,
|
|
}
|
|
gtimer.delayed_call(
|
|
function ()
|
|
layout.machi_editor.start_interactive(
|
|
screen,
|
|
{
|
|
workarea = workarea,
|
|
original_cmd = original_cmd,
|
|
cmd_prefix = prefix,
|
|
cmd_suffix = suffix,
|
|
}
|
|
)
|
|
end
|
|
)
|
|
exit()
|
|
elseif (key == "f" or key == ".") and c then
|
|
if cd[c].draft == nil then
|
|
cd[c].draft = true
|
|
elseif cd[c].draft == true then
|
|
cd[c].draft = false
|
|
else
|
|
cd[c].draft = nil
|
|
end
|
|
awful.layout.arrange(screen)
|
|
elseif key == "Escape" or key == "Return" then
|
|
exit()
|
|
else
|
|
log(DEBUG, "Unhandled key " .. key)
|
|
end
|
|
end
|
|
|
|
kg = awful.keygrabber.run(
|
|
function (...)
|
|
ok, _ = pcall(handle_key, ...)
|
|
if not ok then exit() end
|
|
end
|
|
)
|
|
end
|
|
|
|
return module
|