def init_keys(mod):
keys = [
# Switch between windows in current stack pane
Key([mod], "k", lazy.layout.down()),
Key([mod], "j", lazy.layout.up()),
# Move windows up or down in current stack
Key([mod, "control"], "k", lazy.layout.shuffle_down()),
Key([mod, "control"], "j", lazy.layout.shuffle_up()),
# Move windows to other stack
Key([mod, "shift"], "j", lazy.layout.client_to_next()),
# Switch window focus to other pane(s) of stack
Key(["mod1"], "Tab", lazy.layout.next()),
# Swap panes of split stack
Key(["mod5"], "Tab", lazy.screen.next()),
# Toggle between split and unsplit sides of stack.
# Split = all windows displayed
# Unsplit = 1 window displayed, like Max layout, but still with
# multiple stack panes
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
Key([mod], "Return", lazy.spawn("xterm")),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.next_layout()),
Key([mod], "w", lazy.window.kill()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Monitor orientation
Key([mod], "v", lazy.function(screenlayout, 'vertical')),
Key([mod], "h", lazy.function(screenlayout, 'horizontal')),
# Keyboard layouts
Key([mod], "s", lazy.function(kbd_layout, "es", option=" ")),
Key([mod], "e",
lazy.function(kbd_layout, "us", "altgr-intl",
"compose:menu,ctrl:nocaps")),
# Lock screen
Key([mod], "l", lazy.spawn("xscreensaver-command -lock")),
# DropDown
Key([], 'F11', lazy.group['scratchpad'].dropdown_toggle('term')),
Key([], 'F12', lazy.group['scratchpad'].dropdown_toggle('org')),
]
return keys
def __init__(self,
modifiers,
key,
children,
*commands,
ishome=False,
**kwds):
super().__init__(modifiers, key, *commands,
lazy.function(self.updateMap()))
# if this key has commands
if commands:
self.iscommand = True
else:
self.iscommand = False
# Set the group name
if 'name' in kwds:
self.desc = kwds.get('name')
if ishome:
self.home = self
KeyNode.homenode = self
self.key = key
self.ishome = ishome
self.children = children
def move_mouse(mov_x, mov_y):
def move(qtile):
subprocess.call(
["xdotool", "mousemove_relative", "--sync", "--", str(mov_x), str(mov_y)]
)
return lazy.function(move)
def layout_change(layout):
layouts = {
"monadtall": 0,
"max": 1,
"stack": 2,
"tile": 3,
}
layout_num = layouts[layout]
return lazy.function(lambda q: q.current_group.use_layout(layout_num))
def get_keyboard_hotkey(mod):
return [
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], "l",
lazy.layout.grow()),
Key([mod], "h",
lazy.layout.shrink()),
Key([mod], "n",
lazy.layout.normalize()),
Key([mod], "o",
lazy.layout.maximize()),
Key([mod], "space",
lazy.nextlayout()),
Key([mod], "r",
lazy.function(lambda qtile: DMenu().run(True))),
Key([mod, "shift"], "r",
lazy.function(lambda qtile: DMenu().run(False))),
Key([mod, "control"], "r",
lazy.spawncmd()),
Key([mod], "equal",
lazy.function(inc_volume)),
Key([mod], "minus",
lazy.function(dec_volume)),
Key([mod], "Return",
lazy.spawn("urxvt")),
Key([mod], "e",
lazy.spawn("emacs")),
Key([mod, "shift"], "q",
lazy.window.kill()),
Key([mod, "shift", "control"], "r",
lazy.restart()),
Key([mod, "shift", "control"], "q",
lazy.shutdown()),
Key([mod, "shift"], "d",
lazy.hide_show_bar()),
]
def main(qtile):
from dgroups import DGroups, Match, simple_key_binder
import re
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))
key = Key([], "F12", lazy.function(TermHack(qtile, 'h4x')))
qtile.mapKey(key)
key = Key(['shift'], "F12", lazy.function(to_urgent))
qtile.mapKey(key)
def init_keys(self):
"""
Initialize key bindings
"""
def move_window_to_screen(screen_num):
"""
Move the selected window to a different screen
"""
def inner(qtile):
if qtile.currentWindow is not None:
qtile.currentWindow.togroup(qtile.screens[
self.screen_layout[screen_num]].group.name)
return inner
return [
Key('M-j', lazy.layout.down()),
Key('M-k', lazy.layout.up()),
Key('M-h', lazy.layout.left()),
Key('M-l', lazy.layout.right()),
Key('M-S-j', lazy.layout.shuffle_down()),
Key('M-S-k', lazy.layout.shuffle_up()),
Key('M-S-h', lazy.layout.swap_left()),
Key('M-S-l', lazy.layout.swap_right()),
Key('A-<Tab>', lazy.next_layout()),
Key('M-q', lazy.window.kill()),
Key(
'A-S-r',
lazy.spawn(
"termite --name ranger -e '/usr/bin/tmux new -A -s ranger ranger'"
)),
Key('M-v', projectm_toggle),
Key('M-e', lazy.spawn("termite")),
Key('M-S-r', lazy.restart()),
Key('M-b', lazy.hide_show_bar("all")),
Key('M-S-q', lazy.shutdown()),
Key('M-r', dm_run),
Key('M-a', decrease_master_volume),
Key('M-f', increase_master_volume),
Key('M-s', decrease_mpd_volume),
Key('M-d', increase_mpd_volume),
Key('M-x', mpd_prev_song),
Key('M-c', mpd_next_song),
Key('M-<space>', mpd_toggle_play),
] + [
Key('M-%s' % str(index + 1), lazy.to_screen(screen))
for index, screen in enumerate(self.screen_layout)
] + [
Key('M-S-%s' % str(i + 1), lazy.function(move_window_to_screen(i)))
for i in self.screen_layout
]
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)
# Switch between windows in current stack pane
Key([mod], 'Tab', lazy.layout.down()),
Key([mod, 'shift'], 'Tab', lazy.layout.up()),
# Move windows up or down in current stack
Key([mod, 'mod1'], 'Tab', lazy.layout.shuffle_down()),
Key([mod, 'mod1', 'shift'], 'Tab', lazy.layout.shuffle_up()),
# Switch window focus to other pane(s) of stack
Key([mod, 'control'], 'Tab', lazy.layout.next()),
Key([mod, 'control', 'shift'], 'Tab', lazy.layout.prev()),
# Swap panes of split stack
#Key([mod, 'shift'], 'space', lazy.layout.rotate()),
# Change ratios
Key([mod], 'k', lazy.layout.increase_ratio()),
Key([mod], 'j', lazy.layout.decrease_ratio()),
# kick to next/prev screen
Key([mod], "o", lazy.function(kick_to_next_screen)),
Key([mod, "shift"], "o", lazy.function(kick_to_next_screen, -1)),
# Toggle between split and unsplit sides of stack.
# Split = all windows displayed
# Unsplit = 1 window displayed, like Max layout, but still with
# multiple stack panes
#Key([mod, 'shift'], 'Return', lazy.layout.toggle_split()),
Key([mod], 'Return', lazy.spawn('x-terminal-emulator')),
Key([mod], 'v', lazy.spawn('gvim')),
Key([mod], 'l', lazy.spawn('xlock')),
Key([], 'XF86Launch1', lazy.spawn('xlock')),
Key([], 'XF86AudioMute', lazy.spawn('amixer -D pulse set Master toggle')),
#Key([], 'XF86AudioMicMute', lazy.spawn('amixer -D pulse set Master toggle')),
Key([], 'XF86AudioRaiseVolume', lazy.spawn('amixer -c 0 -q set Master 2dB+')),
Key([], 'XF86AudioLowerVolume', lazy.spawn('amixer -c 0 -q set Master 2dB-')),
# Switch groups
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()),
# start specific apps
Key([mod], "n", lazy.function(app_or_group("www", "firefox"))),
Key([mod], "m", lazy.function(app_or_group("music", "clementine"))),
Key([mod], "c", lazy.function(app_or_group("io", "pidgin"))),
Key([mod], "Return", lazy.spawn("xterm")),
# Change the volume if our keyboard has keys
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB+")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB-")),
Key([], "XF86AudioMute", lazy.spawn("amixer -c 0 -q set Master toggle")),
Key([], "XF86AudioPlay", lazy.spawn("clementine --play-pause")),
Key([], "XF86AudioNext", lazy.spawn("clementine --next")),
Key([], "XF86AudioPrev", lazy.spawn("clementine --prev")),
# also allow changing volume the old fashioned way
'foreground': foreground,
}
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()),
Key([mod], "w", lazy.to_screen(0)),
Key([mod, "shift"], "w", lazy.function(move_window_to_screen(0))),
Key([mod], "e", lazy.to_screen(1)),
Key([mod, "shift"], "e", lazy.function(move_window_to_screen(1))),
Key([mod], "Return", lazy.spawn("urxvt")),
Key([mod], "p",
lazy.spawn("dmenu_run -fn '%s:pixelsize=%d'" % (font, fontsize))),
Key([mod, "shift"], "c", lazy.window.kill()),
Key([mod], "q", lazy.restart()),
Key([mod, "shift"], "q", lazy.shutdown()),
]
mouse = [
Click([mod], "Button1", lazy.window.bring_to_front()),
Drag([mod],
"Button1",
lazy.window.set_position_floating(),
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()),
Key([mod], "w", lazy.to_screen(0)),
Key([mod, "shift"], "w", lazy.function(move_window_to_screen(0))),
Key([mod], "e", lazy.to_screen(1)),
Key([mod, "shift"], "e", lazy.function(move_window_to_screen(1))),
Key([mod], "Return", lazy.spawn("urxvt")),
Key([mod], "p", lazy.spawn("dmenu_run -fn '%s:pixelsize=%d'" % (font, fontsize))),
Key([mod, "shift"], "c", lazy.window.kill()),
Key([mod], "q", lazy.restart()),
Key([mod, "shift"], "q", lazy.shutdown()),
]
mouse = [
Click([mod], "Button1", lazy.window.bring_to_front()),
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.next()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return",lazy.layout.toggle_split()),
Key(["mod1"], "Tab", lazy.next_layout()),
Key([mod, "mod1"], "h", lazy.to_screen(0)),
Key([mod, "mod1"], "l", lazy.to_screen(1)),
Key([mod], "x", lazy.window.kill()),
Key([mod, "shift"], "l", lazy.layout.swap_left()),
# interact with prompts
Key([mod], "r", lazy.spawncmd()),
Key([mod], "g", lazy.togroup()),
# start specific apps
Key([mod], "n", lazy.function(app_or_group("www", "google-chrome"))),
Key([mod], "m", lazy.function(app_or_group("music", "clementine"))),
Key([mod], "c", lazy.function(app_or_group("io", "pidgin"))),
Key([mod], "Return", lazy.spawn("urxvt")),
# Change the volume if our keyboard has keys
Key(
[], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c %d -q set Master 2dB+" % sound_card)
),
Key(
[], "XF86AudioLowerVolume",
lazy.spawn("amixer -c %d -q set Master 2dB-" % sound_card)
),
Key(
[], "XF86AudioMute",
[mod, "shift"], "Return",
lazy.layout.toggle_split()
),
Key([mod], "Return", lazy.spawn("st")),
Key([mod, "control"], "Return", lazy.spawn("vimprobable2")),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.next_layout()),
Key([mod, "shift"], "c", lazy.window.kill()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
Key([mod], "p", lazy.spawncmd()),
Key([mod], "i", lazy.function(winstash)),
Key([mod, "shift"], "i", lazy.function(winunstash)),
]
groups = [Group(i) for i in "1234567890"]
for i in groups:
# mod1 + letter of group = switch to group
keys.append(
Key([mod], i.name, lazy.group[i.name].toscreen())
)
# mod1 + shift + letter of group = switch to & move focused window to group
keys.append(
Key([mod, "shift"], i.name, lazy.window.togroup(i.name))
)
Key([mod], "f", lazy.window.toggle_floating()),
Key([mod, "shift"], "r", lazy.restart()),
Key([mod, "shift"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Applications
Key([mod], "c", lazy.spawn("firefox")),
Key([mod], "l", lazy.spawn("clementine")),
Key([mod], "Return", lazy.spawn("alacritty")),
# Key([mod], "i", lazy.spawn("ipython qtconsole --profile labwork")),
Key([mod], "i", lazy.spawn("jupyter qtconsole")),
Key([mod, "shift"], "l", lazy.spawn("xscreensaver-command -lock")),
Key([], "Print", lazy.spawn("scrot")),
# Multimedia keys
Key([], "XF86Display", lazy.function(lambda q: resize(toggle=True))),
Key([mod], "s", lazy.function(lambda q: resize())),
Key([mod, "shift"], "s", lazy.function(lambda q: resize(clone=True))),
Key([], "XF86AudioPlay", lazy.spawn("clementine --play-pause")),
Key([], "XF86AudioNext", lazy.spawn("clementine --next")),
Key([], "XF86AudioPrev", lazy.spawn("clementine --prev")),
Key([], "XF86AudioMute", lazy.widget["volume"].toggle()),
Key([], "XF86AudioLowerVolume", lazy.widget["volume"].volume_down()),
Key([], "XF86AudioRaiseVolume", lazy.widget["volume"].volume_up()),
# Key([], "XF86MicMute", lazy.spawn("/home/sean/.qtile/volume.sh mic")),
]
# Drag floating layouts.
mouse = [
Drag([mod],
"Button1",
# No mute key @notebook
# Key(["shift"], "XF86AudioMute",
Key(
[mod],
"p",
# lazy.function(lambda q: fipc_jango("pause"))),
lazy.spawn("mpc toggle")),
# replace qtile with awesome, only to test stuff
Key([mod, "control"], "a", lazy.execute("/usr/bin/awesome",
("awesome", ))),
# restart qtile
Key([mod, "control"], "r", lazy.restart()),
# fast switches
Key([mod], "t", lazy.function(switch_to("Gajim"))),
Key([], "F12", lazy.function(SwapGroup('h4x'))),
Key(['shift'], "F12", lazy.function(to_urgent)),
]
# Floating Drag
# ------------------
mouse = [
Drag([mod],
"Button1",
lazy.window.set_position_floating(),
start=lazy.window.get_position()),
Drag([mod],
"Button3",
lazy.window.set_size_floating(),
qtile.current_window.togroup(group)
def switch_screens(qtile):
i = qtile.screens.index(qtile.current_screen)
group = qtile.screens[i - 1].group
qtile.current_screen.set_group(group)
# Define keybinds
keys = [
EzKey(k[0], *k[1:]) for k in [
# ------ Movement ------ #
# Navigate between windows
("M-h", lazy.function(left)),
("M-j", lazy.function(down)),
("M-k", lazy.function(up)),
("M-l", lazy.function(right)),
# Switch windows
("M-S-<space>", lazy.function(switch_screens)),
# Switch focus between two screens
("M-<period>", lazy.next_screen()),
("M-<comma>", lazy.prev_screen()),
("M-S-<period>", lazy.function(window_to_next_screen)),
("M-S-<comma>", lazy.function(window_to_previous_screen)),
# Move windows around
("M-S-h", lazy.layout.shuffle_left(), lazy.layout.swap_left()),
("M-S-j", lazy.layout.shuffle_down()),
("M-S-k", lazy.layout.shuffle_up()),
("M-S-l", lazy.layout.shuffle_right(), lazy.layout.swap_right()),
Key(["mod1", "control"], "r", lazy.restart()),
Key(["mod4"], "f", lazy.spawn("firefox")),
Key(["mod4"], "d", lazy.spawn("deluge")),
]
for i in groups:
keys.append(
Key(["mod1"], i.name, lazy.group[i.name].toscreen())
)
keys.append(
Key(["mod1", "shift"], i.name, lazy.window.togroup(i.name))
)
keys.append(Key(["mod1"], "Left", lazy.group.prevgroup()))
keys.append(Key(["mod1"], "Right", lazy.group.nextgroup()))
keys.append(Key(["mod1", "shift"], "Left", lazy.function(toPrevGroup)))
keys.append(Key(["mod1", "shift"], "Right", lazy.function(toNextGroup)))
##########################################################################################
layouts = [
layout.Max(),
layout.Stack(stacks=2)
]
screens = [
Screen(
bottom = bar.Bar(
[
def app_or_group(group, app):
""" Go to specified group if it exists. Otherwise, run the specified app.
When used in conjunction with dgroups to auto-assign apps to specific
groups, this can be used as a way to go to an app if it is already
running. """
def f(qtile):
try:
qtile.groupMap[group].cmd_toscreen()
except KeyError:
qtile.cmd_spawn(app)
return f
keys = [
Key([mod], "i", lazy.function(winstash)),
Key([mod, "shift"], "i", lazy.function(winunstash)),
# 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()),
# I don't ever use floating, but sometimes it is handy to toggle to
# floating for debugging, so I use the "out of band" mnemonic for this as
# well.
Key(["shift", "mod1"], "f", lazy.window.toggle_floating()),
Key([mod], "k", lazy.layout.up()),
Key([mod], "j", lazy.layout.down()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
debug("ERROR: %s" % e)
def fromExt(qtile):
w = qtile.groupMap['ext'].currentWindow
groupName = qtile.currentGroup.name
w.cmd_togroup(groupName)
def toExt(qtile):
w = qtile.currentGroup.currentWindow
w.cmd_togroup('ext')
keys = [
# Switch between windows in current stack pane
Key(
[mod], "k",
lazy.function(fromExt)
),
Key(
[mod], "j",
lazy.function(toExt)
),
# Switch window focus to other pane(s) of stack
Key(["mod1"], "Tab",lazy.layout.next()),
Key([mod], "Right",lazy.layout.next()),
Key([mod], "Left",lazy.layout.previous()),
# Swap panes of split stack
Key(
[mod, "shift"], "space",
lazy.layout.rotate()
--hide-menubar \
--hide-borders \
--hide-toolbars")),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.nextlayout()),
Key([mod], "w", lazy.window.kill()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod], "r", lazy.spawn("dmenu_run -fn 'DejaVu Sans Mono Book-14' -nb '#000000' -nf '#87FF03' -sb '#87FF03' -sf '#000000'")),
# start specific apps
Key(["mod4"], "o", lazy.spawn("opera")),
Key(["mod4"], "f", lazy.spawn("firefox")),
Key(["mod4"], "l", lazy.spawn("liferea")),
Key([mod], "n", lazy.function(app_or_group("web", "firefox"))),
Key([mod], "g", lazy.function(app_or_group("music", "gmusicbrowser"))),
Key([mod], "c", lazy.function(app_or_group("chat", "pidgin"))),
Key([mod], "m", lazy.function(app_or_group("mail", "thunderbird"))),
]
groups = [
Group("a"),
Group("s"),
Group("d"),
Group("i"),
Group("o"),
Group("p"),
]
for i in groups:
# mod1 + letter of group = switch to group
Key([mod, 'shift'], 'Return', lazy.layout.toggle_split()),
Key([mod], '1', lazy.to_screen(1)),
Key([mod], '2', lazy.to_screen(2)),
Key([mod], 'Tab', lazy.next_layout()),
Key([mod], 'x', lazy.window.kill()),
Key([mod], 'r', lazy.spawncmd()),
Key([mod, 'control'], 'r', lazy.restart()),
Key([mod, 'control'], 'q', lazy.shutdown()),
# Screen
Key([], 'F7', lazy.spawn('xset dpms force off')),
Key([], 'XF86MonBrightnessUp', lazy.function(backlight('inc'))),
Key([], 'XF86MonBrightnessDown', lazy.function(backlight('dec'))),
# Audio
Key([], 'XF86AudioMute', lazy.spawn('ponymix toggle')),
Key([], 'XF86AudioRaiseVolume', lazy.spawn('ponymix increase 5')),
Key([], 'XF86AudioLowerVolume', lazy.spawn('ponymix decrease 5')),
Key([], 'XF86AudioPlay', lazy.spawn(music_cmd + 'PlayPause')),
Key([], 'XF86AudioNext', lazy.function(next_prev('Next'))),
Key([], 'XF86AudioPrev', lazy.function(next_prev('Previous'))),
# Apps
Key([mod], 'Return', lazy.spawn(TERM_EMULATOR)),
Key([mod], 'b', lazy.spawn(BROWSER)),
Key([mod], 'g', lazy.spawn('steam')),
Key([mod], 'n', lazy.spawn('discord')),
# Switch between windows in current stack pane
Key([mod], 'Tab', lazy.layout.down()),
Key([mod, 'shift'], 'Tab', lazy.layout.up()),
# Move windows up or down in current stack
Key([mod, 'mod1'], 'Tab', lazy.layout.shuffle_down()),
Key([mod, 'mod1', 'shift'], 'Tab', lazy.layout.shuffle_up()),
# Switch window focus to other pane(s) of stack
Key([mod, 'control'], 'Tab', lazy.layout.next()),
Key([mod, 'control', 'shift'], 'Tab', lazy.layout.prev()),
# Swap panes of split stack
#Key([mod, 'shift'], 'space', lazy.layout.rotate()),
# Change ratios
Key([mod], 'k', lazy.layout.increase_ratio()),
Key([mod], 'j', lazy.layout.decrease_ratio()),
# kick to next/prev screen
Key([mod], "o", lazy.function(kick_to_next_screen)),
Key([mod, "shift"], "o", lazy.function(kick_to_next_screen, -1)),
# Toggle between split and unsplit sides of stack.
# Split = all windows displayed
# Unsplit = 1 window displayed, like Max layout, but still with
# multiple stack panes
#Key([mod, 'shift'], 'Return', lazy.layout.toggle_split()),
Key([mod], 'Return', lazy.spawn('x-terminal-emulator')),
Key([mod], 'v', lazy.spawn('gvim')),
Key([mod], 'l', lazy.spawn('xlock')),
Key([], 'XF86Launch1', lazy.spawn('xlock')),
Key([], 'XF86AudioMute', lazy.spawn('amixer -D pulse set Master toggle')),
#Key([], 'XF86AudioMicMute', lazy.spawn('amixer -D pulse set Master toggle')),
Key([], 'XF86AudioRaiseVolume',
lazy.spawn('amixer -c 0 -q set Master 2dB+')),
Key([], 'XF86AudioLowerVolume',
# Toggle between different layouts as defined below
KeyNode([mod4], "space", [], lazy.next_layout()),
# Restart or quit qtile
KeyNode([mod4, "control"], "r", [], lazy.restart()),
KeyNode([mod4, "control"], "q", [], lazy.shutdown()),
# Launch a command
KeyNode([mod4], "r", [], lazy.spawncmd()),
# toggle visibiliy of above defined DropDown named "term"
KeyNode([mod4], 'z', [], lazy.group['scratchpad'].dropdown_toggle('term')),
# Lock the screensaver (password)
KeyNode([mod4], "F12", [], lazy.function(lock)),
# Change the volume if our keyboard has keys
KeyNode([], "XF86AudioRaiseVolume", [],
lazy.spawn("amixer -c 0 -q set Master 2dB+")),
KeyNode([], "XF86AudioLowerVolume", [],
lazy.spawn("amixer -c 0 -q set Master 2dB-")),
KeyNode([], "XF86AudioMute", [],
lazy.spawn("amixer -c 0 -q set Master toggle")),
)
# Set the home of the extra node
extra.sethome(home)
# set the main qtile keys variable to the children of the home node.
keys = home.children
Key([mod], "space", lazy.layout.next()),
# Swap panes of split stack
Key([mod, "shift"], "space", lazy.layout.rotate()),
# Toggle between split and unsplit sides of stack.
# Split = all windows displayed
# Unsplit = 1 window displayed, like Max layout, but still with
# multiple stack panes
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.next_layout()),
Key([mod, "shift"], "q", lazy.window.kill()),
Key([mod, "shift"], "r", lazy.restart()),
Key([mod, "shift"], "x", lazy.function(hide_show_bar))
]
groups = [Group(i) for i in "12345678"]
for i in groups:
keys.extend([
# mod1 + letter of group = switch to group
Key([mod], i.name, lazy.group[i.name].toscreen()),
# mod1 + shift + letter of group = switch to & move focused window to group
Key([mod, "shift"], i.name, lazy.window.togroup(i.name)),
])
layouts = [layout.Max(), layout.Stack(num_stacks=2)]
('M-w', lazy.window.kill()),
('M-C-q', lazy.shutdown()),
('M-C-h', lazy.layout.grow_left(), lazy.layout.decrease_ratio(),
lazy.layout.grow_width(-30)), # dvorak h
('M-C-t', lazy.layout.grow_down(), lazy.layout.decrease_nmaster(),
lazy.layout.grow_height(-30)), # dvorak j
('M-C-n', lazy.layout.grow_up(), lazy.layout.increase_nmaster(),
lazy.layout.grow_height(30)), # dvorak k
('M-C-s', lazy.layout.grow_right(), lazy.layout.increase_ratio(),
lazy.layout.grow_width(30)), # dvorak l
# ('M-h', lazy.layout.left(), lazy.layout.previous()), # h
# ('M-t', lazy.layout.down()), # j
# ('M-n', lazy.layout.up()), # k
# ('M-s', lazy.layout.right(), lazy.layout.next()), # l
('M-h', lazy.function(qtools.focus.left)), # h
('M-t', lazy.function(qtools.focus.down)), # j
('M-n', lazy.function(qtools.focus.up)), # k
('M-s', lazy.function(qtools.focus.right)), # l
('M-S-h', lazy.layout.move_left(), lazy.layout.shuffle_left()), # h
('M-S-t', lazy.layout.move_down(), lazy.layout.shuffle_down()), # j
('M-S-n', lazy.layout.move_up(), lazy.layout.shuffle_up()), # k
('M-S-s', lazy.layout.move_right(), lazy.layout.shuffle_right()), # l
('M-A-h', lazy.layout.integrate_left(), lazy.layout.flip_left()), # h
('M-A-t', lazy.layout.integrate_down(), lazy.layout.flip_down()), # j
('M-A-n', lazy.layout.integrate_up(), lazy.layout.flip_up()), # k
('M-A-s', lazy.layout.integrate_right(), lazy.layout.flip_right()), # l
('M-y', lazy.layout.mode_horizontal()),
('M-p', lazy.layout.mode_vertical()),
('M-C-y', lazy.layout.mode_horizontal_split()),
('M-C-p', lazy.layout.mode_vertical_split()),
Key([mod, 'control'], 'j', lazy.layout.shuffle_up()),
Key([mod, 'shift'], 'h', lazy.layout.client_to_previous()),
Key([mod, 'shift'], 'l', lazy.layout.client_to_next()),
Key([mod, 'shift'], 'space', lazy.layout.rotate()),
Key([mod, 'shift'], 'Return', lazy.layout.toggle_split()),
Key([mod], '1', lazy.to_screen(1)),
Key([mod], '2', lazy.to_screen(2)),
Key([mod], 'Tab', lazy.next_layout()),
Key([mod], 'x', lazy.window.kill()),
Key([mod], 'r', lazy.spawncmd()),
Key([mod, 'control'], 'r', lazy.restart()),
Key([mod, 'control'], 'q', lazy.shutdown()),
# Screen
Key([], 'F7', lazy.spawn('xset dpms force off')),
Key([], 'XF86MonBrightnessUp', lazy.function(backlight('inc'))),
Key([], 'XF86MonBrightnessDown', lazy.function(backlight('dec'))),
# Audio
Key([], 'XF86AudioMute', lazy.spawn('ponymix toggle')),
Key([], 'XF86AudioRaiseVolume', lazy.spawn('ponymix increase 5')),
Key([], 'XF86AudioLowerVolume', lazy.spawn('ponymix decrease 5')),
Key([], 'XF86AudioPlay', lazy.spawn(music_cmd + 'PlayPause')),
Key([], 'XF86AudioNext', lazy.function(next_prev('Next'))),
Key([], 'XF86AudioPrev', lazy.function(next_prev('Previous'))),
# Apps
Key([mod], 'Return', lazy.spawn(TERM_EMULATOR)),
Key([mod], 'b', lazy.spawn(BROWSER)),
Key([mod], 'g', lazy.spawn('steam')),
Key([mod], 'n', lazy.spawn('discord')),
def command_tab(qtile):
groups = itertools.chain.from_iterable(itertools.repeat(qtile.groups, 3))
for group in groups:
if group != qtile.currentGroup:
continue
else:
group = next(group for group in groups if group.windows)
qtile.currentScreen.setGroup(group)
return
keys = [
Key(["control"], "Tab", lazy.function(command_tab)),
Key([SUPER], "Left", lazy.group.prevgroup()),
Key([SUPER], "Right", lazy.group.nextgroup()),
Key([], "XF86Launch5", lazy.spawn("urxvt")),
Key([], "XF86Launch6", lazy.spawn(os.getenv("BROWSER"))),
Key([], "XF86Launch7", lazy.spawn("gimp")),
Key([], "XF86Launch8", lazy.spawn("vlc")),
Key([], "XF86Launch9", lazy.spawn("vlc")),
Key([], "XF86AudioLowerVolume", lazy.spawn("amixer sset Master 5%-")),
Key([], "XF86AudioRaiseVolume", lazy.spawn("amixer sset Master 5%+")),
Key([], "XF86AudioMute", lazy.spawn("amixer sset Master toggle")),
Key([], "XF86AudioPlay", lazy.spawn("ncmpcpp play")),
Key([ALT, "shift"], "q", lazy.spawn("sudo shutdown -h 0")),
Key([mod], "Tab", lazy.next_layout()),
Key([mod], "q", lazy.window.kill()),
Key([mod, ctrl], "r", lazy.restart()),
Key([mod, ctrl], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Screens
Key([mod, ctrl], "1", lazy.to_screen(0)),
Key([mod, ctrl], "2", lazy.to_screen(1))
]
system = [
# Key([mod, shift], "x", lazy.function(lock_screen())),
Key([mod, shift], "x", lazy.spawn("./.script/wm/lock")),
Key([], 'XF86MonBrightnessUp', lazy.function(change_backlight('up'))),
Key([], 'XF86MonBrightnessDown', lazy.function(change_backlight('down'))),
Key([], 'XF86AudioRaiseVolume', lazy.spawn('pactl set-sink-volume 0 +5%')),
Key([], 'XF86AudioLowerVolume', lazy.spawn('pactl set-sink-volume 0 -5%')),
Key([], 'XF86AudioMute', lazy.spawn('pactl set-sink-mute 0 toggle'))
]
rofi = [
Key([mod], "d", lazy.spawn("rofi -show drun")),
Key([mod], "e", lazy.spawn("./.script/rofi/edit-config.sh"))
]
mpc = [
Key([], 'XF86AudioPlay', lazy.spawn("mpc toggle")),
Key([], 'XF86AudioNext', lazy.spawn("mpc next")),
Key([], 'XF86AudioPrev', lazy.spawn("mpc prev"))
Key([sup], "Down", lazy.layout.shuffle_down()),
Key([sup], "Up", lazy.layout.shuffle_up()),
Key([alt], "space", lazy.nextlayout()),
Key([alt, shift], "space", lazy.layout.rotate()),
Key([alt, shift], "Return", lazy.layout.toggle_split()),
Key([alt, "shift"], "k", lazy.window.kill()),
Key([alt], "x", lazy.window.kill()),
# interact with prompts
Key([sup], "space", lazy.spawn(Commands.dmenu)),
Key([sup], "r", lazy.spawncmd()),
# start specific apps
Key([sup], "e", lazy.function(app_or_group("vm", "virtualbox"))),
Key([sup], "j", lazy.function(app_or_group("sns", "jd"))),
Key([sup], "n", lazy.function(app_or_group("www", "chromium"))),
Key([sup], "s", lazy.spawn(Commands.screenshot)),
Key([sup], "v", lazy.function(app_or_group("media", "vlc"))),
Key([sup], "BackSpace", lazy.function(app_or_group("editor", "emacs"))),
Key([sup, 'control'], 'l', lazy.spawn(Commands.lock_screen)),
Key([alt], "Return", lazy.spawn("urxvt")),
# Change the volume if our keyboard has keys
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB+")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB-")),
Key([], "XF86AudioMute",
lazy.spawn("amixer -c 0 -q set Master toggle")),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Short Key
## volume control
Key([alt, "shift"], "k", lazy.spawn("amixer -c 0 -q set Master 2dB+")),
Key([alt, "shift"], "j", lazy.spawn("amixer -c 0 -q set Master 2dB-")),
Key([alt, "shift"], "h", lazy.spawn("amixer -c 0 -q set Master 100")),
Key([alt, "shift"], "l", lazy.spawn("amixer -c 0 -q set Master 0")),
## lock screen
Key([alt], "l", lazy.spawn("i3lock -i /home/arch/.archcfg/lock.png")),
## apps
Key([alt], "b", lazy.spawn("google-chrome-stable")),
Key([alt], "n", lazy.function(app_or_group("www", "google-chrome-stable"))),
Key([alt], "f", lazy.spawn("xterm ranger")),
Key([alt], "p", lazy.function(screenshot())),
Key([alt, "shift"], "p", lazy.function(screenshot(selection=True))),
]
myMonadTall = layout.MonadTall(
border_focus=l_gray,
border_width=1
)
myColumns = layout.Columns(
name="C",
autosplit=False,
border_focus=l_gray,
border_width=1,
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.next()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return",lazy.layout.toggle_split()),
Key(["mod1"], "Tab", lazy.next_layout()),
Key([mod, "mod1"], "h", lazy.to_screen(0)),
Key([mod, "mod1"], "l", lazy.to_screen(1)),
Key([mod], "x", lazy.window.kill()),
Key([mod, "shift"], "l", lazy.layout.swap_left()),
# interact with prompts
Key([mod], "r", lazy.spawncmd()),
Key([mod], "g", lazy.togroup()),
# start specific apps
Key([mod], "n", lazy.function(app_or_group("www", "google-chrome"))),
Key([mod], "m", lazy.function(app_or_group("music", "clementine"))),
Key([mod], "c", lazy.function(app_or_group("io", "pidgin"))),
Key([mod], "Return", lazy.spawn("urxvt")),
# Change the volume if our keyboard has keys
Key(
[], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c %d -q set Master 2dB+" % sound_card)
),
Key(
[], "XF86AudioLowerVolume",
lazy.spawn("amixer -c %d -q set Master 2dB-" % sound_card)
),
Key(
[], "XF86AudioMute",
Key([], "XF86AudioPrev",
# lazy.function(lambda q: fipc_jango("prev"))),
lazy.spawn("mpc prev")),
# No mute key @notebook
# Key(["shift"], "XF86AudioMute",
Key([mod], "p",
# lazy.function(lambda q: fipc_jango("pause"))),
lazy.spawn("mpc toggle")),
# replace qtile with awesome, only to test stuff
Key([mod, "control"], "a", lazy.execute("/usr/bin/awesome", ("awesome",))),
# restart qtile
Key([mod, "control"], "r", lazy.restart()),
# fast switches
Key([mod], "t", lazy.function(switch_to("Gajim"))),
Key([], "F12", lazy.function(SwapGroup('h4x'))),
Key(['shift'], "F12", lazy.function(to_urgent)),
]
# Floating Drag
# ------------------
mouse = [
Drag([mod], "Button1", lazy.window.set_position_floating(),
start=lazy.window.get_position()),
Drag([mod], "Button3", lazy.window.set_size_floating(),
start=lazy.window.get_size()),
Click([mod], "Button2", lazy.window.bring_to_front())
]
Key([mod], "h", lazy.layout.previous()),
Key([mod], "l", lazy.layout.next()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
Key(["mod1"], "Tab", lazy.next_layout()),
Key([mod, "mod1"], "h", lazy.to_screen(0)),
Key([mod, "mod1"], "l", lazy.to_screen(1)),
Key([mod], "x", lazy.window.kill()),
Key([mod, "shift"], "l", lazy.layout.swap_left()),
# interact with prompts
Key([mod], "r", lazy.spawncmd()),
Key([mod], "g", lazy.togroup()),
# start specific apps
Key([mod], "n", lazy.function(app_or_group("www", "google-chrome"))),
Key([mod], "m", lazy.function(app_or_group("music", "clementine"))),
Key([mod], "c", lazy.function(app_or_group("io", "pidgin"))),
Key([mod], "Return", lazy.spawn("urxvt")),
# Change the volume if our keyboard has keys
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c %d -q set Master 2dB+" % sound_card)),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c %d -q set Master 2dB-" % sound_card)),
Key([], "XF86AudioMute", lazy.spawn("amixer -D pulse set Master toggle")),
Key([], "XF86AudioPlay", lazy.spawn("clementine --play-pause")),
Key([], "XF86AudioNext", lazy.spawn("clementine --next")),
Key([], "XF86AudioPrev", lazy.spawn("clementine --prev")),
# also allow changing volume, tracks the old fashioned way
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()),
# start specific apps
Key([mod], "n", lazy.function(app_or_group("www", "firefox"))),
Key([mod], "m", lazy.function(app_or_group("music", "clementine"))),
Key([mod], "c", lazy.function(app_or_group("io", "pidgin"))),
Key([mod], "Return", lazy.spawn("xterm")),
# Change the volume if our keyboard has keys
Key(
[], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB+")
),
Key(
[], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 0 -q set Master 2dB-")
),
Key(
[], "XF86AudioMute",
Key([mod, "shift"], "p", lazy.spawn(tmux_session("pomodoro"))),
# Run an application
Key([mod], "d", lazy.spawn(App.launcher)),
# Close application
Key([mod, "shift"], "q", lazy.window.kill()),
# Lock screen
Key([mod], "9", lazy.spawn(lock_screen)),
# Exit qtile
Key([mod], "Escape", lazy.spawn(["powermenu", resolve("powermenu.conf")])),
# Toggle bar
Key([mod], "b", lazy.function(hide_bar)),
# Move between groups
Key([mod], "Tab", lazy.screen.toggle_group()),
Key([mod], "n", lazy.screen.next_group()),
Key([mod, "shift"], "n", lazy.screen.prev_group()),
# Manage floating windows
Key([mod], "f", lazy.window.toggle_floating()),
Key([mod, "shift"], "f", lazy.window.bring_to_front()),
Key([mod, ctrl], "f", lazy.function(float_to_stacked)),
# Toggle between different layouts
Key([mod], "t", set_layout(0)), # set monadtall
Key([mod], "u", set_layout(1)), # set monadwide
Key([mod], "m", set_layout(2)), # set max
Key([mod, "shift"], "r", lazy.restart()),
Key([mod, "shift"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Applications
Key([mod], "c", lazy.spawn("firefox")),
Key([mod], "l", lazy.spawn("clementine")),
Key([mod], "Return", lazy.spawn("urxvt")),
# Key([mod], "i", lazy.spawn("ipython qtconsole --profile labwork")),
Key([mod], "i", lazy.spawn("jupyter qtconsole")),
Key([mod, "shift"], "l", lazy.spawn("xscreensaver-command -lock")),
Key([], "Print", lazy.spawn("scrot")),
# Multimedia keys
Key([], "XF86Display", lazy.function(lambda q: resize(toggle=True))),
Key([mod], "s", lazy.function(lambda q: resize())),
Key([mod, "shift"], "s", lazy.function(lambda q: resize(clone=True))),
Key([], "XF86AudioPlay", lazy.spawn("clementine --play-pause")),
Key([], "XF86AudioNext", lazy.spawn("clementine --next")),
Key([], "XF86AudioPrev", lazy.spawn("clementine --prev")),
Key([], "XF86AudioMute", lazy.spawn("/home/sean/.config/qtile/volume.sh mute")),
Key([], "XF86AudioLowerVolume", lazy.spawn("/home/sean/.config/qtile/volume.sh down")),
Key([], "XF86AudioRaiseVolume", lazy.spawn("/home/sean/.config/qtile/volume.sh up"))
# Key([], "XF86MicMute", lazy.spawn("/home/sean/.qtile/volume.sh mic")),
]
# Drag floating layouts.
mouse = [
Drag([mod], "Button1", lazy.window.set_position_floating(),
start=lazy.window.get_position()),
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:
keys.append(Key(["mod1"], i.name, lazy.group[i.name].toscreen()))
keys.append(Key(["mod1", "shift"], i.name, lazy.window.togroup(i.name)))
keys.append(Key(["mod1"], "Left", lazy.group.prevgroup()))
keys.append(Key(["mod1"], "Right", lazy.group.nextgroup()))
keys.append(Key(["mod1", "shift"], "Left", lazy.function(toPrevGroup)))
keys.append(Key(["mod1", "shift"], "Right", lazy.function(toNextGroup)))
##########################################################################################
layouts = [layout.Max(), layout.Stack(stacks=2)]
screens = [
Screen(bottom=bar.Bar(
[
widget.GroupBox(),
widget.WindowName(fontsize=12),
widget.Systray(),
widget.Clock('%I:%M %p', fontsize=12, padding=6),
],
30,
add_group(q)
if win:
win.togroup(q.currentGroup.name)
def stop_move(q):
""" @type q: Qtile """
window = q.currentWindow
assert isinstance(window, Window)
if window.in_move:
window.disablefloating()
del window.in_move
q.unmapKey(stop_move_key)
stop_move_key = Key([], "space", lazy.function(stop_move))
def move_to_side_group(q, toLeft):
"""
@rtype : None
@type q: Qtile
@type toLeft: bool
"""
win = q.currentWindow
if win is None:
return
screen = q.currentScreen
assert isinstance(win, Window)
assert isinstance(screen, Screen)
# Add stop move functionality
alt = 'mod1'
terminal = 'kitty --single-instance'
browser = 'firefox'
keys = [
# Switch between windows in current stack pane
Key([mod], 'k', lazy.layout.down()),
Key([mod], 'j', lazy.layout.up()),
# Move windows up or down in current stack
Key([mod, ctrl], 'k', lazy.layout.shuffle_down()),
Key([mod, ctrl], 'j', lazy.layout.shuffle_up()),
# Switch window focus to other pane(s) of stack
Key([mod], 'space', lazy.next_layout()),
Key([alt], 'Tab', lazy.function(user.PrevFocus())),
Key([mod], 'u', lazy.function(user.to_urgent)),
Key([mod, ctrl], 'q', lazy.window.kill()),
Key([mod, ctrl], 'f', lazy.window.toggle_floating()),
Key([mod], 'n', lazy.window.toggle_minimize()),
Key([mod], 'f', lazy.window.toggle_fullscreen()),
# Rofi keys
Key([mod], 'a', lazy.spawn('''bash -c '~/.local/bin/addTask' ''')),
Key([mod], 'd', lazy.spawn('rofi -show window')),
Key([mod], 's', lazy.spawn('''bash -c '~/.local/bin/songChooser' ''')),
Key([mod], 'g', lazy.spawn('rofi -show run')),
Key([mod], 'r',
lazy.spawn(
'rofi -modi combi -show-icons -show combi -combi-modi drun,run')),
return
cur_win = qtile.currentWindow
cur_layout = qtile.currentLayout
cur_group = qtile.currentGroup
cur_layout.remove(cur_win)
cur_group.remove(cur_win)
target_layout.group.add(cur_win)
if isinstance(target_layout, layout.Stack):
target_layout.cmd_client_to_stack(stack_idx)
return callback
for i in range(1, 9):
keys.append(Key([mod], str(i), lazy.function(switch_to_global_stack(i))))
keys.append(Key([mod, "control"], str(i), lazy.function(send_to_global_stack(i))))
groups = [Group(i) for i in "asdf"]
for i in groups:
# mod1 + letter of group = switch to group
keys.append(
Key([mod], i.name, lazy.group[i.name].toscreen())
)
# mod1 + control + letter of group = switch to & move focused window to group
keys.append(
Key([mod, "control"], i.name, lazy.window.togroup(i.name))
)
# scroll in any window with the same shortcut !
Key([mod], "b", lazy.spawn("xdotool click 4")),
Key([mod], "m", lazy.spawn("xdotool click 5")),
# Toggle between different layouts as defined below
Key([mod], "space", lazy.next_layout()),
Key([mod], "Tab", lazy.screen.togglegroup()),
Key([mod, "shift"], "c", lazy.window.kill()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "p", lazy.spawncmd()),
]
for key, group, cmd in dynamic_tags:
keys.append(Key([mod], key, lazy.function(app_or_group(group.name, cmd))))
keys.append(Key([mod, "shift"], key, lazy.window.togroup(group.name)))
for key, i in tag_keys:
# mod1 + letter of group = switch to group
keys.append(
Key([mod], key, lazy.group[i.name].toscreen())
)
# mod1 + shift + letter of group = switch to & move focused window to group
keys.append(
Key([mod, "shift"], key, lazy.window.togroup(i.name))
)
class MyTile(layout.Tile):
def cmd_zoom(self):
# Layout hotkeys
Key([mod, "control"], "h", lazy.layout.shrink_main()),
Key([mod, "control"], "l", lazy.layout.grow_main()),
Key([mod, "control"], "j", lazy.layout.down()),
Key([mod, "control"], "k", lazy.layout.up()),
Key([mod, "shift"], "j", lazy.layout.shuffle_down()),
Key([mod, "shift"], "k", lazy.layout.shuffle_up()),
#Key([mod], "grave", lazy.screen.next_group(skip_empty=True)),
#Key([mod], "Tab", lazy.screen.prev_group(skip_empty=True)),
# Toggle between different layouts as defined below
Key([mod], "m", lazy.prev_layout()),
Key([mod, "shift"], "m", lazy.next_layout()),
Key([mod], "w", lazy.window.kill()),
Key([mod], "space",
lazy.function(lambda qtile: qtile.cmd_hide_show_bar())),
Key([mod, 'control'], "m",
lazy.function(change_abstract_window_state, state=5)),
Key([mod, 'control'], "n", lazy.window.resize_floating(0, 69)),
Key([mod, 'shift'], "n", lazy.window.move_floating(-1, -69)),
# Lazy functions do not capture variables so passing lambda instead.
Key([mod, 'control'], "w",
lazy.function(lambda qtile: toggle_work_hours_widget(
work_start_time, work_hours_widget))),
# Key([mod, "control"], "r", lazy.restart()),
#Key([mod, "control"], "q", lazy.function(shutdown)),
#Key([], 'F11', lazy.group['scratchpad'].dropdown_toggle('term')),
#Key([], 'F12', lazy.group['scratchpad'].dropdown_toggle('qshell')),
]
# Programs
Key([mod], "w", lazy.spawn(browser)),
Key([mod], "e", lazy.spawn(filemgr)),
Key([alt, control], "c", lazy.spawn(editor_gui)),
Key([mod], "t", lazy.spawn(terminal)),
# Brightness
Key([], "XF86MonBrightnessUp", lazy.spawn(Commands.brightness_up)),
Key([], "XF86MonBrightnessDown", lazy.spawn(Commands.brightness_down)),
# Media
Key([], "XF86AudioRaiseVolume", lazy.spawn(Commands.volume_up)),
Key([], "XF86AudioLowerVolume", lazy.spawn(Commands.volume_down)),
Key([], "XF86AudioMute", lazy.spawn(Commands.volume_toggle)),
Key([], "XF86AudioMicMute", lazy.spawn(Commands.mic_toggle)),
Key([], 'Print', lazy.function(screenshot())),
Key(['control'], 'Print', lazy.spawn('xfce4-screenshooter'))
]
# groups = [Group(i) for i in "asdfuiop"]
groups = [Group(i) for i in ''.join(map(str, [*range(1, 10)]))]
for i in groups:
if num_screens == 1:
switch = lazy.group[i.name].toscreen()
else:
switch = None
keys.extend([
# mod1 + letter of group = switch to group
Key([mod], i.name, lazy.group[i.name].toscreen()),
def set_layout(index):
return lazy.function(lambda qtile: qtile.cmd_to_layout_index(index))
def gen_keys():
return expand_placeholders([
# Change window focus
MultiKey([mod], MultiKey.left, lazy.function(focus_left)),
MultiKey([mod], MultiKey.right, lazy.function(focus_right)),
MultiKey([mod], MultiKey.down, lazy.function(focus_down)),
MultiKey([mod], MultiKey.up, lazy.function(focus_up)),
# Swap windows
MultiKey([mod, shift], MultiKey.left, lazy.layout.swap_left()),
MultiKey([mod, shift], MultiKey.right, lazy.layout.swap_right()),
MultiKey([mod, shift], MultiKey.down, lazy.layout.shuffle_down()),
MultiKey([mod, shift], MultiKey.up, lazy.layout.shuffle_up()),
# Layout sizes
Key([mod], "i", lazy.function(shrink_main)),
Key([mod], "o", lazy.function(grow_main)),
Key([mod, shift], "i", lazy.layout.grow()),
Key([mod, shift], "o", lazy.layout.shrink()),
# win + tab
Key([alt], "Tab", lazy.group.next_window()),
Key([alt, shift], "Tab", lazy.group.prev_window()),
# Move window to group
MultiKey([mod, ctrl, shift], MultiKey.left, lazy.function(move_to_left_group)),
MultiKey([mod, ctrl, shift], MultiKey.right, lazy.function(move_to_right_group)),
# Change group
MultiKey([mod, ctrl], MultiKey.left, lazy.function(to_left_group)),
MultiKey([mod, ctrl], MultiKey.right, lazy.function(to_right_group)),
Key([mod], 'BackSpace', lazy.function(to_prev_group)),
# Add/delete group
Key([mod], space, lazy.function(add_group)),
Key([mod, shift], space, lazy.function(move_to_new_group)),
Key([mod, ctrl], 'w', lazy.function(close_group)),
Key([mod], 'p', lazy.function(close_group)), #duplicate
# Run program
Key([mod], ret, lazy.spawn("mlterm")),
Key([mod], "b", lazy.spawn("chromium")),
Key([mod], "t", lazy.spawn("dolphin")),
# Window management
Key([mod], "e", lazy.window.disable_floating()),
Key([mod], "w", lazy.window.kill()),
Key([alt], "F4", lazy.window.kill()),
Key([mod], "m", lazy.window.toggle_maximize()),
Key([mod], "f", lazy.window.toggle_maximize()), #duplicate
Key([mod], "n", lazy.window.toggle_minimize()),
Key([mod], "u", lazy.function(unminimize)),
# Set layout
# Key([mod], 's', lazy.group.setlayout('stack')),
# Key([mod], 'a', lazy.group.setlayout('max')),
# Key([mod], 'r', lazy.group.setlayout('monadtall')),
# Qtile
Key([mod, shift], ret, lazy.spawncmd()),
Key([mod, ctrl], "r", lazy.restart()),
])
qtile.groups[len(qtile.groups) - 1].cmd_toscreen()
return __inner
# TODO use mod+control+j(next screen) and k(prev screen) with shift to move the current window to screen
# TODO would be nice to have a display of the shortcuts like mod+s in awesomewm
keys = [
# Switch to screen
# Key([mod], "1", lazy.to_screen(0)),
# Key([mod], "2", lazy.to_screen(1)),
Key([mod, "control"], "j", lazy.next_screen()),
Key([mod, "control"], "k", lazy.prev_screen()),
Key([mod, "control", "shift"], "1",
lazy.function(utils.move_window_to_screen(0))),
Key([mod, "control", "shift"], "2",
lazy.function(utils.move_window_to_screen(1))),
# Switch between windows in current stack pane
Key([mod], "h", lazy.layout.left()),
Key([mod], "l", lazy.layout.right()),
Key([mod], "j", lazy.layout.down()),
Key([mod], "k", lazy.layout.up()),
Key([mod, "shift"], "h", lazy.layout.swap_left()),
Key([mod, "shift"], "l", lazy.layout.swap_right()),
Key([mod, "shift"], "j", lazy.layout.shuffle_down()),
Key([mod, "shift"], "k", lazy.layout.shuffle_up()),
Key([mod], "space", lazy.layout.next()),
Key([mod, "shift"], "space", lazy.layout.flip()),
def app_or_group(group, app):
""" Go to specified group if it exists. Otherwise, run the specified app.
When used in conjunction with dgroups to auto-assign apps to specific
groups, this can be used as a way to go to an app if it is already
running. """
def f(qtile):
try:
qtile.groupMap[group].cmd_toscreen()
except KeyError:
qtile.cmd_spawn(app)
return f
keys = [
Key([mod], "i", lazy.function(winstash)),
Key([mod, "shift"], "i", lazy.function(winunstash)),
# 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()),
# I don't ever use floating, but sometimes it is handy to toggle to
# floating for debugging, so I use the "out of band" mnemonic for this as
# well.
Key(["shift", "mod1"], "f", lazy.window.toggle_floating()),
Key([mod], "k", lazy.layout.up()),
Key([mod], "j", lazy.layout.down()),
Key([mod, "shift"], "space", lazy.layout.rotate()),
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
def focus_transset(w):
# os.system("transset -i " + str(get_win_id(w)) + ' 1')
global last_window_id
if last_window_id is not get_win_id(w):
if last_window_id is not 0 and last_window_id not in no_transset_window_ids:
# os.system("transset -i " + str(last_window_id) + ' 0.75')
pass
last_window_id = get_win_id(w)
print(no_transset_window_ids)
keys = [
Key([mod], "h", lazy.layout.left(),
lazy.function(lambda x: focus_transset(x.currentWindow))),
Key([mod], "l", lazy.layout.right(),
lazy.function(lambda x: focus_transset(x.currentWindow))),
Key([mod], "j", lazy.group.next_window(),
lazy.function(lambda x: focus_transset(x.currentWindow))),
Key([mod], "k", lazy.group.prev_window(),
lazy.function(lambda x: focus_transset(x.currentWindow))),
Key([mod, shift], 't',
lazy.function(
lambda x: toggle_need_transset(get_win_id(x.currentWindow)))),
Key([mod, shift], "h", lazy.layout.swap_left(),
lazy.layout.shuffle_left()),
Key([mod, shift], "l", lazy.layout.swap_right(),
lazy.layout.shuffle_right()),
Key([mod, shift], "j", lazy.layout.shuffle_down()),
Key([mod, shift], "k", lazy.layout.shuffle_up()),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.next_layout()),
Key([mod, "shift"], "q", lazy.window.kill()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
# Screens?!?jedi=0, ?!? (*args, *_***kwargs*_*) ?!?jedi?!?
Key([mod, "control"], "1", lazy.to_screen(0)),
Key([mod, "control"], "2", lazy.to_screen(1))
]
system = [
Key([mod, "shift"], "x", lazy.function(lock_screen())),
Key([], 'XF86MonBrightnessUp', lazy.function(change_backlight('up'))),
Key([], 'XF86MonBrightnessDown', lazy.function(change_backlight('down'))),
Key([], 'XF86AudioRaiseVolume', lazy.spawn('pactl set-sink-volume 0 +5%')),
Key([], 'XF86AudioLowerVolume', lazy.spawn('pactl set-sink-volume 0 -5%')),
Key([], 'XF86AudioMute', lazy.spawn('pactl set-sink-mute 0 toggle'))
]
rofi = [
Key([mod], "d", lazy.spawn("rofi -show drun")),
]
mpc = [
Key([], 'XF86AudioPlay', lazy.spawn("mpc toggle")),
Key([], 'XF86AudioNext', lazy.spawn("mpc next")),
Key([], 'XF86AudioPrev', lazy.spawn("mpc prev"))
"org.freedesktop.PowerManagement.Suspend")),
# move to
Key([mod], "g", lazy.togroup()),
Key([mod], "q", lazy.findwindow()),
# Sound and Mpd
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer sset Master 5%+")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer sset Master 5%-")),
Key([], "XF86AudioMute",
lazy.spawn("amixer sset Master toggle")),
Key(["shift"], "XF86AudioRaiseVolume",
lazy.function(lambda q: fipc_jango("next"))),
Key(["shift"], "XF86AudioLowerVolume",
lazy.spawn("mpc prev")),
# No mute key @notebook
#Key(["shift"], "XF86AudioMute",
Key([mod], "p",
lazy.function(lambda q: fipc_jango("pause"))),
# replace qtile with awesome, only to test stuff
Key([mod, "control"], "a", lazy.execute("/usr/bin/awesome", ("awesome",))),
# restart qtile
Key([mod, "control"], "r", lazy.restart()),
# fast switches
Key([mod], "t", lazy.function(switch_to("Gajim"))),
)),
# Media hotkeys
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')),
#dmenu
Key([mod], 'm', lazy.spawn('xfce4-appfinder')),
#Key([mod], 'm', lazy.spawn('dmenu_run -i -b -p ">>>" -fn "Open Sans-10" -nb "#000" -nf "#fff" -sb "#00BF32" -sf "#fff"')),
#Key([mod], 'm', lazy.run_extension(extension.J4DmenuDesktop()))
# screenshots
Key([], 'Print', lazy.function(screenshot())),
Key([mod], 'Print', lazy.spawn('deepin-screenshot'))
]
# ----------------------------
# --- Workspaces and Rooms ---
# ----------------------------
# The basic idea behind Workspaces and Rooms is to control
# DIFFERENT subsets of groups with the SAME hotkeys.
# So we can have multiple 'qwerasdf' rooms in a different workspaces.
#
# Qtile Groups are used behind the scenes, but their visibility
# is set dynamically.
def get_keys():
keys = []
########################################################################
index = 1
for current_group in groups.get_groups():
keys.append(Key([mod], str(index), lazy.function(go_to_group, current_group.name))) # Switch to another group
keys.append(Key([mod, "shift"], str(index), lazy.window.togroup(current_group.name))) # Send current window to another group
index += 1
########################################################################
########################################################################
keys.append(Key([mod], "h", lazy.layout.left()))
keys.append(Key([mod], "l", lazy.layout.right()))
keys.append(Key([mod], "j", lazy.layout.down()))
keys.append(Key([mod], "k", lazy.layout.up()))
keys.append(Key([mod, "shift"], "h", lazy.layout.swap_left()))
keys.append(Key([mod, "shift"], "l", lazy.layout.swap_right()))
keys.append(Key([mod, "shift"], "j", lazy.layout.shuffle_down()))
keys.append(Key([mod, "shift"], "k", lazy.layout.shuffle_up()))
keys.append(Key([mod], "i", lazy.layout.grow()))
keys.append(Key([mod], "m", lazy.layout.shrink()))
#keys.append(Key([mod], "m", lazy.layout.maximize())) # Toggle a window between minimum and maximum sizes
keys.append(Key([mod], "n", lazy.layout.normalize()))
keys.append(Key([mod], "o", lazy.layout.maximize()))
#keys.append(Key([mod, "shift"], "space", lazy.layout.flip()))
keys.append(Key([mod, "shift"], "space", lazy.layout.flip()))
keys.append(Key([mod1], "Tab", lazy.layout.next(), desc="Move window focus to other window"))
#keys.append(Key([mod, "shift"], "space", lazy.function(switch_screens)))
# # Switch between windows
# keys.append(Key([mod], "h", lazy.layout.left(), desc="Move focus to left"))
# keys.append(Key([mod], "l", lazy.layout.right(), desc="Move focus to right"))
# keys.append(Key([mod], "j", lazy.layout.down(), desc="Move focus down"))
# keys.append(Key([mod], "k", lazy.layout.up(), desc="Move focus up"))
# keys.append(Key([mod], "space", lazy.layout.next(), desc="Move window focus to other window"))
# # Move windows between left/right columns or move up/down in current stack.
# # Moving out of range in Columns layout will create new column.
# keys.append(Key([mod, "shift"], "h", lazy.layout.shuffle_left(), desc="Move window to the left"))
# keys.append(Key([mod, "shift"], "l", lazy.layout.shuffle_right(), desc="Move window to the right"))
# keys.append(Key([mod, "shift"], "j", lazy.layout.shuffle_down(), desc="Move window down"))
# keys.append(Key([mod, "shift"], "k", lazy.layout.shuffle_up(), desc="Move window up"))
# # Grow windows. If current window is on the edge of screen and direction
# # will be to screen edge - window would shrink.
# keys.append(Key([mod, "control"], "h", lazy.function(grow("WWW")), desc="Grow window to the left"))
# #keys.append(Key([mod, "control"], "h", lazy.layout.grow(), desc="Grow window to the left"))
# #keys.append(Key([mod, "control"], "h", lazy.layout.grow_left(), desc="Grow window to the left"))
# #keys.append(Key([mod, "control"], "l", lazy.layout.grow_right(), desc="Grow window to the right"))
# #keys.append(Key([mod, "control"], "j", lazy.layout.grow_down(), desc="Grow window down"))
# #keys.append(Key([mod, "control"], "k", lazy.layout.grow_up(), desc="Grow window up"))
# keys.append(Key([mod], "n", lazy.layout.normalize(), desc="Reset all window sizes"))
# keys.append(Key([mod], "n", lazy.layout.normalize())) # Restore all windows to default size ratios
# Toggle between split and unsplit sides of stack.
# Split = all windows displayed
# Unsplit = 1 window displayed, like Max layout, but still with
# multiple stack panes
keys.append(Key([mod, "shift"], "Return", lazy.layout.toggle_split(), desc="Toggle between split and unsplit sides of stack"))
keys.append(Key([mod], "Return", lazy.spawn(myTerm), desc="Launch terminal"))
# Toggle between different layouts as defined below
keys.append(Key([mod], "Tab", lazy.next_layout(), desc="Toggle between layouts"))
keys.append(Key([mod], "w", lazy.window.kill(), desc="Kill focused window"))
keys.append(Key([mod, "control"], "r", lazy.restart(), desc="Restart Qtile"))
keys.append(Key([mod, "control"], "q", lazy.shutdown(), desc="Shutdown Qtile"))
keys.append(Key([mod], "r", lazy.spawncmd(), desc="Spawn a command using a prompt widget"))
########################################################################
keys.append(Key(["control", "mod1"], "l", lazy.spawn("light-locker-command -l")))
########################################################################
# Increase number in master pane (Tile)), # Grow size of current window (XmonadTall)
# keys.append(Key([mod, "shift"], "l", lazy.layout.grow(), lazy.layout.increase_nmaster()))
# Shrink size of current window (XmonadTall), # Decrease number in master pane (Tile)
#keys.append(Key([mod, "shift"], "h", lazy.layout.shrink(), lazy.layout.decrease_nmaster()))
#keys.append(Key([mod, "shift"], "Left", window_to_prev_group)) # Move window to workspace to the left
#keys.append(Key([mod, "shift"], "Right", window_to_next_group)) # Move window to workspace to the right
#keys.append(Key([mod, "shift"], "KP_Enter", lazy.window.toggle_floating())) # Toggle floating
# Swap panes of split stack (Stack), # Switch which side main pane occupies (XmonadTall)
#keys.append(Key([mod, "shift"], "space", lazy.layout.rotate(), lazy.layout.flip()))
########################################################################
# Stack controls
#keys.append(Key([mod], "space", lazy.layout.next())) # Switch window focus to other pane(s) of stack
#keys.append(Key([mod, "control"], "Return", lazy.layout.toggle_split())) # Toggle between split and unsplit sides of stack
#keys.append(Key([mod], "Tab", lazy.next_layout())) # Toggle through layouts
#keys.append(Key([mod, "shift"], "c", lazy.window.kill())) # Kill active window
# keys.append(Key([mod], "w", lazy.to_screen(2))) # Keyboard focus screen(0)
# keys.append(Key([mod], "e", lazy.to_screen(0))) # Keyboard focus screen(1)
# keys.append(Key([mod], "r", lazy.to_screen(1))) # Keyboard focus screen(2)
#keys.append(Key([mod, "control"], "k", lazy.layout.section_up())) # Move up a section in treetab
#keys.append(Key([mod, "control"], "j", lazy.layout.section_down())) # Move down a section in treetab
########################################################################
# GUI Apps
#keys.append(Key([mod], "b", lazy.function(app_or_group, "WWW", "firefox")))
keys.append(Key([mod], "b", lazy.function(app_or_group, "SYS", "firefox")))
#keys.append(Key([mod], "b", lazy.function(app_or_group("WWW", "firefox"))))
#keys.append(Key([mod], "f", lazy.spawn("pcmanfm")))
#keys.append(Key([mod], "g", lazy.spawn("geany")))
################################################################################
return keys
# multiple stack panes
Key([mod, "shift"], "Return", lazy.layout.toggle_split()),
Key([mod, "control"], "x", lazy.spawn("xkill")),
# probably the -B option will need i3lock-color package
# Key([mod, "control"], "z", lazy.spawn("killall vmg; sudo optirun vmg")),
# Toggle between different layouts as defined below
Key([mod], "Tab", lazy.next_layout()),
Key([mod, "shift"], "Tab", lazy.prev_layout()),
Key([mod], "q", lazy.window.kill()),
Key([mod, 'shift'], "q", kill_all_windows()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
Key([mod], "F12", lazy.function(to_urgent)),
]
layouts = [
layout.Max(),
layout.Columns(fair=True,
margin=4 * scale_factor,
border_width=4 * scale_factor,
border_normal='d79921',
border_focus='d65d0e'),
layout.Stack(num_stacks=2),
layout.Matrix(),
layout.xmonad.MonadTall()
]
groups = [
mod = 'mod4'
alt = 'mod1'
keys = [
Key([mod], 'Return', lazy.spawn('gnome-terminal --hide-menubar')),
Key([mod], 'b', lazy.spawn('google-chrome')),
# Toggle between different layouts as defined below
# Key([mod], "Tab", lazy.next_layout()),
Key([mod], "w", lazy.window.kill()),
# Switch between windows in current stack pane
Key([alt], 'Tab', lazy.layout.down()),
Key([mod, "control"], "r", lazy.restart()),
Key([mod, "control"], "q", lazy.shutdown()),
Key([mod], "r", lazy.spawncmd()),
Key([], 'Caps_Lock', lazy.function(change_keyboard_layout())),
Key([], "XF86AudioRaiseVolume",
lazy.spawn("amixer -c 1 -q set Master 2dB+")),
Key([], "XF86AudioLowerVolume",
lazy.spawn("amixer -c 1 -q set Master 2dB-")),
]
screens = [
Screen(top=bar.Bar([
widget.GroupBox(),
widget.WindowName(),
widget.TextBox('🔋'),
widget.Battery(battery_name='BAT1'),
widget.TextBox('🔈'),
widget.Volume(cardid=1, device=None, update_interval=0.2),
widget.Systray(icon_size=14),
Key([mod], "space",
lazy.nextlayout()),
Key([mod, "shift"], "space",
lazy.prevlayout()),
Key([mod], "y",
lazy.window.kill()),
Key([mod], "t",
lazy.window.disable_floating()),
Key([mod, "shift"], "t",
lazy.window.enable_floating()),
Key([mod], "Left",
lazy.screen.prevgroup()),
Key([mod], "Right",
lazy.screen.nextgroup()),
Key(["control","shift"], "q", lazy.restart()),
Key([mod], "m", lazy.function(focus_master)),
Key([mod], "x", lazy.function(minimize)),
Key([mod], "a", lazy.function(unminimise_all)),
Key([mod], "Return", lazy.spawn(terminal_command))
]
mouse = [
Drag([mod], "Button1", lazy.window.set_position_floating(),
start=lazy.window.get_position()),
Drag([mod], "Button3", lazy.window.set_size_floating(),
start=lazy.window.get_size()),
Click([mod], "Button2", lazy.window.disable_floating()),
Click([mod], "Button4", lazy.layout.down()),
Click([mod], "Button5", lazy.layout.up())
]
