If you look at the current package list:

• x264
• ffmpeg
• mplayer
• ffmpeg-mt
• mplayer-mt
• mpd
• netembryo
• rxvt-unicode

you might be wondering why I provide these packages. All but three can be found in the official repositories after all. In short: I either upgrade them much more frequently, they differ much from the official packages, they are not available in the official repsitories or all of the above. Now I will go more in depth for each package.

x264, ffmpeg and mplayer

These 3 packages are being actively developed. Many new changes are made even in the scope of just a week. Understandably, the arch packagers can’t rebuild these packages whenever changes are made. I repackage them on a monthly base which makes my packages usually a lot more up to date than the official ones.

This, however, is not the main reason I make these 3 packages available. The official arch mplayer build incorporates its own internal static version of ffmpeg (as recommended by the mplayer devs), ignoring the already available ffmpeg on most systems. This approach results in duplication of code and bigger packages. In the programming community, duplication of code is something that one tries to avoid at all cost, as this usually implies a bad design. I apply the same principle to my packages: compile once and use them everyone else.

Some less commonly used options in mplayer and ffmpeg are also disabled:

• No image support in mplayer.
• Many exotic audio/video ouputs and audio/video codecs are disabled.
• No tv or radio support
• …

I also include features not available in the official mplayer package such as pulseaudio support. I’m a huge fan of pulseaudio and support it in all the packages that can handle it.

ffmpeg-mt and mplayer-mt

ffmpeg-mt and mplayer-mt are the multithreaded versions of ffmpeg and mplayer respectively. They have the same feature set as mentioned in the topic on their single threaded versions. If you have no graphics card that supports hardware accelerated video playback, then this is what you want to playback high definition movies.

mpd

In this package, I mainly strip away less commonly used options and only add 1 new feature:

• no http output
• no last.fm support
• no oss output
• no ipv6
• pulseaudio support

netembryo and libnemesi

I maintain both netembryo and libnemesi in AUR and might as well just make a binary version available as well.

rxvt-unicode

This build contains a particular patch that fixes the resizing of this terminal in tiling window managers. Otherwise there always black borders surrounding each terminal window which is just plain annoying

mplayer -lavdopts threads=n moviefile

Instead of constantly typing that command, you can also add it to the invaluable mplayer config file located at ~/.mplayer/config:

[default]
lavdopts=threads=2

Obviously I’m not one of the happy few that have a graphics card with support for hardware accelerated video playback (vdpau for nvidia). When playing a 1080p high definition movie without vdpau and with the singlethreaded mplayer, the movie becomes pretty much unwatcheable: video stuttering, audio running behind on video or vica versa, fastforwarding crashes mplayer, … It’s odd that in a world full of multicore processors, a multithreaded video player isn’t a commodity and probably never will be. Nonetheless I believe there is actually a market for this. After all, not everyone has a fairly recent graphics card (less than 3 yeard old).

With the multithreaded mplayer all of that changes. I am in the possession of an AMD Athlon64 X2 3800+, the first dual core cpu series of AMD, and playback of a 1080p movie with a video bitrate of 15.5Mbps is smooth. It doesn’t even use the 2 cores to their full potential. It appears I only needed a little more but o so necessary cpu power to play it. Until I buy a recent graphics card, hopefully in the very near future, this will certainly do the trick.

These csrf attacks are very problematic because it is difficult for a user to protect himself from it without completely degrading the web experience, such as disabling javascript (which is not necessarily a sufficient counter measure). It is mainly up to the developer of a site or web application to prevent these attacks by making sure it is impossible to store code on their site that launches such attacks and by making sure their site is not vurnerable to such attacks. But truth is that most developers are just clueless.

However, distrinet, a reseach group of the University of Leuven, has published a firefox addon called csfire that attempts to mitigate csrf attacks. You can find the paper on csfire here.

You’ll need 3 things:

• xmonad
• dzen2 >= rev. 267
• xdotool

Here are the things you’ll need to put in your xmonad.hs config:

import Data.List
 
-- Define amount and names of clickable workspaces.
myWorkspaces    = clickable . (map dzenEscape) $ nWorkspaces 0 ["main","web","chat","media","graph","browse","dev","mail"]
    where nWorkspaces n [] = map show [1 .. n]
          nWorkspaces n l  = init l ++ map show [length l .. n] ++ [last l]
          clickable l      = [ "^ca(1,xdotool key ctrl+F" ++ show (n) ++ ")" ++ ws ++ "^ca()" | (i,ws) <- zip [1..] l, let n = i ]

These lines will wrap every workspace name with ^ca, a click action available in dzen2 >= rev. 267. Xdotool is a small application that simulates pressed keys. You can alter the names of the workspaces to your likings. You do, however, have to change the key in the xdotool command to the key you use in XMonad to switch to a specific workspace. In my case, keys <ctrl>+F1 to <ctrl>+F8 are used to switch to workspaces 1 to 8.

Throughout your xmonad.hs you will need to replace all direct references to workspace names because now your first workspace for example, is named ^ca(1,xdotool key ctrl+F1)main^ca(). One way to do this is to use the following references instead:

-- Workspace variables
mainWs      = (myWorkspaces !! 0)
webWs       = (myWorkspaces !! 1)
chatWs      = (myWorkspaces !! 2)
mediaWs     = (myWorkspaces !! 3)
graphWs     = (myWorkspaces !! 4)
browseWs    = (myWorkspaces !! 5)
devWs       = (myWorkspaces !! 6)
mailWs      = (myWorkspaces !! 7)

Remember to use a dzen2 panel, as this click action is a dzen2 specific thing. Also don’t forget that if you have an urgent hook in your dzen2 pretty printer, you’ll have to rewrap the workspace with ^ca. You can find my entire confg file here

But there’s this one minor annoyance I always encounter while using vimperator: vimperator always focusses on the first input text box it comes across on a web site. Some people may like this behavior but I certainly don’t. I have google’s search engine set as my home page and the search box always steals the focus. Usually I just want to fire a vimporator command to navigate to another site and entering insert mode because of this focus stealing certainly hinders me. Now I have finally narrowed it down to the setting that controls this behavior: focuscontent. Expanding ~/.vimperatorrc with

set focuscontent

disables input text box focussing. It certainly is a huge improvement. Yet another annoyance solved. Hop to the next one.

I’ve considered a few alternatives. KDM is of course out of the question. It doesn’t even come close to being lightweight and I’d rather use Windows than pull in any kind of KDE dependency. Viable alternatives are among others SLIM, Qingy and simply using startx to fire up XMonad. I’ve tryed out SLIM briefly in the past but wanted something even more simple and from what I’ve read, SLIM is not begin further developed. Startx is of course as easy as it can possibly get but is in itself featureless and only works well for a single user/session.

In the end I went with CDM, the Console Display Manager, developed by Ghost1227, a fellow Arch Linux user. It is a minimimalistic, full featured, dialog-based login manager written in pure bash. It supports multiple users/sessions and can start virtually any window manager or desktop environment. I am impressed that it can fire up multiple X sessions of the same user on different ttys.

One step closer to a GNOMEless system.

Since my last XMonad desktop, I’ve changed my wallpaper to something brighter to lighten things up (I usually don’t like dark colors or wallpapers) and adapted the text colors to match with everything else:

System Info:

• Operating System: Arch Linux
• Window Manager: XMonad
• GTK: Customized Ubuntu Human (not visible)
• Icons: Human Icon Set (not visible)
• Wallpaper: Napke
• Various: mpd & ncmpcpp, dzen2, conky, emesene, vim, urxvt

If there is anything else you would like to know, feel free to ask.

Hower, AUR has its limitations. For one, its sole function is to host pkgbuilds. So when you want to install something from AUR, you still have to go through the compile & build process. Depending on the software, this can be very cumbersome and time consuming. Instead you more likely want to install a package that has already been build, much like the regular Arch Linux repositories such as [core], [extra] and [community]. This is where the Unofficial User Repositories come in play. A user can easily set up its own repository with the repo-add script that comes with the package manager pacman. Generally, the user still needs to be very cautious with installing unofficial packages because of the potential dangers it may pose such as malicious software. It is recommended to verify the source of these packages or inspect the packages before installing.

Personally, there a few programs I frequently update myself, i.e. more frequently than then the official repositories, because of new functionality or bug fixes. Therefore I decided to share my efforts and make them available in my own unnoficial user repository. The repository can be accessed at http://www.nepherte.be/repo. To use my repository, add the following lines in /etc/pacman.conf:

[nepherte]
Server = http://www.nepherte.be/repo

The packages are for 64bit systems only as I don’t have a 32bit version of Arch installed. All packages are built in a clean chroot environment to avoid library linking problems. If you are interested in the pkgbuilds, you can find them  on my svn repo. To access my svn repo, you will have to authenticate yourself with username guest and password guest.

The packages I currently maintain are:

• x264
• ffmpeg
• mplayer
• netembryo

The first three are rebuilt on a monthly base at the very least and whenever there is audio involved, pulseaudio is supported. More packages will be added in the future.

I was surprised to see there was no fitting packaged mercury compiler available in any of the Arch Linux repositories. Arch has many compilers available but apparantly not the mercury compiler. I admit that mercury is perhaps not the most popular language, considering it is a) declarative and b) not backed by a major company like Microsoft, but I was suprised nonetheless. It may be worth mentioning that compiling mercury takes a little while (depending on your computer a few hours) so make sure you have the time if you’re building it.

CSRFTester is a whole different application. It is used for testing Cross Site Request Forgeries in web applications. It sits in between your browser and the internet and logs your http requests. Based on those logs, it can generate sample code to exploit possible csrf vurnerabilities. As the name suggests, it’s just for testing purposes and logging. Don’t expect any out of the box exploits.

You can access the svn repository by browsing to https://svn.ulyssis.org/repos/nepherte/pkgbuilds. You will have to authorize yourself with the credentials: user “guest” and password “guest”.

You can of course do a plain chechout. Simply run the following command in a console:

svn checkout https://svn.ulyssis.org/repos/nepherte/pkgbuilds pkgbuilds --username "guest" --password "guest"

It’s the first time I’ve actually moved an active, online site to another host and the whole process was surprisingly easy. It doesn’t take a computer science engineer to do it, though that is exactly what I am studying. I hope visitors didn’t encounter any problems and I don’t think they did. I will soon make a couple svn subrepositories available with some of my work.

Let’s start with the things that didn’t change. Yes, I still use Arch Linux and it’s rock solid as ever. I said I would definetely switch from Gnome to XMonad but I reconsidered. Now I’m using both, depending on the specific task I have in mind. In my experience there simply is no perfect window manager/desktop environment. With Gnome I’m trying to accomplish a complete desktop setup, an environment a regular user could expect. With XMonad I’m trying to realize a lightweight, command-line centric desktop. And no, it’s not for showing off. It leads to funny situations however, having a desktop nobody can use except you.

In my quest for a lightweight XMonad desktop, I went ahead and built a hal-less system. Something that is bound to happen as X Server 1.8 will be without it anyways. This caused a chain of application rebuilds that seemingly relied on hal. I’m not fully updated on the matter and  it  makes me unqualified to make any bold statement but it makes me wonder as to why they all use hal when they can use udev instead. The again, extracting hal from the system doesn’t really improve anything, performance wise that is. It merely removes a layer of abstraction.  It’s more a purist kind of thing.

The best memory usage improvement came from uzbl, a browser that tries to adhere to the unix philosofy:

“Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface”.

I’m happy to see uzbl uses webkit instead of gecko, whether it is from a development point of view or simply for performance improvements I do not care. It also shows that Firefox uses an insane amount of memory, far beyond what should be necessary to view a plain website.

On a whole different subject, the last weekend of November I accompanied 3 friends on a trip to visit another friend in Barcelona. It was good seeing him again and we had a great time together even though he had an exam that very next monday. I guess studying medicine in a foreign language isn’t that hard after all :) We stayed in a not too bad and cheap hostel near the Ramblas, unfortunately some English football hooligans seemed to think alike and resided there as well. I’ll close this topic with a “cullinary tip”: try a tripple whopper. Or if you want to freak out the burger king personel, order  four of them at the same time.

Now let’s get back to the things that really kept me from posting on my site: university assignments. Among other things I had to write a paper on process scheduling in the linux kernel,version 2.6.9. It didn’t come as a surprise the code itself was not documented at all (usually considered bad practice), even the commonly used  “what lunatic came up with this shit”, Torvalds fucked this up” or “2,191 lines of complete and utter shit coming up” were nowhere to be found in sched.c and sched.h, the two files that take care of the scheduling. The assigment itself pretty much came down to reading up about scheduling and rephrasing what was already written on the subject, with a few personal opinions here and there.

To close with, I’m sorry to say that things aren’t really looking good for my posting frequency in the next 2 months. Tomorrow I’ll have to study non-stop for the upcoming exams in January. I also wanted to thank all of you readers for still following this blog. Apparantly I still do have readers after 2 months of no posts.

The first problem is related to GDM and is not that much of a problem but rather a matter of getting used to it. The GNOME login screen has had a major overhaul compared to 2.20, the version I previously had installed. It now blends in  more with the user’s desktop and includes a panel with  session, keyboard and language settings. GDM also doesn’t include a graphical configuration tool. No problem there, I’m “Mister Console” anyways.

The second problem is a little more inconvenient and related to GDM as well. GDM uses its own configuration for the keyboard layout and ignores the hal keyboard layout settings. It always default to the usa keyboard layout. Once you’ve selected your user, it will remember what layout you may have chosen from the gnome panel widget but in the mean while it will stick to the usa layout in the previous user selection prompt. Luckily there’s a patch available. A bug report can be found here and a patch here.

The third problem can be found in gnome-keyring. When logging out of GNOME, there is a 10 to 15 seconds delay before it finally takes effect. This problem was fixed in gnome-keyring 2.28.1.

But enough with the problems. What is new in GNOME 2.28? Most of the changes are made behind the scene. Many efforts were made to remove deprecated libraries from GNOME 2.28. For instance, there is no program anymore that depends on esound,  libgnomevfs, libgnomeprint, or libgnomeprintui. Further efforts were made to remove depenency of libglade, libbonoboui, libgnome and many more. The most visible changes are annotion support for evince, improved bluetooth integration and extra features in Cheese. Webkit has also finally made it in Epiphany after many false announcements since GNOME 2.24. All in all, it’s another fine version of GNOME

While many tiling window managers come with a rather simple configuration file, Haskell, a λ-calculus based functional programming language, lifts up XMonad up to one of the most extendible and finest window manager around. And therein lies “the problem”. Haskell is not what you would call a programming language used by regular folks (if regular folks actually know a programming language) nor does its syntax resemble to Java or C.

This guide will lead you step by step through the process of configuring XMonad. I will take my own config file as example. A lot of this can also be found scattered over the xmonad homepage. I’v taken the liberty to bundle all the information.

Table of Contents

• 1. The working directory
• 2. The basic configuration
• 3. The default terminal
• 4. Workspaces
• 5. Attaching applications to workspaces
• 6. Floating windows
• 7. Tiling layouts
• 8. Key combinations
• 9. A status bar

The working directory

The main working directory, where the configuration is done, where logs are stored and where the compiled binary is placed, is located at /home/<username>/.xmonad. The 2 most important files for this guide are xmonad.hs and xmonad.error. Configuration is done in the first one and errors are spit out in the last one. So if there is problem with compiling the config file, look at xmonad.error first. All the code snippets I’ll be posting have to be put in xmonad.hs. Mind you, I will only mention the code related to the section it is under. You should be capable of putting it all together or simply use my entire config file.

The basic configuration

A working configuration could be as easy as

-- Import statements
import XMonad
 
-- Run XMonad
main = do
	xmonad $ defaultConfig

It basically runs xmonad with the default configuration file (defaultConfig), found here. Note that you don’t have to actually download the template config file I linked to. Everything is already included in the XMonad installation. However, you can use the file as your xmonad.hs and you’ll end up with the same result.

Xmonad provides a few basic Desktop Environment (DE) integration configurations you could use: Gnome (gnomeConfig), KDE (kdeConfig) and XFCE (xfceConfig). Each DE config file will gracefully handle the panels inherent to the DE, shortcut keys, etc. In short you’ll be running your DE as always but the window manager is replaced with XMonad. Since I favor Gnome, we’ll use this instead of the default config. Note that you are not required to use a DE at all, even if you are using a DE specific config.

-- Import statements
import XMonad
import XMonad.Config.Gnome
 
-- Run XMonad
main = do
	xmonad $ gnomeConfig

From now on, we will override and extend the gnome configuration step by step until we have the setup we want.

The default terminal

You’ll probably use the terminal a lot so it is always nice to use the terminal program you prefer. In this example, I use gnome-terminal with a customized profile for XMonad.

-- Import statements
import XMonad
import XMonad.Config.Gnome
 
-- Define terminal
myTerminal = "gnome-terminal --window-with-profile=XMonad"
 
-- Run XMonad
main = do
	xmonad $ gnomeConfig {
	  terminal  = myTerminal
	}

You can consider the variable terminal as a sort of setting/property which we now have overrided with myTerminal. Feel free to replace myTerminal with the one you prefer.

Workspaces

Just as is the case with a desktop environment, XMonad can make use of workspaces and I encourage you to use them extensively. This is how you define workspaces:

-- Import statements
import XMonad
import XMonad.Config.Gnome
 
-- Define amount and names of workspaces
myWorkspaces = ["1:main","2:web","3:chat","4:media","5:graph","6:browse","7:dev","8:mail"]
 
-- Run XMonad
main = do
	xmonad $ gnomeConfig {
	  workspaces  = myWorkspaces
	}

Attaching applications to workspaces

Workspaces are a great way to separate types of programs from one another. As the names of my workspaces suggest, I prefer for example that development, web and multimedia applications don’t get mixed up with eachother. As opposed to a regular floating window manager, you don’t have to put the applications on the workspaces yourself. You can tell xmonad to do it for you instead. Here’s an example for 2 workspaces:

-- Import statements
import XMonad
import XMonad.Config.Gnome
import qualified XMonad.StackSet as W
 
-- Define amount and names of workspaces
myWorkspaces = ["1:main","2:web","3:chat","4:media","5:graph","6:browse","7:dev","8:mail"]
 
-- Define the workspace an application has to go to
myManageHook = composeAll . concat $
            [ -- The applications that go to web
              [ className =? b --> doF (W.shift "2:web") | b < - myClassWebShifts]
              -- The applications that go to chat
            , [ className =? c --> doF (W.shift "3:chat") | c < - myClassChatShifts]
            ]
		where
	          myClassWebShifts    = ["Firefox", "Filezilla"]
		  myClassChatShifts   = ["emesene", "Xchat"]
 
-- Run XMonad
main = do
	xmonad $ gnomeConfig {
	    workspaces  = myWorkspaces
	  , manageHook  = myManageHook
	}

This will place firefox and filezilla on the “2:web” workspace while emesene and xchat are put on the “3:chat” workspace. There are a few ways you can catch an application: class names (className) and title names (title). To figure out what the application’s class or title name is, you can run xprop in a console and click on the app you want to grab the info from.

Due to some encoding issue <- is displayed as < – near the variables b and c. Make sure to remove the space between them.

Floating windows

By default, XMonad will tile all windows. Occasionally you don’t want to tile a certain application because it just gets too messy. The classic examples are MPlayer and GIMP. If you let xmonad tile mplayer, the aspect ratio’s of your movies are ruined and GIMP just has too many tool aid boxes which would normally get tiled just like all other windows. You will need to add them to myManageHook:

-- Import statements
import XMonad
import XMonad.Config.Gnome
 
-- Define the workspace an application has to go to
myManageHook = composeAll . concat $
            [  -- The applications that float
              [ className =? i --> doFloat | i < - myClassFloats]
            ]
		where
		  myClassFloats	      = ["Gnome-mplayer","MPlayer"]
 
-- Run XMonad
main = do
	xmonad $ gnomeConfig {
	    manageHook  = myManageHook
	}

In this example, mplayer and gnome-mplayer will not be tiled but floated instead.

Tiling layouts

There are multiple tiling layouts available, or more specifically, the way your windows will be arranged. The 4 most commonly used layouts are Tall, Full, SimpleFloat and Mirror Tall. But first some further explanation about tiling layouts.

Most layouts have a master pane and one or more slave panes. When you start your first application window, it will open up fully maximized. When opening other application windows, the latest launched application will be placed in the master pane. Every other window will be reorganized, resized and placed in the slave pane(s) according to the used tiling algorithm. That’s the principle of tiling. Now, you can surely think of a few ways how these master and slave panes can be organized and that’s where the layouts kick in. A possible organization of these panes is called a layout.

• Tall is a layout with 2 columns of which the size ratio can be defined by the user. You can set the maximum number of windows in the master pane, which occupies the left part of the screen. In each pane, the windows are organized vertically.
• Full is the layout where each application window will occupy the whole screen. The most current one will be shown, all the others will be hidden behind the current one.
• SimpleFloat is a layout where all windows are put in float mode. Each window also gets a small title bar.
• Mirror Tall is similar to Tall but it uses rows instead of columns and windows are organized horizontally in each pane.

This is how you set the 4 layouts I’ve mentioned:

--import statements
import XMonad
import XMonad.Config.Gnome
import XMonad.Layout.SimpleFloat
 
-- Define default layouts used on most workspaces
defaultLayouts = tiled ||| Mirror tiled ||| simpleFloat ||| Full
  where
       -- default tiling algorithm partitions the screen into two panes
          tiled   = Tall nmaster delta ratio
 
       -- The default number of windows in the master pane
          nmaster = 1
 
       -- Default proportion of screen occupied by master pane
          ratio   = 1/2
 
       -- Percent of screen to increment by when resizing panes
          delta   = 3/100
 
main = do
	xmonad $ gnomeConfig {
		layoutHook  = defaultLayouts
	}

These layouts apply to all your workspaces. You could also set one or more layouts for one specific workspace with onWorkspace. The next example will only set the Full layout for the “4:media” workspace. With the noBorders option, we remove the borders around a window (the ones you get when a window is active).

--import statements
import XMonad
import XMonad.Config.Gnome
import XMonad.Layout.SimpleFloat
import XMonad.Layout.NoBorders (noBorders)
import XMonad.Layout.PerWorkspace (onWorkspace)
 
-- Define default layouts used on most workspaces
defaultLayouts = tiled ||| Mirror tiled ||| simpleFloat ||| Full
  where
       -- default tiling algorithm partitions the screen into two panes
          tiled   = Tall nmaster delta ratio
 
       -- The default number of windows in the master pane
          nmaster = 1
 
       -- Default proportion of screen occupied by master pane
          ratio   = 1/2
 
       -- Percent of screen to increment by when resizing panes
          delta   = 3/100
 
-- Define layout for specific workspaces
mediaLayout = noBorders $ Full
 
-- Put all layouts together
myLayouts = onWorkspace "media" mediaLayout $ defaultLayouts
 
main = do
	xmonad $ gnomeConfig {
		layoutHook  = myLayouts
	}

Key combinations

XMonad can be controlled by the keyboard without the use of a mouse whatsoever. Not only is it very useful to know the most important key combinations in XMonad, but it is also a good idea to create new key combinations to facilitate your work in XMonad.That way you don’t have to open up a terminal every time you want to do something.

In XMonad you can add new key combinations, redefine and remove existing ones. Let us first define the new keys we want to add. The format in which you define new keys is

((key_modifier, key), action)

If you don’t want to use a key modifier you can use 0. If you want a combination of key modifiers, you can combine them with .|. You can find an exhaustive list of keys here. If you are unshure about the value of a key, you can use the xev command that prints all the information of a pressed key in the terminal. Prefix that value witk xK_ or simply use the key code, which can be useful for multimedia keys such as play/volume up & down/mute/media player/…

-- Import statements
import XMonad.Util.Run
import XMonad.Actions.CycleWS
 
-- Define keys to add
keysToAdd x     = [ -- Gnome run dialog
                       ((modMask x, xK_F2), spawn "/home/bart/.run/run.py --interface=full")
                    -- Gnome close window
                    ,  ((modMask x, xK_F4), kill)
                    -- Shift to previous workspace
                    ,  (((modMask x .|. controlMask), xK_Left), prevWS)
                    -- Shift to next workspace
                    ,  (((modMask x .|. controlMask), xK_Right), nextWS)
                    -- Shift window to previous workspace
                    ,  (((modMask x .|. shiftMask), xK_Left), shiftToPrev)
                    -- Shift window to next workspace
                    ,  (((modMask x .|. shiftMask), xK_Right), shiftToNext)
                    -- Mute volume
                    ,  ((0,0x1008ff12), spawn "amixer -Dpulse set Master toggle")
                    -- Launch mpd
                    , ((0,0x1008ff32), spawn "mpd")
                  ]

Next you need to define the keys you want to remove. You only have to specify the key combination and not the action it performs. An example

keysToRemove x  = [ -- Old run dialog binding
                       (modMask x , xK_p)
                    -- Old close window binding
                    ,  (modMask x, xK_c)
                    -- Unused gmrun binding
                    ,  (modMask x .|. shiftMask, xK_p)
                    -- Unused gnome session logout dialog
                    ,  (modMask x .|. shiftMask, xK_q)
                  ]

Last thing remaining is putting it all together.

-- Import statements
import XMonad
import XMonad.Config.Gnome
import qualified Data.Map as M
 
-- Merge keys to add and existing keys
newKeys x       = M.union (keys gnomeConfig x) (M.fromList (keysToAdd x))
 
-- Delete the keys to remove from existing keys
myKeys x        = foldr M.delete (newKeys x) (keysToRemove x)
 
main = do
	xmonad $ gnomeConfig {
		keys = myKeys
	}

Status bar

A status bar always comes in handy: to know what workspace you are on, in what workspace there are still windows, to display conky stats, time & date, the current song you are listening too, … XMonad nicely integrates with xmobar and dzen2. In this tutorial, I’ll be using 2 dzen2 status bars. Make sure you have dzen2 and conky installed. First we specify the commands that launches the dzen2 status bars.

myStatusBar = "dzen2 -x '0' -y '0' -h '24' -w '960' -ta 'l' -fg '#FFFFFF' -bg '#000000' -fn '-*-bitstream vera sans-medium-r-normal-*-11-*-*-*-*-*-*-*'"
conkyStatsBar = "conky -c .conkyrc_console | dzen2 -x '960' -y '0' -h '24' -w '890' -ta 'l' -fg '#3EB5FF' -bg '#000000' -fn '-*-bitstream vera sans-medium-r-normal-*-11-*-*-*-*-*-*-*'"

You can adapt the commands to suit your needs. Set the horizontal, vertical positions and alignment of the bars with the -x, -y, -ta switches. Use the -c switch in conky to specify the conky file to run. For more information see the dzen2 manual pages.

Now you can format the status bars with the dynamicLogHook XMonad library.

import XMonad
import XMonad.Hooks.DynamicLog
import System.IO
 
myLogHook :: Handle -> X ()
myLogHook h = dynamicLogWithPP $ defaultPP
    {
        ppCurrent           =   dzenColor "#3EB5FF" "black" . pad
      , ppVisible           =   dzenColor "white" "black" . pad
      , ppHidden            =   dzenColor "white" "black" . pad
      , ppHiddenNoWindows   =   dzenColor "#444444" "black" . pad
      , ppUrgent            =   dzenColor "red" "black" . pad
      , ppWsSep             =   " "
      , ppSep               =   "  |  "
      , ppTitle             =   (" " ++) . dzenColor "white" "black" . dzenEscape
      , ppOutput            =   hPutStrLn h
    }

In a last step, you launch each dzen2 instance

import XMonad.Hooks.UrgencyHook
import XMonad.Hooks.FadeInactive
import XMonad.Util.Run
import XMonad.Config.Gnome
 
main = do
    workspaceBar < - spawnPipe myStatusBar
    conkyStats <- spawnPipe conkyStatsBar
    xmonad $ withUrgencyHook NoUrgencyHook {
        logHook             = myLogHook workspaceBar >> fadeInactiveLogHook 0xdddddddd
}

Due to some encoding issue, again there is a space between <- near workspaceBar which shouldn’t be there. The tiling algorithm however will overlap these status bars so you will have to tell XMonad not to do so.

import XMonad.Hooks.ManageDocks
 
main = do
    xmonad {
      manageHook          = manageDocks < +> myManageHook
}

Recall that we have specified myManageHook earlier in this tutorial.

Here’s the output of my Nvidia Geforce 8400M GS:

display: :0.0   screen: 0
API version: 0
Information string: NVIDIA VDPAU Driver Shared Library  190.36  Wed Sep 23 06:55:52 PDT 2009
 
Video surface:
 
name   width height types
-------------------------------------------
420     4096  4096  NV12 YV12
422     4096  4096  UYVY YUYV 
 
Decoder capabilities:
 
name               level macbs width height
-------------------------------------------
MPEG1                 0  8192  2048  2048
MPEG2_SIMPLE          3  8192  2048  2048
MPEG2_MAIN            3  8192  2048  2048
H264_MAIN            41  8192  2048  2048
H264_HIGH            41  8192  2048  2048
VC1_SIMPLE            1  8190  2048  2048
VC1_MAIN              2  8190  2048  2048
VC1_ADVANCED          4  8190  2048  2048
 
Output surface:
 
name              width height nat types
----------------------------------------------------
B8G8R8A8          8192  8192    y  Y8U8V8A8 V8U8Y8A8
R10G10B10A2       8192  8192    y  Y8U8V8A8 V8U8Y8A8 
 
Bitmap surface:
 
name              width height
------------------------------
B8G8R8A8          8192  8192
R8G8B8A8          8192  8192
R10G10B10A2       8192  8192
B10G10R10A2       8192  8192
A8                8192  8192
 
Video mixer:
 
feature name                    sup
------------------------------------
DEINTERLACE_TEMPORAL             y
DEINTERLACE_TEMPORAL_SPATIAL     y
INVERSE_TELECINE                 y
NOISE_REDUCTION                  y
SHARPNESS                        y
LUMA_KEY                         y
HIGH QUALITY SCALING - L1        -
HIGH QUALITY SCALING - L2        -
HIGH QUALITY SCALING - L3        -
HIGH QUALITY SCALING - L4        -
HIGH QUALITY SCALING - L5        -
HIGH QUALITY SCALING - L6        -
HIGH QUALITY SCALING - L7        -
HIGH QUALITY SCALING - L8        -
HIGH QUALITY SCALING - L9        -
 
parameter name                  sup      min      max
-----------------------------------------------------
VIDEO_SURFACE_WIDTH              y         1     4096
VIDEO_SURFACE_HEIGHT             y         1     4096
CHROMA_TYPE                      y
LAYERS                           y         0        4
 
attribute name                  sup      min      max
-----------------------------------------------------
BACKGROUND_COLOR                 y
CSC_MATRIX                       y
NOISE_REDUCTION_LEVEL            y      0.00     1.00
SHARPNESS_LEVEL                  y     -1.00     1.00
LUMA_KEY_MIN_LUMA                y
LUMA_KEY_MAX_LUMA                y

In case you’re wondering, vdpau is an api that allows video programs to offload portions of the video decoding process and video post-processing to the GPU video-hardware, resulting in less cpu load.