diff --git a/lib/awful/_compat.lua b/lib/awful/_compat.lua index b7af2bb2..c25714f0 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 cf576427..99259032 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 1852e7d9..32f2322e 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 00000000..da549c8b --- /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 b94d63eb..5e768fe7 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 00000000..373665eb --- /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 b72c572e..7116fc4a 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 86a090b8..61c6c62b 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 52748e7c..1d7ba4f3 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