]> git.madduck.net Git - etc/awesome.git/blobdiff - layout/uselesstile.lua

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

projects / etc / awesome.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
pull #201 fixes
[etc/awesome.git] / layout / uselesstile.lua
diff --git a/layout/uselesstile.lua b/layout/uselesstile.lua
index b82c97e7c9af529ae35c178745fc9f8f24a73fb4..ee3306067121bc5291f041dfdf4f6189bc972961 100644 (file)
--- a/layout/uselesstile.lua
+++ b/layout/uselesstile.lua
@@ -2,150 +2,130 @@
 --[[
                                                   
      Licensed under GNU General Public License v2 
 --[[
                                                   
      Licensed under GNU General Public License v2 
-      * (c) 2013,      Luke Bonham                
-      * (c) 2009       Donald Ephraim Curtis      
-      * (c) 2008       Julien Danjolu             
+      * (c) 2014, projektile, worron              
+      * (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 tag       = require("awful.tag")
 local beautiful = require("beautiful")
 local ipairs    = ipairs
-local math      = { floor = math.floor, 
+local math      = { floor = math.floor,
+                    ceil  = math.ceil,
                     max   = math.max,
                     min   = math.min }
 local tonumber  = tonumber
 
 local uselesstile = {}
 
                     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)
-    if useless_gap == nil
-    then
-        useless_gap = 0
-    end
+-- Transformation functions
+local function flip(canvas, geometry)
+    return {
+        -- vertical only
+        x = 2 * canvas.x + canvas.width - geometry.x - geometry.width,
+        y = geometry.y,
+        width = geometry.width,
+        height = geometry.height
+    }
+end
 
 
-    -- 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
+local function swap(geometry)
+    return { x = geometry.y, y = geometry.x, width = geometry.height, height = geometry.width }
+end
+
+-- Find geometry for secondary windows column
+local function cut_column(wa, n, index)
+    local width = math.floor(wa.width / n)
+    local area = { x = wa.x + (index - 1) * width, y = wa.y, width = width, height = wa.height }
+
+    return area
+end
+
+-- Find geometry for certain window in column
+local function cut_row(wa, factor, index, used)
+    local height = math.floor(wa.height * factor.window[index] / factor.total)
+    local area = { x = wa.x, y = wa.y + used, width = wa.width, height = height }
+
+    return area
+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
+-- 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
+
+-- Check size factor for group of clients and calculate total
+local function calc_factor(n, winfactors)
+    local factor = { window = winfactors, total = 0, min = 1 }
+
+    for i = 1, n do
+        if not factor.window[i] then
+            factor.window[i] = factor.min
         else
         else
-            min_fact = math.min(fact[i],min_fact)
+            factor.min = math.min(factor.window[i], factor.min)
+            if factor.window[i] < 0.05 then factor.window[i] = 0.05 end
         end
         end
-        total_fact = total_fact + fact[i]
+        factor.total = factor.total + factor.window[i]
     end
     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
-
-            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
+    return factor
 end
 
 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"
+-- Tile group of clients in given area
+-- @canvas need for proper transformation only
+-- @winfactors table with clients size factors
+local function tile_column(canvas, area, list, useless_gap, transformation, winfactors)
+    local used = 0
+    local factor = calc_factor(#list, winfactors)
+
+    for i, c in ipairs(list) do
+        local g = cut_row(area, factor, i, used)
+        if i == #list then g.height = area.height - used end
+        used = used + g.height
+
+        -- 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
+end
 
 
-    local cls = param.clients
-    local nmaster = math.min(tag.getnmaster(t), #cls)
-    local nother = math.max(#cls - nmaster,0)
+--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 mwfact = tag.getmwfact(t)
     local mwfact = tag.getmwfact(t)
-    local wa = param.workarea
-    local ncol = tag.getncol(t)
 
 
+    if nmaster == 0 then
+        mwfact = 0
+    elseif nmaster == #cls then
+        mwfact = 1
+    end
+
+    -- clients size factor
     local data = tag.getdata(t).windowfact
 
     if not data then
     local data = tag.getdata(t).windowfact
 
     if not data then
@@ -153,79 +133,98 @@ local function tile(param, orientation)
         tag.getdata(t).windowfact = data
     end
 
         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
+    -- Workarea size correction depending on useless gap and global border
+    wa.height = wa.height - 2 * global_border - useless_gap
+    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
 
 
-    -- 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
+    -- 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
 
 
-        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
+    -- 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
-        place_master = not place_master
     end
 
     end
 
-end
+    -- Tile master windows
+    local master_area = {
+        x = wa.x,
+        y = wa.y,
+        width  = nmaster > 0 and math.floor(wa.width * mwfact) or 0,
+        height = wa.height
+    }
+
+    if not data[0] then data[0] = {} end
+    tile_column(wa, master_area, cls_master, useless_gap, transformation, data[0])
+
+    -- 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)
+
+    if ncol == 0 then ncol = 1 end
+
+    -- 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
+    local used = 0
+    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
 
 
-uselesstile.right = {}
-uselesstile.right.name = "uselesstile"
-uselesstile.right.arrange = tile
+        -- and tile
+        local column_area = cut_column(other_area, ncol, position)
+        if i == ncol then column_area.width = other_area.width - used end
+        used = used + column_area.width
 
 
---- 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")
+        if not data[i] then data[i] = {} end
+        tile_column(wa, column_area, column, useless_gap, transformation, data[i])
+    end
 end
 
 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")
+-- Layout constructor
+local function construct_layout(name, orientation)
+    return {
+        name = name,
+        -- @p screen number to tile
+        arrange = function(p) return tile(p, orientation) end
+    }
 end
 
 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
+-- Build layouts with different tile direction
+uselesstile.right  = construct_layout("uselesstile", "right")
+uselesstile.left   = construct_layout("uselesstileleft", "left")
+uselesstile.bottom = construct_layout("uselesstilebottom", "bottom")
+uselesstile.top    = construct_layout("uselesstiletop", "top")
 
 
+-- Module aliase
 uselesstile.arrange = uselesstile.right.arrange
 uselesstile.name = uselesstile.right.name
 
 uselesstile.arrange = uselesstile.right.arrange
 uselesstile.name = uselesstile.right.name
 
awesome window-manager configuration

Legalese

All content available in this repository is copyright © martin f. krafft, unless otherwise noted.

All files and their content are released under the terms of the Artistic Licence 2.0, unless otherwise noted.

The operator of this repository shall not be held liable for offending content in pages linking to or linked from these page, nor does he endorse their content unless stated otherwise.