aboutsummaryrefslogtreecommitdiff
path: root/.config/awesome/lain/layout
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--.config/awesome/lain/layout/cascade.lua65
-rw-r--r--.config/awesome/lain/layout/cascadetile.lua155
-rw-r--r--.config/awesome/lain/layout/centerfair.lua147
-rw-r--r--.config/awesome/lain/layout/centerwork.lua118
-rw-r--r--.config/awesome/lain/layout/init.lua20
-rw-r--r--.config/awesome/lain/layout/termfair.lua141
-rw-r--r--.config/awesome/lain/layout/uselessfair.lua121
-rw-r--r--.config/awesome/lain/layout/uselesspiral.lua110
-rw-r--r--.config/awesome/lain/layout/uselesstile.lua230
9 files changed, 1107 insertions, 0 deletions
diff --git a/.config/awesome/lain/layout/cascade.lua b/.config/awesome/lain/layout/cascade.lua
new file mode 100644
index 0000000..cabacef
--- /dev/null
+++ b/.config/awesome/lain/layout/cascade.lua
@@ -0,0 +1,65 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local tag = require("awful.tag")
+
+local cascade =
+{
+ name = "cascade",
+ nmaster = 0,
+ offset_x = 32,
+ offset_y = 8
+}
+
+function cascade.arrange(p)
+
+ -- Cascade windows.
+
+ -- Screen.
+ local wa = p.workarea
+ local cls = p.clients
+
+ -- 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 t = tag.selected(p.screen)
+ local num_c
+ if cascade.nmaster > 0
+ then
+ num_c = cascade.nmaster
+ else
+ num_c = tag.getnmaster(t)
+ end
+
+ local how_many = #cls
+ if how_many < num_c
+ then
+ how_many = num_c
+ end
+
+ 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
+
+ c:geometry(g)
+ end
+end
+
+return cascade
diff --git a/.config/awesome/lain/layout/cascadetile.lua b/.config/awesome/lain/layout/cascadetile.lua
new file mode 100644
index 0000000..98821e3
--- /dev/null
+++ b/.config/awesome/lain/layout/cascadetile.lua
@@ -0,0 +1,155 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local tag = require("awful.tag")
+local beautiful = require("beautiful")
+local tonumber = tonumber
+
+local cascadetile =
+{
+ name = "cascadetile",
+ nmaster = 0,
+ ncol = 0,
+ mwfact = 0,
+ offset_x = 5,
+ offset_y = 32,
+ extra_padding = 0
+}
+
+function cascadetile.arrange(p)
+
+ -- 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.
+
+ -- It's a bit hard to demonstrate the behaviour with ASCII-images...
+ --
+ -- (1) (2) (3) (4)
+ -- +-----+---+ +-----+---+ +-----+---+ +-----+---+
+ -- | | | | | | | | | | | 4 |
+ -- | | | | | 2 | | | 3 | | | |
+ -- | 1 | | -> | 1 | | -> | 1 | | -> | 1 +---+
+ -- | | | | +---+ | +---+ | | 3 |
+ -- | | | | | | | | 2 | | |---|
+ -- | | | | | | | |---| | | 2 |
+ -- | | | | | | | | | | |---|
+ -- +-----+---+ +-----+---+ +-----+---+ +-----+---+
+
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width.
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ -- Screen.
+ local wa = p.workarea
+ local cls = p.clients
+
+ -- Width of main column?
+ local t = tag.selected(p.screen)
+ local mwfact
+ if cascadetile.mwfact > 0
+ then
+ mwfact = cascadetile.mwfact
+ else
+ mwfact = tag.getmwfact(t)
+ end
+
+ -- Make slave windows overlap main window? Do this if ncol is 1.
+ local overlap_main
+ if cascadetile.ncol > 0
+ then
+ overlap_main = cascadetile.ncol
+ else
+ overlap_main = tag.getncol(t)
+ end
+
+ -- Minimum space for slave windows? See cascade.lua.
+ local num_c
+ if cascadetile.nmaster > 0
+ then
+ num_c = cascadetile.nmaster
+ else
+ num_c = tag.getnmaster(t)
+ end
+
+ local how_many = #cls - 1
+ if how_many < num_c
+ then
+ how_many = num_c
+ end
+ local current_offset_x = cascadetile.offset_x * (how_many - 1)
+ local current_offset_y = cascadetile.offset_y * (how_many - 1)
+
+ if #cls > 0
+ then
+ -- Main column, fixed width and height.
+ local c = cls[#cls]
+ local g = {}
+ local mainwid = 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 - cascadetile.extra_padding
+ else
+ g.width = mainwid
+ end
+
+ g.height = wa.height
+ g.x = wa.x
+ g.y = wa.y
+ if useless_gap > 0
+ then
+ -- Reduce width once and move window to the right. Reduce
+ -- height twice, however.
+ g.width = g.width - useless_gap
+ g.height = g.height - 2 * useless_gap
+ g.x = g.x + useless_gap
+ g.y = g.y + useless_gap
+
+ -- When there's no window to the right, add an additional
+ -- gap.
+ if overlap_main == 1
+ then
+ g.width = g.width - useless_gap
+ end
+ end
+ c:geometry(g)
+
+ -- Remaining clients stacked in slave column, new ones on top.
+ if #cls > 1
+ then
+ for i = (#cls - 1),1,-1
+ 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) * cascadetile.offset_x
+ g.y = wa.y + (i - 1) * cascadetile.offset_y
+ if useless_gap > 0
+ then
+ g.width = g.width - 2 * useless_gap
+ g.height = g.height - 2 * useless_gap
+ g.x = g.x + useless_gap
+ g.y = g.y + useless_gap
+ end
+ c:geometry(g)
+ end
+ end
+ end
+end
+
+return cascadetile
diff --git a/.config/awesome/lain/layout/centerfair.lua b/.config/awesome/lain/layout/centerfair.lua
new file mode 100644
index 0000000..49b4a14
--- /dev/null
+++ b/.config/awesome/lain/layout/centerfair.lua
@@ -0,0 +1,147 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010, Nicolas Estibals
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local tag = require("awful.tag")
+local beautiful = require("beautiful")
+local math = { ceil = math.ceil,
+ floor = math.floor,
+ max = math.max }
+local tonumber = tonumber
+
+local centerfair = { name = "centerfair" }
+
+function centerfair.arrange(p)
+ -- 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 |
+ -- +---+---+---+ +---+---+---+
+
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width .
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ -- Screen.
+ local wa = p.workarea
+ local cls = p.clients
+
+ -- How many vertical columns? Read from nmaster on the tag.
+ local t = tag.selected(p.screen)
+ local num_x = centerfair.nmaster or tag.getnmaster(t)
+ local ncol = centerfair.ncol or tag.getncol(t)
+
+ local width = math.floor((wa.width-(num_x+1)*useless_gap) / num_x)
+
+ local offset_y = wa.y + useless_gap
+ if #cls < num_x
+ then
+ -- Less clients than the number of columns, let's center it!
+ local offset_x = wa.x + useless_gap + (wa.width - #cls*width - (#cls+1)*useless_gap) / 2
+ local g = {}
+ g.width = width
+ g.height = wa.height - 2*useless_gap - 2
+ g.y = offset_y
+ for i = 1, #cls do
+ g.x = offset_x + (i - 1) * (width + useless_gap + 2)
+ cls[i]:geometry(g)
+ end
+ else
+ -- More clients than the number of columns, let's arrange it!
+ local offset_x = wa.x
+ if useless_gap > 0 then
+ offset_x = offset_x
+ end
+
+ -- Master client deserves a special treatement
+ local g = {}
+ g.width = wa.width - (num_x-1)*width -num_x*useless_gap - 2
+ g.height = wa.height - 2*useless_gap - 2
+ g.x = offset_x + useless_gap
+ g.y = offset_y
+ cls[1]:geometry(g)
+
+ -- Treat the other clients
+
+ -- Compute distribution of clients among columns
+ local num_y ={}
+ do
+ 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
+ end
+
+ -- Compute geometry of the other clients
+ local nclient = 2
+ g.x = g.x + g.width+useless_gap + 2
+ g.width = width
+
+ if useless_gap > 0 then
+ g.width = g.width - useless_gap/2 - 2
+ end
+
+ for i = 1, (num_x-1) do
+ to_remove = 2
+ g.height = math.floor((wa.height-useless_gap)/num_y[i])
+ g.y = offset_y
+ for j = 0, (num_y[i]-2) do
+ cls[nclient]:geometry(g)
+ nclient = nclient + 1
+ g.y = g.y + g.height+useless_gap + 2
+ to_remove = to_remove + 2
+ end
+ g.height = wa.height - num_y[i]*useless_gap - (num_y[i]-1)*g.height - useless_gap - to_remove
+ cls[nclient]:geometry(g)
+ nclient = nclient + 1
+ g.x = g.x+g.width+useless_gap + 2
+ end
+ end
+end
+
+return centerfair
diff --git a/.config/awesome/lain/layout/centerwork.lua b/.config/awesome/lain/layout/centerwork.lua
new file mode 100644
index 0000000..b8175ea
--- /dev/null
+++ b/.config/awesome/lain/layout/centerwork.lua
@@ -0,0 +1,118 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local awful = require("awful")
+local beautiful = require("beautiful")
+local tonumber = tonumber
+local math = { floor = math.floor }
+
+local centerwork =
+{
+ name = "centerwork",
+ top_left = 0,
+ top_right = 1,
+ bottom_left = 2,
+ bottom_right = 3
+}
+
+function centerwork.arrange(p)
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width .
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ -- Screen.
+ local wa = p.workarea
+ local cls = p.clients
+
+ -- Width of main column?
+ local t = awful.tag.selected(p.screen)
+ local mwfact = awful.tag.getmwfact(t)
+
+ if #cls > 0
+ then
+ -- Main column, fixed width and height.
+ local c = cls[#cls]
+ local g = {}
+ local mainwid = math.floor(wa.width * mwfact)
+ local slavewid = wa.width - mainwid
+ local slaveLwid = math.floor(slavewid / 2)
+ local slaveRwid = slavewid - slaveLwid
+ local slaveThei = math.floor(wa.height / 2)
+ local slaveBhei = wa.height - slaveThei
+
+ g.height = wa.height - 2 * useless_gap
+ g.width = mainwid
+ g.x = wa.x + slaveLwid
+ g.y = wa.y + useless_gap
+
+ c:geometry(g)
+
+ -- Auxiliary windows.
+ if #cls > 1
+ then
+ local at = 0
+ for i = (#cls - 1),1,-1
+ do
+ -- It's all fixed. If there are more than 5 clients,
+ -- those additional clients will float. This is
+ -- intentional.
+ if at == 4
+ then
+ break
+ end
+
+ c = cls[i]
+ g = {}
+
+ if at == centerwork.top_left
+ then
+ -- top left
+ g.x = wa.x + useless_gap
+ g.y = wa.y + useless_gap
+ g.width = slaveLwid - 2 * useless_gap
+ g.height = slaveThei - useless_gap
+ elseif at == centerwork.top_right
+ then
+ -- top right
+ g.x = wa.x + slaveLwid + mainwid + useless_gap
+ g.y = wa.y + useless_gap
+ g.width = slaveRwid - 2 * useless_gap
+ g.height = slaveThei - useless_gap
+ elseif at == centerwork.bottom_left
+ then
+ -- bottom left
+ g.x = wa.x + useless_gap
+ g.y = wa.y + slaveThei + useless_gap
+ g.width = slaveLwid - 2 * useless_gap
+ g.height = slaveBhei - 2 * useless_gap
+ elseif at == centerwork.bottom_right
+ then
+ -- bottom right
+ g.x = wa.x + slaveLwid + mainwid + useless_gap
+ g.y = wa.y + slaveThei + useless_gap
+ g.width = slaveRwid - 2 * useless_gap
+ g.height = slaveBhei - 2 * useless_gap
+ end
+
+ c:geometry(g)
+
+ at = at + 1
+ end
+
+ -- Set remaining clients to floating.
+ for i = (#cls - 1 - 4),1,-1
+ do
+ c = cls[i]
+ awful.client.floating.set(c, true)
+ end
+ end
+ end
+end
+
+return centerwork
diff --git a/.config/awesome/lain/layout/init.lua b/.config/awesome/lain/layout/init.lua
new file mode 100644
index 0000000..d79679a
--- /dev/null
+++ b/.config/awesome/lain/layout/init.lua
@@ -0,0 +1,20 @@
+
+--[[
+
+ Lain
+ Layouts, widgets and utilities for Awesome WM
+
+ Layouts section
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local wrequire = require("lain.helpers").wrequire
+local setmetatable = setmetatable
+
+local layout = { _NAME = "lain.layout" }
+
+return setmetatable(layout, { __index = wrequire })
diff --git a/.config/awesome/lain/layout/termfair.lua b/.config/awesome/lain/layout/termfair.lua
new file mode 100644
index 0000000..89a44bb
--- /dev/null
+++ b/.config/awesome/lain/layout/termfair.lua
@@ -0,0 +1,141 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local tag = require("awful.tag")
+local beautiful = require("beautiful")
+local math = { ceil = math.ceil,
+ floor = math.floor,
+ max = math.max }
+local tonumber = tonumber
+
+local termfair = { name = "termfair" }
+
+function termfair.arrange(p)
+ -- Layout with fixed number of vertical columns (read from nmaster).
+ -- New windows align from left to right. When a row is full, a now
+ -- one above it is created. Like this:
+
+ -- (1) (2) (3)
+ -- +---+---+---+ +---+---+---+ +---+---+---+
+ -- | | | | | | | | | | | |
+ -- | 1 | | | -> | 2 | 1 | | -> | 3 | 2 | 1 | ->
+ -- | | | | | | | | | | | |
+ -- +---+---+---+ +---+---+---+ +---+---+---+
+
+ -- (4) (5) (6)
+ -- +---+---+---+ +---+---+---+ +---+---+---+
+ -- | 4 | | | | 5 | 4 | | | 6 | 5 | 4 |
+ -- +---+---+---+ -> +---+---+---+ -> +---+---+---+
+ -- | 3 | 2 | 1 | | 3 | 2 | 1 | | 3 | 2 | 1 |
+ -- +---+---+---+ +---+---+---+ +---+---+---+
+
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width.
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ -- Screen.
+ local wa = p.workarea
+ local cls = p.clients
+
+ -- How many vertical columns?
+ local t = tag.selected(p.screen)
+ local num_x = termfair.nmaster or tag.getnmaster(t)
+
+ -- Do at least "desired_y" rows.
+ local desired_y = termfair.ncol or tag.getncol(t)
+
+ if #cls > 0
+ then
+ local num_y = math.max(math.ceil(#cls / num_x), desired_y)
+ local cur_num_x = num_x
+ local at_x = 0
+ local at_y = 0
+ local remaining_clients = #cls
+ local width = math.floor(wa.width / num_x)
+ local height = math.floor(wa.height / num_y)
+
+ -- 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
+
+ -- Calc 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 useless_gap > 0
+ then
+ -- Top and left clients are shrinked by two steps and
+ -- get moved away from the border. Other clients just
+ -- get shrinked in one direction.
+
+ gap_factor = (useless_gap / 100) * 2
+
+ if this_x == 0
+ then
+ g.width = g.width - (2 + gap_factor) * useless_gap
+ g.x = g.x + useless_gap
+ else
+ g.width = g.width - (1 + gap_factor) * useless_gap
+ end
+
+ if this_y == 0
+ then
+ g.height = g.height - (2 + gap_factor) * useless_gap
+ g.y = g.y + useless_gap
+ else
+ g.height = g.height - (1 + gap_factor) * useless_gap
+ end
+ end
+ c:geometry(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
+ end
+end
+
+return termfair
diff --git a/.config/awesome/lain/layout/uselessfair.lua b/.config/awesome/lain/layout/uselessfair.lua
new file mode 100644
index 0000000..6aa6666
--- /dev/null
+++ b/.config/awesome/lain/layout/uselessfair.lua
@@ -0,0 +1,121 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2012, Josh Komoroske
+ * (c) 2010-2012, Peter Hofmann
+
+--]]
+
+local beautiful = require("beautiful")
+local ipairs = ipairs
+local math = { ceil = math.ceil, sqrt = math.sqrt }
+local tonumber = tonumber
+
+local uselessfair = {}
+
+local function fair(p, orientation)
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width.
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ local wa = p.workarea
+ local cls = p.clients
+
+ if #cls > 0 then
+ local cells = math.ceil(math.sqrt(#cls))
+ local strips = math.ceil(#cls / cells)
+
+ local cell = 0
+ local strip = 0
+ for k, c in ipairs(cls) do
+ local g = {}
+ -- Save actual grid index for use in the useless_gap
+ -- routine.
+ local this_x = 0
+ local this_y = 0
+ if ( orientation == "east" and #cls > 2 )
+ or ( orientation == "south" and #cls <= 2 ) then
+ if #cls < (strips * cells) and strip == strips - 1 then
+ g.width = wa.width / (cells - ((strips * cells) - #cls))
+ else
+ g.width = wa.width / cells
+ end
+ g.height = wa.height / strips
+
+ this_x = cell
+ this_y = strip
+
+ g.x = wa.x + cell * g.width
+ g.y = wa.y + strip * g.height
+
+ else
+ if #cls < (strips * cells) and strip == strips - 1 then
+ g.height = wa.height / (cells - ((strips * cells) - #cls))
+ else
+ g.height = wa.height / cells
+ end
+ g.width = wa.width / strips
+
+ this_x = strip
+ this_y = cell
+
+ g.x = wa.x + strip * g.width
+ g.y = wa.y + cell * g.height
+ end
+
+ -- Useless gap.
+ if useless_gap > 0
+ then
+ -- Top and left clients are shrinked by two steps and
+ -- get moved away from the border. Other clients just
+ -- get shrinked in one direction.
+
+ gap_factor = (useless_gap / 100) * 2
+
+ if this_x == 0
+ then
+ g.width = g.width - (2 + gap_factor) * useless_gap
+ g.x = g.x + useless_gap
+ else
+ g.width = g.width - (1 + gap_factor) * useless_gap
+ end
+
+ if this_y == 0
+ then
+ g.height = g.height - (2 + gap_factor) * useless_gap
+ g.y = g.y + useless_gap
+ else
+ g.height = g.height - (1 + gap_factor) * useless_gap
+ end
+ end
+ -- End of useless gap.
+
+ c:geometry(g)
+
+ cell = cell + 1
+ if cell == cells then
+ cell = 0
+ strip = strip + 1
+ end
+ end
+ end
+end
+
+--- Horizontal fair layout.
+-- @param screen The screen to arrange.
+uselessfair.horizontal = {}
+uselessfair.horizontal.name = "uselessfairh"
+function uselessfair.horizontal.arrange(p)
+ return fair(p, "east")
+end
+
+-- Vertical fair layout.
+-- @param screen The screen to arrange.
+uselessfair.name = "uselessfair"
+function uselessfair.arrange(p)
+ return fair(p, "south")
+end
+
+return uselessfair
diff --git a/.config/awesome/lain/layout/uselesspiral.lua b/.config/awesome/lain/layout/uselesspiral.lua
new file mode 100644
index 0000000..3164c75
--- /dev/null
+++ b/.config/awesome/lain/layout/uselesspiral.lua
@@ -0,0 +1,110 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2009 Uli Schlachter
+ * (c) 2008 Julien Danjolu
+
+--]]
+
+local beautiful = require("beautiful")
+local ipairs = ipairs
+local tonumber = tonumber
+
+local uselesspiral = {}
+
+local function spiral(p, spiral)
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width.
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ local wa = p.workarea
+ local cls = p.clients
+ local n = #cls
+
+ local static_wa = wa
+
+ for k, c in ipairs(cls) do
+ if k < n then
+ if k % 2 == 0 then
+ wa.height = wa.height / 2
+ else
+ wa.width = wa.width / 2
+ end
+ end
+
+ if k % 4 == 0 and spiral then
+ wa.x = wa.x - wa.width
+ elseif k % 2 == 0 or
+ (k % 4 == 3 and k < n and spiral) then
+ wa.x = wa.x + wa.width
+ end
+
+ if k % 4 == 1 and k ~= 1 and spiral then
+ wa.y = wa.y - wa.height
+ elseif k % 2 == 1 and k ~= 1 or
+ (k % 4 == 0 and k < n and spiral) then
+ wa.y = wa.y + wa.height
+ end
+
+ local wa2 = {}
+ wa2.x = wa.x
+ wa2.y = wa.y
+ wa2.height = wa.height
+ wa2.width = wa.width
+
+ -- Useless gap.
+ if useless_gap > 0
+ then
+ -- Top and left clients are shrinked by two steps and
+ -- get moved away from the border. Other clients just
+ -- get shrinked in one direction.
+
+ top = false
+ left = false
+
+ gap_factor = (useless_gap / 100) * 2
+
+ if wa2.y == static_wa.y then
+ top = true
+ end
+
+ if wa2.x == static_wa.x then
+ left = true
+ end
+
+ if top then
+ wa2.height = wa2.height - (2 + gap_factor) * useless_gap
+ wa2.y = wa2.y + useless_gap
+ else
+ wa2.height = wa2.height - (1 + gap_factor) * useless_gap
+ end
+
+ if left then
+ wa2.width = wa2.width - (2 + gap_factor) * useless_gap
+ wa2.x = wa2.x + useless_gap
+ else
+ wa2.width = wa2.width - (1 + gap_factor) * useless_gap
+ end
+ end
+ -- End of useless gap.
+
+ c:geometry(wa2)
+ end
+end
+
+--- Dwindle layout
+uselesspiral.dwindle = {}
+uselesspiral.dwindle.name = "uselessdwindle"
+function uselesspiral.dwindle.arrange(p)
+ return spiral(p, false)
+end
+
+--- Spiral layout
+uselesspiral.name = "uselesspiral"
+function uselesspiral.arrange(p)
+ return spiral(p, true)
+end
+
+return uselesspiral
diff --git a/.config/awesome/lain/layout/uselesstile.lua b/.config/awesome/lain/layout/uselesstile.lua
new file mode 100644
index 0000000..e496500
--- /dev/null
+++ b/.config/awesome/lain/layout/uselesstile.lua
@@ -0,0 +1,230 @@
+
+--[[
+
+ Licensed under GNU General Public License v2
+ * (c) 2013, Luke Bonham
+ * (c) 2009 Donald Ephraim Curtis
+ * (c) 2008 Julien Danjolu
+
+--]]
+
+local tag = require("awful.tag")
+local beautiful = require("beautiful")
+local ipairs = ipairs
+local math = { floor = math.floor,
+ max = math.max,
+ min = math.min }
+local tonumber = tonumber
+
+local uselesstile = {}
+
+local function tile_group(cls, wa, orientation, fact, group)
+ -- A useless gap (like the dwm patch) can be defined with
+ -- beautiful.useless_gap_width .
+ local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+
+ -- get our orientation right
+ local height = "height"
+ local width = "width"
+ local x = "x"
+ local y = "y"
+ if orientation == "top" or orientation == "bottom" then
+ height = "width"
+ width = "height"
+ x = "y"
+ y = "x"
+ end
+
+ -- make this more generic (not just width)
+ available = wa[width] - (group.coord - wa[x])
+
+ -- find our total values
+ local total_fact = 0
+ local min_fact = 1
+ local size = group.size
+ for c = group.first,group.last do
+ -- determine the width/height based on the size_hint
+ local i = c - group.first +1
+ local size_hints = cls[c].size_hints
+ local size_hint = size_hints["min_"..width] or size_hints["base_"..width] or 0
+ size_hint = size_hint + cls[c].border_width*2
+ size = math.max(size_hint, size)
+
+ -- calculate the height
+ if not fact[i] then
+ fact[i] = min_fact
+ else
+ min_fact = math.min(fact[i],min_fact)
+ end
+ total_fact = total_fact + fact[i]
+ end
+ size = math.min(size, available)
+
+ local coord = wa[y]
+ local geom = {}
+ local used_size = 0
+ local unused = wa[height]
+ local stat_coord = wa[x]
+ --stat_coord = size
+ for c = group.first,group.last do
+ local i = c - group.first +1
+ geom[width] = size
+ geom[height] = math.floor(unused * fact[i] / total_fact)
+ geom[x] = group.coord
+ geom[y] = coord
+
+ coord = coord + geom[height]
+ unused = unused - geom[height]
+ total_fact = total_fact - fact[i]
+ used_size = math.max(used_size, geom[width])
+
+ -- Useless gap
+ if useless_gap > 0
+ then
+ -- Top and left clients are shrinked by two steps and
+ -- get moved away from the border. Other clients just
+ -- get shrinked in one direction.
+
+ top = false
+ left = false
+
+ gap_factor = (useless_gap / 100) * 2
+
+ if geom[y] == wa[y] then
+ top = true
+ end
+
+ if geom[x] == 0 or geom[x] == wa[x] then
+ left = true
+ end
+
+ if top then
+ geom[height] = geom[height] - (2 + gap_factor) * useless_gap
+ geom[y] = geom[y] + useless_gap
+ else
+ geom[height] = geom[height] - (1 + gap_factor) * useless_gap
+ end
+
+ if left then
+ geom[width] = geom[width] - (2 + gap_factor) * useless_gap
+ geom[x] = geom[x] + useless_gap
+ else
+ geom[width] = geom[width] - (1 + gap_factor) * useless_gap
+ end
+ end
+ -- End of useless gap.
+
+ geom = cls[c]:geometry(geom)
+ end
+
+ return used_size
+end
+
+local function tile(param, orientation)
+ local t = tag.selected(param.screen)
+ orientation = orientation or "right"
+
+ -- this handles are different orientations
+ local height = "height"
+ local width = "width"
+ local x = "x"
+ local y = "y"
+ if orientation == "top" or orientation == "bottom" then
+ height = "width"
+ width = "height"
+ x = "y"
+ y = "x"
+ end
+
+ local cls = param.clients
+ local nmaster = math.min(tag.getnmaster(t), #cls)
+ local nother = math.max(#cls - nmaster,0)
+
+ local mwfact = tag.getmwfact(t)
+ local wa = param.workarea
+ local ncol = tag.getncol(t)
+
+ local data = tag.getdata(t).windowfact
+
+ if not data then
+ data = {}
+ tag.getdata(t).windowfact = data
+ end
+
+ local coord = wa[x]
+ local place_master = true
+ if orientation == "left" or orientation == "top" then
+ -- if we are on the left or top we need to render the other windows first
+ place_master = false
+ end
+
+ -- this was easier than writing functions because there is a lot of data we need
+ for d = 1,2 do
+ if place_master and nmaster > 0 then
+ local size = wa[width]
+ if nother > 0 then
+ size = math.min(wa[width] * mwfact, wa[width] - (coord - wa[x]))
+ end
+ if not data[0] then
+ data[0] = {}
+ end
+ coord = coord + tile_group(cls, wa, orientation, data[0], {first=1, last=nmaster, coord = coord, size = size})
+ end
+
+ if not place_master and nother > 0 then
+ local last = nmaster
+
+ -- we have to modify the work area size to consider left and top views
+ local wasize = wa[width]
+ if nmaster > 0 and (orientation == "left" or orientation == "top") then
+ wasize = wa[width] - wa[width]*mwfact
+ end
+ for i = 1,ncol do
+ -- Try to get equal width among remaining columns
+ local size = math.min( (wasize - (coord - wa[x])) / (ncol - i + 1) )
+ local first = last + 1
+ last = last + math.floor((#cls - last)/(ncol - i + 1))
+ -- tile the column and update our current x coordinate
+ if not data[i] then
+ data[i] = {}
+ end
+ coord = coord + tile_group(cls, wa, orientation, data[i], { first = first, last = last, coord = coord, size = size })
+ end
+ end
+ place_master = not place_master
+ end
+
+end
+
+uselesstile.right = {}
+uselesstile.right.name = "uselesstile"
+uselesstile.right.arrange = tile
+
+--- The main tile algo, on left.
+-- @param screen The screen number to tile.
+uselesstile.left = {}
+uselesstile.left.name = "uselesstileleft"
+function uselesstile.left.arrange(p)
+ return tile(p, "left")
+end
+
+--- The main tile algo, on bottom.
+-- @param screen The screen number to tile.
+uselesstile.bottom = {}
+uselesstile.bottom.name = "uselesstilebottom"
+function uselesstile.bottom.arrange(p)
+ return tile(p, "bottom")
+end
+
+--- The main tile algo, on top.
+-- @param screen The screen number to tile.
+uselesstile.top = {}
+uselesstile.top.name = "uselesstiletop"
+function uselesstile.top.arrange(p)
+ return tile(p, "top")
+end
+
+uselesstile.arrange = uselesstile.right.arrange
+uselesstile.name = uselesstile.right.name
+
+return uselesstile