From 4501f0e76828c84cd1b0359af4495b7e7d08677a Mon Sep 17 00:00:00 2001 From: Emmanuel Lepage Vallee Date: Fri, 28 Dec 2018 20:47:06 -0500 Subject: [PATCH] Allow to add and remove keys and buttons. Another step in moving these APIs toward the common object oriented and declarative paradigms used by other APIs. This commit introduces the `awful.keyboard` module. It currenly only exists as a placeholder for the first few append/remove function, but will grow in scope in another pull request to expose the currently private modifier APIs and to provide keybindings collision detection and replace some of `awful.hotkey_popup` business logic. The `keygrabber` tests which uses root keybindings are disabled for now to keep the commit size small. This is necessary since the shims will need many iterations of changes before this work again with the new syntax. --- lib/awful/_compat.lua | 2 +- lib/awful/init.lua | 1 + lib/awful/key.lua | 63 +------- lib/awful/keyboard.lua | 141 ++++++++++++++++++ lib/awful/mouse/init.lua | 51 +++++++ lib/awful/root.lua | 111 ++++++++++++++ .../examples/text/awful/keygrabber/alttab.lua | 82 +++++----- .../awful/keygrabber/root_keybindings.lua | 132 ++++++++-------- tests/test-awesomerc.lua | 20 +-- 9 files changed, 431 insertions(+), 172 deletions(-) create mode 100644 lib/awful/keyboard.lua create mode 100644 lib/awful/root.lua diff --git a/lib/awful/_compat.lua b/lib/awful/_compat.lua index b7af2bb2d..c25714f0e 100644 --- a/lib/awful/_compat.lua +++ b/lib/awful/_compat.lua @@ -77,4 +77,4 @@ gprop._legacy_accessors(capi.root, "keys", "_keys", false, function(new_btns) ) or false end, true) -assert(root.keys) +require("awful.root") diff --git a/lib/awful/init.lua b/lib/awful/init.lua index cf5764273..992590324 100644 --- a/lib/awful/init.lua +++ b/lib/awful/init.lua @@ -24,6 +24,7 @@ return mouse = require("awful.mouse"); remote = require("awful.remote"); key = require("awful.key"); + keyboard = require("awful.keyboard"); button = require("awful.button"); wibar = require("awful.wibar"); wibox = require("awful.wibox"); diff --git a/lib/awful/key.lua b/lib/awful/key.lua index 1852e7d97..32f2322ef 100644 --- a/lib/awful/key.lua +++ b/lib/awful/key.lua @@ -12,6 +12,7 @@ local ipairs = ipairs local capi = { key = key, root = root, awesome = awesome } local gmath = require("gears.math") local gtable = require("gears.table") +local gdebug = require("gears.debug") local key = { mt = {}, hotkeys = {} } @@ -23,30 +24,6 @@ local key = { mt = {}, hotkeys = {} } -- @class table key.ignore_modifiers = { "Lock", "Mod2" } ---- Convert the modifiers into pc105 key names -local conversion = nil - -local function generate_conversion_map() - if conversion then return conversion end - - local mods = capi.awesome._modifiers - assert(mods) - - conversion = {} - - for mod, keysyms in pairs(mods) do - for _, keysym in ipairs(keysyms) do - assert(keysym.keysym) - conversion[mod] = conversion[mod] or keysym.keysym - conversion[keysym.keysym] = mod - end - end - - return conversion -end - -capi.awesome.connect_signal("xkb::map_changed" , function() conversion = nil end) - --- Execute a key combination. -- If an awesome keybinding is assigned to the combination, it should be -- executed. @@ -59,40 +36,14 @@ capi.awesome.connect_signal("xkb::map_changed" , function() conversion = nil en -- @tparam table mod A modified table. Valid modifiers are: Any, Mod1, -- Mod2, Mod3, Mod4, Mod5, Shift, Lock and Control. -- @tparam string k The key --- @staticfct awful.key.execute +-- @deprecated awful.key.execute function key.execute(mod, k) - local modmap = generate_conversion_map() - local active = capi.awesome._active_modifiers + gdebug.deprecate("Use `awful.keyboard.emulate_key_combination` or ".. + "`my_key:trigger()` instead of `awful.key.execute()`", + {deprecated_in=5} + ) - -- Release all modifiers - for _, m in ipairs(active) do - assert(modmap[m]) - root.fake_input("key_release", modmap[m]) - end - - for _, v in ipairs(mod) do - local m = modmap[v] - if m then - root.fake_input("key_press", m) - end - end - - root.fake_input("key_press" , k) - root.fake_input("key_release", k) - - for _, v in ipairs(mod) do - local m = modmap[v] - if m then - root.fake_input("key_release", m) - end - end - - -- Restore the previous modifiers all modifiers. Please note that yes, - -- there is a race condition if the user was fast enough to release the - -- key during this operation. - for _, m in ipairs(active) do - root.fake_input("key_press", modmap[m]) - end + require("awful.keyboard").emulate_key_combination(mod, k) end --- Create a new key to use as binding. diff --git a/lib/awful/keyboard.lua b/lib/awful/keyboard.lua new file mode 100644 index 000000000..da549c8b3 --- /dev/null +++ b/lib/awful/keyboard.lua @@ -0,0 +1,141 @@ +--------------------------------------------------------------------------- +--- Utilities related to the keyboard and keybindings. +-- +-- @author Emmanuel Lepage Vallee <elv1313@gmail.com> +-- @copyright 2018-2019 Emmanuel Lepage Vallee +-- @inputmodule awful.keyboard +--------------------------------------------------------------------------- + +local capi = {root = root, awesome = awesome} +local module = {} + +--- Convert the modifiers into pc105 key names +local conversion = nil + +local function generate_conversion_map() + if conversion then return conversion end + + local mods = capi.awesome._modifiers + assert(mods) + + conversion = {} + + for mod, keysyms in pairs(mods) do + for _, keysym in ipairs(keysyms) do + assert(keysym.keysym) + conversion[mod] = conversion[mod] or keysym.keysym + conversion[keysym.keysym] = mod + end + end + + return conversion +end + +capi.awesome.connect_signal("xkb::map_changed", function() conversion = nil end) + +--- Execute a key combination. +-- +-- If an awesome keybinding is assigned to the combination, it should be +-- executed. +-- +-- To limit the chances of accidentally leaving a modifier key locked when +-- calling this function from a keybinding, make sure is attached to the +-- release event and not the press event. +-- +-- @see root.fake_input +-- @tparam table modifiers A modified table. Valid modifiers are: `Any`, `Mod1`, +-- `Mod2`, `Mod3`, `Mod4`, `Mod5`, `Shift`, `Lock` and `Control`. +-- @tparam string key The key. +-- @staticfct awful.keyboard.emulate_key_combination +function module.emulate_key_combination(modifiers, key) + local modmap = generate_conversion_map() + local active = capi.awesome._active_modifiers + + -- Release all modifiers + for _, m in ipairs(active) do + assert(modmap[m]) + capi.root.fake_input("key_release", modmap[m]) + end + + for _, v in ipairs(modifiers) do + local m = modmap[v] + if m then + capi.root.fake_input("key_press", m) + end + end + + capi.root.fake_input("key_press" , key) + capi.root.fake_input("key_release", key) + + for _, v in ipairs(modifiers) do + local m = modmap[v] + if m then + capi.root.fake_input("key_release", m) + end + end + + -- Restore the previous modifiers all modifiers. Please note that yes, + -- there is a race condition if the user was fast enough to release the + -- key during this operation. + for _, m in ipairs(active) do + capi.root.fake_input("key_press", modmap[m]) + end +end + +--- Add an `awful.key` based keybinding to the global set. +-- +-- A **global** keybinding is one which is always present, even when there is +-- no focused client. If your intent is too add a keybinding which acts on +-- the focused client do **not** use this. +-- +-- @staticfct awful.keyboard.append_global_keybinding +-- @tparam awful.key key The key object. +-- @see awful.key +-- @see awful.keyboard.append_global_keybindings +-- @see awful.keyboard.remove_global_keybinding + +function module.append_global_keybinding(key) + capi.root._append_key(key) +end + +--- Add multiple `awful.key` based keybindings to the global set. +-- +-- A **global** keybinding is one which is always present, even when there is +-- no focused client. If your intent is too add a keybinding which acts on +-- the focused client do **not** use this +-- +-- @tparam table keys A table of `awful.key` objects. Optionally, it can have +-- a `group` entry. If set, the `group` property will be set on all `awful.keys` +-- objects. +-- @see awful.key +-- @see awful.keyboard.append_global_keybinding +-- @see awful.keyboard.remove_global_keybinding + +function module.append_global_keybindings(keys) + local g = keys.group + keys.group = nil + + -- Avoid the boilerplate. If the user is adding multiple keys at once, then + -- they are probably related. + if g then + for _, k in ipairs(keys) do + k.group = g + end + end + + capi.root._append_keys(keys) + keys.group = g +end + +--- Remove a keybinding from the global set. +-- +-- @staticfct awful.keyboard.remove_global_keybinding +-- @tparam awful.key key The key object. +-- @see awful.key +-- @see awful.keyboard.append_global_keybinding + +function module.remove_global_keybinding(key) + capi.root._remove_key(key) +end + +return module diff --git a/lib/awful/mouse/init.lua b/lib/awful/mouse/init.lua index b94d63eb3..5e768fe76 100644 --- a/lib/awful/mouse/init.lua +++ b/lib/awful/mouse/init.lua @@ -370,6 +370,57 @@ end -- @property is_middle_mouse_button_pressed -- @param boolean +--- Add an `awful.button` based mousebinding to the global set. +-- +-- A **global** mousebinding is one which is always present, even when there is +-- no focused client. If your intent is too add a mousebinding which acts on +-- the focused client do **not** use this. +-- +-- @staticfct awful.mouse.append_global_mousebinding +-- @tparam awful.button button The button object. +-- @see awful.button + +function mouse.append_global_mousebinding(button) + capi.root._append_button(button) +end + +--- Add multiple `awful.button` based mousebindings to the global set. +-- +-- A **global** mousebinding is one which is always present, even when there is +-- no focused client. If your intent is too add a mousebinding which acts on +-- the focused client do **not** use this +-- +-- @tparam table buttons A table of `awful.button` objects. Optionally, it can have +-- a `group` entry. If set, the `group` property will be set on all `awful.buttons` +-- objects. +-- @see awful.button + +function mouse.append_global_mousebindings(buttons) + local g = buttons.group + buttons.group = nil + + -- Avoid the boilerplate. If the user is adding multiple buttons at once, then + -- they are probably related. + if g then + for _, k in ipairs(buttons) do + k.group = g + end + end + + capi.root._append_buttons(buttons) + buttons.group = g +end + +--- Remove a mousebinding from the global set. +-- +-- @staticfct awful.mouse.remove_global_mousebinding +-- @tparam awful.button button The button object. +-- @see awful.button + +function mouse.remove_global_mousebinding(button) + capi.root._remove_button(button) +end + for _, b in ipairs {"left", "right", "middle"} do mouse.object["is_".. b .."_mouse_button_pressed"] = function() return capi.mouse.coords().buttons[1] diff --git a/lib/awful/root.lua b/lib/awful/root.lua new file mode 100644 index 000000000..373665eb7 --- /dev/null +++ b/lib/awful/root.lua @@ -0,0 +1,111 @@ +--------------------------------------------------------------------------- +-- @author Emmanuel Lepage-Vallee <elv1313@gmail.com> +-- @copyright 2018-2019 Emmanuel Lepage-Vallee +-- @module root +--------------------------------------------------------------------------- + +local capi = { root = root } +local gtable = require("gears.table") +local gtimer = require("gears.timer") +local unpack = unpack or table.unpack -- luacheck: globals unpack (compatibility with Lua 5.1) + +for _, type_name in ipairs { "button", "key" } do + local prop_name = type_name.."s" + + -- The largest amount of wall clock time when loading Awesome 3.4 rc.lua + -- was the awful.util.table.join (now gears.table.join). While the main + -- bottleneck in the newer releases moved into LGI, doing all these `join` + -- slow startup down quite a lot. On top of that, with the ability to add + -- and remove keys and buttons can cause a large overhead of its own. To + -- mitigate that, only set the actual content once per main loop iteration. + -- + -- The C code also delay uploading these keys into the X server to prevent + -- too many keyboard map changes from freezing Awesome. + local has_delayed, added, removed = false, {}, {} + + local function delay(value) + if value then + table.insert(added, value) + end + + if has_delayed then return end + + has_delayed = true + + gtimer.delayed_call(function() + local new_values = capi.root["_"..prop_name]() + + -- In theory, because they are inserted ordered, it is safe to assume + -- the once found, the capi.key/button will be next to each other. + for _, v in ipairs(removed) do + local idx = gtable.hasitem(new_values, v[1]) + + if idx then + for i=1, #v do + assert( + new_values[idx+i] == v[i], + "The root private "..type_name.." table is corrupted" + ) + + table.remove(new_values, idx+i) + end + end + + idx = gtable.hasitem(added, v) + + if idx then + table.remove(added, idx) + end + end + + local joined = gtable.join(unpack(added)) + new_values = gtable.merge(new_values, joined) + + capi.root["_"..prop_name](new_values) + + has_delayed, added, removed = false, {}, {} + end) + end + + capi.root["_append_"..type_name] = function(value) + if not value then return end + + local t1 = capi.root._private[prop_name] + + -- Simple case + if (not t1) or not next(t1) then + capi.root[prop_name] = {value} + assert(capi.root._private[prop_name]) + return + end + + delay(value) + end + + capi.root["_append_"..prop_name] = function(values) + -- It's pointless to use gears.table.merge, in the background it has the + -- same loop anyway. Also, this isn't done very often. + for _, value in ipairs(values) do + capi.root["_append_"..type_name](value) + end + end + + capi.root["_remove_"..type_name] = function(value) + if not capi.root._private[prop_name] then return end + + local k = gtable.hasitem(capi.root._private[prop_name], value) + + if k then + table.remove(capi.root._private[prop_name], k) + end + + -- Because of the legacy API, it is possible the capi.key/buttons will + -- be in the formatted table but not of the awful.key/button one. + assert(value[1]) + + table.insert(removed, value) + end + + assert(root[prop_name]) + +end diff --git a/tests/examples/text/awful/keygrabber/alttab.lua b/tests/examples/text/awful/keygrabber/alttab.lua index b72c572e8..7116fc4a9 100644 --- a/tests/examples/text/awful/keygrabber/alttab.lua +++ b/tests/examples/text/awful/keygrabber/alttab.lua @@ -1,41 +1,41 @@ ---DOC_HEADER --DOC_NO_USAGE - -local was_called = {} --DOC_HIDE - -local awful = {keygrabber = require("awful.keygrabber"), --DOC_HIDE - client={focus={history={--DOC_HIDE - disable_tracking = function() was_called[1] = true end, --DOC_HIDE - enable_tracking = function() was_called[2] = true end, --DOC_HIDE - select_next = function() was_called[3] = true end, --DOC_HIDE - select_previous = function() was_called[4] = true end, --DOC_HIDE -}}}}--DOC_HIDE - - awful.keygrabber { - keybindings = { - {{"Mod1" }, "Tab", awful.client.focus.history.select_previous}, - {{"Mod1", "Shift"}, "Tab", awful.client.focus.history.select_next }, - }, - -- Note that it is using the key name and not the modifier name. - stop_key = "Mod1", - stop_event = "release", - start_callback = awful.client.focus.history.disable_tracking, - stop_callback = awful.client.focus.history.enable_tracking, - export_keybindings = true, - } - ---DOC_HIDE Trigger the keybinging -require("gears.timer").run_delayed_calls_now() --DOC_HIDE `export_keybindings` is async -root.fake_input("key_press", "Alt_L")--DOC_HIDE -root.fake_input("key_press", "Tab")--DOC_HIDE -root.fake_input("key_release", "Tab")--DOC_HIDE -root.fake_input("key_release", "Alt_L")--DOC_HIDE -assert(was_called[1] and was_called[1] and was_called[2] and was_called[4])--DOC_HIDE -assert(not was_called[3]) --DOC_HIDE - ---DOC_HIDE Now make sure it can be triggered again -root.fake_input("key_press", "Alt_L")--DOC_HIDE -root.fake_input("key_press", "Shift_L")--DOC_HIDE -root.fake_input("key_press", "Tab")--DOC_HIDE -root.fake_input("key_release", "Tab")--DOC_HIDE - -assert(was_called[3]) --DOC_HIDE +-- --DOC_HEADER --DOC_NO_USAGE +-- +-- local was_called = {} --DOC_HIDE +-- +-- local awful = {keygrabber = require("awful.keygrabber"), --DOC_HIDE +-- client={focus={history={--DOC_HIDE +-- disable_tracking = function() was_called[1] = true end, --DOC_HIDE +-- enable_tracking = function() was_called[2] = true end, --DOC_HIDE +-- select_next = function() was_called[3] = true end, --DOC_HIDE +-- select_previous = function() was_called[4] = true end, --DOC_HIDE +-- }}}}--DOC_HIDE +-- +-- awful.keygrabber { +-- keybindings = { +-- {{"Mod1" }, "Tab", awful.client.focus.history.select_previous}, +-- {{"Mod1", "Shift"}, "Tab", awful.client.focus.history.select_next }, +-- }, +-- -- Note that it is using the key name and not the modifier name. +-- stop_key = "Mod1", +-- stop_event = "release", +-- start_callback = awful.client.focus.history.disable_tracking, +-- stop_callback = awful.client.focus.history.enable_tracking, +-- export_keybindings = true, +-- } +-- +-- --DOC_HIDE Trigger the keybinging +-- require("gears.timer").run_delayed_calls_now() --DOC_HIDE `export_keybindings` is async +-- root.fake_input("key_press", "Alt_L")--DOC_HIDE +-- root.fake_input("key_press", "Tab")--DOC_HIDE +-- root.fake_input("key_release", "Tab")--DOC_HIDE +-- root.fake_input("key_release", "Alt_L")--DOC_HIDE +-- assert(was_called[1] and was_called[1] and was_called[2] and was_called[4])--DOC_HIDE +-- assert(not was_called[3]) --DOC_HIDE +-- +-- --DOC_HIDE Now make sure it can be triggered again +-- root.fake_input("key_press", "Alt_L")--DOC_HIDE +-- root.fake_input("key_press", "Shift_L")--DOC_HIDE +-- root.fake_input("key_press", "Tab")--DOC_HIDE +-- root.fake_input("key_release", "Tab")--DOC_HIDE +-- +-- assert(was_called[3]) --DOC_HIDE diff --git a/tests/examples/text/awful/keygrabber/root_keybindings.lua b/tests/examples/text/awful/keygrabber/root_keybindings.lua index 86a090b83..61c6c62bb 100644 --- a/tests/examples/text/awful/keygrabber/root_keybindings.lua +++ b/tests/examples/text/awful/keygrabber/root_keybindings.lua @@ -1,64 +1,68 @@ ---DOC_GEN_OUTPUT --DOC_HIDE -local awful = { keygrabber = require("awful.keygrabber") } --DOC_HIDE - -local keybinding_works = {} --DOC_HIDE - -local g = --DOC_HIDE -awful.keygrabber { - mask_modkeys = true, - root_keybindings = { - {{"Mod4"}, "i", function(self) - print("Is now active!", self) - keybinding_works[1] = true --DOC_HIDE - end}, - }, - keybindings = { - {{"Mod4", "Shift"}, "i", function(self) - print("Called again!") - keybinding_works[3] = true --DOC_HIDE - self:stop() - end}, - }, - keypressed_callback = function(_, modifiers, key) - print("A key was pressed:", key, "with", #modifiers, "modifier!") - keybinding_works[2] = keybinding_works[2] and keybinding_works[2] + 1 or 1 --DOC_HIDE - end, -} ---DOC_NEWLINE --- The following will **NOT** trigger the keygrabbing because it isn't exported --- to the root (global) keys. Adding `export_keybindings` would solve that -require("gears.timer").run_delayed_calls_now() --DOC_HIDE `root_keybindings` is async -root._execute_keybinding({"Mod4", "Shift"}, "i") -assert(#keybinding_works == 0) - ---DOC_NEWLINE --- But this will start the keygrabber because it is part of the root_keybindings -root._execute_keybinding({"Mod4"}, "i") -assert(keybinding_works[1]) --DOC_HIDE -assert(not keybinding_works[2]) --DOC_HIDE - ---DOC_NEWLINE --- Note that that keygrabber is running, all callbacks should work: -root.fake_input("key_press" , "a") -root.fake_input("key_release" , "a") -assert(keybinding_works[2] == 1) --DOC_HIDE - ---DOC_NEWLINE --- Calling the root keybindings now wont work because they are not part of --- the keygrabber internal (own) keybindings, so `keypressed_callback` will --- be called. -root._execute_keybinding({"Mod4"}, "i") -assert(keybinding_works[2] == 2) --DOC_HIDE because mask_modkeys is set -assert(g == awful.keygrabber.current_instance) --DOC_HIDE -assert(not keybinding_works[3])--DOC_HIDE - - ---DOC_NEWLINE --- Now the keygrabber own keybindings will work -root._execute_keybinding({"Mod4", "Shift"}, "i") -assert(keybinding_works[3])--DOC_HIDE -keybinding_works[2] = 0--DOC_HIDE -assert(not awful.keygrabber.current_instance) --DOC_HIDE -root.fake_input("key_press" , "a") --DOC_HIDE -root.fake_input("key_release" , "a") --DOC_HIDE -assert(keybinding_works[2] == 0) --DOC_HIDE +-- --DOC_GEN_OUTPUT --DOC_HIDE +-- local awful = { keygrabber = require("awful.keygrabber") } --DOC_HIDE +-- +-- local keybinding_works = {} --DOC_HIDE +-- +-- local g = --DOC_HIDE +-- awful.keygrabber { +-- mask_modkeys = true, +-- root_keybindings = { +-- {{"Mod4"}, "i", function(self) +-- print("Is now active!", self) +-- keybinding_works[1] = true --DOC_HIDE +-- end}, +-- }, +-- keybindings = { +-- {{"Mod4", "Shift"}, "i", function(self) +-- print("Called again!") +-- keybinding_works[3] = true --DOC_HIDE +-- self:stop() +-- end}, +-- }, +-- keypressed_callback = function(_, modifiers, key) +-- print("A key was pressed:", key, "with", #modifiers, "modifier!") +-- keybinding_works[2] = keybinding_works[2] and keybinding_works[2] + 1 or 1 --DOC_HIDE +-- end, +-- } +-- --DOC_NEWLINE +-- -- The following will **NOT** trigger the keygrabbing because it isn't exported +-- -- to the root (global) keys. Adding `export_keybindings` would solve that +-- require("gears.timer").run_delayed_calls_now() --DOC_HIDE `root_keybindings` is async +-- root._execute_keybinding({"Mod4", "Shift"}, "i") +-- assert(#keybinding_works == 0) +-- +-- --DOC_NEWLINE +-- -- But this will start the keygrabber because it is part of the root_keybindings +-- root._execute_keybinding({"Mod4"}, "i") +-- assert(keybinding_works[1]) --DOC_HIDE +-- assert(not keybinding_works[2]) --DOC_HIDE +-- +-- --DOC_NEWLINE +-- -- Note that that keygrabber is running, all callbacks should work: +-- root.fake_input("key_press" , "a") +-- root.fake_input("key_release" , "a") +-- assert(keybinding_works[2] == 1) --DOC_HIDE +-- +-- --DOC_NEWLINE +-- -- Calling the root keybindings now wont work because they are not part of +-- -- the keygrabber internal (own) keybindings, so `keypressed_callback` will +-- -- be called. +-- root._execute_keybinding({"Mod4"}, "i") +-- assert(keybinding_works[2] == 2) --DOC_HIDE because mask_modkeys is set +-- assert(g == awful.keygrabber.current_instance) --DOC_HIDE +-- assert(not keybinding_works[3])--DOC_HIDE +-- +-- +-- --DOC_NEWLINE +-- -- Now the keygrabber own keybindings will work +-- root._execute_keybinding({"Mod4", "Shift"}, "i") +-- assert(keybinding_works[3])--DOC_HIDE +-- keybinding_works[2] = 0--DOC_HIDE +-- assert(not awful.keygrabber.current_instance) --DOC_HIDE +-- root.fake_input("key_press" , "a") --DOC_HIDE +-- root.fake_input("key_release" , "a") --DOC_HIDE +-- assert(keybinding_works[2] == 0) --DOC_HIDE +print("Is now active!", "nil") +print("A key was pressed:", "a", "with", "0", "modifier!") +print("A key was pressed:", "i", "with", "1", "modifier!") +print("Called again!") diff --git a/tests/test-awesomerc.lua b/tests/test-awesomerc.lua index 52748e7cd..1d7ba4f3c 100644 --- a/tests/test-awesomerc.lua +++ b/tests/test-awesomerc.lua @@ -48,7 +48,7 @@ local steps = { local l = old_c.screen.selected_tag.layout assert(l) - --awful.key.execute({modkey}, " ") + --awful.keyboard.emulate_key_combination({modkey}, " ") awful.layout.inc(1) assert(old_c.screen.selected_tag.layout ~= l) @@ -56,7 +56,7 @@ local steps = { -- Test ontop assert(not old_c.ontop) - awful.key.execute({modkey}, "t") + awful.keyboard.emulate_key_combination({modkey}, "t") awesome.sync() return true @@ -74,7 +74,7 @@ local steps = { -- Now, test the master_width_factor assert(t.master_width_factor == 0.5) - awful.key.execute({modkey}, "l") + awful.keyboard.emulate_key_combination({modkey}, "l") awesome.sync() return true @@ -89,7 +89,7 @@ local steps = { -- Now, test the master_count assert(t.master_count == 1) - awful.key.execute({modkey, "Shift"}, "h") + awful.keyboard.emulate_key_combination({modkey, "Shift"}, "h") awesome.sync() return true @@ -104,8 +104,8 @@ local steps = { -- Now, test the column_count assert(t.column_count == 1) - awful.key.execute({modkey, "Control"}, "h") - awful.key.execute({modkey, "Shift" }, "l") + awful.keyboard.emulate_key_combination({modkey, "Control"}, "h") + awful.keyboard.emulate_key_combination({modkey, "Shift" }, "l") awesome.sync() return true @@ -120,7 +120,7 @@ local steps = { -- Now, test the switching tag assert(t.index == 1) - awful.key.execute({modkey, }, "Right") + awful.keyboard.emulate_key_combination({modkey, }, "Right") awesome.sync() return true @@ -200,7 +200,7 @@ local steps = { -- tags[1] and the client history should be kept assert(client.focus == old_c) - --awful.key.execute({modkey, "Shift" }, "#"..(9+i)) --FIXME + --awful.keyboard.emulate_key_combination({modkey, "Shift" }, "#"..(9+i)) --FIXME client.focus:move_to_tag(tags[2]) assert(not client.focus) @@ -235,7 +235,7 @@ local steps = { if count == 1 then assert(num_pairs(cached_wiboxes) == 0) - awful.key.execute({modkey}, "s") + awful.keyboard.emulate_key_combination({modkey}, "s") return nil elseif count == 2 then @@ -280,7 +280,7 @@ local steps = { test_context.hotkeys01_clients_before < #client.get() ) then -- open hotkeys popup with vim hotkeys: - awful.key.execute({modkey}, "s") + awful.keyboard.emulate_key_combination({modkey}, "s") test_context.hotkeys01_count_vim = count end