– Mads

Configuration highlights:

• Viper
• Tabbar
• Org-mode

The files are available at my Github repo.

github.com/mntnoe/mntnoe-dotfiles

]]> http://mntnoe.com/2011/08/configuration-files-now-on-github/feed/ 0 http://mntnoe.com/2010/05/xmonad-config-may-2010/ http://mntnoe.com/2010/05/xmonad-config-may-2010/#comments Sun, 16 May 2010 16:30:59 +0000 Mads Navntoft Noe http://www.mntnoe.com/?p=150 I think it’s about time I post my updated XMonad configuration. This version does not require any patches, at XMonad 0.9 supports modular configurations natively.

New highlights:

• The application pager now uses icons
• Per application configuration.
• Minimize windows by using special workspaces

Note that I have converted my Colemak key bindings to Qwerty to give an idea of the placement I use. Also note that this work is not finished. There are still lot of things I want to behave differently, and I need to do some cleanup here and there.

Still, I hope you can get inspired by some of my ideas. Enjoy

• Whole config (incl. icons)

• xmonad.hs (html)
• App.hs (html)
• BorderColors.hs (html)
• Commands.hs (html)
• Config.hs (html)
• DMenu.hs (html)
• IM.hs
• Layout.hs (html)
• MyApps.hs (html)
• Pager.hs (html)
• Panel.hs (html)
• Utils.hs (html)
• Workspace.hs (html)

If you use many web applications like GMail and Remember the Milk, you may want to get access to them using a single key binding. In Firefox you can use the following snippet together with the Keyconfig extension to

• cycle between all tabs matching the regular expression re
• if no tab matches, open a new tab showing url

function openOrCycle(url, re) {
    var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
        .getService(Components.interfaces.nsIWindowMediator);
    var browserEnumerator = wm.getEnumerator("navigator:browser");

    // Check each browser instance for our URL
    var found = false;
    while (!found && browserEnumerator.hasMoreElements()) {
        var browserWin = browserEnumerator.getNext();
        var tabbrowser = browserWin.gBrowser;

        // Check each tab of this browser instance
        var numTabs = tabbrowser.browsers.length;
        var currentIndex = tabbrowser.tabContainer.selectedIndex;
        var nextIndex = (currentIndex + 1) % numTabs;
        for (var index = nextIndex;
             index != currentIndex;
             index = (index + 1) % numTabs) {
            var currentBrowser = tabbrowser.getBrowserAtIndex(index);
            if (re.test(currentBrowser.currentURI.spec)) {

                // The URL is already opened. Select this tab.
                tabbrowser.selectedTab = tabbrowser
                    .tabContainer
                    .childNodes[index];

                // Focus *this* browser-window
                browserWin.focus();

                found = true;
                break;
            }
        }
    }

    if (!found &&
        re.test(tabbrowser
            .getBrowserAtIndex(currentIndex)
            .currentURI.spec)) {

        // The URL is already opened. Select this tab.
        tabbrowser.selectedTab = tabbrowser
            .tabContainer
            .childNodes[currentIndex];

        // Focus *this* browser-window
        browserWin.focus();
        found = true;
    }

    // Our URL isn't open. Open it now.
    if (!found) {
        var recentWindow = wm.getMostRecentWindow("navigator:browser");
        if (recentWindow) {
            // Use an existing browser window
            if (window._content.document.location.href == "about:blank") {
                window._content.document.location.href = url;
                window._content.focus();
            } else {
                recentWindow.delayedOpenTab(url, null, null, null, null);
            }
        }
        else {
            // No browser windows are open, so open a new one.
            window.open(url);
        }
    }
}

openOrCycle("https://mail.google.com/mail/#inbox",
            /https?://mail.google.com/);

The snippet is based on examples from MDC.

Using Xmonad and Prism

If you use Xmonad and want very fast access to tasks like sending a mail, checking your calendar or marking a todo-item as completed, you may consider using Prism. You can assign a key binding in Xmonad to bring focus to a given Prism window – check out the WindowGo and NamedScratchpad modules.

Unfortunately the only thing distinguishing Prism windows  is the window title, so we need to force the title to stay fixed using a Greasemonkey script. You will need Teramako’s Greasemonkey build for Prism to do this, and something like the following:

// ==UserScript==
// @name           title-gmail
// @namespace      mntnoe.com
// @include        *
// ==/UserScript==

document.title="Gmail";

Note that some web applications will update the title dynamically, so you may need to adjust your predicate to account for that. For instance, GMail will update the title to “Gmail – Inbox (3) – foo@gmail.com”, so our predicate will read

className =? "Prism" <&&> fmap ("Gmail" `isPrefixOf`) title

It is a hack, but it works quite well

My complete solution is based on NamedScratchpad and makes sure that only one Prism window is shown at a time, enabling you to switch fast between web applications. I will post it together with my current Xmonad setup when I get time.

Bug 327323 has a patch that uses gvfs to determine the mime type from the extension if Firefox cannot determine it itself. However, if you can’t wait for that fix to reach your distributions package repository, here is a patch for Firefox 3.5 that bypasses the security restriction for octet-streams and executables. Note that it won’t remember the application you specify to handle the file, but your can circumvent that by using the OpenDownload add-on, which uses your native mime system to look up the default application.

Edit: I found out that OpenDownload also alters the security restricted download dialog, so you can suffice to install OpenDownload if you want to avoid patching Firefox. You will only be able to open the file with your OS’ default handler, though.

You can make Vim automatically activate the mail file type plugin when edit a GMail message by adding the following to ~/.vimrc:

autocmd BufRead   mail.google.com.* setlocal ft=mail

Further customization go in ~/.vim/ftplugin/mail.vim:

setl textwidth=68
call IMAP("sig1","<++>Med venlig hilsen,nMads...","mail")
call IMAP("sig2","<++>Regards,nMads...","mail")

Wrapping your text makes your mail appear more readable and professional, as the line width does not depend on the width of the receivers window. Remember that GMail automatically wraps text at the 72th column, so be sure that textwidth is lesser than that if you set it. The IMAP lines uses imaps to provide an easy way to handle multiple signatures. The <++> thing indicates where to put the cursor; see the comments in imaps.vim for further info.

Likewise, you can set up Vim to use special syntax highlighting on wiki pages that are edited as plain text. This is great when working with for instance twiki pages on Trac.

By the way, see Vito Chin’s article about Keyboard Enabling Web Applications.

binding "gtk-binding-menu" {
    bind "j" { "move-current" (next) }
    bind "k" { "move-current" (prev) }
    bind "h" { "move-current" (parent) }
    bind "l" { "move-current" (child) }
}
class "GtkMenuShell" binding "gtk-binding-menu"

Keybindings for other GTK widgets can be defined in a similar way. What about moving focus between widgets in the direction they appear?

binding "gtk-binding-widget" {
    bind "j" { "move-focus" (up) }
    bind "k" { "move-focus" (down) }
    bind "h" { "move-focus" (left) }
    bind "l" { "move-focus" (right) }
    bind "m" { "popup-menu" () }
}
class "GtkWidget" binding "gtk-binding-widget"

The m binding lets you pop up the context menu in any widget that not steal the modifier-less keystrokes for text input. For such widgets, prepend a modifier:

    bind "<mod4>m" { "popup-menu" () }

Likewise, the move-focus bindings must also be prepended with a modifier if you want to navigate through text fields.

More examples

Of course you can’t use modal editing for text fields, but the following makes it possible to make small corrections without moving your hands to the arrow keys:

binding "gtk-binding-text" {
    bind "<mod3>j"         { "move-cursor" (display-lines, 1, 0) }
    bind "<mod3><shift>j"  { "move-cursor" (display-lines, 1, 1) }
    bind "<mod3>k"         { "move-cursor" (display-lines, -1, 0) }
    bind "<mod3><shift>k"  { "move-cursor" (display-lines, -1, 1) }
    bind "<mod3>l"         { "move-cursor" (logical-positions, 1, 0) }
    bind "<mod3><shift>i"  { "move-cursor" (logical-positions, 1, 1) }
    bind "<mod3>h"         { "move-cursor" (logical-positions, -1, 0) }
    bind "<mod3><shift>h"  { "move-cursor" (logical-positions, -1, 1) }
    bind "<mod3>g"         { "move-cursor" (buffer-ends, -1, 0) }
    bind "<mod3><shift>g"  { "move-cursor" (buffer-ends, -1, 1) }
    bind "<mod3>y"         { "move-cursor" (buffer-ends, 1, 0) }
    bind "<mod3><shift>y"  { "move-cursor" (buffer-ends, 1, 1) }
    bind "<mod3>u"         { "move-cursor" (words, 1, 0) }
    bind "<mod3><shift>u"  { "move-cursor" (words, 1, 1) }
    bind "<mod3>o"         { "move-cursor" (words, -1, 0) }
    bind "<mod3><shift>o"  { "move-cursor" (words, -1, 1) }

    # Xahlee'ish deletion
    bind "<mod3>d"         { "delete-from-cursor" (chars, -1) }
    bind "<mod3>f"         { "delete-from-cursor" (chars, 1) }
    bind "<mod3>e"         { "delete-from-cursor" (word-ends, -1) }
    bind "<mod3>r"         { "delete-from-cursor" (word-ends, 1) }
    bind "<mod3>s"         { "delete-from-cursor" (paragraph-ends, -1) }
    bind "<mod3>g"         { "delete-from-cursor" (paragraph-ends, 1) }

    # Emacs'ish deletion
    bind "<alt>BackSpace"  { "delete-from-cursor" (word-ends, -1) }
}
class "GtkEntry" binding "gtk-binding-text"
class "GtkTextView" binding "gtk-binding-text"

This one is my favorite and works  neatly in nautilus if you set the default view to list view:

binding "gtk-binding-tree-view" {
    bind "j"        { "move-cursor" (display-lines, 1) }
    bind "<shift>j" { "move-cursor" (display-lines, 1) }
    bind "k"        { "move-cursor" (display-lines, -1) }
    bind "<shift>k" { "move-cursor" (display-lines, -1) }
    bind "h"        { "move-cursor" (logical-positions, -1) }
    bind "<shift>h" { "move-cursor" (logical-positions, -1) }
    bind "l"        { "move-cursor" (logical-positions, 1) }
    bind "<shift>l" { "move-cursor" (logical-positions, 1) }
    bind "o"        { "move-cursor" (pages, 1) }
    bind "<shift>o" { "move-cursor" (pages, 1) }
    bind "u"        { "move-cursor" (pages, -1) }
    bind "<shift>u" { "move-cursor" (pages, -1) }
    bind "g"        { "move-cursor" (buffer-ends, -1) }
    bind "<shift>g" { "move-cursor" (buffer-ends, -1) }
    bind "y"        { "move-cursor" (buffer-ends, 1) }
    bind "<shift>y" { "move-cursor" (buffer-ends, 1) }
    bind "p"        { "select-cursor-parent" () }
    bind "i"        { "expand-collapse-cursor-row" (0,0,0) }
    bind "semicolon"        { "expand-collapse-cursor-row" (0,1,0) }
    bind "<shift>semicolon" { "expand-collapse-cursor-row" (0,1,1) }
    bind "slash"    { "start-interactive-search" () }
}
class "GtkTreeView" binding "gtk-binding-tree-view"

Note that you can’t use the keys you redefine to autostart interactive search any more — you have to start it manually, in this case by using slash (/). However, I find it faster to navigate this way. Redefine the rest of the alphanummeric keys to some dummy action if you get disturbed by the interactive search when you accidently hit one of the keys not redefined.

You could also experiment with GtkPaned,  GtkNotebook, GtkScrolledWindow and GtkIconView:

binding "gtk-binding-paned" {
    bind "<mod4>s" { "cycle-child-focus" (0) }
    bind "<mod4><shift>s" { "cycle-child-focus" (1) }
}
class "GtkPaned" binding "gtk-binding-paned"

binding "gtk-binding-notebook" {
    bind "<mod4>d" { "change-current-page" (-1) }
    bind "<mod4>f" { "change-current-page" (1) }
}
class "GtkNotebook" binding "gtk-binding-notebook"

binding "gtk-binding-scrolled-window" {
    bind "<mod4>j" { "scroll-child" (step-down, 0) }
    bind "<mod4>k" { "scroll-child" (step-up, 0) }
    bind "<mod4>h" { "scroll-child" (step-left, 0) }
    bind "<mod4>l" { "scroll-child" (step-right, 0) }
    bind "<mod4>o" { "scroll-child" (page-down, 0) }
    bind "<mod4>u" { "scroll-child" (page-up, 0) }
    bind "<mod4>g" { "scroll-child" (start, 0) }
    bind "<mod4>y" { "scroll-child" (end, 0) }
}
class "GtkScrolledWindow" binding "gtk-binding-scrolled-window"

binding "gtk-binding-icon-view" {
    bind "j"        { "move-cursor" (display-lines, 1) }
    bind "<shift>j" { "move-cursor" (display-lines, 1) }
    bind "k"        { "move-cursor" (display-lines, -1) }
    bind "<shift>k" { "move-cursor" (display-lines, -1) }
    bind "h"        { "move-cursor" (logical-positions, -1) }
    bind "<shift>h" { "move-cursor" (logical-positions, -1) }
    bind "l"        { "move-cursor" (logical-positions, 1) }
    bind "<shift>l" { "move-cursor" (logical-positions, 1) }
    bind "o"        { "move-cursor" (pages, 1) }
    bind "<shift>o" { "move-cursor" (pages, 1) }
    bind "u"        { "move-cursor" (pages, -1) }
    bind "<shift>u" { "move-cursor" (pages, -1) }
    bind "g"        { "move-cursor" (buffer-ends, -1) }
    bind "<shift>g" { "move-cursor" (buffer-ends, -1) }
    bind "y"        { "move-cursor" (buffer-ends, 1) }
    bind "<shift>y" { "move-cursor" (buffer-ends, 1) }
}
class "GtkIconView" binding "gtk-binding-icon-view"

Note that the bindings does not work everywhere. For instance, nautilus does not use GtkIconView for the icon view, nor GtkNotebook for tabs, so you must use the list view to use bindings to navigate between files, as well as use nautilus’ own tab bindings (which can be configured with gtk-can-change-accels).

Further information

The best place to get further information on customizing GTK application is the API. It describes the syntax for .gtkrc, and the actions available for each widget. The actions available are the signals with the label “action”. Also see GtkSettings for miscellaneous settings that affects application behavior.

Finally it should be noted that the layout of bindings in this post serve as example only. It is not the layout that I actually use, as I have lots other bindings competing for the available key combinations

In addition to my modified Colemak keyboard layout created by the Microsoft Keyboard Layout Creater, I use scancodes to remap special keys, which is not possible in MKLC.

My current setup is this:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlKeyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,08,00,00,00,01,00,3a,00,3a,00,01,00,19,00,46,00,0e,00,19,00,2a,00,56,00,38,00,38,e0,38,e0,2a,00,00,00,00,00

Note: Be careful when pasting stuff like this into your registry — you have been warned

The scancode mapping does the following:

• Swaps Escape and Caps Lock.
• Makes QWERTY P an extra Backspace key.
  Remember, Colemak has the semicolon on QWERTY P’s position. This makes it possible to delete
• Makes P available on Scroll Lock.
  A pragmatic backup key for P when using other layouts than Colemak. For instance, some virtual machines read raw input from the keyboard, but the scancode map still applies.
• Moves Left Shift to Less Than (at the right of Left Shift on pc-105 keyboards).
  This eases the strain on the left little finger.
• Copies Left Alt to Alt-Gr.
  This way, you can use both hands for the Alt modifier, which greatly reduces the strain on the hands. Generally, use the one hand for the key and the other hand for the modifier.
• Moves Alt-Gr to the original position of Left Shift.
  Takes a little to get used to, but very handy when defining custom keybindings.

The format of the scancode map is pretty simple:

00,00,00,00, <- preamble
00,00,00,00,
08,00,00,00, <- number of remaining 4-tuples (end-sequence inclusive)
01,00,3a,00, <- swap Escape and Caps Lock
3a,00,01,00,
...
00,00,00,00  <- end-sequence

You can find more information on the scancode map format here, and a scan code reference here. Have fun…