]> git.madduck.net Git - etc/awesome.git/blobdiff - layout/cascade.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:

calendar, #289: attempt to assert notification timeout when t_out is 0
[etc/awesome.git] / layout / cascade.lua
index 3d7598b4c9380c3833424a7e9ff02d2c26ecf05c..204ce4017bc211f532c750ae5f2e6c3979590486 100644 (file)
                                                   
 --]]
 
                                                   
 --]]
 
-local tag       = require("awful.tag")
-local beautiful = require("beautiful")
+local floor  = math.floor
+local screen = screen
 
 
-local cascade =
-{
+local cascade = {
     name     = "cascade",
     nmaster  = 0,
     offset_x = 32,
     name     = "cascade",
     nmaster  = 0,
     offset_x = 32,
-    offset_y = 8
+    offset_y = 8,
+    tile     = {
+        name          = "cascadetile",
+        nmaster       = 0,
+        ncol          = 0,
+        mwfact        = 0,
+        offset_x      = 5,
+        offset_y      = 32,
+        extra_padding = 0
+    }
 }
 
 }
 
-function cascade.arrange(p)
+local function do_cascade(p, tiling)
+    local t = p.tag or screen[p.screen].selected_tag
+    local wa = p.workarea
+    local cls = p.clients
 
 
-    -- Cascade windows.
+    if #cls == 0 then return 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
+    if not tiling then
+        -- Cascade windows.
 
 
-    -- Screen.
-    local wa = p.workarea
-    local cls = p.clients
+        local num_c
+        if cascade.nmaster > 0 then
+            num_c = cascade.nmaster
+        else
+            num_c = t.master_count
+        end
+
+        -- Opening a new window will usually force all existing windows to
+        -- get resized. This wastes a lot of CPU time. So let's set a lower
+        -- bound to "how_many": This wastes a little screen space but you'll
+        -- get a much better user experience.
+        local how_many = (#cls >= num_c and #cls) or num_c
+
+        local current_offset_x = cascade.offset_x * (how_many - 1)
+        local current_offset_y = cascade.offset_y * (how_many - 1)
+
+        -- Iterate.
+        for i = 1,#cls,1 do
+            local c = cls[i]
+            local g = {}
 
 
-    wa.height = wa.height - (global_border * 2)
-    wa.width = wa.width - (global_border * 2)
-    wa.x = wa.x + global_border
-    wa.y = wa.y + global_border
-
-    -- Opening a new window will usually force all existing windows to
-    -- get resized. This wastes a lot of CPU time. So let's set a lower
-    -- bound to "how_many": This wastes a little screen space but you'll
-    -- get a much better user experience.
-    local t = tag.selected(p.screen)
-    local num_c
-    if cascade.nmaster > 0
-    then
-        num_c = cascade.nmaster
+            g.x      = wa.x + (how_many - i) * cascade.offset_x
+            g.y      = wa.y + (i - 1) * cascade.offset_y
+            g.width  = wa.width - current_offset_x
+            g.height = wa.height - current_offset_y
+
+            if g.width  < 1 then g.width  = 1 end
+            if g.height < 1 then g.height = 1 end
+
+            p.geometries[c] = g
+        end
     else
     else
-        num_c = tag.getnmaster(t)
-    end
+        -- Layout with one fixed column meant for a master window. Its
+        -- width is calculated according to mwfact. Other clients are
+        -- cascaded or "tabbed" in a slave column on the right.
 
 
-    local how_many = #cls
-    if how_many < num_c
-    then
-        how_many = num_c
-    end
+        --         (1)                 (2)                 (3)                 (4)
+        --   +----------+---+    +----------+---+    +----------+---+    +----------+---+
+        --   |          |   |    |          | 3 |    |          | 4 |    |         +---+|
+        --   |          |   | -> |          |   | -> |         +---++ -> |        +---+|+
+        --   |  1       | 2 |    |  1      +---++    |  1      | 3 ||    |  1    +---+|+|
+        --   |          |   |    |         | 2 ||    |        +---++|    |      +---+|+ |
+        --   |          |   |    |         |   ||    |        | 2 | |    |      | 2 |+  |
+        --   +----------+---+    +---------+---++    +--------+---+-+    +------+---+---+
+
+        local mwfact
+        if cascade.tile.mwfact > 0 then
+            mwfact = cascade.tile.mwfact
+        else
+            mwfact = t.master_width_factor
+        end
+
+        -- Make slave windows overlap main window? Do this if ncol is 1.
+        local overlap_main
+        if cascade.tile.ncol > 0 then
+            overlap_main = cascade.tile.ncol
+        else
+            overlap_main = t.column_count
+        end
+
+        -- Minimum space for slave windows? See cascade.tile.lua.
+        local num_c
+        if cascade.tile.nmaster > 0 then
+            num_c = cascade.tile.nmaster
+        else
+            num_c = t.master_count
+        end
 
 
-    local current_offset_x = cascade.offset_x * (how_many - 1)
-    local current_offset_y = cascade.offset_y * (how_many - 1)
+        local how_many = (#cls - 1 >= num_c and (#cls - 1)) or num_c
 
 
-    -- Iterate.
-    for i = 1,#cls,1
-    do
-        local c = cls[i]
+        local current_offset_x = cascade.tile.offset_x * (how_many - 1)
+        local current_offset_y = cascade.tile.offset_y * (how_many - 1)
+
+        if #cls <= 0 then return end
+
+        -- Main column, fixed width and height.
+        local c = cls[1]
         local g = {}
         local g = {}
+        -- Rounding is necessary to prevent the rendered size of slavewid
+        -- from being 1 pixel off when the result is not an integer.
+        local mainwid = floor(wa.width * mwfact)
+        local slavewid = wa.width - mainwid
+
+        if overlap_main == 1 then
+            g.width = wa.width
+
+            -- The size of the main window may be reduced a little bit.
+            -- This allows you to see if there are any windows below the
+            -- main window.
+            -- This only makes sense, though, if the main window is
+            -- overlapping everything else.
+            g.width = g.width - cascade.tile.extra_padding
+        else
+            g.width = mainwid
+        end
 
 
-        g.x = wa.x + (how_many - i) * cascade.offset_x
-        g.y = wa.y + (i - 1) * cascade.offset_y
-        g.width = wa.width - current_offset_x - 2*c.border_width
-        g.height = wa.height - current_offset_y - 2*c.border_width
-        if g.width < 1 then g.width = 1 end
+        g.height = wa.height
+        g.x = wa.x
+        g.y = wa.y
+
+        if g.width < 1  then g.width  = 1 end
         if g.height < 1 then g.height = 1 end
 
         if g.height < 1 then g.height = 1 end
 
-        c:geometry(g)
+        p.geometries[c] = g
+
+        -- Remaining clients stacked in slave column, new ones on top.
+        if #cls <= 1 then return end
+        for i = 2,#cls do
+            c = cls[i]
+            g = {}
+
+            g.width  = slavewid - current_offset_x
+            g.height = wa.height - current_offset_y
+
+            g.x = wa.x + mainwid + (how_many - (i - 1)) * cascade.tile.offset_x
+            g.y = wa.y + (i - 2) * cascade.tile.offset_y
+
+            if g.width < 1  then g.width  = 1 end
+            if g.height < 1 then g.height = 1 end
+
+            p.geometries[c] = g
+        end
     end
 end
 
     end
 end
 
+function cascade.tile.arrange(p)
+    return do_cascade(p, true)
+end
+
+function cascade.arrange(p)
+    return do_cascade(p, false)
+end
+
 return cascade
 return cascade