obsolete.computer/geekery/

My Awesome Awesome Config

Awesome Overview

For about 5 years now, I've been using the Awesome window manager, which is a tiling window manager that you configure using Lua scripts. What I always wanted out of it, though, was not necessarily just the tiling feature, but a window manager that stayed out of my way and managed my windows for me with minimal effort.

Pixel Overload

With my main PC build, I have a 40" 4k screen -- a Samsung Smart TV. It's a cheap way to get a 60Hz 4k monitor -- though I definitely have regrets, and wish I had spent the extra money on a real monitor. Anyway, since 4k resolution is basically like four 1080p screens, the idea I had was to make Awesome manage my windows in a way that sort of resembled a multi-monitor setup, but with some sensible exceptions. For example, instead of making my first window snap to a corner as if it was maximized inside one of four monitors, the windows start in the center and work their way outward. I got the idea from a Lua layout script called centerwork, from an Awesome module called Lain (which also provides some cool widgets and other utilities I'm using). The centerwork script was close to what I wanted, except due to the height of the 4k screen, I always found the centered full-height window to be kind of useless... web pages look ridiculous and terminals are mostly empty. Tiling window managers typically assume you want to use every inch of screen real estate, but with a 4k monitor that isn't necessary or even practical. So I made some modifications which did two things: One, set a maximum height for the center and side windows, and two, add the ability to honor the number of "master windows" that are currently in the nmast variable and thus divide the center section into that many panes (up to a limit of four). Here are some pictures of it in action:

Awesome Window Progression - 1 of 5 Awesome Window Progression - 2 of 5 Awesome Window Progression - 3 of 5 Awesome Window Progression - 4 of 5 Awesome Window Progression - 5 of 5

Here's the modified centerwork script that makes it happen:

centerwork.lua

Download Source

--[[

     Licensed under GNU General Public License v2
      * (c) 2021       Sean Corbett
      * (c) 2018,      Eugene Pakhomov
      * (c) 2016,      Henrik Antonsson
      * (c) 2015,      Joerg Jaspert
      * (c) 2014,      projektile
      * (c) 2013,      Luca CPZ
      * (c) 2010-2012, Peter Hofmann

--]]

local floor, max, min, mouse, mousegrabber, screen = math.floor, math.max, math.min, mouse, mousegrabber, screen

local centerwork = {
    name       = "centerwork",
    horizontal = { name = "centerworkh" }
}

local function arrange(p, layout)
    local t   = p.tag or screen[p.screen].selected_tag
    local wa  = p.workarea
    local cls = p.clients

    if #cls == 0 then return end

    -- Main column, fixed width and height
    local mwfact          = t.master_width_factor
    local nmast           = t.master_count
    local mainhei         = floor(wa.height * mwfact)
    local mainwid         = floor(wa.width * mwfact)
    local maxmasthei      = floor(wa.height * 0.7)
    local maxmastwid      = floor(wa.width * 0.6)
    local maxslahei      = floor(wa.height * 0.5)
    local maxslawid      = floor(wa.width * 0.5)
    local slavewid        = wa.width - mainwid
    local slaveLwid       = floor(slavewid / 2)
    local slaveRwid       = slavewid - slaveLwid
    local slavehei        = wa.height - mainhei
    local slaveThei       = floor(slavehei / 2)
    local slaveBhei       = slavehei - slaveThei
    local nbrFirstSlaves  = floor((#cls-nmast+1) / 2)
    local nbrSecondSlaves = floor((#cls-nmast) / 2)

    local slaveFirstDim, slaveSecondDim = 0, 0

    if layout.name == "centerwork" then -- vertical
        if nbrFirstSlaves  > 0 then slaveFirstDim  = floor(wa.height / nbrFirstSlaves) end
        if nbrSecondSlaves > 0 then slaveSecondDim = floor(wa.height / nbrSecondSlaves) end

        if nmast > 0 then
            for i = 1, nmast do
                local c, g = cls[i], {}

                g.height = min(floor(wa.height / nmast), maxmasthei)
                g.width  = mainwid

                g.x = wa.x + slaveLwid
                g.y = wa.y + (i - 1) * floor(wa.height / nmast) + floor((wa.height / nmast - g.height) / 2)

                g.width  = max(g.width, 1)
                g.height = max(g.height, 1)

                p.geometries[c] = g
            end
        end

    else -- horizontal
        if nbrFirstSlaves  > 0 then slaveFirstDim  = floor(wa.width / nbrFirstSlaves) end
        if nbrSecondSlaves > 0 then slaveSecondDim = floor(wa.width / nbrSecondSlaves) end

        if nmast > 0 then
            for i = 1, nmast do
                local c, g = cls[i], {}

                g.height  = mainhei
                g.width = min(floor(wa.width / nmast), maxmastwid)

                g.x = wa.x + (i - 1) * floor(wa.width / nmast) + floor((wa.width / nmast - g.width) / 2)
                g.y = wa.y + slaveThei

                g.width  = max(g.width, 1)
                g.height = max(g.height, 1)

                p.geometries[c] = g
            end
        end

    end

    -- Auxiliary clients
    if #cls <= nmast then return end
    for i = nmast + 1, #cls do
        local c, g = cls[i], {}
        local idxChecker, dimToAssign
        local sli = i - nmast

        local rowIndex = floor((sli+1)/2)

        if layout.name == "centerwork" then -- horizontal
            if sli % 2 == 1 then -- left slave
                g.x     = wa.x
                g.y     = wa.y + (rowIndex - 1) * slaveFirstDim
                g.width = slaveLwid

                idxChecker, dimToAssign = nbrFirstSlaves, slaveFirstDim
            else -- right slave
                g.x     = wa.x + slaveLwid + mainwid
                g.y     = wa.y + (rowIndex - 1) * slaveSecondDim
                g.width = slaveRwid

                idxChecker, dimToAssign = nbrSecondSlaves, slaveSecondDim
            end

            -- if last slave in row, use remaining space for it
            if rowIndex == idxChecker then
                g.height = wa.y + wa.height - g.y
            else
                g.height = dimToAssign
            end

            -- center-up oversize clients
            if g.height > maxslahei then
                g.y = g.y + (g.height - maxslahei) / 2
                g.height = maxslahei
            end

        else -- vertical
            if sli % 2 == 1 then -- top slave
                g.x      = wa.x + (rowIndex - 1) * slaveFirstDim
                g.y      = wa.y
                g.height = slaveThei

                idxChecker, dimToAssign = nbrFirstSlaves, slaveFirstDim
            else -- bottom slave
                g.x      = wa.x + (rowIndex - 1) * slaveSecondDim
                g.y      = wa.y + slaveThei + mainhei
                g.height = slaveBhei

                idxChecker, dimToAssign = nbrSecondSlaves, slaveSecondDim
            end

            -- if last slave in row, use remaining space for it
            if rowIndex == idxChecker then
                g.width = wa.x + wa.width - g.x
            else
                g.width = dimToAssign
            end

            -- center-up oversize clients
            if g.width > maxslawid then
                g.x = g.x + (g.width - maxslawid) / 2
                g.width = maxslawid
            end
        end

        g.width  = max(g.width, 1)
        g.height = max(g.height, 1)

        p.geometries[c] = g
    end
end

local function mouse_resize_handler(c, corner, x, y, orientation)
    local wa     = c.screen.workarea
    local mwfact = c.screen.selected_tag.master_width_factor
    local g      = c:geometry()
    local offset = 0
    local cursor = "cross"

    local corner_coords

    if orientation == 'vertical' then
        if g.height + 15 >= wa.height then
            offset = g.height * .5
            cursor = "sb_h_double_arrow"
        elseif not (g.y + g.height + 15 > wa.y + wa.height) then
            offset = g.height
        end
        corner_coords = { x = wa.x + wa.width * (1 - mwfact) / 2, y = g.y + offset }
    else
        if g.width + 15 >= wa.width then
            offset = g.width * .5
            cursor = "sb_v_double_arrow"
        elseif not (g.x + g.width + 15 > wa.x + wa.width) then
            offset = g.width
        end
        corner_coords = { y = wa.y + wa.height * (1 - mwfact) / 2, x = g.x + offset }
    end

    mouse.coords(corner_coords)

    local prev_coords = {}

    mousegrabber.run(function(_mouse)
        if not c.valid then return false end
        for _, v in ipairs(_mouse.buttons) do
            if v then
                prev_coords = { x = _mouse.x, y = _mouse.y }
                local new_mwfact
                if orientation == 'vertical' then
                    new_mwfact = 1 - (_mouse.x - wa.x) / wa.width * 2
                else
                    new_mwfact = 1 - (_mouse.y - wa.y) / wa.height * 2
                end
                c.screen.selected_tag.master_width_factor = math.min(math.max(new_mwfact, 0.01), 0.99)
                return true
            end
        end
        return prev_coords.x == _mouse.x and prev_coords.y == _mouse.y
    end, cursor)
end

function centerwork.arrange(p)
    return arrange(p, centerwork)
end

function centerwork.horizontal.arrange(p)
    return arrange(p, centerwork.horizontal)
end

function centerwork.mouse_resize_handler(c, corner, x, y)
    return mouse_resize_handler(c, corner, x, y, 'vertical')
end

function centerwork.horizontal.mouse_resize_handler(c, corner, x, y)
    return mouse_resize_handler(c, corner, x, y, 'horizontal')
end

return centerwork

Toggling Importance

Since the centerwork script now allowed me to have several master windows, I wanted a quick and easy way to promote a window to master. Also, I wanted a few certain windows to always get master status. So there are three places in my config where this is accomplished. One, a key binding:

    awful.key({ modkey,           }, "i",
        function (c)
            c.prefer_master = not c.prefer_master
            if c.prefer_master then 
                awful.client.setmaster(c) 
            else
                awful.client.setslave(c)
            end            
            if c.first_tag then update_master_count(c.first_tag) end
        end,
        {description = "toggle prefer master", group = "client"})

This function toggles a property called prefer_master for the current window. It will then move the window to the top of the window list if it's currently true, or to the bottom of the window list if it's false. Then it calls the second piece of the puzzle, the update_master_count() function:

function update_master_count(t)
    --set the master_count to however many windows want master status, within a bounded range.
    local prefer_master_count = 0
    local cls = t:clients()
    for i = 1, #cls do
        if cls[i].prefer_master == true and cls[i].floating == false then
            --naughty.notify({ title = cls[i].name, text = "true" })
            prefer_master_count = prefer_master_count + 1
        else
            --naughty.notify({ title = cls[i].name, text = "false" })
        end
    end

    t.master_count = math.max(math.min(prefer_master_count, 4), 1)
end

As the comment descrption says, this function calculates how many windows prefer_master == true for, and sets the master_count accordingly (up to a max of 4, since more than 4 masters gets a little ridiculous).

The final piece is as follows, in the section of the config file where you can set up various window rules:

    --Apps which prefer to be a master window
    { rule_any =
        { class = 
            { 
                "firefox", "librewolf", "LibreWolf", "Navigator", "gimp", "Gimp", "lbry", "LBRY", "mpv", "Steam", 
                "com.github.tkashkin.gamehub", "Com.github.tkashkin.gamehub", "vlc", "geany", "Geany",
                "Gnucash", "gnucash", "brave-browser", "Brave-browser", "org.remmina.Remmina",
                "libreoffice", "libreoffice-calc", "libreoffice-writer", "Trello", "Ardour", "Mixbus", "Xephyr"
            },
          instance = 
            {
                "libreoffice", "libreoffice-calc", "libreoffice-writer", "Xephyr"
            }
        },
      except_any =
        { name = 
            { 
                "Remmina Remote Desktop Client"
            }
        },
      properties = { prefer_master = true },
    },

These are all programs which will automatically get prefer_master set to true, and thus put at the top of the stack. It's quite nice, for example, that the WM knows that even though I might have a terminal window open, if I open a web browser or Gimp window the terminal should be shoved to the side to make room rather than putting the browser in the comparatively small gutter space. Additionally, it's also possible to adjust the master window factor mwfact using some key bindings, and the center master window column adjusts accordingly (edging out the side windows if any).

Non-fancy dynamic tagging

There's one more feature that I want to highlight, and that's a function called cleanup_tags(). What this does is automatically keep the number of tags at a minimum, and creates one extra tag at the end. For example, if I have windows on tags 1 and 2, it will make an empty tag 3... then when all the windows on tag 2 are closed, it will delete tag 3 and leave tag two so there's still only one empty one. This way, when I want a fresh workspace I can always go to the end and get a blank tag... and there are never unused tags sitting there doing nothing.

function cleanup_tags(s)
    s = s or awful.screen.focused()
    local last_tag_with_clients = 0
    for i = 1, #s.tags do
        if #s.tags[i]:clients() > 0 then
            last_tag_with_clients = i
        end
    end

    --Add tag if all tags have clients
    if last_tag_with_clients == #s.tags then
        add_tag(s)
    end

    --Delete tags if there are more than one empty at the end
    if last_tag_with_clients < #s.tags - 1 then
        for i = #s.tags, last_tag_with_clients + 2, -1 do
            delete_tag(s.tags[i])
        end
    end
end

function add_tag(s)
    s = s or awful.screen.focused()
    awful.tag.add(tostring(#s.tags + 1), { screen = awful.screen.focused(), layout = awful.layout.layouts[1] })
end

function delete_tag(t)
    t = t or awful.screen.focused().selected_tag
    if not t then return end
    t:delete()
end

This function is called from functions which handle both the manage and untagged signals, to keep things tidy when windows are added and removed from tags.

That about does 'er

Blogging to Krull

It's not perfect, and there are certain times it messes up the window order or otherwise gets wonky. But now that I've done all of these tweaks once I understand the way Awesome works quite a bit better, and could maybe design something more comprehensive and intelligent and less hacky. Perhaps someday I will re-implement a similar setup in a different WM like Qtile... I'm much more familiar with Python, though Lua has been fun to work with too. It would also be good to make it adapt to smaller resolutions better. It should work on any resolution, but some of the proportions that are hard-coded in the layout script would need to be tweaked to make sense on smaller screens or ones with a different aspect ratio.

Here's my full rc.lua config file, in case there's anything I missed:

rc.lua

Download Source

-- [[[ Required libraries
local awesome, client, mouse, screen, tag = awesome, client, mouse, screen, tag
local ipairs, string, os, table, tostring, tonumber, type, math = ipairs, string, os, table, tostring, tonumber, type, math

local gears         = require("gears")
local awful         = require("awful")
                      require("awful.autofocus")
local wibox         = require("wibox")
local beautiful     = require("beautiful")
local naughty       = require("naughty")
local lain          = require("lain")
local menubar       = require("menubar")
local freedesktop   = require("freedesktop")
local hotkeys_popup = require("awful.hotkeys_popup").widget
                      require("awful.hotkeys_popup.keys")
local my_table      = awful.util.table or gears.table -- 4.{0,1} compatibility
-- ]]]


--Notifications in lower right
naughty.config.defaults.position = "bottom_right"


-- [[[ Error handling
-- Check if awesome encountered an error during startup and fell back to
-- another config (This code will only ever execute for the fallback config)
if awesome.startup_errors then
    naughty.notify({ preset = naughty.config.presets.critical,
                     title = "Oops, there were errors during startup!",
                     text = awesome.startup_errors })
end

-- Handle runtime errors after startup
do
    local in_error = false
    awesome.connect_signal("debug::error", function (err)
        if in_error then return end
        in_error = true

        naughty.notify({ preset = naughty.config.presets.critical,
                         title = "Oops, an error happened!",
                         text = tostring(err) })
        in_error = false
    end)
end
-- ]]]

-- [[[ Autostart windowless processes

-- This function will run once every time Awesome is started
local function run_once(cmd_arr)
    for _, cmd in ipairs(cmd_arr) do
        awful.spawn.with_shell(string.format("pgrep -u $USER -fx '%s' > /dev/null || (%s)", cmd, cmd))
    end
end

--run_once({ "urxvtd", "unclutter -root" }) -- entries must be separated by commas

-- This function implements the XDG autostart specification
--[[
awful.spawn.with_shell(
    'if (xrdb -query | grep --quiet "^awesome\\.started:\\s*true$"); then; exit; fi;' ..
    'xrdb -merge <<< "awesome.started:true";' ..
    -- list each of your autostart commands, followed by ; inside single quotes, followed by ..
    'dex --environment Awesome --autostart --search-paths "$XDG_CONFIG_DIRS/autostart:$XDG_CONFIG_HOME/autostart"' -- https://github.com/jceb/dex
)
--]]

-- ]]]

-- [[[ Variable definitions

local themes = {
    "vinyl",      -- 1
    "powerarrow", -- 2
}

local chosen_theme = themes[2]
local modkey       = "Mod4"
local altkey       = "Mod1"
local terminal     = "lxterminal"
--local terminal     = "cool-retro-term"
local editor       = os.getenv("EDITOR") or "vim"
local gui_editor   = "gedit"
local browser      = "librewolf"
local mail         = "thunderbird"
local file_manager = "thunar"
local music_player = "cool-retro-term -e ncmpcpp"
--local music_player = terminal .. " -e ncmpcpp"
local passwords    = "keepassxc"
local guieditor    = "atom"
local scrlocker    = "xscreensaver-command -activate"
local screenshot   = "scrot $HOME/Images/Shared/screenshots/$(date +%Y-%m-%d-%H:%M:%S).jpg"

local quake = lain.util.quake({
                    app = terminal
                })

awful.util.terminal = terminal
menubar.utils.terminal = terminal -- Set the Menubar terminal for applications that require it
awful.util.tagnames = { "1" }
awful.layout.layouts = {

    --awful.layout.suit.tile,
    --awful.layout.suit.tile.left,
    --awful.layout.suit.tile.bottom,
    --awful.layout.suit.tile.top,
    --awful.layout.suit.fair,
    --awful.layout.suit.fair.horizontal,
    --awful.layout.suit.spiral,
    --awful.layout.suit.spiral.dwindle,
    --awful.layout.suit.max,
    --awful.layout.suit.max.fullscreen,
    --awful.layout.suit.magnifier,
    --awful.layout.suit.corner.nw,
    --awful.layout.suit.corner.ne,
    --awful.layout.suit.corner.sw,
    --awful.layout.suit.corner.se,
    --lain.layout.cascade,
    --lain.layout.cascade.tile,
    lain.layout.centerwork,
    lain.layout.centerwork.horizontal,
    --lain.layout.termfair,
    lain.layout.termfair.center,
    awful.layout.suit.floating,
}

awful.util.taglist_buttons = my_table.join(
    awful.button({ }, 1, function(t) t:view_only() end),
    awful.button({ modkey }, 1, function(t)
        if client.focus then
            client.focus:move_to_tag(t)
        end
    end),
    awful.button({ }, 3, awful.tag.viewtoggle),
    awful.button({ modkey }, 3, function(t)
        if client.focus then
            client.focus:toggle_tag(t)
        end
    end),
    awful.button({ }, 5, function(t) awful.tag.viewnext(t.screen) end),
    awful.button({ }, 4, function(t) awful.tag.viewprev(t.screen) end)
)

awful.util.tasklist_buttons = my_table.join(
    awful.button({ }, 1, function (c)
        if c == client.focus then
            c.minimized = true
        else
            --c:emit_signal("request::activate", "tasklist", {raise = true})<Paste>

            -- Without this, the following
            -- :isvisible() makes no sense
            c.minimized = false
            if not c:isvisible() and c.first_tag then
                c.first_tag:view_only()
            end
            -- This will also un-minimize
            -- the client, if needed
            client.focus = c
            c:raise()
        end
    end),
    awful.button({ }, 3, function ()
        local instance = nil

        return function ()
            if instance and instance.wibox.visible then
                instance:hide()
                instance = nil
            else
                instance = awful.menu.clients({theme = {width = 250}})
            end
        end
    end),
    awful.button({ }, 4, function () awful.client.focus.byidx(1) end),
    awful.button({ }, 5, function () awful.client.focus.byidx(-1) end)
)

lain.layout.termfair.nmaster           = 3
lain.layout.termfair.ncol              = 1
lain.layout.termfair.center.nmaster    = 3
lain.layout.termfair.center.ncol       = 1
lain.layout.cascade.tile.offset_x      = 2
lain.layout.cascade.tile.offset_y      = 32
lain.layout.cascade.tile.extra_padding = 5
lain.layout.cascade.tile.nmaster       = 5
lain.layout.cascade.tile.ncol          = 2

beautiful.init(string.format("%s/.config/awesome/themes/%s/theme.lua", os.getenv("HOME"), chosen_theme))
beautiful.arch_icon = awful.util.getdir("config") .. "/shared/arch-linux-icon.png"
-- ]]]

-- [[[ Menu
local myawesomemenu = {
    { "hotkeys", function() return false, hotkeys_popup.show_help end },
    { "manual", terminal .. " -e man awesome" },
    { "edit config", string.format("%s -e %s %s", terminal, editor, awesome.conffile) },
    { "restart", awesome.restart },
    { "quit", function() awesome.quit() end }
}
local mysystemmenu = {
    { "==xdmcp==" },
    { "-> reels (tile)", "Xephyr :1 -resizeable -query 192.168.42.25" },
    { "-> reels (float)", "Xephyr :1 -screen 2560x1440 -query 192.168.42.25" },
    { "--" },
    { "lock", scrlocker },
    { "--" },
    { "shutdown", terminal .. " -e sudo poweroff" },
    { "reboot", terminal .. " -e sudo reboot" },
}
awful.util.mymainmenu = freedesktop.menu.build({
    icon_size = beautiful.menu_height or 16,
    before = {
        { "Browser", browser},
        { "File Manager", file_manager},
        { "Terminal", terminal},
        { "Music Player", music_player},
        { "Mail", mail },
        { "Passwords", passwords },
        -- other triads can be put here
    },
    after = {
        { "Awesome", myawesomemenu, beautiful.awesome_icon },
        { "System", mysystemmenu, beautiful.arch_icon },
        -- other triads can be put here
    }
})

-- ]]]

-- [[[ Screen
-- Re-set wallpaper when a screen's geometry changes (e.g. different resolution)
screen.connect_signal("property::geometry", function(s)
    -- Wallpaper
    if beautiful.wallpaper then
        local wallpaper = beautiful.wallpaper
        -- If wallpaper is a function, call it with the screen
        if type(wallpaper) == "function" then
            wallpaper = wallpaper(s)
        end
        gears.wallpaper.maximized(wallpaper, s, true)
    end
end)
-- Create a wibox for each screen and add it
awful.screen.connect_for_each_screen(function(s) beautiful.at_screen_connect(s) end)
-- ]]]

-- [[[ Mouse bindings
root.buttons(my_table.join(
    awful.button({ }, 3, function () awful.util.mymainmenu:toggle() end),
    awful.button({ }, 5, awful.tag.viewnext),
    awful.button({ }, 4, awful.tag.viewprev),
    awful.button({ modkey }, 5, function () awful.layout.inc( 1) end),
    awful.button({ modkey }, 4, function () awful.layout.inc(-1) end)
))
-- ]]]

-- [[[ Key bindings
globalkeys = my_table.join(
    --[[ Take a screenshot
    -- https://github.com/lcpz/dots/blob/master/bin/screenshot
    awful.key({ modkey }, "p", function() os.execute(screenshot) end,
              {description = "take a screenshot", group = "hotkeys"}),
    --]]

    -- X screen locker
    awful.key({ }, "Scroll_Lock", function () os.execute(scrlocker) end,
              {description = "lock screen", group = "hotkeys"}),

    -- Hotkeys
    awful.key({ modkey,           }, "F1",      hotkeys_popup.show_help,
              {description = "show help", group="awesome"}),
    -- Tag browsing
    awful.key({ modkey,           }, "Left",   awful.tag.viewprev,
              {description = "view previous", group = "tag"}),
    awful.key({ modkey,           }, "Right",  awful.tag.viewnext,
              {description = "view next", group = "tag"}),
    awful.key({ modkey,           }, "Escape", awful.tag.history.restore,
              {description = "go back", group = "tag"}),

    -- Non-empty tag browsing
    awful.key({ altkey }, "Left", function () lain.util.tag_view_nonempty(-1) end,
              {description = "view  previous nonempty", group = "tag"}),
    awful.key({ altkey }, "Right", function () lain.util.tag_view_nonempty(1) end,
              {description = "view  previous nonempty", group = "tag"}),

    -- Default client focus
    awful.key({ altkey,           }, "j",
        function ()
            awful.client.focus.byidx( 1)
        end,
        {description = "focus next by index", group = "client"}
    ),
    awful.key({ altkey,           }, "k",
        function ()
            awful.client.focus.byidx(-1)
        end,
        {description = "focus previous by index", group = "client"}
    ),

    -- By direction client focus
    awful.key({ modkey }, "j",
        function()
            awful.client.focus.global_bydirection("down")
            if client.focus then client.focus:raise() end
        end,
        {description = "focus down", group = "client"}),
    awful.key({ modkey }, "k",
        function()
            awful.client.focus.global_bydirection("up")
            if client.focus then client.focus:raise() end
        end,
        {description = "focus up", group = "client"}),
    awful.key({ modkey }, "h",
        function()
            awful.client.focus.global_bydirection("left")
            if client.focus then client.focus:raise() end
        end,
        {description = "focus left", group = "client"}),
    awful.key({ modkey }, "l",
        function()
            awful.client.focus.global_bydirection("right")
            if client.focus then client.focus:raise() end
        end,
        {description = "focus right", group = "client"}),
    awful.key({ modkey,           }, "w", function () awful.util.mymainmenu:show() end,
              {description = "show main menu", group = "awesome"}),

    -- Layout manipulation
    awful.key({ modkey, "Shift"   }, "j", function () awful.client.swap.byidx(  1)    end,
              {description = "swap with next client by index", group = "client"}),
    awful.key({ modkey, "Shift"   }, "k", function () awful.client.swap.byidx( -1)    end,
              {description = "swap with previous client by index", group = "client"}),
    awful.key({ modkey, "Control" }, "j", function () awful.screen.focus_relative( 1) end,
              {description = "focus the next screen", group = "screen"}),
    awful.key({ modkey, "Control" }, "k", function () awful.screen.focus_relative(-1) end,
              {description = "focus the previous screen", group = "screen"}),
    awful.key({ modkey,           }, "u", awful.client.urgent.jumpto,
              {description = "jump to urgent client", group = "client"}),
    awful.key({ modkey,           }, "Tab",
        function ()
            awful.client.focus.history.previous()
            if client.focus then
                client.focus:raise()
            end
        end,
        {description = "go back", group = "client"}),

    -- Show/Hide Wibox
    awful.key({ modkey }, "b", function ()
            for s in screen do
                s.mywibox.visible = not s.mywibox.visible
                if s.mybottomwibox then
                    s.mybottomwibox.visible = not s.mybottomwibox.visible
                end
            end
        end,
        {description = "toggle wibox", group = "awesome"}),

    -- On the fly useless gaps change
    awful.key({ modkey }, "=", function () lain.util.useless_gaps_resize(1) end,
              {description = "increment useless gaps", group = "tag"}),
    awful.key({ modkey }, "-", function () lain.util.useless_gaps_resize(-1) end,
              {description = "decrement useless gaps", group = "tag"}),

    -- Dynamic tagging
    --awful.key({ modkey, "Shift" }, "n", function () lain.util.add_tag(lain.layout.centerwork, tostring(#awful.screen.focused().tags + 1)) end,
    --          {description = "add new tag", group = "tag"}),
    awful.key({ modkey, "Shift" }, "r", function () lain.util.rename_tag() end,
              {description = "rename tag", group = "tag"}),
    awful.key({ modkey, "Shift" }, "Left", function () lain.util.move_tag(-1) end,
              {description = "move tag to the left", group = "tag"}),
    awful.key({ modkey, "Shift" }, "Right", function () lain.util.move_tag(1) end,
              {description = "move tag to the right", group = "tag"}),
    --awful.key({ modkey, "Shift" }, "d", function () lain.util.delete_tag() end,
    --          {description = "delete tag", group = "tag"}),

    -- Standard program
    awful.key({ modkey,           }, "Return", function () awful.spawn(terminal) end,
              {description = "open a terminal", group = "launcher"}),
    awful.key({ modkey, "Control" }, "r", awesome.restart,
              {description = "reload awesome", group = "awesome"}),
    awful.key({ modkey, "Shift"   }, "q", awesome.quit,
              {description = "quit awesome", group = "awesome"}),

    awful.key({ altkey, "Shift"   }, "l",     function () awful.tag.incmwfact( 0.05)          end,
              {description = "increase master width factor", group = "layout"}),
    awful.key({ altkey, "Shift"   }, "h",     function () awful.tag.incmwfact(-0.05)          end,
              {description = "decrease master width factor", group = "layout"}),
    awful.key({ modkey, "Shift"   }, "=",     function () awful.tag.incnmaster( 1, nil, true) end,
              {description = "increase the number of master clients", group = "layout"}),
    awful.key({ modkey, "Shift"   }, "-",     function () awful.tag.incnmaster(-1, nil, true) end,
              {description = "decrease the number of master clients", group = "layout"}),
    awful.key({ modkey, "Control" }, "h",     function () awful.tag.incncol( 1, nil, true)    end,
              {description = "increase the number of columns", group = "layout"}),
    awful.key({ modkey, "Control" }, "l",     function () awful.tag.incncol(-1, nil, true)    end,
              {description = "decrease the number of columns", group = "layout"}),
    awful.key({ modkey,           }, "space", function () awful.layout.inc( 1)                end,
              {description = "select next", group = "layout"}),
    awful.key({ modkey, "Shift"   }, "space", function () awful.layout.inc(-1)                end,
              {description = "select previous", group = "layout"}),

    awful.key({ modkey, "Control" }, "n",
              function ()
                  local c = awful.client.restore()
                  -- Focus restored client
                  if c then
                      client.focus = c
                      c:raise()
                  end
              end,
              {description = "restore minimized", group = "client"}),

    -- Dropdown application
    awful.key({ modkey, }, "z", function () quake:toggle() end,
              {description = "dropdown application", group = "launcher"}),

    -- Widgets popups
    awful.key({ altkey, }, "c", function () if beautiful.cal then beautiful.cal.show(7) end end,
              {description = "show calendar", group = "widgets"}),
    awful.key({ altkey, }, "h", function () if beautiful.fs then beautiful.fs.show(7) end end,
              {description = "show filesystem", group = "widgets"}),
    awful.key({ altkey, }, "w", function () if beautiful.weather then beautiful.weather.show(7) end end,
              {description = "show weather", group = "widgets"}),

    -- Brightness
    awful.key({ }, "XF86MonBrightnessUp", function () os.execute("xbacklight -inc 10") end,
              {description = "+10%", group = "hotkeys"}),
    awful.key({ }, "XF86MonBrightnessDown", function () os.execute("xbacklight -dec 10") end,
              {description = "-10%", group = "hotkeys"}),

--[[
    -- ALSA volume control
    awful.key({ altkey }, "Up",
        function ()
            os.execute(string.format("amixer -q set %s 1%%+", beautiful.volume.channel))
            beautiful.volume.update()
        end,
        {description = "volume up", group = "hotkeys"}),
    awful.key({ altkey }, "Down",
        function ()
            os.execute(string.format("amixer -q set %s 1%%-", beautiful.volume.channel))
            beautiful.volume.update()
        end,
        {description = "volume down", group = "hotkeys"}),
    awful.key({ altkey }, "m",
        function ()
            os.execute(string.format("amixer -q set %s toggle", beautiful.volume.togglechannel or beautiful.volume.channel))
            beautiful.volume.update()
        end,
        {description = "toggle mute", group = "hotkeys"}),
    awful.key({ altkey, "Control" }, "m",
        function ()
            os.execute(string.format("amixer -q set %s 100%%", beautiful.volume.channel))
            beautiful.volume.update()
        end,
        {description = "volume 100%", group = "hotkeys"}),
    awful.key({ altkey, "Control" }, "0",
        function ()
            os.execute(string.format("amixer -q set %s 0%%", beautiful.volume.channel))
            beautiful.volume.update()
        end,
        {description = "volume 0%", group = "hotkeys"}),
--]]

    -- MPD control
    awful.key({ altkey, "Control" }, "Up",
        function ()
            os.execute("mpc toggle")
            beautiful.mpd.update()
        end,
        {description = "mpc toggle", group = "widgets"}),
    awful.key({ altkey, "Control" }, "Down",
        function ()
            os.execute("mpc stop")
            beautiful.mpd.update()
        end,
        {description = "mpc stop", group = "widgets"}),
    awful.key({ altkey, "Control" }, "Left",
        function ()
            os.execute("mpc prev")
            beautiful.mpd.update()
        end,
        {description = "mpc prev", group = "widgets"}),
    awful.key({ altkey, "Control" }, "Right",
        function ()
            os.execute("mpc next")
            beautiful.mpd.update()
        end,
        {description = "mpc next", group = "widgets"}),
    awful.key({ altkey }, "0",
        function ()
            local common = { text = "MPD widget ", timeout = 2 }
            if beautiful.mpd.timer.started then
                beautiful.mpd.timer:stop()
                common.text = common.text .. lain.util.markup.bold("OFF")
            else
                beautiful.mpd.timer:start()
                common.text = common.text .. lain.util.markup.bold("ON")
            end
            naughty.notify(common)
        end,
        {description = "mpc on/off", group = "widgets"}),

    -- Copy primary to clipboard (terminals to gtk)
    awful.key({ modkey }, "c", function () awful.spawn.with_shell("xsel | xsel -i -b") end,
              {description = "copy terminal to gtk", group = "hotkeys"}),
    -- Copy clipboard to primary (gtk to terminals)
    awful.key({ modkey }, "v", function () awful.spawn.with_shell("xsel -b | xsel") end,
              {description = "copy gtk to terminal", group = "hotkeys"}),

    -- User programs
    awful.key({ modkey }, "q", function () awful.spawn(browser) end,
              {description = "run browser", group = "launcher"}),
    awful.key({ modkey }, "a", function () awful.spawn(guieditor) end,
              {description = "run gui editor", group = "launcher"}),

    -- Default

    -- Menubar
    awful.key({ modkey }, "p", function() menubar.show() end,
              {description = "show the menubar", group = "launcher"}),

    --[[ dmenu
    awful.key({ modkey }, "x", function ()
            os.execute(string.format("dmenu_run -i -fn 'Monospace' -nb '%s' -nf '%s' -sb '%s' -sf '%s'",
            beautiful.bg_normal, beautiful.fg_normal, beautiful.bg_focus, beautiful.fg_focus))
        end,
        {description = "show dmenu", group = "launcher"})
    --]]
    -- Prompt
    awful.key({ modkey }, "r", function () awful.screen.focused().mypromptbox:run() end,
              {description = "run prompt", group = "launcher"}),

    awful.key({ modkey }, "x",
              function ()
                  awful.prompt.run {
                    prompt       = "Run Lua code: ",
                    textbox      = awful.screen.focused().mypromptbox.widget,
                    exe_callback = awful.util.eval,
                    history_path = awful.util.get_cache_dir() .. "/history_eval"
                  }
              end,
              {description = "lua execute prompt", group = "awesome"})
    --]]
)

clientkeys = my_table.join(
    --awful.key({ altkey, "Shift"   }, "m",      lain.util.magnify_client,
    --          {description = "magnify client", group = "client"}),
    awful.key({ modkey,           }, "m",
        function (c)
            c.fullscreen = not c.fullscreen
            c:raise()
        end,
        {description = "toggle fullscreen", group = "client"}),
    awful.key({ modkey, "Shift"   }, "c",      function (c) c:kill()                         end,
              {description = "close", group = "client"}),
    awful.key({ modkey,           }, "f",  awful.client.floating.toggle                     ,
              {description = "toggle floating", group = "client"}),
    awful.key({ modkey, "Control" }, "Return", function (c) c:swap(awful.client.getmaster()) end,
              {description = "move to master", group = "client"}),
    awful.key({ modkey,           }, "o",      function (c) c:move_to_screen()               end,
              {description = "move to screen", group = "client"}),
    awful.key({ modkey,           }, "t",      function (c) c.ontop = not c.ontop            end,
              {description = "toggle keep on top", group = "client"}),
    awful.key({ modkey,           }, "s",      function (c) c.sticky = not c.sticky          end,
              {description = "toggle sticky", group = "client"}),
    awful.key({ modkey,           }, "n",
        function (c)
            -- The client currently has the input focus, so it cannot be
            -- minimized, since minimized clients can't have the focus.
            c.minimized = true
        end ,
        {description = "minimize", group = "client"}),
    awful.key({ modkey,           }, "m",
        function (c)
            c.maximized = not c.maximized
            c:raise()
        end ,
        {description = "maximize", group = "client"}),

    awful.key({ modkey,           }, "i",
        function (c)
            c.prefer_master = not c.prefer_master
            if c.prefer_master then 
                awful.client.setmaster(c) 
            else
                awful.client.setslave(c)
            end            
            if c.first_tag then update_master_count(c.first_tag) end
        end,
        {description = "toggle prefer master", group = "client"})
)

-- Bind all key numbers to tags.
-- Be careful: we use keycodes to make it works on any keyboard layout.
-- This should map on the top row of your keyboard, usually 1 to 9.
for i = 1, 9 do
    -- Hack to only show tags 1 and 9 in the shortcut window (mod+s)
    local descr_view, descr_toggle, descr_move, descr_toggle_focus
    if i == 1 or i == 9 then
        descr_view = {description = "view tag #", group = "tag"}
        descr_toggle = {description = "toggle tag #", group = "tag"}
        descr_move = {description = "move focused client to tag #", group = "tag"}
        descr_toggle_focus = {description = "toggle focused client on tag #", group = "tag"}
    end
    globalkeys = my_table.join(globalkeys,
        -- View tag only.
        awful.key({ modkey }, "#" .. i + 9,
                  function ()
                        local screen = awful.screen.focused()
                        local tag = screen.tags[i]
                        if tag then
                           tag:view_only()
                        end
                  end,
                  descr_view),
        -- Toggle tag display.
        awful.key({ modkey, "Control" }, "#" .. i + 9,
                  function ()
                      local screen = awful.screen.focused()
                      local tag = screen.tags[i]
                      if tag then
                         awful.tag.viewtoggle(tag)
                      end
                  end,
                  descr_toggle),
        -- Move client to tag.
        awful.key({ modkey, "Shift" }, "#" .. i + 9,
                  function ()
                      if client.focus then
                          local tag = client.focus.screen.tags[i]
                          if tag then
                              client.focus:move_to_tag(tag)
                          end
                     end
                  end,
                  descr_move),
        -- Toggle tag on focused client.
        awful.key({ modkey, "Control", "Shift" }, "#" .. i + 9,
                  function ()
                      if client.focus then
                          local tag = client.focus.screen.tags[i]
                          if tag then
                              client.focus:toggle_tag(tag)
                          end
                      end
                  end,
                  descr_toggle_focus)
    )
end

clientbuttons = gears.table.join(
    awful.button({ }, 1, function (c)
        c:emit_signal("request::activate", "mouse_click", {raise = true})
    end),
    awful.button({ modkey }, 1, function (c)
        c:emit_signal("request::activate", "mouse_click", {raise = true})
        awful.mouse.client.move(c)
    end),
    awful.button({ modkey }, 3, function (c)
        c:emit_signal("request::activate", "mouse_click", {raise = true})
        awful.mouse.client.resize(c)
    end)
)

-- Set keys
root.keys(globalkeys)
-- ]]]

-- [[[ Rules
-- Rules to apply to new clients (through the "manage" signal).
awful.rules.rules = {
    -- All clients will match this rule.
    { rule = { },
      properties = { border_width = beautiful.border_width,
                     border_color = beautiful.border_normal,
                     focus = awful.client.focus.filter,
                     raise = true,
                     keys = clientkeys,
                     buttons = clientbuttons,
                     screen = awful.screen.preferred,
                     --placement = awful.placement.centered+awful.placement.no_overlap+awful.placement.no_offscreen,
                     placement = awful.placement.centered+awful.placement.no_offscreen,
                     size_hints_honor = false,
                     prefer_master = false
     }
    },

    -- Titlebars
    --{ rule_any = { type = { "dialog", "normal" } },
    --  properties = { titlebars_enabled = true } },

    -- Set Firefox to always map on the first tag on screen 1.
    --{ rule = { class = "Firefox" },
    --  properties = { screen = 1, tag = awful.util.tagnames[1] } },

    --{ rule = { class = "Gimp", role = "gimp-image-window" },
    --      properties = { maximized = true } },

    --Float 'em
    { rule_any =
        { class = 
            {
                "QjackCtl", "Emixer"
            }
        },
        properties = { floating = true }
    },
    --Don't float 'em
    --[[
    { rule_any =
        { class = 
            {
                "Xephyr"
            }
        },
        properties = { floating = false }
    },
    --]]
    --Apps to hide titlebars for
    { rule_any = 
        { class =
            {
                "Lxterminal", "Steam", "cool-retro-term",
                --GTK3 Apps
                "Lutris", "Gnome-calculator", "Org.gnome.gedit", "Eog", 
                "Gnome-twitch", "Evince", "Com.github.tkashkin.gamehub",
                "Baobab", "org.remmina.Remmina", "Gedit", "sound-juicer"
            }
        },
      properties = { titlebars_enabled = false }
    },

    --Apps which prefer to be a master window
    { rule_any =
        { class = 
            { 
                "firefox", "librewolf", "LibreWolf", "Navigator", "gimp", "Gimp", "lbry", "LBRY", "mpv", "Steam", 
                "com.github.tkashkin.gamehub", "Com.github.tkashkin.gamehub", "vlc", "geany", "Geany",
                "Gnucash", "gnucash", "brave-browser", "Brave-browser", "org.remmina.Remmina",
                "libreoffice", "libreoffice-calc", "libreoffice-writer", "Trello", "Ardour", "Mixbus", "Xephyr"
            },
          instance = 
            {
                "libreoffice", "libreoffice-calc", "libreoffice-writer", "Xephyr"
            }
        },
      except_any =
        { name = 
            { 
                "Remmina Remote Desktop Client"
            }
        },
      properties = { prefer_master = true },
    },
}
-- ]]]

-- [[[ Signals
-- Signal function to execute when a new client appears.

function update_master_count(t)
    --set the master_count to however many windows want master status, within a bounded range.
    local prefer_master_count = 0
    local cls = t:clients()
    for i = 1, #cls do
        if cls[i].prefer_master == true and cls[i].floating == false then
            --naughty.notify({ title = cls[i].name, text = "true" })
            prefer_master_count = prefer_master_count + 1
        else
            --naughty.notify({ title = cls[i].name, text = "false" })
        end
    end

    t.master_count = math.max(math.min(prefer_master_count, 4), 1)
end

function cleanup_tags(s)
    s = s or awful.screen.focused()
    local last_tag_with_clients = 0
    for i = 1, #s.tags do
        if #s.tags[i]:clients() > 0 then
            last_tag_with_clients = i
        end
    end

    --Add tag if all tags have clients
    if last_tag_with_clients == #s.tags then
        add_tag(s)
    end

    --Delete tags if there are more than one empty at the end
    if last_tag_with_clients < #s.tags - 1 then
        for i = #s.tags, last_tag_with_clients + 2, -1 do
            delete_tag(s.tags[i])
        end
    end
end

function add_tag(s)
    s = s or awful.screen.focused()
    awful.tag.add(tostring(#s.tags + 1), { screen = awful.screen.focused(), layout = awful.layout.layouts[1] })
end

function delete_tag(t)
    t = t or awful.screen.focused().selected_tag
    if not t then return end
    t:delete()
end

function set_tag_names(s)
    s = s or awful.screen.focused()
    for i = 1, #s.tags do
        local cls = s.tags[i]:clients()
        if #cls > 0 then
            s.tags[i].name = tostring(i) .. ":" .. string.lower(cls[1].class)
        else
            s.tags[i].name = tostring(i)
        end
    end
end

client.connect_signal("manage", function (c)

    if c.first_tag then update_master_count(c.first_tag) end

    -- Set the windows at the slave,
    -- i.e. put it at the end of others instead of setting it master.
    if not awesome.startup 
       and not c.prefer_master then 
       awful.client.setslave(c) 
    end

    if awesome.startup and
      not c.size_hints.user_position
      and not c.size_hints.program_position then
        -- Prevent clients from being unreachable after screen count changes.
        awful.placement.no_offscreen(c)
    end

    cleanup_tags(c.first_tag.screen)
    --set_tag_names(c.first_tag.screen)
end)

tag.connect_signal("untagged", function (t)
    if #t:clients() > 0 then
        update_master_count(t)
    end

    cleanup_tags(t.screen)
    --set_tag_names(t.screen)
end)

client.connect_signal("property::floating", function(c)
    if not awesome.startup and c.first_tag then update_master_count(c.first_tag) end
end)


-- Add a titlebar if titlebars_enabled is set to true in the rules.
client.connect_signal("request::titlebars", function(c)
    -- Custom
    if beautiful.titlebar_fun then
        beautiful.titlebar_fun(c)
        return
    end

    -- Default
    -- buttons for the titlebar
    local buttons = my_table.join(
        awful.button({ }, 1, function()
            c:emit_signal("request::activate", "titlebar", {raise = true})
            awful.mouse.client.move(c)
        end),
        awful.button({ }, 3, function()
            c:emit_signal("request::activate", "titlebar", {raise = true})
            awful.mouse.client.resize(c)
        end)
    )

    awful.titlebar(c, {size = 16}) : setup {
        { -- Left
            awful.titlebar.widget.iconwidget(c),
            buttons = buttons,
            layout  = wibox.layout.fixed.horizontal
        },
        { -- Middle
            { -- Title
                align  = "center",
                widget = awful.titlebar.widget.titlewidget(c)
            },
            buttons = buttons,
            layout  = wibox.layout.flex.horizontal
        },
        { -- Right
            awful.titlebar.widget.floatingbutton (c),
            awful.titlebar.widget.maximizedbutton(c),
            awful.titlebar.widget.stickybutton   (c),
            awful.titlebar.widget.ontopbutton    (c),
            awful.titlebar.widget.closebutton    (c),
            layout = wibox.layout.fixed.horizontal()
        },
        layout = wibox.layout.align.horizontal
    }
end)

-- Enable sloppy focus, so that focus follows mouse.
client.connect_signal("mouse::enter", function(c)
    c:emit_signal("request::activate", "mouse_enter", {raise = false})
end)

-- No border for maximized clients
function border_adjust(c)
    if c.maximized then -- no borders if only 1 client visible
        c.border_width = 0
    elseif #awful.screen.focused().clients > 1 then
        c.border_width = beautiful.border_width
        c.border_color = beautiful.border_focus
    end
end

client.connect_signal("property::maximized", border_adjust)
client.connect_signal("focus", border_adjust)
client.connect_signal("unfocus", function(c) c.border_color = beautiful.border_normal end)
-- ]]]