Merge branch 'worron-master'

layout/uselessfair.lua

@@ -2,7 +2,7 @@
 --[[
 
      Licensed under GNU General Public License v2
-      * (c) 2014,      projektile                 
+      * (c) 2014,      projektile, worron
       * (c) 2013,      Luke Bonham
       * (c) 2012,      Josh Komoroske
       * (c) 2010-2012, Peter Hofmann
@@ -11,111 +11,98 @@
 
 local beautiful = require("beautiful")
 local ipairs    = ipairs
-local math      = { ceil = math.ceil, sqrt = math.sqrt }
+local math      = { ceil = math.ceil, sqrt = math.sqrt, floor = math.floor, max = math.max }
 local tonumber  = tonumber
 
 local uselessfair = {}
 
+-- Transformation functions
+local function swap(geometry)
+    return { x = geometry.y, y = geometry.x, width = geometry.height, height = geometry.width }
+end
+
+-- Client geometry correction depending on useless gap and window border
+local function size_correction(c, geometry, useless_gap)
+    geometry.width  = math.max(geometry.width  - 2 * c.border_width - useless_gap, 1)
+    geometry.height = math.max(geometry.height - 2 * c.border_width - useless_gap, 1)
+    geometry.x = geometry.x + useless_gap / 2
+    geometry.y = geometry.y + useless_gap / 2
+end
+
+-- Main tiling function
 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
-    if useless_gap < 0 then useless_gap = 0 end
 
-    -- A global border can be defined with
+    -- Theme vars
-    -- beautiful.global_border_width.
+    local useless_gap = beautiful.useless_gap_width or 0
-    local global_border = tonumber(beautiful.global_border_width) or 0
+    local global_border = beautiful.global_border_width or 0
-    if global_border < 0 then global_border = 0 end
 
-    -- Themes border width requires an offset.
+    -- Aliases
-    local bw = tonumber(beautiful.border_width) or 0
-
-    -- get our orientation right.
     local wa = p.workarea
     local cls = p.clients
 
-    wa.height = wa.height - ((global_border * 2) + (bw * 2))
+    -- Nothing to tile here
-    wa.width = wa.width - ((global_border * 2) + (bw * 2))
+    if #cls == 0 then return end
 
-    if #cls > 0 then
+    -- Workarea size correction depending on useless gap and global border
-        local cells = math.ceil(math.sqrt(#cls))
+    wa.height = wa.height - 2 * global_border - useless_gap
-        local strips = math.ceil(#cls / cells)
+    wa.width  = wa.width -  2 * global_border - useless_gap
+    wa.x = wa.x + useless_gap / 2 + global_border
+    wa.y = wa.y + useless_gap / 2 + global_border
 
-        local cell = 0
+    -- Geometry calculation
-        local strip = 0
+    local row, col = 0, 0
-        for k, c in ipairs(cls) do
+
+    local rows = math.ceil(math.sqrt(#cls))
+    local cols = math.ceil(#cls / rows)
+
+    for i, c in ipairs(cls) do
         local g = {}
-            -- Save actual grid index for use in the useless_gap
+
-            -- routine.
+        -- find tile orientation for current client and swap geometry if need
-            local this_x = 0
+        local need_swap = (orientation == "east" and #cls <= 2) or (orientation == "south" and #cls > 2)
-            local this_y = 0
+        local area = need_swap and swap(wa) or wa
-            if ( orientation == "east" and #cls > 2 )
+
-            or ( orientation == "south" and #cls <= 2 ) then
+        -- calculate geometry
-                if #cls < (strips * cells) and strip == strips - 1 then
+        if #cls < (cols * rows) and row == cols - 1 then
-                    g.width = wa.width / (cells - ((strips * cells) - #cls))
+            g.width = area.width / (rows - ((cols * rows) - #cls))
         else
-                    g.width = wa.width / cells
+            g.width = area.width / rows
-                end
-                g.height = wa.height / strips
-
-                this_x = cell
-                this_y = strip
-
-                g.x = wa.x + cell * g.width + global_border
-                g.y = wa.y + strip * g.height + global_border
-
-            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 + global_border
-                g.y = wa.y + cell * g.height + global_border
-
         end
 
-            -- Useless gap.
+        g.height = area.height / cols
-            if useless_gap > 0
+        g.x = area.x + col * g.width
-            then
+        g.y = area.y + row * g.height
-                -- All clients tile evenly.
-                g.width = g.width - useless_gap
-                g.x = g.x + (useless_gap / 2)
-                g.height = g.height - useless_gap
-                g.y = g.y + (useless_gap / 2)
 
-            end
+        -- turn back to real if geometry was swapped
-            -- End of useless gap.
+        if need_swap then g = swap(g) end
 
+        -- window size correction depending on useless gap and window border
+        size_correction(c, g, useless_gap)
+
+        -- set geometry
         c:geometry(g)
 
-            cell = cell + 1
+        -- update tile grid coordinates
-            if cell == cells then
+        col = i % rows
-                cell = 0
+        row = math.floor(i / rows)
-                strip = strip + 1
-            end
-        end
     end
 end
 
---- Horizontal fair layout.
+-- Layout constructor
--- @param screen The screen to arrange.
+local function construct_layout(name, direction)
-uselessfair.horizontal = {}
+    return {
-uselessfair.horizontal.name = "uselessfairh"
+        name = name,
-function uselessfair.horizontal.arrange(p)
+        -- @p screen The screen number to tile
-    return fair(p, "east")
+        arrange = function(p) return fair(p, direction) end
+    }
 end
 
--- Vertical fair layout.
+-- Build layouts with different tile direction
--- @param screen The screen to arrange.
+uselessfair.vertical   = construct_layout("uselessfair", "south")
-uselessfair.name = "uselessfair"
+uselessfair.horizontal = construct_layout("uselessfairh", "east")
-function uselessfair.arrange(p)
+
-    return fair(p, "south")
+-- Module aliase
-end
+uselessfair.arrange = uselessfair.vertical.arrange
+uselessfair.name = uselessfair.vertical.name
 
 return uselessfair

layout/uselesstile.lua

@@ -2,7 +2,7 @@
 --[[
 
      Licensed under GNU General Public License v2
-      * (c) 2014       projektile                 
+      * (c) 2014       projektile, worron
       * (c) 2013       Luke Bonham
       * (c) 2009       Donald Ephraim Curtis
       * (c) 2008       Julien Danjolu
@@ -13,227 +13,180 @@ local tag       = require("awful.tag")
 local beautiful = require("beautiful")
 local ipairs    = ipairs
 local math      = { floor = math.floor,
+                    ceil  = math.ceil,
                     max   = math.max,
                     min   = math.min }
 local tonumber  = tonumber
 
 local uselesstile = {}
 
-local function tile_group(cls, wa, orientation, fact, group)
+-- Transformation functions
-    -- A useless gap (like the dwm patch) can be defined with
+local function flip(canvas, geometry)
-    -- beautiful.useless_gap_width .
+    return {
-    local useless_gap = tonumber(beautiful.useless_gap_width) or 0
+        -- vertical only
-    if useless_gap < 0 then useless_gap = 0 end
+        x = 2 * canvas.x + canvas.width - geometry.x - geometry.width,
-
+        y = geometry.y,
-    -- A global border can be defined with
+        width = geometry.width,
-    -- beautiful.global_border_width
+        height = geometry.height
-    local global_border = tonumber(beautiful.global_border_width) or 0
+    }
-    if global_border < 0 then global_border = 0 end
-
-    -- Themes border width requires an offset
-    local bw = tonumber(beautiful.border_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)
-    --if for top
-    available = wa[width] - (group.coord - wa[x]) -- it's truly not here
-
-    -- 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 - global_border))
-    local coord = wa[y]
-    local geom = {}
-    local used_size = 0
-    local unused = wa[height] - (global_border * 2)
-    local stat_coord = wa[x]
-    --stat_coord = size
-    for c = group.first,group.last do
-        local i = c - group.first +1
-        geom[width] = size - global_border - (bw * 2)
-        geom[height] = math.floor(unused * fact[i] / total_fact) - (bw * 2)
-        geom[x] = group.coord + global_border
-        geom[y] = coord + global_border
-
-        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
-
-            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 * useless_gap)
-                geom[y] = geom[y] + useless_gap
-            else
-                geom[height] = geom[height] - useless_gap
-            end
-
-            if left then
-                geom[width] = geom[width] - (2 * useless_gap)
-                geom[x] = geom[x] + useless_gap
-            else
-                geom[width] = geom[width] - useless_gap
-            end
-        end
-        -- End of useless gap.
-
-        geom = cls[c]:geometry(geom)
-    end
-
-    return used_size
 end
 
-local function tile(param, orientation)
+local function swap(geometry)
-    local t = tag.selected(param.screen)
+    return { x = geometry.y, y = geometry.x, width = geometry.height, height = geometry.width }
-    orientation = orientation or "right"
+end
 
-    -- this handles are different orientations
+-- Find geometry for column/row tiling
-    local height = "height"
+local function cut_area(wa, total, index, is_horizontal)
-    local width = "width"
+    local wa = is_horizontal and swap(wa) or wa
-    local x = "x"
+    local height = wa.height / total
-    local y = "y"
+
-    if orientation == "top" or orientation == "bottom" then
+    local area = {
-        height = "width"
+        x = wa.x,
-        width = "height"
+        y = wa.y + (index - 1) * height,
-        x = "y"
+        width = wa.width,
-        y = "x"
+        height = height
+    }
+
+    if is_horizontal then area = swap(area) end
+
+    return area
+end
+
+-- Client geometry correction depending on useless gap and window border
+local function size_correction(c, geometry, useless_gap)
+    geometry.width  = math.max(geometry.width  - 2 * c.border_width - useless_gap, 1)
+    geometry.height = math.max(geometry.height - 2 * c.border_width - useless_gap, 1)
+    geometry.x = geometry.x + useless_gap / 2
+    geometry.y = geometry.y + useless_gap / 2
+end
+
+-- Tile group of clients in given area
+-- @canvas need for proper transformation only
+local function tile_column(canvas, area, list, useless_gap, transformation)
+    for i, c in ipairs(list) do
+        local g = cut_area(area, #list, i)
+
+        -- swap workarea dimensions
+        if transformation.flip then g = flip(canvas, g) end
+        if transformation.swap then g = swap(g) end
+
+        -- useless gap and border correction
+        size_correction(c, g, useless_gap)
+
+        c:geometry(g)
     end
+end
 
-    local cls = param.clients
+--Main tile function
+local function tile(p, orientation)
+
+    -- Theme vars
+    local useless_gap = beautiful.useless_gap_width or 0
+    local global_border = beautiful.global_border_width or 0
+
+    -- Aliases
+    local wa = p.workarea
+    local cls = p.clients
+    local t = tag.selected(p.screen)
+
+    -- Nothing to tile here
+    if #cls == 0 then return end
+
+    -- Get tag prop
     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 nmaster == 0 then
-
+        mwfact = 0
-    if not data then
+    elseif nmaster == #cls then
-        data = {}
+        mwfact = 1
-        tag.getdata(t).windowfact = data
     end
 
-    local coord = wa[x]
+    -- Workarea size correction depending on useless gap and global border
-    local place_master = true
+    wa.height = wa.height - 2 * global_border - useless_gap
-    if orientation == "left" or orientation == "top" then
+    wa.width  = wa.width -  2 * global_border - useless_gap
-        -- if we are on the left or top we need to render the other windows first
+    wa.x = wa.x + useless_gap / 2 + global_border
-        place_master = false
+    wa.y = wa.y + useless_gap / 2 + global_border
+
+    -- Find which transformation we need for given orientation
+    local transformation = {
+        swap = orientation == 'top' or orientation == 'bottom',
+        flip = orientation == 'left' or orientation == 'top'
+    }
+
+    -- Swap workarea dimensions if orientation vertical
+    if transformation.swap then wa = swap(wa) end
+
+    -- Split master and other windows
+    local cls_master, cls_other = {}, {}
+
+    for i, c in ipairs(cls) do
+        if i <= nmaster then
+            table.insert(cls_master, c)
+        else
+            table.insert(cls_other, c)
+        end
     end
 
-    -- this was easier than writing functions because there is a lot of data we need
+    -- Tile master windows
-    for d = 1,2 do
+    local master_area = {
-        if place_master and nmaster > 0 then
+        x = wa.x,
-            local size = wa[width]
+        y = wa.y,
-            if nother > 0 then
+        width  = nmaster > 0 and wa.width * mwfact or 0,
-                size = math.min(wa[width] * mwfact, wa[width] - (coord - wa[x]))
+        height = wa.height
-            end
+    }
-            if not data[0] then
+
-                data[0] = {}
+    tile_column(wa, master_area, cls_master, useless_gap, transformation)
-            end
+
-            coord = coord + tile_group(cls, wa, orientation, data[0], {first=1, last=nmaster, coord = coord, size = size})
+    -- Tile other windows
+    local other_area = {
+        x = wa.x + master_area.width,
+        y = wa.y,
+        width  = wa.width - master_area.width,
+        height = wa.height
+    }
+
+    -- get column number for other windows
+    local ncol = math.min(tag.getncol(t), #cls_other)
+
+    -- split other windows to column groups
+    local last_small_column = ncol - #cls_other % ncol
+    local rows_min = math.floor(#cls_other / ncol)
+
+    local client_index = 1
+    for i = 1, ncol do
+        local position = transformation.flip and ncol - i + 1 or i
+        local rows = i <= last_small_column and rows_min or rows_min + 1
+        local column = {}
+
+        for j = 1, rows do
+            table.insert(column, cls_other[client_index])
+            client_index = client_index + 1
         end
 
-        if not place_master and nother > 0 then
+		-- and tile
-            local last = nmaster
+		local column_area = cut_area(other_area, ncol, position, true)
-
+        tile_column(wa, column_area, column, useless_gap, transformation)
-            -- 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)) --+ (global_border/(ncol))/(ncol+i^2)
-                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 = {}
+-- Layout constructor
-uselesstile.right.name = "uselesstile"
+local function construct_layout(name, orientation)
-uselesstile.right.arrange = tile
+    return {
-
+        name = name,
---- The main tile algo, on left.
+        -- @p screen number to tile
--- @param screen The screen number to tile.
+        arrange = function(p) return tile(p, orientation) end
-uselesstile.left = {}
+    }
-uselesstile.left.name = "uselesstileleft"
-function uselesstile.left.arrange(p)
-    return tile(p, "left")
 end
 
---- The main tile algo, on bottom.
+-- Build layouts with different tile direction
--- @param screen The screen number to tile.
+uselesstile.right  = construct_layout("uselesstile", "right")
-uselesstile.bottom = {}
+uselesstile.left   = construct_layout("uselesstileleft", "left")
-uselesstile.bottom.name = "uselesstilebottom"
+uselesstile.bottom = construct_layout("uselesstilebottom", "bottom")
-function uselesstile.bottom.arrange(p)
+uselesstile.top    = construct_layout("uselesstiletop", "top")
-    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
 
+-- Module aliase
 uselesstile.arrange = uselesstile.right.arrange
 uselesstile.name = uselesstile.right.name
 
 return uselesstile
-