root/dotfiles
1
0
Fork 0
Code Issues 7 Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Matthias
2022-12-24 21:58:57 +01:00
commit 4c4a94857e
546 changed files with 13350 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
.config/awesome/lain/layout/cascade.lua Normal file
View File

@@ -0,0 +1,172 @@
--[[
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

276
.config/awesome/lain/layout/centerwork.lua Normal file
View File

@@ -0,0 +1,276 @@
--[[
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 * .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 * .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
.config/awesome/lain/layout/init.lua Normal file
View 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 })

282
.config/awesome/lain/layout/termfair.lua Normal file
View File

@@ -0,0 +1,282 @@
--[[
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