X-Git-Url: https://git.madduck.net/etc/awesome.git/blobdiff_plain/82766de14737919c4d1eb3b27333a6ef0b80e6d2..10cd5d629dbe917b220b1e54456ea79da07333f9:/layout/uselesstile.lua?ds=inline diff --git a/layout/uselesstile.lua b/layout/uselesstile.lua index 65ce9b5..e48c85d 100644 --- a/layout/uselesstile.lua +++ b/layout/uselesstile.lua @@ -2,10 +2,10 @@ --[[ Licensed under GNU General Public License v2 - * (c) 2014 projektile - * (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 --]] @@ -13,145 +13,117 @@ 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) - -- 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 - -- beautiful.global_border_width - 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 +-- 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 + +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 = 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 = 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) - --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 +-- 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 - 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 - total_fact = total_fact + fact[i] + factor.total = factor.total + factor.window[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 + return factor 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) + 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 - 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 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 @@ -159,81 +131,96 @@ local function tile(param, orientation) 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 + + -- Split master and other windows + local cls_master, cls_other = {}, {} - 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)) --+ (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 + for i, c in ipairs(cls) do + if i <= nmaster then + table.insert(cls_master, c) + else + table.insert(cls_other, c) end - place_master = not place_master end -end + -- Tile master windows + local master_area = { + x = wa.x, + y = wa.y, + width = nmaster > 0 and 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 + 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) ---- 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 ---- 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 ---- 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 return uselesstile -