def func(dgroup):
# unbind all
for key in dgroup.keys[:]:
dgroup.qtile.unmapKey(key)
dgroup.keys.remove(key)
if keynames:
keys = keynames
else:
# keys 1 to 9 and 0
keys = map(str, range(1, 10) + [0])
# bind all keys
for keyname, group in zip(keys, dgroup.qtile.groups):
name = group.name
key = Key([mod], keyname, lazy.group[name].toscreen())
key_s = Key([mod, "shift"], keyname, lazy.window.togroup(name))
key_c = Key([mod, "control"], keyname,
lazy.group.switch_groups(name))
dgroup.keys.append(key)
dgroup.keys.append(key_s)
dgroup.keys.append(key_c)
dgroup.qtile.mapKey(key)
dgroup.qtile.mapKey(key_s)
dgroup.qtile.mapKey(key_c)
def func(dgroup):
# unbind all
for key in dgroup.keys[:]:
dgroup.qtile.unmapKey(key)
dgroup.keys.remove(key)
# keys 1 to 9 and 0
keynumbers = range(1, 10) + [0]
# bind all keys
for num, group in zip(keynumbers, dgroup.qtile.groups[:10]):
name = group.name
key = Key([mod], str(num), lazy.group[name].toscreen())
key_s = Key([mod, "shift"], str(num), lazy.window.togroup(name))
dgroup.keys.append(key)
dgroup.keys.append(key_s)
dgroup.qtile.mapKey(key)
dgroup.qtile.mapKey(key_s)
from libqtile.manager import Key, Screen
from libqtile.command import lazy
from libqtile import layout, bar, widget
modkey = "mod4"
keys = [
# First, a set of bindings to control the layouts
Key([modkey], "k", lazy.layout.down()),
Key([modkey], "j", lazy.layout.up()),
Key([modkey, "shift"], "k", lazy.layout.shuffle_down()),
Key([modkey, "shift"], "j", lazy.layout.shuffle_up()),
Key([modkey], "space", lazy.layout.next()),
Key([modkey, "shift"], "space", lazy.layout.rotate()),
Key([modkey, "shift"], "Return", lazy.layout.toggle_split()),
Key([modkey], "p", lazy.spawn("exe=`dmenu_path | dmenu` && eval \"exec $exe\"")),
Key([modkey], "Return", lazy.spawn("urxvt")),
Key([modkey], "Tab", lazy.nextlayout()),
Key([modkey, "shift"], "c", lazy.window.kill())
]
groups = [str(i) for i in xrange(1, 10)]
for i in groups:
keys.append(Key([modkey], i, lazy.group[i].toscreen()))
layouts = [
layout.Stack(stacks=1, borderWidth=1),
layout.Stack(stacks=2, borderWidth=1)
]
from libqtile.command import lazy
from libqtile import layout, bar, widget, hook
try:
from libqtile.manager import Key, Group, Click, Drag, Screen
except ImportError:
from libqtile.config import Key, Group, Click, Drag, Screen
sup = "mod4"
alt = "mod1"
keys = [
# SWAP MASTER WINDOWS AROUND
Key([alt], "n", lazy.layout.down()),
Key([alt], "m", lazy.layout.up()),
# LAYOUT CHANGERS
# move to next layout in the stack
Key([alt], "space", lazy.nextlayout()),
# switch master windows
Key([alt, "shift"], "space", lazy.layout.rotate()),
# MOVEMENT KEYS
# windows style alt-tab/alt-shift-tab
Key([alt], "Tab", lazy.layout.next()),
Key([alt, "shift"], "Tab", lazy.layout.previous()),
# kill current window
Key([alt, "shift"], "c", lazy.window.kill()),
# dec ratio of current window
Key([alt], "q", lazy.layout.decrease_ratio()),
import os
from libqtile import layout, widget, bar, manager, hook
from libqtile.widget import base
from libqtile.manager import Screen, Drag # , Click
from libqtile.command import lazy
try:
from libqtile.manager import Key, Group
except ImportError:
from libqtile.config import Key, Group
mod = 'mod4'
keys = [
Key([mod], "k", lazy.layout.down()),
Key([mod], "j", lazy.layout.up()),
Key([mod, "shift"], "k", lazy.layout.shuffle_down()),
Key([mod, "shift"], "j", lazy.layout.shuffle_up()),
Key([mod], "Tab", lazy.layout.next()),
Key([mod, "shift"], "Tab", lazy.layout.client_to_next()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
Key([mod], "space", lazy.nextlayout()),
Key([mod], "t", lazy.window.toggle_floating()),
# for MonadTall layout
Key([mod], "l", lazy.layout.grow()),
Key([mod], "h", lazy.layout.shrink()),
Key([mod], "n", lazy.layout.normalize()),
Key([mod], "m", lazy.layout.maximize()),
running. """
def f(qtile):
try:
qtile.groupMap[group].cmd_toscreen()
except KeyError:
qtile.cmd_spawn(app)
return f
keys = [
# Log out; note that this doesn't use mod3: that's intentional in case mod3
# gets hosed (which happens if you unplug and replug your usb keyboard
# sometimes, or on ubuntu upgrades). This way you can still log back out
# and in gracefully.
Key(["shift", "mod1"], "q", lazy.shutdown()),
Key([mod], "k", lazy.layout.down()),
Key([mod], "j", lazy.layout.up()),
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.previous()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
Key(["mod1"], "Tab", lazy.nextlayout()),
Key([mod, "mod1"], "h", lazy.to_screen(0)),
Key([mod, "mod1"], "l", lazy.to_screen(1)),
Key([mod], "x", lazy.window.kill()),
# interact with prompts
Key([mod], "r", lazy.spawncmd()),
Key([mod], "g", lazy.switchgroup()),
from libqtile.config import Key, Group
from libqtile import bar, hook, layout, widget
from libqtile.manager import Screen
from libqtile.command import lazy
# from libqtile.widget.wlan import Wlan
# from libqtile.widget.battery import Battery
import os
sup = "mod4"
alt = "mod1"
keys = [
Key([alt], "Tab", lazy.layout.down()),
Key([alt, "shift"], "Tab", lazy.layout.down()),
Key([sup, "control"], "k", lazy.shuffle_down()),
Key([sup, "control"], "j", lazy.shuffle_up()),
Key([sup], "space", lazy.layout.next()),
Key([sup, "shift"], "space", lazy.layout.previous()),
Key([sup, "shift"], "Return", lazy.layout.rotate()),
Key([sup], "Return", lazy.spawn("terminator")),
Key([sup, alt], "f", lazy.spawn("firefox")),
Key([sup, "control"], "r", lazy.restart()),
# cycle to previous group
Key([sup], "Left", lazy.group.prevgroup()),
# cycle to next group
i = getIndex(currentGroup)
qtile.currentWindow.togroup(groups[(i - 1) % len(groups)].name)
def toNextGroup(qtile):
currentGroup = qtile.currentGroup.name
i = getIndex(currentGroup)
qtile.currentWindow.togroup(groups[(i + 1) % len(groups)].name)
##########################################################################################
# KEYBINDINGS
##########################################################################################
keys = [
Key(["mod1"], "k", lazy.layout.down()),
Key(["mod1"], "j", lazy.layout.up()),
Key(["mod1", "control"], "k", lazy.layout.shuffle_down()),
Key(["mod1", "control"], "j", lazy.layout.shuffle_up()),
Key(["mod1"], "space", lazy.layout.next()),
Key(["mod1", "shift"], "space", lazy.layout.rotate()),
Key(["mod1", "shift"], "Return", lazy.layout.toggle_split()),
Key(["mod1"], "Return", lazy.spawn("urxvt -tr +sb -fg white -sh 30")),
Key(["mod1"], "Tab", lazy.nextlayout()),
Key(["mod1"], "w", lazy.window.kill()),
Key(["mod1", "control"], "r", lazy.restart()),
Key(["mod4"], "f", lazy.spawn("firefox")),
Key(["mod4"], "d", lazy.spawn("deluge")),
]
for i in groups:
22,
opacity=0.1)) # our bar is 22px high
]
# Super_L (the Windows key) is typically bound to mod4 by default, so we use
# that here.
mod = "mod4"
# The keys variable contains a list of all of the keybindings that qtile will
# look through each time there is a key pressed.
keys = [
# Log out; note that this doesn't use mod4: that's intentional in case mod4
# gets hosed (which happens if you unplug and replug your usb keyboard
# sometimes, or on system upgrades). This way you can still log back out
# and in gracefully.
Key(["shift", "mod1"], "q", lazy.shutdown()),
# toggle between windows just like in unity with 'alt+tab'
Key(["mod1", "shift"], "Tab", lazy.layout.down()),
Key(["mod1"], "Tab", lazy.layout.up()),
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.previous()),
# swap tile positions,(works only on tiles)
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
# change the layout
Key([mod], "j", lazy.nextlayout()),
# quit the program "qtile way"
from libqtile.manager import Key, Screen, Group
from libqtile.command import lazy
from libqtile import layout, bar, widget
keys = [
Key(["mod1"], "k", lazy.layout.down()),
Key(["mod1"], "j", lazy.layout.up()),
Key(["mod1", "control"], "k", lazy.layout.shuffle_down()),
Key(["mod1", "control"], "j", lazy.layout.shuffle_up()),
Key(["mod1"], "space", lazy.layout.next()),
Key(["mod1", "shift"], "space", lazy.layout.rotate()),
Key(["mod1", "shift"], "Return", lazy.layout.toggle_split()),
Key(["mod1"], "h", lazy.to_screen(1)),
Key(["mod1"], "l", lazy.to_screen(0)),
Key(["mod1"], "Return", lazy.spawn("xterm")),
Key(["mod1"], "Tab", lazy.nextlayout()),
Key(["mod1"], "w", lazy.window.kill()),
Key(["mod1", "control"], "r", lazy.restart()),
]
groups = [
Group("a"),
Group("s"),
Group("d"),
Group("f"),
Group("u"),
Group("i"),
Group("o"),
Group("p"),
]
for i in groups:
"setxkbmap -layout 'us,ru' -option 'grp:alt_shift_toggle' 2>/dev/null",
"feh --bg-scale {0!r}".format(qtile_default_feh_bg),
"dropbox start",
]
_fp_distr = _popen('lsb_release -d').stdout
if _fp_distr.read().find('Ubuntu'):
_applications.insert(0, "pacmd set-sink-mute 0 true")
_fp_distr.close()
del _fp_distr
autostart(check_proc=True, apps=_applications)
del _applications, qtile_default_feh_bg
keys = [
Key([mod], "Return", lazy.spawn('gmrun')),
Key([mod], "F1", lazy.spawn(getFileManager(''))),
Key([mod], "F2", lazy.spawn('lxterminal')),
Key([mod, "shift"], "F2", lazy.spawn(getTerminal(''))),
Key([mod], "F3", lazy.spawn(getWebBrowser(''))),
Key([mod, "shift"], "F4", lazy.restart()),
Key([mod], "F9", lazy.spawn("mpg123 http://pub2.di.fm:80/di_techhouse 2>~/.mpg123.log")),
Key([mod, "shift"], "F9", lazy.spawn("killall mpg123")),
Key([mod], "k", lazy.layout.down()),
Key([mod, "shift"], "k", lazy.layout.shuffle_down()),
sep = {
'background': bar['background'],
'foreground': '444444',
'height_percent': 75
}
systray = dict(widget)
systray.update({'icon_size': 16, 'padding': 3})
ALT = 'mod1'
MOD = 'mod4'
SHIFT = 'shift'
keys = [
# Applications
Key([MOD], 'b', lazy.spawn(Commands.browser)),
Key([MOD], 'm', lazy.spawn(Commands.menu)),
Key([MOD], 'l', lazy.spawn(Commands.lock)),
Key([MOD], 'Return', lazy.spawn(Commands.terminal)),
# Simple Window Management
Key([MOD], 'Tab', lazy.layout.up()),
Key([MOD, SHIFT], 'Tab', lazy.layout.shuffle_up()),
Key([MOD], 'c', lazy.window.kill()),
# Advanced Window Management
Key([MOD, ALT], 'Right', lazy.layout.up()),
Key([MOD, ALT], 'Left', lazy.layout.down()),
Key([MOD, ALT], 'Up', lazy.layout.shuffle_up()),
Key([MOD, ALT], 'Down', lazy.layout.shuffle_down()),
Key([MOD, SHIFT], 'Up', lazy.layout.grow()),
# I have configured the key bindings to be optimal on my 10" EeePC, so some may
# not be appropriate on regular keyboards.
# some of the widgets and layouts are not from the core Qtile distribution.
from libqtile.manager import Key, Screen, Group, Drag, Click
from libqtile.command import lazy
from libqtile import layout, bar, widget, hook
from she_widget import She
follow_mouse_focus = False
mod = "mod4"
alt = "mod1"
keys = [
Key([mod, "control"], "r", lazy.restart()),
Key([mod], "w", lazy.window.kill()),
Key([alt], "Tab", lazy.group.next_window()),
# this is usefull when floating windows get buried
Key([alt], "grave", lazy.window.bring_to_front()),
Key([mod, alt], "Tab", lazy.window.to_next_screen()),
Key([mod, alt], "1", lazy.to_screen(0), lazy.group.toscreen(0)),
Key([mod, alt], "2", lazy.to_screen(1), lazy.group.toscreen(1)),
Key([mod], "Left", lazy.group.prevgroup()),
Key([mod], "Right", lazy.group.nextgroup()),
Key([mod], "m", lazy.group.setlayout('max')),
Key([mod], "s", lazy.group.setlayout('stack')),
Key([mod], "t", lazy.group.setlayout('tile')),
Key([mod], "r", lazy.group.setlayout('ratiotile')),
Key([mod], "x", lazy.group.setlayout('xmonad-tall')),
# Bindings to control the layouts
def main(qtile):
groups = {
'h4x': {
'init': True,
'persist': True,
'exclusive': True
},
'design': {},
'www': {
'exclusive': True
},
# master set the master window/windows of layout
'emesene': {
'layout': 'tile',
'master': Match(role=['main'])
},
'gajim': {
'layout': 'tile',
'master': Match(role=['roster']),
'exclusive': True
},
}
apps = [
{
'match': Match(wm_class=['Gimp']),
'group': 'design',
'float': True
},
{
'match': Match(wm_class=['Terminator', 'Qterminal']),
'group': 'h4x'
},
{
'match': Match(wm_class=['emesene']),
'group': 'emesene'
},
{
'match':
Match(wm_class=['Chromium-browser', 'Minefield'],
role=['browser']),
'group':
'www'
},
{
'match': Match(wm_class=['Gajim.py']),
'group': 'gajim'
},
{
'match': Match(wm_class=['Wine']),
'float': True,
'group': 'wine'
},
{
'match': Match(wm_class=['Xephyr']),
'float': True
},
# Everything i want to be float, but don't want to change group
{
'match':
Match(title=['nested', 'gscreenshot'],
wm_class=[
'Guake.py', 'MPlayer', 'Exe',
re.compile('Gnome-keyring-prompt.*?'), 'Terminal'
],
wm_type=['dialog', 'utility', 'splash']),
'float':
True,
'intrusive':
True
},
]
dgroups = DGroups(qtile, groups, apps, simple_key_binder(mod))
# fast switching from/to terminal
key = Key([], "F12", lazy.function(TermHack(qtile, 'h4x')))
qtile.mapKey(key)
# fast switching to urgent
key = Key(['shift'], "F12", lazy.function(to_urgent))
qtile.mapKey(key)
import re
from libqtile.command import lazy
from libqtile.manager import Key, Click, Drag, Screen
from libqtile import layout, bar, widget
from libqtile.dgroups import DGroups, Match, simple_key_binder
mod = 'mod4'
keys = [
# vim like movement
Key(
[mod], "h", lazy.group.prevgroup(),
),
Key(
[mod], "l", lazy.group.nextgroup(),
),
Key(
[mod], "k",
lazy.layout.down()
),
Key(
[mod], "j",
lazy.layout.up()
),
Key(
[mod], "f",
lazy.window.toggle_floating()
),
try:
from libqtile.manager import Key, Group
except ImportError:
from libqtile.config import Key, Group
from libqtile.manager import Click, Drag, Screen
from libqtile.command import lazy
from libqtile import layout, bar, widget
# The bindings below are for use with a Kinesis keyboard, and may not make
# sense for standard keyboards.
keys = [
# First, a set of bindings to control the layouts
Key(
["mod1"], "k",
lazy.layout.down()
),
Key(
["mod1"], "j",
lazy.layout.up()
),
Key(
["mod1", "control"], "k",
lazy.layout.shuffle_down()
),
Key(
["mod1", "control"], "j",
lazy.layout.shuffle_up()
),
Key(
["mod1"], "space",
from libqtile.manager import Key, Click, Drag, Screen, Group
from libqtile.command import lazy
from libqtile import layout, bar, widget
mod = 'mod4'
keys = [
Key(
[mod], "k",
lazy.layout.down()
),
Key(
[mod], "j",
lazy.layout.up()
),
Key(
[mod], "f",
lazy.window.toggle_floating()
),
Key(
[mod], "space",
lazy.nextlayout()
),
Key([mod], "Tab",
lazy.layout.next()
),
Key([mod, "shift"], "Tab",
lazy.layout.previous()
),
Key(
[mod, "shift"], "space",
lazy.layout.rotate()
from libqtile.manager import Key, Screen, Group, Drag, Click
from libqtile.command import lazy
from libqtile import layout, bar, widget, hook
import os
sup = "mod4"
alt = "mod1"
keys = [
Key([alt], "Tab", lazy.layout.down()),
Key([alt, "shift"], "Tab", lazy.layout.up()),
Key([sup, "control"], "k", lazy.layout.shuffle_down()),
Key([sup, "control"], "j", lazy.layout.shuffle_up()),
Key([sup], "space", lazy.layout.next()),
Key([sup, "shift"], "space", lazy.layout.rotate()),
Key([sup, "shift"], "Return", lazy.layout.toggle_split()),
Key([sup], "Return", lazy.spawn("terminator")),
Key([sup], "i", lazy.spawn("icedove")),
Key([sup], "x", lazy.spawn("xchat")),
Key([sup], "f", lazy.spawn("iceweasel")),
Key([sup], "a", lazy.spawn("gajim")),
Key([sup], "p", lazy.spawn("pidgin")),
Key([sup], "d", lazy.spawn("setxkbmap -layout es -variant dvorak")),
Key([sup], "q", lazy.spawn("setxkbmap -layout latan")),
Key([sup], "w", lazy.window.kill()),
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB+")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB-")),
Key([sup, "control"], "r", lazy.restart()),
# cycle to previous group
from libqtile.command import lazy
from libqtile import layout, bar, widget, hook
try:
from libqtile.manager import Key, Group
except ImportError:
from libqtile.config import Key, Group
from libqtile.manager import Click, Drag, Screen
sup = "mod4"
alt = "mod1"
keys = [
# General Keybindings
Key([sup, "shift"], "q", lazy.shutdown()),
Key([sup], "k", lazy.layout.down()),
Key([sup], "j", lazy.layout.up()),
Key([sup, "control"], "k", lazy.layout.shuffle_down()),
Key([sup, "control"], "j", lazy.layout.shuffle_up()),
Key([sup], "space", lazy.layout.next()),
Key([sup, "shift"], "space", lazy.layout.rotate()),
Key([sup, "shift"], "Return", lazy.layout.toggle_split()),
Key([sup], "Tab", lazy.next_layout()),
Key([sup], "w", lazy.window.kill()),
Key([sup, "control"], "r", lazy.restart()),
Key([sup, "control"], "q", lazy.shutdown()),
Key([sup], "r", lazy.spawncmd()),
Key([], "XF86AudioMute", lazy.spawn("amixer -q set Master toggle")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 0 sset Master 1- unmute")),
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 0 sset Master 1+ unmute")),
('SquirrelMail', 'E-mail'),
('zeromq', 'Docs'),
('PyYAML', 'Docs'),
('documentation', 'Docs'),
('-ietf-', 'Docs'),
('GNOME Live!', 'Docs'),
('Guide', 'Docs'),
)
for k, v in patterns:
if k in win.name:
return v
mod = "mod4"
keys = [
Key([mod], "j", lazy.layout.down()),
Key([mod], "k", lazy.layout.up()),
Key([mod, "shift"], "j", lazy.layout.move_down()),
Key([mod, "shift"], "k", lazy.layout.move_up()),
Key([mod, "control"], "j", lazy.layout.section_down()),
Key([mod, "control"], "k", lazy.layout.section_up()),
Key([mod], "h", lazy.layout.collapse_branch()), # for tree layout
Key([mod], "l", lazy.layout.expand_branch()), # for tree layout
Key([mod], "r",
lazy.layout.sort_windows(window_sorter)), # for tree layout
Key([mod, "shift"], "h", lazy.layout.move_left()),
Key([mod, "shift"], "l", lazy.layout.move_right()),
Key([mod, "control"], "l", lazy.layout.increase_ratio()),
Key([mod, "control"], "h", lazy.layout.decrease_ratio()),
Key([mod], "comma", lazy.layout.increase_nmaster()),
Key([mod], "period", lazy.layout.decrease_nmaster()),
widget.Clock('%Y-%m-%d %a %I:%M %p', **font_options),
widget.WindowName(**font_options),
],
30)
)
]
# Super_L (the Windows key) is typically bound to mod4 by default, so we use
# that here.
mod = "mod4"
# The keys variable contains a list of all of the keybindings that qtile will
# look through each time there is a key pressed.
keys = [
# Admin commands
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod], "Return", lazy.spawn("urxvt")),
Key([mod], "F2", lazy.spawn("dmenu_run -fn 'Monospace:size=10' -nb '#000000' -nf '#fefefe'")),
Key([mod], "F4", lazy.spawn("slock")),
# Key([mod], "F4", lazy.spawn("gnome-screensaver-command -l")),
Key([mod, "shift"], "c", lazy.window.kill()),
# Layout commands
Key([mod], "k", lazy.layout.down()),
Key([mod], "j", lazy.layout.up()),
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.next()),
Key([mod, "control"], "k", lazy.layout.shuffle_up()),
Key([mod, "control"], "j", lazy.layout.shuffle_down()),
# move_up() and move_down() are only supported by tree layout
widget.Clock('%Y-%m-%d %a %I:%M %p'),
], 30)) # our bar is 30px high
]
# Super_L (the Windows key) is typically bound to mod4 by default, so we use
# that here.
mod = "mod4"
# The keys variable contains a list of all of the keybindings that qtile will
# look through each time there is a key pressed.
keys = [
# Log out; note that this doesn't use mod4: that's intentional in case mod4
# gets hosed (which happens if you unplug and replug your usb keyboard
# sometimes, or on system upgrades). This way you can still log back out
# and in gracefully.
Key(["shift", "mod1"], "q", lazy.shutdown()),
Key([mod], "k", lazy.layout.down()),
Key([mod], "j", lazy.layout.up()),
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.previous()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return",lazy.layout.toggle_split()),
Key(["mod1"], "Tab", lazy.nextlayout()),
Key([mod], "x", lazy.window.kill()),
# interact with prompts
Key([mod], "r", lazy.spawncmd()),
Key([mod], "g", lazy.switchgroup()),
# start specific apps