667 lines
23 KiB
Lua
667 lines
23 KiB
Lua
local this_package = ... and (...):match("(.-)[^%.]+$") or ""
|
|
local machi_engine = require(this_package.."engine")
|
|
local beautiful = require("beautiful")
|
|
local awful = require("awful")
|
|
local wibox = require("wibox")
|
|
local naughty = require("naughty")
|
|
local gears = require("gears")
|
|
local gfs = require("gears.filesystem")
|
|
local lgi = require("lgi")
|
|
local dpi = require("beautiful.xresources").apply_dpi
|
|
|
|
local ERROR = 2
|
|
local WARNING = 1
|
|
local INFO = 0
|
|
local DEBUG = -1
|
|
|
|
local module = {
|
|
log_level = WARNING,
|
|
nested_layouts = {
|
|
["0"] = awful.layout.suit.tile,
|
|
["1"] = awful.layout.suit.spiral,
|
|
["2"] = awful.layout.suit.fair,
|
|
["3"] = awful.layout.suit.fair.horizontal,
|
|
},
|
|
}
|
|
|
|
local function log(level, msg)
|
|
if level > module.log_level then
|
|
print(msg)
|
|
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
|
|
|
|
local function max(a, b)
|
|
if a < b then return b else return a end
|
|
end
|
|
|
|
local function is_tiling(c)
|
|
return
|
|
not (c.tomb_floating or c.floating or c.maximized_horizontal or c.maximized_vertical or c.maximized or c.fullscreen)
|
|
end
|
|
|
|
local function set_tiling(c)
|
|
c.floating = false
|
|
c.maximized = false
|
|
c.maximized_vertical = false
|
|
c.maximized_horizontal = false
|
|
c.fullscreen = false
|
|
end
|
|
|
|
local function _area_tostring(wa)
|
|
return "{x:" .. tostring(wa.x) .. ",y:" .. tostring(wa.y) .. ",w:" .. tostring(wa.width) .. ",h:" .. tostring(wa.height) .. "}"
|
|
end
|
|
|
|
local function shrink_area_with_gap(a, gap)
|
|
return {
|
|
x = a.x + gap,
|
|
y = a.y + gap,
|
|
width = a.width - gap * 2,
|
|
height = a.height - gap * 2,
|
|
}
|
|
end
|
|
|
|
function module.restore_data(data)
|
|
if data.history_file then
|
|
local file, err = io.open(data.history_file, "r")
|
|
if err then
|
|
log(INFO, "cannot read history from " .. data.history_file)
|
|
else
|
|
data.cmds = {}
|
|
data.last_cmd = {}
|
|
local last_layout_name
|
|
for line in file:lines() do
|
|
if line:sub(1, 1) == "+" then
|
|
last_layout_name = line:sub(2, #line)
|
|
else
|
|
if last_layout_name ~= nil then
|
|
log(DEBUG, "restore last cmd " .. line .. " for " .. last_layout_name)
|
|
data.last_cmd[last_layout_name] = line
|
|
last_layout_name = nil
|
|
else
|
|
log(DEBUG, "restore cmd " .. line)
|
|
data.cmds[#data.cmds + 1] = line
|
|
end
|
|
end
|
|
end
|
|
file:close()
|
|
end
|
|
end
|
|
|
|
return data
|
|
end
|
|
|
|
function module.create(data)
|
|
if data == nil then
|
|
data = module.restore_data({
|
|
history_file = gfs.get_cache_dir() .. "/history_machi",
|
|
history_save_max = 100,
|
|
})
|
|
end
|
|
|
|
data.cmds = data.cmds or {}
|
|
data.last_cmd = data.last_cmd or {}
|
|
data.minimum_size = data.minimum_size or 100
|
|
|
|
|
|
local function add_cmd(instance_name, cmd)
|
|
-- remove duplicated entries
|
|
local j = 1
|
|
for i = 1, #data.cmds do
|
|
if data.cmds[i] ~= cmd then
|
|
data.cmds[j] = data.cmds[i]
|
|
j = j + 1
|
|
end
|
|
end
|
|
for i = #data.cmds, j, -1 do
|
|
table.remove(data.cmds, i)
|
|
end
|
|
|
|
data.cmds[#data.cmds + 1] = cmd
|
|
data.last_cmd[instance_name] = cmd
|
|
if data.history_file then
|
|
local file, err = io.open(data.history_file, "w")
|
|
if err then
|
|
log(ERROR, "cannot save history to " .. data.history_file)
|
|
else
|
|
for i = max(1, #data.cmds - data.history_save_max + 1), #data.cmds do
|
|
if data.cmds[i] ~= "." then
|
|
log(DEBUG, "save cmd " .. data.cmds[i])
|
|
file:write(data.cmds[i] .. "\n")
|
|
end
|
|
end
|
|
for name, cmd in pairs(data.last_cmd) do
|
|
log(DEBUG, "save last cmd " .. cmd .. " for " .. name)
|
|
file:write("+" .. name .. "\n" .. cmd .. "\n")
|
|
end
|
|
end
|
|
file:close()
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
local function start_interactive(screen, embed_args)
|
|
local info_size = dpi(60)
|
|
-- colors are in rgba
|
|
local border_color = with_alpha(
|
|
gears.color(beautiful.machi_editor_border_color or beautiful.border_focus),
|
|
beautiful.machi_editor_border_opacity or 0.75)
|
|
local active_color = with_alpha(
|
|
gears.color(beautiful.machi_editor_active_color or beautiful.bg_focus),
|
|
beautiful.machi_editor_active_opacity or 0.5)
|
|
local open_color = with_alpha(
|
|
gears.color(beautiful.machi_editor_open_color or beautiful.bg_normal),
|
|
beautiful.machi_editor_open_opacity or 0.5)
|
|
local done_color = with_alpha(
|
|
gears.color(beautiful.machi_editor_done_color or beautiful.bg_focus),
|
|
beautiful.machi_editor_done_opacity or 0.5)
|
|
local closed_color = open_color
|
|
|
|
if to_save == nil then
|
|
to_save = true
|
|
end
|
|
|
|
screen = screen or awful.screen.focused()
|
|
local tag = screen.selected_tag
|
|
local prev_layout = nil
|
|
|
|
if tag.layout.machi_set_cmd == nil then
|
|
prev_layout = tag.layout
|
|
for _, l in ipairs(awful.layout.layouts) do
|
|
if l.machi_set_cmd ~= nil then
|
|
awful.layout.set(l, tag)
|
|
naughty.notify {
|
|
text = 'Switched layout to machi',
|
|
timeout = 2
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
local gap = tag.gap or 0
|
|
local layout = tag.layout
|
|
|
|
if layout.machi_set_cmd == nil then
|
|
naughty.notify {
|
|
text = "The layout to edit is not machi",
|
|
timeout = 3
|
|
}
|
|
return
|
|
end
|
|
|
|
local cmd_index = #data.cmds + 1
|
|
data.cmds[cmd_index] = ""
|
|
|
|
local start_x = screen.workarea.x
|
|
local start_y = screen.workarea.y
|
|
|
|
local kg
|
|
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
|
|
|
|
workarea = embed_args and embed_args.workarea or screen.workarea
|
|
|
|
local closed_areas
|
|
local open_areas
|
|
local pending_op
|
|
local current_cmd
|
|
local to_exit
|
|
local to_apply
|
|
|
|
local key_translate_tab = {
|
|
["Return"] = ".",
|
|
[" "] = "-",
|
|
}
|
|
|
|
local curpos = 0
|
|
local current_info_pre = ""
|
|
local current_info_post = ""
|
|
local current_msg
|
|
|
|
local function set_cmd(cmd, arbitrary_input)
|
|
local new_closed_areas, new_open_areas, new_pending_op = machi_engine.areas_from_command(
|
|
cmd,
|
|
{
|
|
x = workarea.x + gap,
|
|
y = workarea.y + gap,
|
|
width = workarea.width - gap * 2,
|
|
height = workarea.height - gap * 2
|
|
},
|
|
gap * 2 + data.minimum_size)
|
|
if new_closed_areas or not arbitrary_input then
|
|
if new_closed_areas then
|
|
closed_areas, open_areas, pending_op =
|
|
new_closed_areas, new_open_areas, new_pending_op
|
|
end
|
|
current_cmd = cmd
|
|
|
|
current_info_pre = current_cmd:sub(0, curpos)
|
|
current_info_post = current_cmd:sub(curpos+1, #current_cmd)
|
|
if embed_args then
|
|
current_info_pre = embed_args.cmd_prefix.."["..current_info_pre
|
|
current_info_post = current_info_post.."]"..embed_args.cmd_suffix
|
|
end
|
|
|
|
current_msg = ""
|
|
if new_closed_areas and #open_areas == 0 and not pending_op then
|
|
current_msg = "(enter to apply)"
|
|
end
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
local move_cursor = function(n)
|
|
curpos = curpos + n
|
|
if curpos > #current_cmd then
|
|
curpos = #current_cmd
|
|
elseif curpos < 0 then
|
|
curpos = 0
|
|
end
|
|
-- trigger refresh
|
|
set_cmd(current_cmd)
|
|
end
|
|
|
|
|
|
local function handle_key(key)
|
|
if key_translate_tab[key] ~= nil then
|
|
key = key_translate_tab[key]
|
|
end
|
|
|
|
return set_cmd(current_cmd:sub(0, curpos)..key..current_cmd:sub(curpos+1, #current_cmd), true)
|
|
end
|
|
|
|
|
|
local function cleanup()
|
|
infobox.visible = false
|
|
if prev_layout ~= nil and (not to_apply) then
|
|
awful.layout.set(prev_layout, tag)
|
|
end
|
|
prev_layout = nil
|
|
end
|
|
|
|
local function draw_info(context, cr, width, height)
|
|
cr:set_source_rgba(0, 0, 0, 0)
|
|
cr:rectangle(0, 0, width, height)
|
|
cr:fill()
|
|
|
|
local msg, ext
|
|
|
|
for i, a in ipairs(closed_areas) do
|
|
if a.habitable then
|
|
local sa = shrink_area_with_gap(a, gap)
|
|
local to_highlight = false
|
|
if pending_op ~= nil then
|
|
to_highlight = a.group_id == op_count
|
|
end
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:clip()
|
|
if to_highlight then
|
|
cr:set_source(done_color)
|
|
else
|
|
cr:set_source(closed_color)
|
|
end
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:fill()
|
|
cr:set_source(border_color)
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:set_line_width(10.0)
|
|
cr:stroke()
|
|
cr:reset_clip()
|
|
end
|
|
end
|
|
|
|
for i, a in ipairs(open_areas) do
|
|
local sa = shrink_area_with_gap(a, gap)
|
|
local to_highlight = false
|
|
if not pending_op then
|
|
to_highlight = i == #open_areas
|
|
else
|
|
to_highlight = a.group_id == op_count
|
|
end
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:clip()
|
|
if i == #open_areas then
|
|
cr:set_source(active_color)
|
|
else
|
|
cr:set_source(open_color)
|
|
end
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:fill()
|
|
|
|
cr:set_source(border_color)
|
|
cr:rectangle(sa.x - start_x, sa.y - start_y, sa.width, sa.height)
|
|
cr:set_line_width(10.0)
|
|
if to_highlight then
|
|
cr:stroke()
|
|
else
|
|
cr:set_dash({5, 5}, 0)
|
|
cr:stroke()
|
|
cr:set_dash({}, 0)
|
|
end
|
|
cr:reset_clip()
|
|
end
|
|
|
|
local pl = lgi.Pango.Layout.create(cr)
|
|
pl:set_font_description(beautiful.get_merged_font(beautiful.font, info_size))
|
|
pl:set_alignment("CENTER")
|
|
pl:set_text(current_info_pre)
|
|
local w0, _ = pl:get_pixel_size()
|
|
pl:set_text(current_info_pre..current_info_post)
|
|
local w, h = pl:get_pixel_size()
|
|
|
|
local pl_msg = lgi.Pango.Layout.create(cr)
|
|
pl_msg:set_font_description(beautiful.get_merged_font(beautiful.font, info_size))
|
|
pl_msg:set_alignment("CENTER")
|
|
pl_msg:set_text(current_msg)
|
|
local w_msg, h_msg = pl_msg:get_pixel_size()
|
|
local lh = pl_msg:get_line_spacing()
|
|
|
|
local draw = function(pl, w, h, y_offset, color)
|
|
local ext = { width = w, height = h, x_bearing = 0, y_bearing = 0 }
|
|
cr:move_to(
|
|
width / 2 - ext.width / 2 - ext.x_bearing,
|
|
y_offset + height / 2 - ext.height / 2 - ext.y_bearing
|
|
)
|
|
if color then
|
|
cr:set_source(color)
|
|
else
|
|
cr:set_source_rgba(1, 1, 1, 1)
|
|
end
|
|
cr:show_layout(pl)
|
|
cr:fill()
|
|
end
|
|
local wpad, hpad = dpi(50), dpi(5)
|
|
local mw, mh = max(w, w_msg) + wpad, h + hpad
|
|
if current_msg ~= "" then
|
|
mh = mh + h_msg + lh
|
|
end
|
|
if mw < dpi(120) then
|
|
mw = dpi(120)
|
|
end
|
|
cr:rectangle(width / 2 - mw / 2, height / 2 - (h + hpad) / 2, mw, mh)
|
|
cr:set_source_rgba(0, 0, 0, 1)
|
|
cr:fill()
|
|
local cursor_border = 0
|
|
local cursor_width = 1
|
|
if cursor_border >= 0 then
|
|
cr:rectangle(
|
|
width / 2 - w / 2 + w0,
|
|
height / 2 - h / 2 + lh,
|
|
2 * cursor_border + cursor_width,
|
|
h
|
|
)
|
|
cr:set_source_rgba(0, 0, 0, 0.8)
|
|
cr:fill()
|
|
end
|
|
cr:rectangle(
|
|
cursor_border + width / 2 - w / 2 + w0,
|
|
cursor_border + height / 2 - h / 2 + lh,
|
|
cursor_width,
|
|
h - 2 * cursor_border
|
|
)
|
|
cr:set_source_rgba(1, 1, 1, 1)
|
|
cr:fill()
|
|
draw(pl, w, h, lh)
|
|
draw(pl_msg, w_msg, h_msg, h + lh)
|
|
end
|
|
|
|
local function refresh()
|
|
log(DEBUG, "closed areas:")
|
|
for i, a in ipairs(closed_areas) do
|
|
log(DEBUG, " " .. _area_tostring(a))
|
|
end
|
|
log(DEBUG, "open areas:")
|
|
for i, a in ipairs(open_areas) do
|
|
log(DEBUG, " " .. _area_tostring(a))
|
|
end
|
|
infobox.bgimage = draw_info
|
|
end
|
|
|
|
local function get_final_cmd()
|
|
local final_cmd = current_cmd
|
|
if embed_args then
|
|
final_cmd = embed_args.cmd_prefix ..
|
|
machi_engine.areas_to_command(closed_areas, true) ..
|
|
embed_args.cmd_suffix
|
|
end
|
|
return final_cmd
|
|
end
|
|
|
|
log(DEBUG, "interactive layout editing starts")
|
|
|
|
set_cmd("")
|
|
refresh()
|
|
|
|
kg = awful.keygrabber.run(
|
|
function (mod, key, event)
|
|
if event == "release" then
|
|
return
|
|
end
|
|
|
|
local ok, err = pcall(
|
|
function ()
|
|
if key == "Left" then
|
|
move_cursor(-1)
|
|
elseif key == "Right" then
|
|
move_cursor(1)
|
|
elseif key == "BackSpace" then
|
|
local alt = false
|
|
for _, m in ipairs(mod) do
|
|
if m == "Shift" then
|
|
alt = true
|
|
break
|
|
end
|
|
end
|
|
if alt then
|
|
if embed_args then
|
|
set_cmd(embed_args.original_cmd or "")
|
|
else
|
|
local _cd, _td, areas = layout.machi_get_instance_data(screen, tag)
|
|
set_cmd(machi_engine.areas_to_command(areas))
|
|
end
|
|
else
|
|
local s = curpos - 1
|
|
if s < 0 then
|
|
s = 0
|
|
end
|
|
set_cmd(current_cmd:sub(0, s)..current_cmd:sub(curpos+1, #current_cmd))
|
|
move_cursor(-1)
|
|
end
|
|
elseif key == "Escape" then
|
|
table.remove(data.cmds, #data.cmds)
|
|
to_exit = true
|
|
elseif key == "Up" or key == "Down" then
|
|
if current_cmd ~= data.cmds[cmd_index] then
|
|
data.cmds[#data.cmds] = current_cmd
|
|
end
|
|
|
|
if key == "Up" and cmd_index > 1 then
|
|
cmd_index = cmd_index - 1
|
|
elseif key == "Down" and cmd_index < #data.cmds then
|
|
cmd_index = cmd_index + 1
|
|
end
|
|
|
|
log(DEBUG, "restore history #" .. tostring(cmd_index) .. ":" .. data.cmds[cmd_index])
|
|
set_cmd(data.cmds[cmd_index])
|
|
move_cursor(#data.cmds[cmd_index])
|
|
elseif #open_areas > 0 or pending_op or curpos < #current_cmd then
|
|
if key == "." or key == "Return" then
|
|
move_cursor(#current_cmd)
|
|
end
|
|
if handle_key(key) then
|
|
move_cursor(1)
|
|
end
|
|
else
|
|
if key == "Return" then
|
|
local alt = false
|
|
for _, m in ipairs(mod) do
|
|
if m == "Shift" then
|
|
alt = true
|
|
break
|
|
end
|
|
end
|
|
|
|
local instance_name, persistent = layout.machi_get_instance_info(tag)
|
|
if not alt and persistent then
|
|
table.remove(data.cmds, #data.cmds)
|
|
add_cmd(instance_name, get_final_cmd())
|
|
current_msg = "Saved!"
|
|
else
|
|
current_msg = "Applied"
|
|
end
|
|
|
|
to_exit = true
|
|
to_apply = true
|
|
end
|
|
end
|
|
|
|
refresh()
|
|
|
|
if to_exit then
|
|
log(DEBUG, "interactive layout editing ends")
|
|
if to_apply then
|
|
layout.machi_set_cmd(get_final_cmd(), tag)
|
|
awful.layout.arrange(screen)
|
|
end
|
|
cleanup()
|
|
end
|
|
end)
|
|
|
|
if not ok then
|
|
log(ERROR, "Getting error in keygrabber: " .. err)
|
|
to_exit = true
|
|
cleanup()
|
|
end
|
|
|
|
if to_exit then
|
|
awful.keygrabber.stop(kg)
|
|
end
|
|
end
|
|
)
|
|
end
|
|
|
|
local function run_cmd(cmd, screen, tag)
|
|
local gap = tag.gap
|
|
local areas, closed = machi_engine.areas_from_command(
|
|
cmd,
|
|
{
|
|
x = screen.workarea.x + gap,
|
|
y = screen.workarea.y + gap,
|
|
width = screen.workarea.width - gap * 2,
|
|
height = screen.workarea.height - gap * 2
|
|
},
|
|
gap * 2 + data.minimum_size)
|
|
if not areas or #closed > 0 then
|
|
return nil
|
|
end
|
|
for _, a in ipairs(areas) do
|
|
a.x = a.x + gap
|
|
a.y = a.y + gap
|
|
a.width = a.width - gap * 2
|
|
a.height = a.height - gap * 2
|
|
end
|
|
return areas
|
|
end
|
|
|
|
local function get_last_cmd(name)
|
|
return data.last_cmd[name]
|
|
end
|
|
|
|
function adjust_shares(c, axis, adj)
|
|
if not c:isvisible() or c.floating or c.immobilized then
|
|
return
|
|
end
|
|
local screen = c.screen
|
|
local tag = screen.selected_tag
|
|
local layout = tag.layout
|
|
if not layout.machi_get_instance_data then return end
|
|
local cd, _td, areas = layout.machi_get_instance_data(screen, tag)
|
|
local key_shares = axis.."_shares"
|
|
local key_spare = axis.."_spare"
|
|
local key_parent_shares = "parent_"..axis.."_shares"
|
|
|
|
if not cd[c] or not cd[c].area then
|
|
return
|
|
end
|
|
|
|
if adj < 0 then
|
|
if axis == "x" and c.width + adj < data.minimum_size then
|
|
adj = data.minimum_size - c.width
|
|
elseif axis == "y" and c.height + adj < data.minimum_size then
|
|
adj = data.minimum_size - c.height
|
|
end
|
|
end
|
|
|
|
local function adjust(parent_id, shares, adj)
|
|
-- The propagation part is questionable. But it is not critical anyway..
|
|
if type(shares) ~= "table" then
|
|
local old = areas[parent_id].split[key_shares][shares][2] or 0
|
|
areas[parent_id].split[key_shares][shares][2] = old + adj
|
|
else
|
|
local acc = 0
|
|
for i = 1, #shares do
|
|
local old = areas[parent_id].split[key_shares][shares[i]][2] or 0
|
|
local adj_split = i == #shares and adj - acc or math.floor(adj * i / #shares - acc + 0.5)
|
|
areas[parent_id].split[key_shares][shares[i]][2] = old + adj_split
|
|
acc = acc + adj_split
|
|
end
|
|
end
|
|
if adj <= 0 then
|
|
return #areas[parent_id].split[key_shares] > 1
|
|
else
|
|
return areas[parent_id].split[key_spare] >= adj
|
|
end
|
|
end
|
|
|
|
local area = cd[c].area
|
|
while areas[area].parent_id do
|
|
if adjust(areas[area].parent_id, areas[area][key_parent_shares], adj) then
|
|
break
|
|
end
|
|
area = areas[area].parent_id
|
|
end
|
|
|
|
layout.machi_set_cmd(machi_engine.areas_to_command(areas), tag, true)
|
|
awful.layout.arrange(screen)
|
|
end
|
|
|
|
function adjust_x_shares(c, adj)
|
|
adjust_shares(c, "x", adj)
|
|
end
|
|
|
|
function adjust_y_shares(c, adj)
|
|
adjust_shares(c, "y", adj)
|
|
end
|
|
|
|
return {
|
|
start_interactive = start_interactive,
|
|
run_cmd = run_cmd,
|
|
get_last_cmd = get_last_cmd,
|
|
adjust_x_shares = adjust_x_shares,
|
|
adjust_y_shares = adjust_y_shares,
|
|
}
|
|
end
|
|
|
|
module.default_editor = module.create()
|
|
|
|
return module
|