From 76657e590c956e09fb86af2ac2197bbbae351dad Mon Sep 17 00:00:00 2001 From: Lucas de Vries Date: Wed, 11 Jun 2008 10:35:54 +0200 Subject: [PATCH] [awful/tabulous] Tagging to marking, add tabulous keybindings Rename awful tagging to marking clients, create ismarked, togglemarked and unmark, use userhooks for marked and unmarked, add tabulous keybindings to the default config. Signed-off-by: Julien Danjou --- awesomerc.lua.in | 66 ++++++++++++++++++++++-- awful.lua | 130 ++++++++++++++++++++++++++++++----------------- 2 files changed, 143 insertions(+), 53 deletions(-) diff --git a/awesomerc.lua.in b/awesomerc.lua.in index db1ef4d7..05a4628d 100644 --- a/awesomerc.lua.in +++ b/awesomerc.lua.in @@ -2,6 +2,10 @@ -- Include awesome library, with lots of useful function! require("awful") +require("tabulous") + +-- Uncomment this to activate autotabbing +-- tabulous.autotab_start() -- {{{ Colors and fonts awesome.font_set("sans 8") @@ -175,15 +179,51 @@ keybinding.new({ modkey, "Shift" }, "space", function () awful.layout.inc(layout -- Menu keybinding.new({ modkey }, "F1", function () awful.menu("Run: ", mymenubox, awful.spawn) end):add() +--- Tabulous, tab manipulation +keybinding.new({ modkey, "Control" }, "y", function () + local tabbedview = tabulous.tabindex_get() + + if tabbedview == nil then + tabbedview = tabulous.tab_create() + end + + tabulous.tab(tabbedview, awful.client.next(1)) +end):add() + +keybinding.new({ modkey, "Shift" }, "y", tabulous.untab):add() + +keybinding.new({ modkey }, "y", function () + local tabbedview = tabulous.tabindex_get() + + if tabbedview ~= nil then + local n = tabulous.next(tabbedview) + tabulous.display(tabbedview, n) + end +end):add() + -- Client awful tagging: this is useful to tag some clients and then do stuff like move to tag on them -awful.client.ontag(function (c) c:border_set({ color = "red" }) end) -keybinding.new({ modkey }, "t", awful.client.tag):add() +keybinding.new({ modkey }, "t", awful.client.togglemarked):add() +keybinding.new({ modkey, 'Shift' }, "t", function () + local tabbedview = tabulous.tabindex_get() + local clients = awful.client.getmarked() + + if tabbedview == nil then + tabbedview = tabulous.tab_create(clients[1]) + table.remove(clients, 1) + end + + for k,c in pairs(clients) do + tabulous.tab(tabbedview, c) + end + +end):add() + for i = 1, keynumber do keybinding.new({ modkey, "Shift" }, "F" .. i, function () local screen = mouse.screen_get() if tags[screen][i] then - for c, v in pairs(awful.client.gettagged()) do + for k, c in pairs(awful.client.getmarked()) do awful.client.movetotag(tags[screen][i], c) end end @@ -194,12 +234,26 @@ end -- {{{ Hooks -- Hook function to execute when focusing a client. function hook_focus(c) - c:border_set({ width = 1, color = "white" }) + if not awful.client.ismarked(c) then + c:border_set({ width = 1, color = "white" }) + end end -- Hook function to execute when unfocusing a client. function hook_unfocus(c) - c:border_set({ width = 1, color = "black" }) + if not awful.client.ismarked(c) then + c:border_set({ width = 1, color = "black" }) + end +end + +-- Hook function to execute when marking a client +function hook_marked(c) + c:border_set({ width = 1, color = "red" }) +end + +-- Hook function to execute when unmarking a client +function hook_unmarked(c) + c:border_set({ width = 1, color = "white" }) end -- Hook function to exeucte when the mouse is over a client. @@ -239,6 +293,8 @@ end -- Set up some hooks awful.hooks.focus(hook_focus) awful.hooks.unfocus(hook_unfocus) +awful.hooks.marked(hook_marked) +awful.hooks.unmarked(hook_unmarked) awful.hooks.manage(hook_manage) awful.hooks.mouseover(hook_mouseover) awful.hooks.arrange(hook_arrange) diff --git a/awful.lua b/awful.lua index 95e7eedc..9b2fef2d 100644 --- a/awful.lua +++ b/awful.lua @@ -31,6 +31,26 @@ local keygrabber = keygrabber -- Reset env setfenv(1, P) +-- Hook functions, wrappers around awesome's hooks. functions so we +-- can easily add multiple functions per hook. +P.hooks = {} +P.myhooks = {} + +-- Create a new userhook (for external libs) +local function userhook_create(name) + P.myhooks[name] = {} + P.hooks[name] = function (f) + table.insert(P.myhooks[name], {callback = f}) + end +end + +-- Call a created userhook (for external libs +local function userhook_call(name, args) + for i,o in pairs(P.myhooks[name]) do + P.myhooks[name][i]['callback'](unpack(args)) + end +end + -- Function to the good value in table, cycling local function array_boundandcycle(t, i) if i > #t then @@ -268,42 +288,75 @@ local function layout_get(screen) end end --- Just set a awful tag to a client to move it later. -local awfultags = {} -local ontag_callback = nil -local onuntag_callback = nil +-- Just set an awful mark to a client to move it later. +local awfulmarked = {} +userhook_create('marked') +userhook_create('unmarked') -local function client_ontag (f) - ontag_callback = f -end - -local function client_onuntag (f) - onuntag_callback = f -end - -local function client_tag (c) +-- Mark a client +local function client_mark (c) local cl = c or client.focus_get() if cl then - for k, v in pairs(awfultags) do + for k, v in pairs(awfulmarked) do if cl == v then - return + return false end end - awfultags[cl] = true + + table.insert(awfulmarked, cl) + -- Call callback - if ontag_callback then ontag_callback(cl) end + userhook_call('marked', {cl}) + return true end end --- Return the tagged client and empty the table -local function client_gettagged () - if onuntag_callback then - for k, v in pairs(awfultags) do - onuntag_callback(k) +-- Unmark a client +local function client_unmark(c) + local cl = c or client.focus_get() + + for k, v in pairs(awfulmarked) do + if cl == v then + table.remove(awfulmarked, k) + userhook_call('unmarked', {cl}) + return true end end - t = awfultags - awfultags = {} + + return false +end + +-- Check if marked +local function client_ismarked(c) + local cl = c or client.focus_get() + if cl then + for k, v in pairs(awfulmarked) do + if cl == v then + return true + end + end + + return false + end +end + +-- Toggle marked +local function client_togglemarked(c) + local cl = c or client.focus_get() + + if not client_mark(c) then + client_unmark(c) + end +end + +-- Return the marked clients and empty the table +local function client_getmarked () + for k, v in pairs(awfulmarked) do + userhook_call('unmarked', {v}) + end + + t = awfulmarked + awfulmarked = {} return t end @@ -336,26 +389,6 @@ local function layout_set(layout) end end --- Hook functions, wrappers around awesome's hooks. functions so we --- can easily add multiple functions per hook. -P.hooks = {} -P.myhooks = {} - --- Create a new userhook (for external libs) -local function userhook_create(name) - P.myhooks[name] = {} - P.hooks[name] = function (f) - table.insert(P.myhooks[name], {callback = f}) - end -end - --- Call a created userhook (for external libs -local function userhook_call(name, args) - for i,o in pairs(P.myhooks[name]) do - P.myhooks[name][i]['callback'](unpack(args)) - end -end - P.hooks['userhook_create'] = userhook_create P.hooks['userhook_call'] = userhook_call @@ -468,10 +501,11 @@ P.client = togglefloating = client_togglefloating; moveresize = client_moveresize; movetoscreen = client_movetoscreen; - tag = client_tag; - gettagged = client_gettagged; - ontag = client_ontag; - onuntag = client_onuntag; + mark = client_mark; + unmark = client_unmark; + ismarked = client_ismarked; + togglemarked = client_togglemarked; + getmarked = client_getmarked; } P.screen = {