ryuslash/legacy-dotfiles
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add awesome config

Browse source
This commit is contained in:
Tom Willemsen 2012-09-12 23:15:44 +02:00
parent cc9491a610
commit ab1346c7a8
4 changed files with 1132 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

205
.config/awesome/bowl.lua Normal file
View file

@ -0,0 +1,205 @@
-- -*- coding: utf-8 -*-
--------------------------------------------------------------------------------
-- @author Nicolas Berthier <nberthier@gmail.com>
-- @copyright 2010 Nicolas Berthier
--------------------------------------------------------------------------------
--
-- Bowls are kind of helpers that can be drawn (at the bottom --- for now) of an
-- area, and displaying the current key prefix. It is inspired by emacs'
-- behavior, that prints prefix keys in the minibuffer after a certain time.
--
-- I call it `bowl' as a reference to the bowl that one might have at home,
-- where one puts its actual keys... A more serious name would be `hint' or
-- `tooltip' (but they do not fit well for this usage).
--
-- Example usage: see `rc.lua' file.
--
--------------------------------------------------------------------------------
--{{{ Grab environment (mostly aliases)
local setmetatable = setmetatable
local ipairs = ipairs
local type = type
local pairs = pairs
local string = string
local print = print
local error = error
local capi = capi
local client = client
local awesome = awesome
local root = root
local timer = timer
local infoline = require ("infoline")
--}}}
module ("bowl")
-- Privata data: we use weak keys in order to allow collection of private data
-- if keys (clients) are collected (i.e., no longer used, after having been
-- killed for instance)
local data = setmetatable ({}, { __mode = 'k' })
--{{{ Default values
--- Default modifier filter
local modfilter = {
["Mod1"] = "M",
["Mod4"] = "S",
["Control"] = "C",
["Shift"] = string.upper,
}
-- Timers configuration
local use_timers = true
local timeout = 2.0
--}}}
--{{{ Keychain pretty-printing
function mod_to_string (mods, k)
local ret, k = "", k
for _, mod in ipairs (mods) do
if modfilter[mod] then
local t = type (modfilter[mod])
if t == "function" then
k = modfilter[mod](k)
elseif t == "string" then
ret = ret .. modfilter[mod] .. "-"
else
error ("Invalid modifier key filter: got a " .. t)
end
else
ret = ret .. mod .. "-"
end
end
return ret, k
end
function ks_to_string (m, k)
local m, k = mod_to_string (m, k)
return m .. k
end
--}}}
--{{{ Timer management
local function delete_timer_maybe (d)
if d.timer then -- stop and remove the timer
d.timer:remove_signal ("timeout", d.timer_function)
d.timer:stop ()
d.timer = nil
d.timer_expired = true
end
end
local function delayed_call_maybe (d, f)
if use_timers then
if not d.timer_expired and not d.timer then
-- create and start the timer
d.timer = timer ({ timeout = timeout })
d.timer_function = function () f (); delete_timer_maybe (d) end
d.timer:add_signal ("timeout", d.timer_function)
d.timer:start ()
d.timer_expired = false
elseif not d.timer_expired then
-- restart the timer...
-- XXX: What is the actual semantics of the call to `start' (ie,
-- does it restart the timer with the initial timeout)?
d.timer:stop ()
d.timer.timeout = timeout -- reset timeout
d.timer:start ()
end
else -- timers disabled
f () -- call the given function directly
end
end
--}}}
--{{{ Infoline management
function dispose (w)
local d = data[w]
if d.bowl then -- if bowl was enabled... (should always be true...)
infoline.dispose (d.bowl)
d.bowl = nil
end
delete_timer_maybe (d)
data[w] = nil
end
function append (w, m, k)
local d = data[w]
local pretty_ks = ks_to_string (m, k) .. " "
infoline.set_text (d.bowl, infoline.get_text (d.bowl) .. pretty_ks)
local function enable_bowl ()
-- XXX: is there a possible bad interleaving that could make
-- this function execute while the bowl has already been
-- disposed of? in which case the condition should be checked
-- first...
-- if d.bowl then
infoline.attach (d.bowl, w)
-- end
end
delayed_call_maybe (d, enable_bowl)
end
function create (w)
-- XXX: Note the prefix text could be customizable...
data[w] = { bowl = infoline.new (" ") }
end
--}}}
--- Initializes the bowl module, with given properties; should be called before
--- ANY other function of this module.
-- Configurations fields include:
--
-- `use_timers', `timeout': A boolean defining whether bowls drawing should be
-- delayed, along with a number being this time shift, in seconds (Default
-- values are `true' and `2').
--
-- `modfilter': A table associating modifiers (Mod1, Mod4, Control, Shift, etc.)
-- with either a string (in this case it will replace the modifier when printed
-- in heplers) or functions (in this case the key string will be repaced by a
-- call to this function with the key string as parameter). Default value is:
-- { ["Mod1"] = "M", ["Mod4"] = "S", ["Control"] = "C", ["Shift"] =
-- string.upper }
--
-- @param c The table of properties.
function init (c)
local c = c or { }
modfilter = c.modfilter and c.modfilter or modfilter
if c.use_timers ~= nil then use_timers = c.use_timers end
if use_timers then
timeout = c.timeout ~= nil and c.timeout or timeout
end
end
--- Setup signal listeners, that trigger appropriate functions for a default
--- behavior.
function default_setup ()
local function to_root (f) return function (...) f (root, ...) end end
client.add_signal ("keychain::enter", create)
client.add_signal ("keychain::append", append)
client.add_signal ("keychain::leave", dispose)
awesome.add_signal ("keychain::enter", to_root (create))
awesome.add_signal ("keychain::append", to_root (append))
awesome.add_signal ("keychain::leave", to_root (dispose))
end
-- Local variables:
-- indent-tabs-mode: nil
-- fill-column: 80
-- lua-indent-level: 4
-- End:
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80

183
.config/awesome/infoline.lua Normal file
View file

@ -0,0 +1,183 @@
-- -*- coding: utf-8 -*-
--------------------------------------------------------------------------------
-- @author Nicolas Berthier <nberthier@gmail.com>
-- @copyright 2010 Nicolas Berthier
--------------------------------------------------------------------------------
--
-- This is a module for defining infolines in awesome. An infoline is a wibox
-- attached to a region (typically, a client or the root window).
--
-- Remarks:
--
-- - It has not been tested with multiple screens yet.
--
-- Example usage: (TODO --- read the comments for now, there are not many
-- functions)
--
--------------------------------------------------------------------------------
--{{{ Grab environment (mostly aliases)
local setmetatable = setmetatable
local ipairs = ipairs
local type = type
local pairs = pairs
local string = string
local print = print
local error = error
local io = io
local client = client
local awesome = awesome
local wibox = wibox
local widget = widget
local root = root
local screen = screen
local mouse = mouse
--}}}
module ("infoline")
-- Privata data: we use weak keys in order to allow collection of private data
-- if keys (clients) are collected (i.e., no longer used, after having been
-- killed for instance).
--
-- XXX: For now, we have at most one infoline per client, but it could be
-- interesting to create several types of infolines (identified by indexes to be
-- allocated by this module), and associated to, e.g., different configuration
-- flags and positioning routine...
local data = setmetatable ({}, { __mode = 'k' })
--{{{ Infoline positioning
-- XXX: this is a hack that positions an infoline at the bottom of a given area.
local function setup_position (wb, geom)
local b = wb:geometry ()
b.x = geom.x
b.width = geom.width
b.y = geom.y + geom.height - awesome.font_height
b.height = awesome.font_height
wb:geometry (b)
end
--}}}
--{{{ Configurations:
-- When true, this flag indicates that an infoline is hidden if its attached
-- client loses its focus. Otherwise, it remains always visible.
follow_focus = true
--}}}
--{{{ Infoline updates
function get_text (il) return il.wb.widgets[1].text end
function set_text (il, text) il.wb.widgets[1].text = text end
-- Forces a refresh of the given infoline.
function update (il)
local wb = il.wb
local c = il.cli
if il.enabled then
-- XXX: Note this could be much better if we had some sort of root and
-- client interface unification: the following involves a priori useless
-- code duplication...
if c == root then
wb.screen = mouse.screen -- XXX: is this the behavior we need?
wb.visible = true
setup_position (wb, screen[mouse.screen].workarea)
else
if c:isvisible () and (not follow_focus or client.focus == c) then
wb.screen = c.screen
wb.visible = true
setup_position (wb, c:geometry ())
else -- do we have to hide it?
wb.visible = false
end
end
elseif wb.visible then --otherwise we need to hide it.
wb.visible = false
end
end
local function update_from_client (c)
-- Note that we may not have an infoline for this client, hence the
-- conditional...
if data[c] then update (data[c]) end
end
-- Force execution of the above function on client state modification.
client.add_signal ("focus", update_from_client)
client.add_signal ("unfocus", update_from_client)
client.add_signal ("unmanage", update_from_client)
--}}}
--{{{ Infoline management
--- Creates a new infoline, with the given initial text. Note it is not visible
--- by default, and not attached to any client.
function new (text)
local il = {
wb = wibox ({
ontop = true, -- XXX: setting a depth when attaching to
--a client would be much better
widgets = {
widget ({ type = "textbox", align="left" })
},
})
}
-- these will remain false until the infoline is attached to a client.
il.wb.visible = false
il.enabled = false
set_text (il, text or "")
return il
end
-- Attached infolines will react to the following client-related signals, and
-- automatically setup their position according to the client's geometry.
local csignals = { "property::geometry", "property::minimized",
"property::visible", "property::focus", "property::screen", }
-- Attaches an infoline to a client. Note the infoline becomes visible at that
-- time, if the client is currently visible (and if it has focus, when
-- `follow_focus' holds).
function attach (il, c)
data[c] = il
il.cli = c
il.enabled = true
update (il)
if c ~= root then
-- subscribe to client-related signals
for _, s in ipairs (csignals) do
c:add_signal (s, update_from_client)
end
end
end
--- Detach the given infoline from its client, if any.
function dispose (il)
local c = il.cli
if c then -- note c can be nil here, if the given infoline has not been
--attached to any client...
il.enabled = false
update (il) -- a shortcut here would be: `il.wb.visible = false'
data[c] = nil
if c ~= root then
-- unsubscribe from client-related signals
for _, s in ipairs (csignals) do
c:remove_signal (s, update_from_client)
end
end
end
end
--}}}
-- Local variables:
-- indent-tabs-mode: nil
-- fill-column: 80
-- lua-indent-level: 4
-- End:
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80

334
.config/awesome/keychain.lua Normal file
View file

@ -0,0 +1,334 @@
-- -*- coding: utf-8 -*-
--------------------------------------------------------------------------------
-- @author Nicolas Berthier <nberthier@gmail.com>
-- @copyright 2010 Nicolas Berthier
--------------------------------------------------------------------------------
--
-- This is a module for defining keychains à la emacs in awesome. I was also
-- inspired by ion3 behavior when designing it.
--
-- Remarks:
--
-- - This module does not handle `release' key bindings, but is it useful for
-- keychains?
--
-- - It has not been tested with multiple screens yet.
--
-- - There might (... must) be incompatibilities with the shifty module. Also,
-- defining global and per-client keychains with the same prefix is not
-- allowed (or leads to unspecified behaviors... --- in practice: the
-- per-client ones are ignored). However, I do think separation of per-client
-- and global keys is a bad idea if client keys do not have a higher priority
-- than the global ones...
--
-- Example usage: see `rc.lua' file.
--
--------------------------------------------------------------------------------
--{{{ Grab environment (mostly aliases)
local setmetatable = setmetatable
local ipairs = ipairs
local type = type
local pairs = pairs
local string = string
local print = print
local error = error
local io = io
local capi = capi
local client = client
local awesome = awesome
local root = root
local akey = require ("awful.key")
local join = awful.util.table.join
local clone = awful.util.table.clone
--}}}
module ("keychain")
-- Privata data: we use weak keys in order to allow collection of private data
-- if keys (clients) are collected (i.e., no longer used, after having been
-- killed for instance)
local data = setmetatable ({}, { __mode = 'k' })
--{{{ Functional Tuples
-- see http://lua-users.org/wiki/FunctionalTuples for details
--- Creates a keystroke representation to fill the `escape' table configuration
--- property.
-- @param m Modifiers table.
-- @param k The key itself.
-- @return A keystroke representation (only for the escape sequence, for now?).
function keystroke (m, k)
if type (m) ~= "table" then
error ("Keystroke modifiers must be given a table (got a "..
type (m)..")")
end
if type (k) ~= "string" then
error ("Keystroke key must be given a string (got a "..
type (m)..")")
end
return function (fn) return fn (m, k) end
end
-- keystroke accessors
local function ks_mod (_m, _k) return _m end
local function ks_key (_m, _k) return _k end
-- ---
--- Creates a final keychain binding to fill the keychain binding tables,
--- meaning that the given function will be executed at the end of the keychain.
-- @param m Modifiers table.
-- @param k The key.
-- @param cont The function to be bound to the given keys.
-- @return A "final" key binding.
function key (m, k, cont)
if type (cont) ~= "function" then
error ("Final binding must be given a function (got a "..
type (cont)..")")
end
return function (fn) return fn (keystroke (m, k), cont, true) end
end
--- Creates an intermediate (prefix) keychain binding.
-- @param m Modifiers table.
-- @param k The key.
-- @param sub The subchain description table to be bound to the given keys.
-- @return An "intermediate" key binding.
function subchain (m, k, sub)
if type (sub) ~= "table" then
error ("Subchain binding must be given a table (got a "..
type (sub)..")")
end
return function (fn) return fn (keystroke (m, k), sub, false) end
end
-- key/subchain binding accessors
local function binding_ks (ks, cont, leaf) return ks end
local function binding_cont (ks, cont, leaf) return cont end
local function binding_leaf (ks, cont, leaf) return leaf end
--- Creates an intermediate keychain if sub is a table, or a final key binding
--- otherwise (and then sub must be a function).
-- @param m Modifiers table.
-- @param k The key.
-- @param sub Either the subchain description table, or the function, to be
-- bound to the given keys.
function sub (m, k, sub)
if type (sub) == "table" then
return subchain (m, k, sub)
else
return key (m, k, sub)
end
end
--}}}
--{{{ Default values
--- Default escape sequences (S-g is inspired by emacs...)
local escape_keystrokes = {
keystroke ( { }, "Escape" ),
keystroke ( { "Mod4" }, "g" ),
}
--}}}
--{{{ Key table management facilities
local function set_keys (c, k)
if c == root then root.keys (k) else c:keys (k) end
end
local function keys_of (c)
if c == root then return root.keys () else return c:keys () end
end
--}}}
--{{{ Signal emission helper
local function notif (sig, w, ...)
if w ~= root then
client.emit_signal (sig, w, ...)
else -- we use global signals otherwise
awesome.emit_signal (sig, ...)
end
end
--}}}
--{{{ Client/Root-related state management
local function init_client_state_maybe (w)
if data[w] == nil then
local d = { }
d.keys = keys_of (w) -- save client keys
data[w] = d -- register client
notif ("keychain::enter", w)
end
end
local function restore_client_state (c)
local w = c or root
local d = data[w]
-- XXX: Turns out that `d' can be nil already here, in case the keyboard has
-- been grabbed since the previous call to this funtion... (that also seems
-- to be called again upon release…)
if d then
set_keys (w, d.keys) -- restore client keys
data[w] = nil -- unregister client
end
end
local function leave (c)
local w = c or root
-- Destroy notifier structures if needed
if data[w] then -- XXX: necessary test?
notif ("keychain::leave", w)
end
end
-- force disposal of resources when clients are killed
client.add_signal ("unmanage", leave)
--}}}
--{{{ Key binding tree access helpers
local function make_on_entering (m, k, subchain) return
function (c)
local w = c or root
-- Register and initialize client state, if not already in a keychain
init_client_state_maybe (w)
-- Update notifier text, and trigger its drawing if necessary
notif ("keychain::append", w, m, k)
-- Setup subchain
set_keys (w, subchain)
end
end
local function on_leaving (c)
-- Trigger disposal routine
leave (c)
-- Restore initial key mapping of client
restore_client_state (c)
end
--}}}
--{{{ Configuration
-- Flag to detect late initialization error
local already_used = false
-- Escape binding table built once upon initialization
local escape_bindings = { }
--- Fills the escape bindings table with actual `awful.key' elements triggering
--- execution of `on_leaving'.
local function init_escape_bindings ()
escape_bindings = { }
for _, e in ipairs (escape_keystrokes) do
escape_bindings = join (escape_bindings,
akey (e (ks_mod), e (ks_key), on_leaving))
end
end
-- Call it once upon module loading to initialize escape_bindings (in case
-- `init' is not called).
init_escape_bindings ()
--- Initializes the keychain module, with given properties; to be called before
--- ANY other function of this module.
-- Configurations fields include:
--
-- `escapes': A table of keystrokes (@see keychain.keystroke) escaping keychains
-- (defaults are `Mod4-g' and `Escape').
--
-- @param c The table of properties.
function init (c)
local c = c or { }
if already_used then
-- heum... just signal the error: "print" or "error"?
return print ("E: keychain: Call to `init' AFTER having bound keys!")
end
escape_keystrokes = c.escapes and c.escapes or escape_keystrokes
-- Now, fill the escape bindings table again with actual `awful.key'
-- elements triggering `on_leaving' executions, in case escape keys has
-- changed.
init_escape_bindings ()
end
--}}}
--{{{ Keychain creation
--- Creates a new keychain binding.
-- @param m Modifiers table.
-- @param k The key.
-- @param chains A table of keychains, describing either final bindings (see
-- key constructor) or subchains (see subchain constructor). If arg is not a
-- table, then `awful.key' is called directly with the arguments.
-- @return A key binding for the `awful.key' module.
-- @see awful.key
function new (m, k, chains)
-- If the argument is a function, then we need to return an actual awful.key
-- directly.
if type (chains) ~= "table" then
return akey (m, k, chains)
end
-- This table will contain the keys to be mapped upon <m, k> keystroke. It
-- initially contains the escape bindings, so that one can still rebind them
-- differently in `chains'.
local subchain = clone (escape_bindings)
already_used = true -- subsequent init avoidance flag...
-- For each entry of the given chains, add a corresponding `awful.key'
-- element in the subchain
for _, e in ipairs (chains) do
local ks = e (binding_ks)
if e (binding_leaf) then
-- We encountered a leaf in the chains.
local function on_leaf (c) on_leaving (c); e (binding_cont) (c) end
subchain = join (subchain, akey (ks (ks_mod), ks (ks_key), on_leaf))
else
-- Recursively call subchain creation. "Funny" detail: I think there
-- is no way of creating ill-structured keychain descriptors that
-- would produce infinite recursive calls here, since we control
-- their creation with functional tuples, that cannot lead to cyclic
-- structures...
local subch = new (ks (ks_mod), ks (ks_key), e (binding_cont))
subchain = join (subchain, subch)
end
end
-- Then return an actual `awful.key', triggering the `on_entering' routine
return akey (m, k, make_on_entering (m, k, subchain))
end
--}}}
-- Setup `__call' entry in module's metatable so that we can create new prefix
-- binding using `keychain (m, k, ...)' directly.
setmetatable (_M, { __call = function (_, ...) return new (...) end })
-- Local variables:
-- indent-tabs-mode: nil
-- fill-column: 80
-- lua-indent-level: 4
-- End:
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80

410
.config/awesome/rc.lua Normal file
View file

@ -0,0 +1,410 @@
-- Standard awesome library
require("awful")
require("awful.autofocus")
require("awful.rules")
-- Theme handling library
require("beautiful")
-- Notification library
require("naughty")
require("bowl")
require("keychain")
-- {{{ Error handling
-- Check if awesome encountered an error during startup and fell back to
-- another config (This code will only ever execute for the fallback config)
if awesome.startup_errors then
naughty.notify({ preset = naughty.config.presets.critical,
title = "Oops, there were errors during startup!",
text = awesome.startup_errors })
end
-- Handle runtime errors after startup
do
local in_error = false
awesome.add_signal("debug::error", function (err)
-- Make sure we don't go into an endless error loop
if in_error then return end
in_error = true
naughty.notify({ preset = naughty.config.presets.critical,
title = "Oops, an error happened!",
text = err })
in_error = false
end)
end
-- }}}
-- {{{ Variable definitions
-- Themes define colours, icons, and wallpapers
beautiful.init("/usr/share/awesome/themes/default/theme.lua")
bowl.init({ use_timers = true, timeout = 1 })
bowl.default_setup()
-- This is used later as the default terminal and editor to run.
terminal = "urxvt"
editor = os.getenv("EDITOR") or "nano"
editor_cmd = terminal .. " -e " .. editor
-- Default modkey.
-- Usually, Mod4 is the key with a logo between Control and Alt.
-- If you do not like this or do not have such a key,
-- I suggest you to remap Mod4 to another key using xmodmap or other tools.
-- However, you can use another modifier like Mod1, but it may interact with others.
modkey = "Mod4"
-- Table of layouts to cover with awful.layout.inc, order matters.
layouts =
{
awful.layout.suit.tile,
awful.layout.suit.tile.left,
awful.layout.suit.tile.bottom,
awful.layout.suit.tile.top,
awful.layout.suit.fair,
awful.layout.suit.fair.horizontal,
awful.layout.suit.spiral,
awful.layout.suit.spiral.dwindle,
awful.layout.suit.max,
awful.layout.suit.max.fullscreen,
awful.layout.suit.magnifier,
awful.layout.suit.floating
}
-- }}}
-- {{{ Tags
-- Define a tag table which hold all screen tags.
tags = {}
for s = 1, screen.count() do
-- Each screen has its own tag table.
tags[s] = awful.tag({ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s, layouts[1])
end
-- }}}
-- {{{ Menu
-- Create a laucher widget and a main menu
myawesomemenu = {
{ "manual", terminal .. " -e man awesome" },
{ "edit config", editor_cmd .. " " .. awesome.conffile },
{ "restart", awesome.restart },
{ "quit", awesome.quit }
}
mymainmenu = awful.menu({ items = { { "awesome", myawesomemenu, beautiful.awesome_icon },
{ "open terminal", terminal }
}
})
mylauncher = awful.widget.launcher({ image = image(beautiful.awesome_icon),
menu = mymainmenu })
-- }}}
-- {{{ Wibox
-- Create a textclock widget
mytextclock = awful.widget.textclock({ align = "right" })
-- Create a systray
mysystray = widget({ type = "systray" })
-- Create a wibox for each screen and add it
mywibox = {}
mypromptbox = {}
mylayoutbox = {}
mytaglist = {}
mytaglist.buttons = awful.util.table.join(
awful.button({ }, 1, awful.tag.viewonly),
awful.button({ modkey }, 1, awful.client.movetotag),
awful.button({ }, 3, awful.tag.viewtoggle),
awful.button({ modkey }, 3, awful.client.toggletag),
awful.button({ }, 4, awful.tag.viewnext),
awful.button({ }, 5, awful.tag.viewprev)
)
mytasklist = {}
mytasklist.buttons = awful.util.table.join(
awful.button({ }, 1, function (c)
if c == client.focus then
c.minimized = true
else
if not c:isvisible() then
awful.tag.viewonly(c:tags()[1])
end
-- This will also un-minimize
-- the client, if needed
client.focus = c
c:raise()
end
end),
awful.button({ }, 3, function ()
if instance then
instance:hide()
instance = nil
else
instance = awful.menu.clients({ width=250 })
end
end),
awful.button({ }, 4, function ()
awful.client.focus.byidx(1)
if client.focus then client.focus:raise() end
end),
awful.button({ }, 5, function ()
awful.client.focus.byidx(-1)
if client.focus then client.focus:raise() end
end))
for s = 1, screen.count() do
-- Create a promptbox for each screen
mypromptbox[s] = awful.widget.prompt({ layout = awful.widget.layout.horizontal.leftright })
-- Create an imagebox widget which will contains an icon indicating which layout we're using.
-- We need one layoutbox per screen.
mylayoutbox[s] = awful.widget.layoutbox(s)
mylayoutbox[s]:buttons(awful.util.table.join(
awful.button({ }, 1, function () awful.layout.inc(layouts, 1) end),
awful.button({ }, 3, function () awful.layout.inc(layouts, -1) end),
awful.button({ }, 4, function () awful.layout.inc(layouts, 1) end),
awful.button({ }, 5, function () awful.layout.inc(layouts, -1) end)))
-- Create a taglist widget
mytaglist[s] = awful.widget.taglist(s, awful.widget.taglist.label.all, mytaglist.buttons)
-- Create a tasklist widget
mytasklist[s] = awful.widget.tasklist(function(c)
return awful.widget.tasklist.label.currenttags(c, s)
end, mytasklist.buttons)
-- Create the wibox
mywibox[s] = awful.wibox({ position = "top", screen = s })
-- Add widgets to the wibox - order matters
mywibox[s].widgets = {
{
mylauncher,
mytaglist[s],
mypromptbox[s],
layout = awful.widget.layout.horizontal.leftright
},
mylayoutbox[s],
mytextclock,
s == 1 and mysystray or nil,
mytasklist[s],
layout = awful.widget.layout.horizontal.rightleft
}
end
-- }}}
-- {{{ Mouse bindings
root.buttons(awful.util.table.join(
awful.button({ }, 3, function () mymainmenu:toggle() end),
awful.button({ }, 4, awful.tag.viewnext),
awful.button({ }, 5, awful.tag.viewprev)
))
-- }}}
function keyhandler (mod, key, event)
if event == "release" then return true end
if key == "o" then
awful.client.focus.byidx(1)
if client.focus then client.focus:raise() end
elseif key == "O" then
awful.screen.focus_relative(1)
elseif key == "f" then
awful.client.focus.bydirection("right")
if client.focus then client.focus:raise() end
elseif key == "b" then
awful.client.focus.bydirection("left")
if client.focus then client.focus:raise() end
elseif key == "n" then
awful.client.focus.bydirection("down")
if client.focus then client.focus:raise() end
elseif key == "p" then
awful.client.focus.bydirection("up")
if client.focus then client.focus:raise() end
else
naughty.notify({text=key})
end
return false
end
-- {{{ Key bindings
local bind = keychain
local sub = keychain.sub
globalkeys = awful.util.table.join(
bind({ "Control", }, "z",
{ sub({ }, "o",
function ()
awful.client.focus.byidx(1)
if client.focus then client.focus:raise() end
end),
sub({ "Shift", }, "o",
function ()
awful.screen.focus_relative(1)
end),
sub({ }, "f",
function ()
awful.client.focus.bydirection("right")
if client.focus then client.focus:raise() end
end) }),
awful.key({ modkey, }, "Left", awful.tag.viewprev ),
awful.key({ modkey, }, "Right", awful.tag.viewnext ),
awful.key({ modkey, }, "Escape", awful.tag.history.restore),
awful.key({ modkey, }, "w", function () mymainmenu:show({keygrabber=true}) end),
-- Layout manipulation
awful.key({ modkey, "Shift" }, "j", function () awful.client.swap.byidx( 1) end),
awful.key({ modkey, "Shift" }, "k", function () awful.client.swap.byidx( -1) end),
awful.key({ modkey, }, "u", awful.client.urgent.jumpto),
awful.key({ modkey, }, "Tab",
function ()
awful.client.focus.history.previous()
if client.focus then
client.focus:raise()
end
end),
-- Standard program
awful.key({ modkey, }, "Return", function () awful.util.spawn(terminal) end),
awful.key({ modkey, "Control" }, "r", awesome.restart),
awful.key({ modkey, "Shift" }, "q", awesome.quit),
awful.key({ modkey, }, "l", function () awful.tag.incmwfact( 0.05) end),
awful.key({ modkey, }, "h", function () awful.tag.incmwfact(-0.05) end),
awful.key({ modkey, "Shift" }, "h", function () awful.tag.incnmaster( 1) end),
awful.key({ modkey, "Shift" }, "l", function () awful.tag.incnmaster(-1) end),
awful.key({ modkey, "Control" }, "h", function () awful.tag.incncol( 1) end),
awful.key({ modkey, "Control" }, "l", function () awful.tag.incncol(-1) end),
awful.key({ modkey, }, "space", function () awful.layout.inc(layouts, 1) end),
awful.key({ modkey, "Shift" }, "space", function () awful.layout.inc(layouts, -1) end),
awful.key({ modkey, "Control" }, "n", awful.client.restore),
-- Prompt
awful.key({ modkey }, "r", function () mypromptbox[mouse.screen]:run() end),
awful.key({ modkey }, "x",
function ()
awful.prompt.run({ prompt = "Run Lua code: " },
mypromptbox[mouse.screen].widget,
awful.util.eval, nil,
awful.util.getdir("cache") .. "/history_eval")
end)
)
clientkeys = awful.util.table.join(
awful.key({ modkey, }, "f", function (c) c.fullscreen = not c.fullscreen end),
awful.key({ modkey, "Shift" }, "c", function (c) c:kill() end),
awful.key({ modkey, "Control" }, "space", awful.client.floating.toggle ),
awful.key({ modkey, "Control" }, "Return", function (c) c:swap(awful.client.getmaster()) end),
awful.key({ modkey, }, "o", awful.client.movetoscreen ),
awful.key({ modkey, "Shift" }, "r", function (c) c:redraw() end),
awful.key({ modkey, }, "t", function (c) c.ontop = not c.ontop end),
awful.key({ modkey, }, "n",
function (c)
-- The client currently has the input focus, so it cannot be
-- minimized, since minimized clients can't have the focus.
c.minimized = true
end),
awful.key({ modkey, }, "m",
function (c)
c.maximized_horizontal = not c.maximized_horizontal
c.maximized_vertical = not c.maximized_vertical
end)
)
-- Compute the maximum number of digit we need, limited to 9
keynumber = 0
for s = 1, screen.count() do
keynumber = math.min(9, math.max(#tags[s], keynumber));
end
-- Bind all key numbers to tags.
-- Be careful: we use keycodes to make it works on any keyboard layout.
-- This should map on the top row of your keyboard, usually 1 to 9.
for i = 1, keynumber do
globalkeys = awful.util.table.join(globalkeys,
awful.key({ modkey }, "#" .. i + 9,
function ()
local screen = mouse.screen
if tags[screen][i] then
awful.tag.viewonly(tags[screen][i])
end
end),
awful.key({ modkey, "Control" }, "#" .. i + 9,
function ()
local screen = mouse.screen
if tags[screen][i] then
awful.tag.viewtoggle(tags[screen][i])
end
end),
awful.key({ modkey, "Shift" }, "#" .. i + 9,
function ()
if client.focus and tags[client.focus.screen][i] then
awful.client.movetotag(tags[client.focus.screen][i])
end
end),
awful.key({ modkey, "Control", "Shift" }, "#" .. i + 9,
function ()
if client.focus and tags[client.focus.screen][i] then
awful.client.toggletag(tags[client.focus.screen][i])
end
end))
end
clientbuttons = awful.util.table.join(
awful.button({ }, 1, function (c) client.focus = c; c:raise() end),
awful.button({ modkey }, 1, awful.mouse.client.move),
awful.button({ modkey }, 3, awful.mouse.client.resize))
-- Set keys
root.keys(globalkeys)
-- }}}
-- {{{ Rules
awful.rules.rules = {
-- All clients will match this rule.
{ rule = { },
properties = { border_width = beautiful.border_width,
border_color = beautiful.border_normal,
focus = true,
keys = clientkeys,
buttons = clientbuttons } },
{ rule = { class = "MPlayer" },
properties = { floating = true } },
{ rule = { class = "pinentry" },
properties = { floating = true } },
{ rule = { class = "gimp" },
properties = { floating = true } },
-- Set Firefox to always map on tags number 2 of screen 1.
-- { rule = { class = "Firefox" },
-- properties = { tag = tags[1][2] } },
}
-- }}}
-- {{{ Signals
-- Signal function to execute when a new client appears.
client.add_signal("manage", function (c, startup)
-- Add a titlebar
-- awful.titlebar.add(c, { modkey = modkey })
-- Enable sloppy focus
c:add_signal("mouse::enter", function(c)
if awful.layout.get(c.screen) ~= awful.layout.suit.magnifier
and awful.client.focus.filter(c) then
client.focus = c
end
end)
if not startup then
-- Set the windows at the slave,
-- i.e. put it at the end of others instead of setting it master.
-- awful.client.setslave(c)
-- Put windows in a smart way, only if they does not set an initial position.
if not c.size_hints.user_position and not c.size_hints.program_position then
awful.placement.no_overlap(c)
awful.placement.no_offscreen(c)
end
end
end)
client.add_signal("focus", function(c) c.border_color = beautiful.border_focus end)
client.add_signal("unfocus", function(c) c.border_color = beautiful.border_normal end)
-- }}}