dotfiles/awesome/lib/lain/util/menu_iterator.lua

--[[

     Licensed under GNU General Public License v2
      * (c) 2017, Simon Désaulniers <sim.desaulniers@gmail.com>
      * (c) 2017, Uli Schlachter
      * (c) 2017, Jeferson Siqueira <jefersonlsiq@gmail.com>

--]]

-- Menu iterator with Naughty notifications
-- lain.util.menu_iterator

local naughty = require('naughty')
local helpers = require('lain.helpers')
local atable = require('awful.util').table
local assert = assert
local pairs = pairs
local tconcat = table.concat
local unpack = unpack or table.unpack -- lua 5.1 retro-compatibility

local state = { cid = nil }

local function naughty_destroy_callback(reason)
	local closed = naughty.notificationClosedReason
	if reason == closed.expired or reason == closed.dismissedByUser then
		local actions = state.index and state.menu[state.index - 1][2]
		if actions then
			for _, action in pairs(actions) do
				-- don't try to call nil callbacks
				if action then
					action()
				end
			end
			state.index = nil
		end
	end
end

-- Iterates over a menu.
-- After the timeout, callbacks associated to the last visited choice are
-- executed. Inputs:
-- * menu:    a list of {label, {callbacks}} pairs
-- * timeout: time to wait before confirming the menu selection
-- * icon:    icon to display in the notification of the chosen label
local function iterate(menu, timeout, icon)
	timeout = timeout or 4 -- default timeout for each menu entry
	icon = icon or nil -- icon to display on the menu

	-- Build the list of choices
	if not state.index then
		state.menu = menu
		state.index = 1
	end

	-- Select one and display the appropriate notification
	local label
	local next = state.menu[state.index]
	state.index = state.index + 1

	if not next then
		label = 'Cancel'
		state.index = nil
	else
		label, _ = unpack(next)
	end

	state.cid = naughty.notify({
		text = label,
		icon = icon,
		timeout = timeout,
		screen = mouse.screen,
		replaces_id = state.cid,
		destroy = naughty_destroy_callback,
	}).id
end

-- Generates a menu compatible with the first argument of `iterate` function and
-- suitable for the following cases:
-- * all possible choices individually (partition of singletons);
-- * all possible subsets of the set of choices (powerset).
--
-- Inputs:
-- * args: an array containing the following members:
--   * choices:       Array of choices (string) on which the menu will be
--                    generated.
--   * name:          Displayed name of the menu (in the form "name: choices").
--   * selected_cb:   Callback to execute for each selected choice. Takes
--                    the choice as a string argument. Can be `nil` (no action
--                    to execute).
--   * rejected_cb:   Callback to execute for each rejected choice (possible
--                    choices which are not selected). Takes the choice as a
--                    string argument. Can be `nil` (no action to execute).
--   * extra_choices: An array of extra { choice_str, callback_fun } pairs to be
--                    added to the menu. Each callback_fun can be `nil`.
--   * combination:   The combination of choices to generate. Possible values:
--                    "powerset" and "single" (default).
-- Output:
-- * m: menu to be iterated over.
local function menu(args)
	local choices = assert(args.choices or args[1])
	local name = assert(args.name or args[2])
	local selected_cb = args.selected_cb
	local rejected_cb = args.rejected_cb
	local extra_choices = args.extra_choices or {}

	local ch_combinations = args.combination == 'powerset' and helpers.powerset(choices)
		or helpers.trivial_partition_set(choices)

	for _, c in pairs(extra_choices) do
		ch_combinations = atable.join(ch_combinations, { { c[1] } })
	end

	local m = {} -- the menu

	for _, c in pairs(ch_combinations) do
		if #c > 0 then
			local cbs = {}

			-- selected choices
			for _, ch in pairs(c) do
				if atable.hasitem(choices, ch) then
					cbs[#cbs + 1] = selected_cb and function()
						selected_cb(ch)
					end or nil
				end
			end

			-- rejected choices
			for _, ch in pairs(choices) do
				if not atable.hasitem(c, ch) and atable.hasitem(choices, ch) then
					cbs[#cbs + 1] = rejected_cb and function()
						rejected_cb(ch)
					end or nil
				end
			end

			-- add user extra choices (like the choice "None" for example)
			for _, x in pairs(extra_choices) do
				if x[1] == c[1] then
					cbs[#cbs + 1] = x[2]
				end
			end

			m[#m + 1] = { name .. ': ' .. tconcat(c, ' + '), cbs }
		end
	end

	return m
end

return { iterate = iterate, menu = menu }