Awesome WM script that restores floating clients geometry (width / height / position) when switching layouts or unmaximizing

restore_floating_clients.lua

-- Restore last used floating client geometry (with / height / position) when
-- switching layouts and unmaximizing clients.
--
-- When unmaximizing a never-before floating client, it will nicely center the
-- client in the middle of the screen.
--

local capi = {
   client = client,
   tag = tag,
   awesome = awesome
}

local awful = require("awful")
local gears = require("gears")
local json = require("cjson")

local floating_geometry = {}

function floating_geometry:identify(c)
   return (c.class or c.name) .. "_" .. c.type
end

-- Save geometries to file
function floating_geometry:save_geometries()
   local file = io.open(self.opts.file, "w")
   if file then
      file:write(json.encode(self.class_geometries))
      file:close()
   end
end

-- Load geometries from file
function floating_geometry:load_geometries()
   local file = io.open(self.opts.file, "r")
   if file then
      local content = file:read("*all")
      file:close()

      if content then
         self.class_geometries = json.decode(content)
      end
   end
end

function floating_geometry:flush_geometries()
   for _, c in ipairs(capi.client.get()) do
      local identifier = self:identify(c)
      if identifier and self.floating_client_geometries[c.window] then
	 self.class_geometries[identifier] = self.floating_client_geometries[c.window]
      end
   end
end

-- When the geometry of a client changes, and the layout is floating, then
-- store the client's maximized state. And if the client is also not maximized,
-- then also store the client's geometry. This will be used to restore the
-- client's geometry when they become floating again.
function floating_geometry:on_property_geometry(c)
   self.clients_screens[c.window] = c.screen
   if (capi.awesome.startup or awful.layout.get(awful.screen.focused()) ~= awful.layout.suit.floating)
   then
      -- Don't store anything during startup, or when we're not in a floating
      -- layout.
      return
   end

   -- Store the unmaximized state
   self.unmaximized_state[c.window] = not c.maximized
   if c.maximized then
      -- Don't store geometry for maximized clients
      return
   end

   if self.floating_client_geometries[c.window] then
      -- Store the previous client geometry, before saving new one, for
      -- the unmaximize trigger.
      self.prev_floating_client_geometries[c.window] = self.floating_client_geometries[c.window]
   end

   local geometry = c:geometry()

   -- Store client geometry
   self.floating_client_geometries[c.window] = geometry
end


-- When the layout changes, then if the layout is floating, restore the
-- geometry of clients that were not maximized the last time the floating
-- layout was used, if there is any previously stored geometry to restore.
function floating_geometry:on_property_layout(t)
   if t.layout == awful.layout.suit.floating
   then
      for k, c in ipairs(t:clients())
      do
	 if (self.floating_client_geometries[c.window] and self.unmaximized_state[c.window])
	 then
	    -- Restore client geometry
	    c:geometry(self.floating_client_geometries[c.window])
	 else
	    -- If the client was maximized in the last used floating layout,
	    -- or if there's no geometry to restore, just set the client to
	    -- maximized.
	    c.maximized = true
	 end
      end
   else
      -- If the layout is not floating, then remove the maximized state from
      -- all clients, otherwise those layouts don't work properly.
      for k, c in ipairs(t:clients()) do c.maximized = false end
   end
end

-- When changing a maximized client to unmaximized in a floating layout, then
-- restore the floating client geometry to what it was in the previous floating
-- state.
function floating_geometry:on_property_maximized(c)
   if (c.maximized or awful.layout.get(awful.screen.focused()) ~= awful.layout.suit.floating)
   then
      -- If the client is maximized, or the layout is not floating, don't
      -- restore anything.
      return
   end

   if self.prev_floating_client_geometries[c.window] then
      -- Restore client geometry
      c:geometry(self.prev_floating_client_geometries[c.window])
   else
      -- If there is no previous geometry state, then center the client nicely in the
      -- middle of the screen, so that it's not off bounds or in a corner or
      -- extremely small or anything. Then it's easy to move / resize the floating
      -- client to your wish.

      local g = c.screen.geometry
      c:geometry({
            x = g.width / 6,
            y = g.height / 6,
            width = g.width / 1.5,
            height = g.height / 1.5
      })

      -- Restore the client screen, because this seems to get lost due to the
      -- `c:geometry()` call. This issue only occurs when you have multiple
      -- screens in use.
      c.screen = self.clients_screens[c.window]
   end
end

-- When a new client appears, reset the geometry states. Because this signal
-- comes after the geometry signal, and the geometry signal in this case stores
-- incorrect geometries for a new client. So since this signal comes after the
-- geometry signal, we can reset it, so a new client starts with a blank slate.
function floating_geometry:on_manage (c)
   if (capi.awesome.startup or awful.layout.get(awful.screen.focused()) ~= awful.layout.suit.floating)
   then
      return
   end

   self.floating_client_geometries[c.window] = nil
   self.prev_floating_client_geometries[c.window] = nil

   local identifier = self:identify(c)
   if self.opts.exclude and self.opts.exclude(c)
   then
      return
   end
   if identifier and self.class_geometries[identifier] then
      c:geometry(self.class_geometries[identifier])
   end
end

function floating_geometry:on_startup()
   self:load_geometries()
end

function floating_geometry:on_exit()
   self:save_geometries()
end


function floating_geometry.new(opts)
   opts = opts or {}
   if not opts.file
   then
      opts.file = os.getenv("HOME") .. "/.config/awesome/floating-geometry.json"
   end

   --

   local obj = gears.object { class = floating_geometry }
   obj.opts = opts

   -- The following variables contain different states of clients, with the
   -- `client.window` in the key and the relevant state in the value.

   -- Store the floating clients geometries (with / height / position), so we can
   -- restore the clients when the layout changes.
   obj.floating_client_geometries = {}

   -- Store geometries by window class/name for persistence across sessions
   obj.class_geometries = {}

   -- Store the previous floating clients geometries. We need this to restore from
   -- maximized, because the maximized signal happens after the geometry signal.
   -- So the state we want to revert to gets overridden before we can restore it.
   -- Therefore we also store the previous floating client geometries.
   obj.prev_floating_client_geometries = {}

   -- Store whether a client was NOT maximized in the last used floating layout.
   -- We use this to determin whether a client should become maximized or floating
   -- when switching to floating layout.
   obj.unmaximized_state = {}

   -- Store on which screen a client is. This is needed because when setting the
   -- geometry of a client, the client seems to get moved to the first screen
   -- regardless of which screen it was on.
   obj.clients_screens = {}

   obj.flush_geometries_timer = gears.timer {
      timeout = 5,
      call_now = false,
      autostart = true,
      callback = function() obj:flush_geometries() end
   }

   obj.save_geometries_timer = gears.timer {
      timeout = 15,
      call_now = false,
      autostart = true,
      callback = function() obj:save_geometries() end
   }

   capi.client.connect_signal("manage", function(c) obj:on_manage(c) end)
   capi.client.connect_signal("property::maximized", function(c) obj:on_property_maximized(c) end)
   capi.client.connect_signal("property::geometry", function(c) obj:on_property_geometry(c) end)
   capi.tag.connect_signal("property::layout", function(t) obj:on_property_layout(t) end)
   capi.awesome.connect_signal("startup", function() obj:on_startup() end)
   capi.awesome.connect_signal("exit", function() obj:on_exit() end)
end

function floating_geometry.init(opts)
   instance = floating_geometry.new(opts)
   return instance
end

return floating_geometry