View difference between Paste ID: MiSDULf2 and 5V6PecHK

 ---------------------------------------------------------------------------
 -- @author Donald Ephraim Curtis <[email protected]>
 -- @author Julien Danjou <[email protected]>
 -- @copyright 2009 Donald Ephraim Curtis
 -- @copyright 2008 Julien Danjou
--- @release v3.4.13
+-- @release v3.5.1
 ---------------------------------------------------------------------------
 
 -- Grab environment we need
 local ipairs = ipairs
 local math = math
 local tonumber = tonumber
 local beautiful = beautiful
 local tag = require("awful.tag")
 
 --- Tiled layouts module for awful
-module("awful.layout.suit.tile")
+-- awful.layout.suit.tile
 local tile = {}
 
 local function tile_group(cls, wa, orientation, fact, group)
     local padding = tonumber(beautiful.padding)
     if padding == nil then
         padding = 0
     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
 
-    available = wa[width] - (group.coord - wa[x])
+
     local 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]
     for c = group.first,group.last do
-        geom[width] = size - padding * (group.first == 1 and 2 or 1)
+	local i = c - group.first +1
-        geom[height] = math.floor(unused * fact[i] / total_fact) - padding * 2
+	geom[width] = size - cls[c].border_width * 2
-        geom[x] = group.coord + ((orientation ~= "right" or group.first == 1) and padding or 0)
+	geom[height] = math.floor(unused * fact[i] / total_fact) - cls[c].border_width * 2
-        geom[y] = coord + padding
+	geom[x] = group.coord
-        geom = cls[c]:geometry(geom)
+	geom[y] = coord
-        coord = coord + geom[height] + padding
+	coord = coord + geom[height] + cls[c].border_width * 2
-        unused = unused - geom[height] - padding
+	unused = unused - geom[height] - cls[c].border_width * 2
-        total_fact = total_fact - fact[i]
+	total_fact = total_fact - fact[i]
-        used_size = math.max(used_size, size)
+	used_size = math.max(used_size, geom[width] + cls[c].border_width * 2)
 
 	if padding > 0 then
-    return used_size
+	    top = false
 	    left = false
 
-local function tile(param, orientation)
+	    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 * padding
 		geom[y] = geom[y] + padding
 	    else
 		geom[height] = geom[height] - padding
 	    end
 
 	    if left then
 		geom[width] = geom[width] - 2 * padding
 		geom[x] = geom[x] + padding
 	    else
 		geom[width] = geom[width] - padding
 	    end
 	end
 
 	geom = cls[c]:geometry(geom)
      end
 
      return used_size
 end
 
 local function do_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)
-            coord = coord + tile_group(cls, wa, orientation, data[0], { first = 1, last = nmaster, coord = coord, size = size })
+
     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] = {}
-right = {}
+
-right.name = "tile"
+            coord = coord + tile_group(cls, wa, orientation, data[0], {first=1, last=nmaster, coord = coord, size = size})
-right.arrange = tile
+
 
         if not place_master and nother > 0 then
             local last = nmaster
-left = {}
+
-left.name = "tileleft"
+
-function left.arrange(p)
+
-    return tile(p, "left")
+
                 wasize = wa[width] - wa[width]*mwfact
             end
             for i = 1,ncol do
                 -- Try to get equal width among remaining columns
-bottom = {}
+
-bottom.name = "tilebottom"
+
-function bottom.arrange(p)
+
-    return tile(p, "bottom")
+
                 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 })
-top = {}
+
-top.name = "tiletop"
+
-function top.arrange(p)
+
-    return tile(p, "top")
+
 
 end
-arrange = right.arrange
+
-name = right.name
+tile.right = {}
 tile.right.name = "tile"
 tile.right.arrange = do_tile
 
 --- The main tile algo, on left.
 -- @param screen The screen number to tile.
 tile.left = {}
 tile.left.name = "tileleft"
 function tile.left.arrange(p)
     return do_tile(p, "left")
 end
 
 --- The main tile algo, on bottom.
 -- @param screen The screen number to tile.
 tile.bottom = {}
 tile.bottom.name = "tilebottom"
 function tile.bottom.arrange(p)
     return do_tile(p, "bottom")
 end
 
 --- The main tile algo, on top.
 -- @param screen The screen number to tile.
 tile.top = {}
 tile.top.name = "tiletop"
 function tile.top.arrange(p)
     return do_tile(p, "top")
 end
 
 tile.arrange = tile.right.arrange
 tile.name = tile.right.name
 
 return tile