245 lines
7.9 KiB
Lua
245 lines
7.9 KiB
Lua
local awful = require("awful")
|
|
local gears = require("gears")
|
|
local wibox = require("wibox")
|
|
local beautiful = require("beautiful")
|
|
|
|
local mylayout = {}
|
|
|
|
mylayout.name = "mstab"
|
|
|
|
local tabbar_ontop = beautiful.mstab_bar_ontop or false
|
|
local tabbar_padding = beautiful.mstab_bar_padding or "default"
|
|
local border_radius = beautiful.mstab_border_radius
|
|
or beautiful.border_radius
|
|
or 0
|
|
local tabbar_position = beautiful.mstab_tabbar_position
|
|
or beautiful.tabbar_position
|
|
or "top"
|
|
|
|
local bar_style = beautiful.mstab_tabbar_style
|
|
or beautiful.tabbar_style
|
|
or "default"
|
|
local bar = require(
|
|
tostring(...):match(".*bling") .. ".widget.tabbar." .. bar_style
|
|
)
|
|
local tabbar_size = bar.size
|
|
or beautiful.mstab_bar_height
|
|
or beautiful.tabbar_size
|
|
or 40
|
|
local dont_resize_slaves = beautiful.mstab_dont_resize_slaves or false
|
|
|
|
-- The top_idx is the idx of the slave clients (excluding all master clients)
|
|
-- that should be on top of all other slave clients ("the focused slave")
|
|
-- by creating a variable outside of the arrange function, this layout can "remember" that client
|
|
-- by creating it as a new property of every tag, this layout can be active on different tags and
|
|
-- still have different "focused slave clients"
|
|
for idx, tag in ipairs(root.tags()) do
|
|
tag.top_idx = 1
|
|
end
|
|
|
|
-- Haven't found a signal that is emitted when a new tag is added. That should work though
|
|
-- since you can't use a layout on a tag that you haven't selected previously
|
|
tag.connect_signal("property::selected", function(t)
|
|
if not t.top_idx then
|
|
t.top_idx = 1
|
|
end
|
|
end)
|
|
|
|
function update_tabbar(
|
|
clients,
|
|
t,
|
|
top_idx,
|
|
area,
|
|
master_area_width,
|
|
slave_area_width
|
|
)
|
|
local s = t.screen
|
|
|
|
-- create the list of clients for the tabbar
|
|
local clientlist = bar.layout()
|
|
for idx, c in ipairs(clients) do
|
|
-- focus with right click, kill with mid click, minimize with left click
|
|
local buttons = gears.table.join(
|
|
awful.button({}, 1, function()
|
|
c:raise()
|
|
client.focus = c
|
|
end),
|
|
awful.button({}, 2, function()
|
|
c:kill()
|
|
end),
|
|
awful.button({}, 3, function()
|
|
c.minimized = true
|
|
end)
|
|
)
|
|
local client_box = bar.create(c, (idx == top_idx), buttons)
|
|
clientlist:add(client_box)
|
|
end
|
|
|
|
-- if no tabbar exists, create one
|
|
if not s.tabbar then
|
|
s.tabbar = wibox({
|
|
ontop = tabbar_ontop,
|
|
shape = function(cr, width, height)
|
|
gears.shape.rounded_rect(cr, width, height, border_radius)
|
|
end,
|
|
bg = bar.bg_normal,
|
|
visible = true,
|
|
})
|
|
|
|
-- Change visibility of the tab bar when layout, selected tag or number of clients (visible, master, slave) changes
|
|
local function adjust_visiblity(t)
|
|
s.tabbar.visible = (#t:clients() - t.master_count > 1)
|
|
and (t.layout.name == mylayout.name)
|
|
end
|
|
|
|
tag.connect_signal("property::selected", function(t)
|
|
adjust_visiblity(t)
|
|
end)
|
|
tag.connect_signal("property::layout", function(t, layout)
|
|
adjust_visiblity(t)
|
|
end)
|
|
tag.connect_signal("tagged", function(t, c)
|
|
adjust_visiblity(t)
|
|
end)
|
|
tag.connect_signal("untagged", function(t, c)
|
|
adjust_visiblity(t)
|
|
end)
|
|
tag.connect_signal("property::master_count", function(t)
|
|
adjust_visiblity(t)
|
|
end)
|
|
client.connect_signal("property::minimized", function(c)
|
|
local t = c.first_tag
|
|
adjust_visiblity(t)
|
|
end)
|
|
end
|
|
|
|
-- update the tabbar size and position (to support gap size change on the fly)
|
|
if tabbar_position == "top" then
|
|
s.tabbar.x = area.x + master_area_width + t.gap
|
|
s.tabbar.y = area.y + t.gap
|
|
s.tabbar.width = slave_area_width - 2 * t.gap
|
|
s.tabbar.height = tabbar_size
|
|
elseif tabbar_position == "bottom" then
|
|
s.tabbar.x = area.x + master_area_width + t.gap
|
|
s.tabbar.y = area.y + area.height - tabbar_size - t.gap
|
|
s.tabbar.width = slave_area_width - 2 * t.gap
|
|
s.tabbar.height = tabbar_size
|
|
elseif tabbar_position == "left" then
|
|
s.tabbar.x = area.x + master_area_width + t.gap
|
|
s.tabbar.y = area.y + t.gap
|
|
s.tabbar.width = tabbar_size
|
|
s.tabbar.height = area.height - 2 * t.gap
|
|
elseif tabbar_position == "right" then
|
|
s.tabbar.x = area.x
|
|
+ master_area_width
|
|
+ slave_area_width
|
|
- tabbar_size
|
|
- t.gap
|
|
s.tabbar.y = area.y + t.gap
|
|
s.tabbar.width = tabbar_size
|
|
s.tabbar.height = area.height - 2 * t.gap
|
|
end
|
|
|
|
-- update clientlist
|
|
s.tabbar:setup({ layout = wibox.layout.flex.horizontal, clientlist })
|
|
end
|
|
|
|
function mylayout.arrange(p)
|
|
local area = p.workarea
|
|
local t = p.tag or screen[p.screen].selected_tag
|
|
local s = t.screen
|
|
local mwfact = t.master_width_factor
|
|
local nmaster = math.min(t.master_count, #p.clients)
|
|
local nslaves = #p.clients - nmaster
|
|
|
|
local master_area_width = area.width * mwfact
|
|
local slave_area_width = area.width - master_area_width
|
|
|
|
-- "default" means that it uses standard useless gap size
|
|
if tabbar_padding == "default" then
|
|
tabbar_padding = 2 * t.gap
|
|
end
|
|
|
|
-- Special case: No masters -> full screen slave width
|
|
if nmaster == 0 then
|
|
master_area_width = 1
|
|
slave_area_width = area.width
|
|
end
|
|
|
|
-- Special case: One or zero slaves -> no tabbar (essentially tile right)
|
|
if nslaves <= 1 then
|
|
-- since update_tabbar isnt called that way we have to hide it manually
|
|
if s.tabbar then
|
|
s.tabbar.visible = false
|
|
end
|
|
-- otherwise just do tile right
|
|
awful.layout.suit.tile.right.arrange(p)
|
|
return
|
|
end
|
|
|
|
-- Iterate through masters
|
|
for idx = 1, nmaster do
|
|
local c = p.clients[idx]
|
|
local g = {
|
|
x = area.x,
|
|
y = area.y + (idx - 1) * (area.height / nmaster),
|
|
width = master_area_width,
|
|
height = area.height / nmaster,
|
|
}
|
|
p.geometries[c] = g
|
|
end
|
|
|
|
local tabbar_size_change = 0
|
|
local tabbar_width_change = 0
|
|
local tabbar_y_change = 0
|
|
local tabbar_x_change = 0
|
|
if tabbar_position == "top" then
|
|
tabbar_size_change = tabbar_size + tabbar_padding
|
|
tabbar_y_change = tabbar_size + tabbar_padding
|
|
elseif tabbar_position == "bottom" then
|
|
tabbar_size_change = tabbar_size + tabbar_padding
|
|
elseif tabbar_position == "left" then
|
|
tabbar_width_change = tabbar_size + tabbar_padding
|
|
tabbar_x_change = tabbar_size + tabbar_padding
|
|
elseif tabbar_position == "right" then
|
|
tabbar_width_change = tabbar_size + tabbar_padding
|
|
end
|
|
|
|
-- Iterate through slaves
|
|
-- (also creates a list of all slave clients for update_tabbar)
|
|
local slave_clients = {}
|
|
for idx = 1, nslaves do
|
|
local c = p.clients[idx + nmaster]
|
|
slave_clients[#slave_clients + 1] = c
|
|
if c == client.focus then
|
|
t.top_idx = #slave_clients
|
|
end
|
|
local g = {
|
|
x = area.x + master_area_width + tabbar_x_change,
|
|
y = area.y + tabbar_y_change,
|
|
width = slave_area_width - tabbar_width_change,
|
|
height = area.height - tabbar_size_change,
|
|
}
|
|
if not dont_resize_slaves and idx ~= t.top_idx then
|
|
g = {
|
|
x = area.x + master_area_width + slave_area_width / 4,
|
|
y = area.y + tabbar_size + area.height / 4,
|
|
width = slave_area_width / 2,
|
|
height = area.height / 4 - tabbar_size,
|
|
}
|
|
end
|
|
p.geometries[c] = g
|
|
end
|
|
|
|
update_tabbar(
|
|
slave_clients,
|
|
t,
|
|
t.top_idx,
|
|
area,
|
|
master_area_width,
|
|
slave_area_width
|
|
)
|
|
end
|
|
|
|
return mylayout
|