Package:Qtile

Qtile

   Tip

We welcome improvements to this page. To edit this page, Create a Funtoo account. Then log in and then click here to edit this page. See our editing guidelines to becoming a wiki-editing pro.

About Qtile

Qtile is a highly configurable tiling window manager distributed under MIT license. It handles both tiling and floating layouts. It is especially a good alternative to Awesome for those who are more used to Python than Lua. Indeed, Qtile is written and configured entirely in Python. So whether you are Python guru or whether you are learning Python for a few time, Qtile is an ideal choice to get your environment fit your needs and feel. If you don't know Python, you can still stuck to the default configuration or pick out one of the configuration examples but a basic understanding of Python language is recommended though.

Installation

root # emerge -av qtile

It is generally a good idea to enable the dbus useflag to deal with dbus messages. The widget-* useflags are only needed if you would like to include the given widgets. These widgets are included in Qtile, but require additional dependencies. Leaving widget-* useflags unset will remove the underlying widgets from qtile sources to avoid warnings about missing dependencies.

Very likely, you don't need to enable multiple python ABIs for qtile. To make your mind, here are the few things to know to choose the right ABI:

• Python 2.7 uses trollius, Python 3.3 uses asyncio, Python 3.4 has asyncio built-in.
• GoogleCalendar and Wlan widgets depend on packages that are python 2.7 only. If you plan to use one of these widgets, use python 2.7 ABI.

Once you've emerged qtile with the useflags and python ABI of your choice, you can skip to #Getting Started if you use a display manager. The following lines describe how to use qtile with Xinit.

In order to run qtile with xinit, add this line to your ~/.xinitrc:

   ~/.xinitrc

exec --sh-syntax --exit-with-session qtile

You might also want to pass ck-launch-session and/or dbus-launch if you want respectively ConsoleKit and/or dbus support (note that the latter requires the `dbus` useflag). Your ~/.xinitrc would then look like:

   ~/.xinitrc - with consolekit and dbus support

exec ck-launch-session dbus-launch --sh-syntax --exit-with-session qtile

And run xinit to launch qtile. You can also configure a display manager instead, but this is not covered in this document.

Getting Started

   Tip

As far as possible, when a default behavior is explained, a link to the related configuration snippet is given so that you can get more information and tweak it as you want.

When Qtile is run and no valid configuration file is found, it fallsback to the default configuration. So, the first time you run qtile, you should be welcomed with a black background and a bottom bar. On the left of this bottom bar, stands the list of your workspaces represented by the characters 'a', 's', 'd', 'f', 'u', 'i', 'o', 'p'. On the right of the bottom bar, you should see "default config" followed by the date and time.

You can press Mod4 + r to open a prompt box, then type a program name to launch it. You can also run xterm with the shortcut Mod4 + Return. To close a window, press Mod4 + w.

Workspaces are highlighted in white font when windows are opened in them (against gray font when it contains no window). The current workspace is surrounded with a blue border, if you have multiple screens, workspaces currently displayed in other screens are surrounded with a gray border. You can go to a given workspace pressing Mod4 + <workspace ID> (a, s, d, f, u, i, o or p by default). If you go to a workspace that is already displayed in another screen, workspaces will be swapped. You can move the current window to a given workspace pressing Mod4 + Shift + <workspace ID>.

Configuration

Qtile looks in the following places for a configuration file, in order: book.com/

1. The location specified by the -f argument.
2. $XDG_CONFIG_HOME/qtile/config.py
3. ~/.config/qtile/config.py

   Tip

At anytime, you can fire Mod4 + Ctrl + r to restart qtile with your new configuration. You should also `tail -f ~/.qtile.log` to checkout errors and warnings while editing your Qtile configuration.

In order to configure your Qtile environnement, I would suggest you to start with the default config base and tweak it bit by bit:

user $ mkdir -p ~/.config/qtile
user $ wget -O ~/.config/qtile/config.py https://raw.githubusercontent.com/qtile/qtile/v0.9.1/libqtile/resources/default_config.py
user $ vim ~/.config/qtile/config.py

   Warning

Don't forget to replace "v0.9.1" with the version you installed or it may not work.

Customize bars

The first thing you might want to customize is the bottom bar on the first screen. Here is the default code:

   ~/.config/qtile/config.py (python source code)

screens = [
    Screen(
        bottom=bar.Bar(
            [
                widget.GroupBox(),
                widget.Prompt(),
                widget.WindowName(),
                widget.TextBox("default config", name="default"),
                widget.Systray(),
                widget.Clock(format='%Y-%m-%d %a %I:%M %p'),
            ],
            30,
        ),
    ),
]

If you want this bar to be on top, replace bottom=bar.Bar( by top=bar.Bar(. Of course, you can have a bar on top and on bottom. Just specify both top and bottom as Screen keyword arguments. You can also place bars on the left or on the right, using Screen's left and right keyword arguments.

The first argument of bar.Bar() is a list of widgets (we'll talk about it later). The second argument is the thickness of the bar in pixels.

If you have multiple screens and want bars on both screens, you must de define multiple Screen instances.

Example

   ~/.config/qtile/config.py (python source code)

screens = [
    Screen(
        bottom=bar.Bar(
            [
                widget.GroupBox(),
                widget.Prompt(),
                widget.WindowName(),
                widget.TextBox("I am a 30px height bottom bar", name="default"),
                widget.Systray(),
                widget.Clock(format='%Y-%m-%d %a %I:%M %p'),
            ],
            30,
        ),
    ),
    Screen(
        top=bar.Bar(
            [
                widget.WindowName(),
                widget.TextBox("I am a 24px height top bar", name="default"),
            ],
            24,
        ),
        right=bar.Bar(
            [
                widget.TextBox("I am a 50px width right bar", name="default"),
                widget.Systray(),
            ],
            50,
        ),
    ),
]

Customize workspaces

By default workspaces are labelled 'a', 's', 'd', 'f', 'u', 'i', 'o', 'p' and can be accessed via Mod4 + a, Mod4 + s, ...

   ~/.config/qtile/config.py (python source code)

groups = [Group(i) for i in "asdfuiop"]

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))
    )

You can name your workspaces as you want, changing the string "asdfuiop". As far as I am concerned, I rather like having keys such as F1, F2, F3, ... mapped for my workspaces. Thus I think numbered workspaces are better:

   ~/.config/qtile/config.py (python source code)

groups = [Group(i) for i in "12345"]

for i in groups:
    grp = group[i].name
    key = 'F%d' % (i+1)
    keys.append(Key([mod], key,
                    lazy.group[grp].toscreen()))
    keys.append(Key([mod, "shift"], key,
                    lazy.window.togroup(grp)))

Startup applications

The Group object accepts a spawn argument that is the name of an application to launch on this group when qtile starts up. Unfortunately, you can currently autostart only one application per group.

For instance, if you want to run urxvt and on the group "a" and firefox on the group "s", you could right something like this.

   ~/.config/qtile/config.py (python source code)

startapps = {'a': 'urxvt', 's': 'firefox'}
groups = [Group(i, spawn=startapps.get(i)) for i in "asdfuiop"]

Use widgets

Coming soon

Configuration examples

pytony's configuration
https://github.com/apinsard/mycfg-qtile/blob/master/config.py