From 605ab1f899b8cc5b1c3257b64f9076a755879e0a Mon Sep 17 00:00:00 2001 From: worron Date: Sat, 10 Jan 2015 19:52:08 +0300 Subject: [PATCH] Uselesstile code refactoring --- layout/uselesstile.lua | 312 +++++++++++++++++++---------------------- 1 file changed, 144 insertions(+), 168 deletions(-) diff --git a/layout/uselesstile.lua b/layout/uselesstile.lua index 5bb0c05..d244f43 100644 --- a/layout/uselesstile.lua +++ b/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,204 +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, gap) - - -- 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 - -- 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) - 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 - (bw * 2) - geom[height] = math.floor(unused * fact[i] / total_fact) - (bw * 2) - geom[x] = group.coord - geom[y] = coord - - coord = coord + geom[height] + 2 * bw - unused = unused - geom[height] - 2 * bw - total_fact = total_fact - fact[i] - used_size = math.max(used_size, geom[width] + 2 * bw) - - -- Useless gap correction - geom.width = geom.width - gap - geom.height = geom.height - gap - - geom = cls[c]:geometry(geom) - end +local function swap(geometry) + return { x = geometry.y, y = geometry.x, width = geometry.height, height = geometry.width } +end + +-- Find geometry for column/row tiling +local function cut_area(wa, total, index, is_horizontal) + local wa = is_horizontal and swap(wa) or wa + local height = wa.height / total + + local area = { + x = wa.x, + y = wa.y + (index - 1) * height, + width = wa.width, + height = height + } - return used_size + 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 -local function tile(param, orientation) - local t = tag.selected(param.screen) - orientation = orientation or "right" - - -- 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 - - -- 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 +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 - 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) - -- Workarea size correction + if nmaster == 0 then + mwfact = 0 + elseif nmaster == #cls then + mwfact = 1 + 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 + global_border - wa.y = wa.y + useless_gap + global_border + wa.x = wa.x + useless_gap / 2 + global_border + wa.y = wa.y + useless_gap / 2 + global_border - local data = tag.getdata(t).windowfact + -- Find which transformation we need for given orientation + local transformation = { + swap = orientation == 'top' or orientation == 'bottom', + flip = orientation == 'left' or orientation == 'top' + } - if not data then - data = {} - tag.getdata(t).windowfact = data - end + -- Swap workarea dimensions if orientation vertical + if transformation.swap then wa = swap(wa) 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 + -- Split master and other windows + local cls_master, cls_other = {}, {} - -- 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}, useless_gap) - 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)) --+ (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 }, useless_gap) - 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 - -uselesstile.right = {} -uselesstile.right.name = "uselesstile" -uselesstile.right.arrange = tile + -- Tile master windows + local master_area = { + x = wa.x, + y = wa.y, + width = nmaster > 0 and wa.width * mwfact or 0, + height = wa.height + } + + tile_column(wa, master_area, cls_master, useless_gap, transformation) + + -- 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 ---- 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") + -- and tile + local column_area = cut_area(other_area, ncol, position, true) + tile_column(wa, column_area, column, useless_gap, transformation) + 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 - -- 2.39.5