Initial commit
This commit is contained in:
190
lib/lain/layout/cascade.lua
Normal file
190
lib/lain/layout/cascade.lua
Normal file
@@ -0,0 +1,190 @@
|
||||
--[[
|
||||
|
||||
Licensed under GNU General Public License v2
|
||||
* (c) 2014, projektile
|
||||
* (c) 2013, Luca CPZ
|
||||
* (c) 2010-2012, Peter Hofmann
|
||||
|
||||
--]]
|
||||
|
||||
local floor = math.floor
|
||||
local screen = screen
|
||||
|
||||
local cascade = {
|
||||
name = 'cascade',
|
||||
nmaster = 0,
|
||||
offset_x = 32,
|
||||
offset_y = 8,
|
||||
tile = {
|
||||
name = 'cascadetile',
|
||||
nmaster = 0,
|
||||
ncol = 0,
|
||||
mwfact = 0,
|
||||
offset_x = 5,
|
||||
offset_y = 32,
|
||||
extra_padding = 0,
|
||||
},
|
||||
}
|
||||
|
||||
local function do_cascade(p, tiling)
|
||||
local t = p.tag or screen[p.screen].selected_tag
|
||||
local wa = p.workarea
|
||||
local cls = p.clients
|
||||
|
||||
if #cls == 0 then
|
||||
return
|
||||
end
|
||||
|
||||
if not tiling then
|
||||
-- Cascade windows.
|
||||
|
||||
local num_c
|
||||
if cascade.nmaster > 0 then
|
||||
num_c = cascade.nmaster
|
||||
else
|
||||
num_c = t.master_count
|
||||
end
|
||||
|
||||
-- Opening a new window will usually force all existing windows to
|
||||
-- get resized. This wastes a lot of CPU time. So let's set a lower
|
||||
-- bound to "how_many": This wastes a little screen space but you'll
|
||||
-- get a much better user experience.
|
||||
local how_many = (#cls >= num_c and #cls) or num_c
|
||||
|
||||
local current_offset_x = cascade.offset_x * (how_many - 1)
|
||||
local current_offset_y = cascade.offset_y * (how_many - 1)
|
||||
|
||||
-- Iterate.
|
||||
for i = 1, #cls, 1 do
|
||||
local c = cls[i]
|
||||
local g = {}
|
||||
|
||||
g.x = wa.x + (how_many - i) * cascade.offset_x
|
||||
g.y = wa.y + (i - 1) * cascade.offset_y
|
||||
g.width = wa.width - current_offset_x
|
||||
g.height = wa.height - current_offset_y
|
||||
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
|
||||
p.geometries[c] = g
|
||||
end
|
||||
else
|
||||
-- Layout with one fixed column meant for a master window. Its
|
||||
-- width is calculated according to mwfact. Other clients are
|
||||
-- cascaded or "tabbed" in a slave column on the right.
|
||||
|
||||
-- (1) (2) (3) (4)
|
||||
-- +----------+---+ +----------+---+ +----------+---+ +----------+---+
|
||||
-- | | | | | 3 | | | 4 | | +---+|
|
||||
-- | | | -> | | | -> | +---++ -> | +---+|+
|
||||
-- | 1 | 2 | | 1 +---++ | 1 | 3 || | 1 +---+|+|
|
||||
-- | | | | | 2 || | +---++| | +---+|+ |
|
||||
-- | | | | | || | | 2 | | | | 2 |+ |
|
||||
-- +----------+---+ +---------+---++ +--------+---+-+ +------+---+---+
|
||||
|
||||
local mwfact
|
||||
if cascade.tile.mwfact > 0 then
|
||||
mwfact = cascade.tile.mwfact
|
||||
else
|
||||
mwfact = t.master_width_factor
|
||||
end
|
||||
|
||||
-- Make slave windows overlap main window? Do this if ncol is 1.
|
||||
local overlap_main
|
||||
if cascade.tile.ncol > 0 then
|
||||
overlap_main = cascade.tile.ncol
|
||||
else
|
||||
overlap_main = t.column_count
|
||||
end
|
||||
|
||||
-- Minimum space for slave windows? See cascade.tile.lua.
|
||||
local num_c
|
||||
if cascade.tile.nmaster > 0 then
|
||||
num_c = cascade.tile.nmaster
|
||||
else
|
||||
num_c = t.master_count
|
||||
end
|
||||
|
||||
local how_many = (#cls - 1 >= num_c and (#cls - 1)) or num_c
|
||||
|
||||
local current_offset_x = cascade.tile.offset_x * (how_many - 1)
|
||||
local current_offset_y = cascade.tile.offset_y * (how_many - 1)
|
||||
|
||||
if #cls <= 0 then
|
||||
return
|
||||
end
|
||||
|
||||
-- Main column, fixed width and height.
|
||||
local c = cls[1]
|
||||
local g = {}
|
||||
-- Rounding is necessary to prevent the rendered size of slavewid
|
||||
-- from being 1 pixel off when the result is not an integer.
|
||||
local mainwid = floor(wa.width * mwfact)
|
||||
local slavewid = wa.width - mainwid
|
||||
|
||||
if overlap_main == 1 then
|
||||
g.width = wa.width
|
||||
|
||||
-- The size of the main window may be reduced a little bit.
|
||||
-- This allows you to see if there are any windows below the
|
||||
-- main window.
|
||||
-- This only makes sense, though, if the main window is
|
||||
-- overlapping everything else.
|
||||
g.width = g.width - cascade.tile.extra_padding
|
||||
else
|
||||
g.width = mainwid
|
||||
end
|
||||
|
||||
g.height = wa.height
|
||||
g.x = wa.x
|
||||
g.y = wa.y
|
||||
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
|
||||
p.geometries[c] = g
|
||||
|
||||
-- Remaining clients stacked in slave column, new ones on top.
|
||||
if #cls <= 1 then
|
||||
return
|
||||
end
|
||||
for i = 2, #cls do
|
||||
c = cls[i]
|
||||
g = {}
|
||||
|
||||
g.width = slavewid - current_offset_x
|
||||
g.height = wa.height - current_offset_y
|
||||
|
||||
g.x = wa.x + mainwid + (how_many - (i - 1)) * cascade.tile.offset_x
|
||||
g.y = wa.y + (i - 2) * cascade.tile.offset_y
|
||||
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
|
||||
p.geometries[c] = g
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function cascade.tile.arrange(p)
|
||||
return do_cascade(p, true)
|
||||
end
|
||||
|
||||
function cascade.arrange(p)
|
||||
return do_cascade(p, false)
|
||||
end
|
||||
|
||||
return cascade
|
||||
290
lib/lain/layout/centerwork.lua
Normal file
290
lib/lain/layout/centerwork.lua
Normal file
@@ -0,0 +1,290 @@
|
||||
--[[
|
||||
|
||||
Licensed under GNU General Public License v2
|
||||
* (c) 2018, Eugene Pakhomov
|
||||
* (c) 2016, Henrik Antonsson
|
||||
* (c) 2015, Joerg Jaspert
|
||||
* (c) 2014, projektile
|
||||
* (c) 2013, Luca CPZ
|
||||
* (c) 2010-2012, Peter Hofmann
|
||||
|
||||
--]]
|
||||
|
||||
local floor = math.floor
|
||||
local max = math.max
|
||||
local mouse = mouse
|
||||
local mousegrabber = mousegrabber
|
||||
local screen = screen
|
||||
|
||||
local centerwork = {
|
||||
name = 'centerwork',
|
||||
horizontal = { name = 'centerworkh' },
|
||||
}
|
||||
|
||||
local function arrange(p, layout)
|
||||
local t = p.tag or screen[p.screen].selected_tag
|
||||
local wa = p.workarea
|
||||
local cls = p.clients
|
||||
|
||||
if #cls == 0 then
|
||||
return
|
||||
end
|
||||
|
||||
local g = {}
|
||||
|
||||
-- Main column, fixed width and height
|
||||
local mwfact = t.master_width_factor
|
||||
local mainhei = floor(wa.height * mwfact)
|
||||
local mainwid = floor(wa.width * mwfact)
|
||||
local slavewid = wa.width - mainwid
|
||||
local slaveLwid = floor(slavewid / 2)
|
||||
local slaveRwid = slavewid - slaveLwid
|
||||
local slavehei = wa.height - mainhei
|
||||
local slaveThei = floor(slavehei / 2)
|
||||
local slaveBhei = slavehei - slaveThei
|
||||
local nbrFirstSlaves = floor(#cls / 2)
|
||||
local nbrSecondSlaves = floor((#cls - 1) / 2)
|
||||
|
||||
local slaveFirstDim, slaveSecondDim = 0, 0
|
||||
|
||||
if layout.name == 'centerwork' then -- vertical
|
||||
if nbrFirstSlaves > 0 then
|
||||
slaveFirstDim = floor(wa.height / nbrFirstSlaves)
|
||||
end
|
||||
if nbrSecondSlaves > 0 then
|
||||
slaveSecondDim = floor(wa.height / nbrSecondSlaves)
|
||||
end
|
||||
|
||||
g.height = wa.height
|
||||
g.width = mainwid
|
||||
|
||||
g.x = wa.x + slaveLwid
|
||||
g.y = wa.y
|
||||
else -- horizontal
|
||||
if nbrFirstSlaves > 0 then
|
||||
slaveFirstDim = floor(wa.width / nbrFirstSlaves)
|
||||
end
|
||||
if nbrSecondSlaves > 0 then
|
||||
slaveSecondDim = floor(wa.width / nbrSecondSlaves)
|
||||
end
|
||||
|
||||
g.height = mainhei
|
||||
g.width = wa.width
|
||||
|
||||
g.x = wa.x
|
||||
g.y = wa.y + slaveThei
|
||||
end
|
||||
|
||||
g.width = max(g.width, 1)
|
||||
g.height = max(g.height, 1)
|
||||
|
||||
p.geometries[cls[1]] = g
|
||||
|
||||
-- Auxiliary clients
|
||||
if #cls <= 1 then
|
||||
return
|
||||
end
|
||||
for i = 2, #cls do
|
||||
g = {}
|
||||
local idxChecker, dimToAssign
|
||||
|
||||
local rowIndex = floor(i / 2)
|
||||
|
||||
if layout.name == 'centerwork' then
|
||||
if i % 2 == 0 then -- left slave
|
||||
g.x = wa.x
|
||||
g.y = wa.y + (rowIndex - 1) * slaveFirstDim
|
||||
g.width = slaveLwid
|
||||
|
||||
idxChecker, dimToAssign = nbrFirstSlaves, slaveFirstDim
|
||||
else -- right slave
|
||||
g.x = wa.x + slaveLwid + mainwid
|
||||
g.y = wa.y + (rowIndex - 1) * slaveSecondDim
|
||||
g.width = slaveRwid
|
||||
|
||||
idxChecker, dimToAssign = nbrSecondSlaves, slaveSecondDim
|
||||
end
|
||||
|
||||
-- if last slave in row, use remaining space for it
|
||||
if rowIndex == idxChecker then
|
||||
g.height = wa.y + wa.height - g.y
|
||||
else
|
||||
g.height = dimToAssign
|
||||
end
|
||||
else
|
||||
if i % 2 == 0 then -- top slave
|
||||
g.x = wa.x + (rowIndex - 1) * slaveFirstDim
|
||||
g.y = wa.y
|
||||
g.height = slaveThei
|
||||
|
||||
idxChecker, dimToAssign = nbrFirstSlaves, slaveFirstDim
|
||||
else -- bottom slave
|
||||
g.x = wa.x + (rowIndex - 1) * slaveSecondDim
|
||||
g.y = wa.y + slaveThei + mainhei
|
||||
g.height = slaveBhei
|
||||
|
||||
idxChecker, dimToAssign = nbrSecondSlaves, slaveSecondDim
|
||||
end
|
||||
|
||||
-- if last slave in row, use remaining space for it
|
||||
if rowIndex == idxChecker then
|
||||
g.width = wa.x + wa.width - g.x
|
||||
else
|
||||
g.width = dimToAssign
|
||||
end
|
||||
end
|
||||
|
||||
g.width = max(g.width, 1)
|
||||
g.height = max(g.height, 1)
|
||||
|
||||
p.geometries[cls[i]] = g
|
||||
end
|
||||
end
|
||||
|
||||
local function mouse_resize_handler(c, _, _, _, orientation)
|
||||
local wa = c.screen.workarea
|
||||
local mwfact = c.screen.selected_tag.master_width_factor
|
||||
local g = c:geometry()
|
||||
local offset = 0
|
||||
local cursor = 'cross'
|
||||
|
||||
local corner_coords
|
||||
|
||||
if orientation == 'vertical' then
|
||||
if g.height + 15 >= wa.height then
|
||||
offset = g.height * 0.5
|
||||
cursor = 'sb_h_double_arrow'
|
||||
elseif g.y + g.height + 15 <= wa.y + wa.height then
|
||||
offset = g.height
|
||||
end
|
||||
corner_coords = { x = wa.x + wa.width * (1 - mwfact) / 2, y = g.y + offset }
|
||||
else
|
||||
if g.width + 15 >= wa.width then
|
||||
offset = g.width * 0.5
|
||||
cursor = 'sb_v_double_arrow'
|
||||
elseif g.x + g.width + 15 <= wa.x + wa.width then
|
||||
offset = g.width
|
||||
end
|
||||
corner_coords = { y = wa.y + wa.height * (1 - mwfact) / 2, x = g.x + offset }
|
||||
end
|
||||
|
||||
mouse.coords(corner_coords)
|
||||
|
||||
local prev_coords = {}
|
||||
|
||||
mousegrabber.run(function(m)
|
||||
if not c.valid then
|
||||
return false
|
||||
end
|
||||
for _, v in ipairs(m.buttons) do
|
||||
if v then
|
||||
prev_coords = { x = m.x, y = m.y }
|
||||
local new_mwfact
|
||||
if orientation == 'vertical' then
|
||||
new_mwfact = 1 - (m.x - wa.x) / wa.width * 2
|
||||
else
|
||||
new_mwfact = 1 - (m.y - wa.y) / wa.height * 2
|
||||
end
|
||||
c.screen.selected_tag.master_width_factor = math.min(math.max(new_mwfact, 0.01), 0.99)
|
||||
return true
|
||||
end
|
||||
end
|
||||
return prev_coords.x == m.x and prev_coords.y == m.y
|
||||
end, cursor)
|
||||
end
|
||||
|
||||
function centerwork.arrange(p)
|
||||
return arrange(p, centerwork)
|
||||
end
|
||||
|
||||
function centerwork.horizontal.arrange(p)
|
||||
return arrange(p, centerwork.horizontal)
|
||||
end
|
||||
|
||||
function centerwork.mouse_resize_handler(c, corner, x, y)
|
||||
return mouse_resize_handler(c, corner, x, y, 'vertical')
|
||||
end
|
||||
|
||||
function centerwork.horizontal.mouse_resize_handler(c, corner, x, y)
|
||||
return mouse_resize_handler(c, corner, x, y, 'horizontal')
|
||||
end
|
||||
|
||||
--[[
|
||||
Make focus.byidx and swap.byidx behave more consistently with other layouts.
|
||||
--]]
|
||||
|
||||
local awful = require('awful')
|
||||
local gears = require('gears')
|
||||
local client = client
|
||||
|
||||
local function compare_position(a, b)
|
||||
if a.x == b.x then
|
||||
return a.y < b.y
|
||||
else
|
||||
return a.x < b.x
|
||||
end
|
||||
end
|
||||
|
||||
local function clients_by_position()
|
||||
local this = client.focus
|
||||
if this then
|
||||
local sorted = {}
|
||||
for _, c in ipairs(client.focus.first_tag:clients()) do
|
||||
if not c.minimized then
|
||||
sorted[#sorted + 1] = c
|
||||
end
|
||||
end
|
||||
table.sort(sorted, compare_position)
|
||||
|
||||
local idx = 0
|
||||
for i, that in ipairs(sorted) do
|
||||
if this.window == that.window then
|
||||
idx = i
|
||||
end
|
||||
end
|
||||
|
||||
if idx > 0 then
|
||||
return { sorted = sorted, idx = idx }
|
||||
end
|
||||
end
|
||||
return {}
|
||||
end
|
||||
|
||||
local function in_centerwork()
|
||||
return client.focus and client.focus.first_tag.layout.name == 'centerwork'
|
||||
end
|
||||
|
||||
centerwork.focus = {}
|
||||
|
||||
--[[
|
||||
Drop in replacements for awful.client.focus.byidx and awful.client.swap.byidx
|
||||
that behaves consistently with other layouts.
|
||||
--]]
|
||||
|
||||
function centerwork.focus.byidx(i)
|
||||
if in_centerwork() then
|
||||
local cls = clients_by_position()
|
||||
if cls.idx then
|
||||
local target = cls.sorted[gears.math.cycle(#cls.sorted, cls.idx + i)]
|
||||
awful.client.focus.byidx(0, target)
|
||||
end
|
||||
else
|
||||
awful.client.focus.byidx(i)
|
||||
end
|
||||
end
|
||||
|
||||
centerwork.swap = {}
|
||||
|
||||
function centerwork.swap.byidx(i)
|
||||
if in_centerwork() then
|
||||
local cls = clients_by_position()
|
||||
if cls.idx then
|
||||
local target = cls.sorted[gears.math.cycle(#cls.sorted, cls.idx + i)]
|
||||
client.focus:swap(target)
|
||||
end
|
||||
else
|
||||
awful.client.swap.byidx(i)
|
||||
end
|
||||
end
|
||||
|
||||
return centerwork
|
||||
19
lib/lain/layout/init.lua
Normal file
19
lib/lain/layout/init.lua
Normal file
@@ -0,0 +1,19 @@
|
||||
--[[
|
||||
|
||||
Lain
|
||||
Layouts, widgets and utilities for Awesome WM
|
||||
|
||||
Layouts section
|
||||
|
||||
Licensed under GNU General Public License v2
|
||||
* (c) 2013, Luca CPZ
|
||||
* (c) 2010-2012, Peter Hofmann
|
||||
|
||||
--]]
|
||||
|
||||
local wrequire = require('lain.helpers').wrequire
|
||||
local setmetatable = setmetatable
|
||||
|
||||
local layout = { _NAME = 'lain.layout' }
|
||||
|
||||
return setmetatable(layout, { __index = wrequire })
|
||||
312
lib/lain/layout/termfair.lua
Normal file
312
lib/lain/layout/termfair.lua
Normal file
@@ -0,0 +1,312 @@
|
||||
--[[
|
||||
|
||||
Licensed under GNU General Public License v2
|
||||
* (c) 2014, projektile
|
||||
* (c) 2013, Luca CPZ
|
||||
* (c) 2010, Nicolas Estibals
|
||||
* (c) 2010-2012, Peter Hofmann
|
||||
|
||||
--]]
|
||||
|
||||
local math = math
|
||||
local screen = screen
|
||||
local tonumber = tonumber
|
||||
|
||||
local termfair = { name = 'termfair' }
|
||||
termfair.center = { name = 'centerfair' }
|
||||
termfair.stable = { name = 'stablefair' }
|
||||
|
||||
local function do_fair(p, orientation)
|
||||
local t = p.tag or screen[p.screen].selected_tag
|
||||
local wa = p.workarea
|
||||
local cls = p.clients
|
||||
|
||||
if #cls == 0 then
|
||||
return
|
||||
end
|
||||
|
||||
-- How many vertical columns? Read from nmaster on the tag.
|
||||
local num_x = tonumber(termfair.nmaster) or t.master_count
|
||||
local ncol = tonumber(termfair.ncol) or t.column_count
|
||||
if num_x <= 2 then
|
||||
num_x = 2
|
||||
end
|
||||
if ncol <= 1 then
|
||||
ncol = 1
|
||||
end
|
||||
local width = math.floor(wa.width / num_x)
|
||||
|
||||
if orientation == 'west' then
|
||||
-- Layout with fixed number of vertical columns (read from nmaster).
|
||||
-- New windows align from left to right. When a row is full, a new
|
||||
-- one above it is created. Like this:
|
||||
|
||||
-- (1) (2) (3)
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
-- | | | | | | | | | | | |
|
||||
-- | 1 | | | -> | 1 | 2 | | -> | 1 | 2 | 3 | ->
|
||||
-- | | | | | | | | | | | |
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
|
||||
-- (4) (5) (6)
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
-- | 1 | | | | 1 | 2 | | | 1 | 2 | 3 |
|
||||
-- +---+---+---+ -> +---+---+---+ -> +---+---+---+
|
||||
-- | 2 | 3 | 4 | | 3 | 4 | 5 | | 4 | 5 | 6 |
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
|
||||
local num_y = math.max(math.ceil(#cls / num_x), ncol)
|
||||
local height = math.floor(wa.height / num_y)
|
||||
local cur_num_x = num_x
|
||||
local at_x = 0
|
||||
local at_y = 0
|
||||
|
||||
local remaining_clients = #cls
|
||||
|
||||
-- We start the first row. Left-align by limiting the number of
|
||||
-- available slots.
|
||||
if remaining_clients < num_x then
|
||||
cur_num_x = remaining_clients
|
||||
end
|
||||
|
||||
-- Iterate in reversed order.
|
||||
for i = #cls, 1, -1 do
|
||||
-- Get x and y position.
|
||||
local c = cls[i]
|
||||
local this_x = cur_num_x - at_x - 1
|
||||
local this_y = num_y - at_y - 1
|
||||
|
||||
-- Calculate geometry.
|
||||
local g = {}
|
||||
if this_x == (num_x - 1) then
|
||||
g.width = wa.width - (num_x - 1) * width
|
||||
else
|
||||
g.width = width
|
||||
end
|
||||
|
||||
if this_y == (num_y - 1) then
|
||||
g.height = wa.height - (num_y - 1) * height
|
||||
else
|
||||
g.height = height
|
||||
end
|
||||
|
||||
g.x = wa.x + this_x * width
|
||||
g.y = wa.y + this_y * height
|
||||
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
|
||||
p.geometries[c] = g
|
||||
|
||||
remaining_clients = remaining_clients - 1
|
||||
|
||||
-- Next grid position.
|
||||
at_x = at_x + 1
|
||||
if at_x == num_x then
|
||||
-- Row full, create a new one above it.
|
||||
at_x = 0
|
||||
at_y = at_y + 1
|
||||
|
||||
-- We start a new row. Left-align.
|
||||
if remaining_clients < num_x then
|
||||
cur_num_x = remaining_clients
|
||||
end
|
||||
end
|
||||
end
|
||||
elseif orientation == 'stable' then
|
||||
-- Layout with fixed number of vertical columns (read from nmaster).
|
||||
-- New windows align from left to right. When a row is full, a new
|
||||
-- one below it is created. Like this:
|
||||
|
||||
-- (1) (2) (3)
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
-- | | | | | | | | | | | |
|
||||
-- | 1 | | | -> | 1 | 2 | | -> | 1 | 2 | 3 | ->
|
||||
-- | | | | | | | | | | | |
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
|
||||
-- (4) (5) (6)
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
-- | 1 | 2 | 3 | | 1 | 2 | 3 | | 1 | 2 | 3 |
|
||||
-- +---+---+---+ +---+---+---+ +---+---+---+
|
||||
-- | 4 | | | | 4 | 5 | | | 4 | 5 | 6 |
|
||||
-- +---+---+---+ -> +---+---+---+ -> +---+---+---+
|
||||
|
||||
local num_y = math.max(math.ceil(#cls / num_x), ncol)
|
||||
local height = math.floor(wa.height / num_y)
|
||||
|
||||
for i = #cls, 1, -1 do
|
||||
-- Get x and y position.
|
||||
local c = cls[i]
|
||||
local this_x = (i - 1) % num_x
|
||||
local this_y = math.floor((i - this_x - 1) / num_x)
|
||||
|
||||
-- Calculate geometry.
|
||||
local g = {}
|
||||
if this_x == (num_x - 1) then
|
||||
g.width = wa.width - (num_x - 1) * width
|
||||
else
|
||||
g.width = width
|
||||
end
|
||||
|
||||
if this_y == (num_y - 1) then
|
||||
g.height = wa.height - (num_y - 1) * height
|
||||
else
|
||||
g.height = height
|
||||
end
|
||||
|
||||
g.x = wa.x + this_x * width
|
||||
g.y = wa.y + this_y * height
|
||||
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
|
||||
p.geometries[c] = g
|
||||
end
|
||||
elseif orientation == 'center' then
|
||||
-- Layout with fixed number of vertical columns (read from nmaster).
|
||||
-- Cols are centerded until there is nmaster columns, then windows
|
||||
-- are stacked in the slave columns, with at most ncol clients per
|
||||
-- column if possible.
|
||||
|
||||
-- with nmaster=3 and ncol=1 you'll have
|
||||
-- (1) (2) (3)
|
||||
-- +---+---+---+ +-+---+---+-+ +---+---+---+
|
||||
-- | | | | | | | | | | | | |
|
||||
-- | | 1 | | -> | | 1 | 2 | | -> | 1 | 2 | 3 | ->
|
||||
-- | | | | | | | | | | | | |
|
||||
-- +---+---+---+ +-+---+---+-+ +---+---+---+
|
||||
|
||||
-- (4) (5)
|
||||
-- +---+---+---+ +---+---+---+
|
||||
-- | | | 3 | | | 2 | 4 |
|
||||
-- + 1 + 2 +---+ -> + 1 +---+---+
|
||||
-- | | | 4 | | | 3 | 5 |
|
||||
-- +---+---+---+ +---+---+---+
|
||||
|
||||
if #cls < num_x then
|
||||
-- Less clients than the number of columns, let's center it!
|
||||
local offset_x = wa.x + (wa.width - #cls * width) / 2
|
||||
for i = 1, #cls do
|
||||
local g = { y = wa.y }
|
||||
g.width = width
|
||||
g.height = wa.height
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
g.x = offset_x + (i - 1) * width
|
||||
p.geometries[cls[i]] = g
|
||||
end
|
||||
else
|
||||
-- More clients than the number of columns, let's arrange it!
|
||||
-- Master client deserves a special treatement
|
||||
local g = {}
|
||||
g.width = wa.width - (num_x - 1) * width
|
||||
g.height = wa.height
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
g.x = wa.x
|
||||
g.y = wa.y
|
||||
p.geometries[cls[1]] = g
|
||||
|
||||
-- Treat the other clients
|
||||
|
||||
-- Compute distribution of clients among columns
|
||||
local num_y = {}
|
||||
local remaining_clients = #cls - 1
|
||||
local ncol_min = math.ceil(remaining_clients / (num_x - 1))
|
||||
|
||||
if ncol >= ncol_min then
|
||||
for i = (num_x - 1), 1, -1 do
|
||||
if (remaining_clients - i + 1) < ncol then
|
||||
num_y[i] = remaining_clients - i + 1
|
||||
else
|
||||
num_y[i] = ncol
|
||||
end
|
||||
remaining_clients = remaining_clients - num_y[i]
|
||||
end
|
||||
else
|
||||
local rem = remaining_clients % (num_x - 1)
|
||||
if rem == 0 then
|
||||
for i = 1, num_x - 1 do
|
||||
num_y[i] = ncol_min
|
||||
end
|
||||
else
|
||||
for i = 1, num_x - 1 do
|
||||
num_y[i] = ncol_min - 1
|
||||
end
|
||||
for i = 0, rem - 1 do
|
||||
num_y[num_x - 1 - i] = num_y[num_x - 1 - i] + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Compute geometry of the other clients
|
||||
local nclient = 2 -- we start with the 2nd client
|
||||
local wx = g.x + g.width
|
||||
for i = 1, (num_x - 1) do
|
||||
local height = math.floor(wa.height / num_y[i])
|
||||
local wy = wa.y
|
||||
for _ = 0, (num_y[i] - 2) do
|
||||
g = {}
|
||||
g.x = wx
|
||||
g.y = wy
|
||||
g.height = height
|
||||
g.width = width
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
p.geometries[cls[nclient]] = g
|
||||
nclient = nclient + 1
|
||||
wy = wy + height
|
||||
end
|
||||
g = {}
|
||||
g.x = wx
|
||||
g.y = wy
|
||||
g.height = wa.height - (num_y[i] - 1) * height
|
||||
g.width = width
|
||||
if g.width < 1 then
|
||||
g.width = 1
|
||||
end
|
||||
if g.height < 1 then
|
||||
g.height = 1
|
||||
end
|
||||
p.geometries[cls[nclient]] = g
|
||||
nclient = nclient + 1
|
||||
wx = wx + width
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function termfair.center.arrange(p)
|
||||
return do_fair(p, 'center')
|
||||
end
|
||||
|
||||
function termfair.stable.arrange(p)
|
||||
return do_fair(p, 'stable')
|
||||
end
|
||||
|
||||
function termfair.arrange(p)
|
||||
return do_fair(p, 'west')
|
||||
end
|
||||
|
||||
return termfair
|
||||
Reference in New Issue
Block a user