Gmail envy

Gmail markers Although Gnus is my primary mail reader, there’s lots of things i like about Gmail (actually, Gmail is my primary inbox: Gnus reads mail from there). For instance, a little feature i love in Gmail is those markers that tell you whether you’re one of the direct recipients of a mail. When seeing a long list of mails in a mail list, i can quickly identify those with me explicitly in the To: or Cc: headers: chances are i’m slightly more interested in them.

In Gnus, one can customize the information shown in the message list by tweaking the variable gnus-summary-line-format. If you press C-h v gnus-summary-line-format to see all the formatting options, you’ll see there’s a lot of information to be shown, but not the one we want. But, as is always the case, we have a hook to extend the format to our hearts content: the %uX directive, where X is any letter you want. When Gnus sees that directive, it calls gnus-user-format-function-X, a function you must write returning a string that gets inserted in the summary line. So here we go: first i define a string with a regexp of my email addresses:

(defvar *jao-mails* 
        "jao@foo\\.org\\|jao@baz\\.com\\|jao@grogle\\.com")

and then i function which returns a “ยป” if i’m the only recipient of the message, or a “~” if i’m in the To:, Cc: or BCc: headers among others:

(defun gnus-user-format-function-j (headers)
  (let ((to (gnus-extra-header 'To headers)))
    (if (string-match *jao-mails* to)
        (if (string-match "," to) "~" "ยป")
        (if (or (string-match *jao-mails* 
                              (gnus-extra-header 'Cc headers))
                (string-match *jao-mails* 
                              (gnus-extra-header 'BCc headers)))
            "~"
            " "))))

Then all that is left is using it in my gnus-summary-line-format:

(setq
 gnus-summary-line-format
 "%U%R %~(pad-right 2)t%* %uj %B%~(max-right 20)~(pad-right 20)n %s\n")

Picture 2.pngNotice the %uj doing the trick here. I’m sure you’ll come up with other uses to this extension mechanism, which, by the way, is also available for gnus-group-line-format, the variable governing how lines in the *Group* buffer are displayed.

Posted in Gnus. 6 Comments »

Smooth scrolling

A quick and sweet tip for one of those things surprisingly difficult to get right in emacs: buffer scrolling. If you find awkward the way emacs makes your buffers jump when you move the cursor near their begin or end, try putting this file in your load path and (require 'smooth-scrolling). You can control when scrolling starts by setting the variable smooth-scroll-margin: when the cursor is that far from the top or bottom borders, scrolling begins (default is 10 lines). Works like a charm here.

By the way, as Adam (the author of the code above) points out in the comments below, the problem is trickier than it seems. If you’re curious, this EmacsWiki page gives the details.

Quick keybindings

So, you just executed a complex, wonderful emacs command using the minibuffer and you’re so excited that need to immediately write it down, lest you forget. As you may already know, you don’t need pen and paper for that. Emacs will do it for you: just press C-x ESC ESC (that is, repeat-complex-command) and you’ll see an Elisp form in your minibuffer that reproduces your last command (C-h w C-x ESC ESC for more details). Now C-a C-k and you got it in the kill-ring, ready to be yanked in one of your configuration files.

I don’t use this trick that much because over the years more and more emacs automatisms are recorded either in my nervous system or my config files. Except for one thing: defining keybindings. There’re a bunch of ways to define a keybinding in emacs, and i’m never sure what’s the right one when there’re special keys involved. The solution is to define the key interactively with M-x global-set-key. Once i’m done, i play C-x ESC ESC and presto: an elisp snippet to yank in my .emacs appears in the minibuffer.

Happy binding!

Gnus and Google Groups

Eternal September notwithstanding, i have great daily fun reading a bunch of usenet groups, and their articles are sometimes a source of ideas for blogging. Of course, my usenet client is Gnus; but in a blog post one needs the Google Groups URL when mentioning and article. So, i just spent five minutes writing a snippet to go from Gnus to GG in a keystroke:

(defun jao-gnus-goto-google ()
  (interactive)
  (when (memq major-mode '(gnus-summary-mode gnus-article-mode))
    (when (eq major-mode 'gnus-article-mode) 
      (gnus-article-show-summary))
    (let* ((article (gnus-summary-article-number))
           (header (gnus-summary-article-header article))
           (id (substring (mail-header-id header) 1 -1)))
      (browse-url 
       (format "http://groups.google.com/groups?selm=%s" id)))))

As you see, i just check that i’m viewing a post, obtain the message identifier (trimming surrounding markup) and construct a query that looks up the corresponding GG article.

Talk about extensibility.

Tip of the Day

Although i don’t use it that much, i’ve had the following defun in my emacs config since i remember:

(defun totd ()
  (interactive)
  (random t) ;; seed with time-of-day
  (with-output-to-temp-buffer "*Tip of the day*"
    (let* ((commands (loop for s being the symbols
                           when (commandp s) collect s))
           (command (nth (random (length commands)) commands)))
      (princ
       (concat "Your tip for the day is:\\n"
               "========================\\n\\n"
               (describe-function command)
               "\\n\\nInvoke with:\\n\\n"
               (with-temp-buffer
                 (where-is command t)
                 (buffer-string)))))))

(Actually, i’ve tracked it down to a gnu.emacs.help thread dated 2001).

I’m sure you’ve guessed what it does. One possible use is to put the invocation (totd) at the end of your .emacs; but, as i tend to have emacs open for days, if not weeks, in a row, i prefer to just bind it to a keyboard shortcut and press it when i’m idling or thinking of a new post. I can also press the shortcut repeatedly until the random chosen command interests me.

Another possibility (if you don’t find it annoying), is to set a timer to get a periodic tip of the day, using something along the lines of:

(defvar jao-totd-timer (run-at-time "12:00am" (* 3600 24) 'totd))
(defun jao-cancel-totd
  (interactive)
  (cancel-timer jao-totd-timer))

Not that bad as a pastime ๐Ÿ™‚

Emacsy OS X

mail-emacs.pngLet me tell you how Emacs is more and more taking the center stage in my MacBook. In a previous post i explained how i set up Gnus as my mail (and of course, news) reader: i like Gnus so much that it quickly became my default. And, just in case you didn’t know, Emacs can be OS X’s default mail handler too: just go to Mail’s general preferences pane and set it–it’s that easy. (In the image, i’m setting fink’s carbon emacs package, but you’ll see there too CarbonEmacs or Aquamacs if you have them installed.) With that setting in place, OS X will dutifully use Gnus whenever a mail handler is requested (e.g., when following mailto: URLs, or when using ‘Send this page…’ in Safari).

fast-scripts.pngUnlike Gnus, Emacs is not my default web browser, although i use w3m-el quite a bit (specially for technical manuals). So, every now and then i find myself seeing a page in Safari than i want to open in Emacs. Applescript to the rescue: fire up that ugly Script Editor and type this simple program:


property eclient : "/sw/bin/emacsclient -e "
tell application "Safari"
  set this_url to the URL of document 1
  do shell script eclient & \
          "'(w3m-browse-url \"" & this_url & "\")'"
	tell application "Emacs22" to activate
end tell

(changing the path to emacsclient and the name of your Emacs as needed). Of course, you’ll also need to start the Emacs server somewhere in your init files with (start-server), and to save the above script in ~/Library/Scripts/Applications/Safari. I’ve named it ‘Open in Emacs’, and it appears nicely as an entry in my FastScripts menu.

The last, and most interesting, bit is going in the opposite direction: accessing Safari (or any other Cocoa application, for that matter) from Emacs. Or, put in another one, executing AppleScript snippets within Emacs. One possibility is using Emacs’ shell-command in conjunction with OS X’s osascript, but there’s a sweeter way: the Elisp function do-applescript. For instance, the function jao-as-safari-doc below returns the URL and title of the active page in Safari:

 (defun jao-as-tell-app (app something)
   (let ((res (do-applescript (concat "tell application \""
                                      app "\" to " something))))
     ;; the string returned is quoted
     (substring res 1 -1)))

 (defun jao-as-safari-doc ()
   (interactive)
   (let ((url (jao-as-tell-app "Safari" 
                               "get the URL of document 1"))
         (name (jao-as-tell-app "Safari" 
                               "get the name of window 1")))
     (cons url name)))

This may seem a bit boring at first, but it can be put to good use: when i see a page worth taking a few notes, i open an org-mode buffer, and type a shortcut bound to the following function:

 (defun jao-org-insert-safari-link ()
   (interactive)
   (let ((l (jao-as-safari-doc)))
     (insert (org-make-link-string (car l) (cdr l)))
     (message "Link to %s inserted" (car l))))

and (minor) magic happens. I’m sure you can think of many other interesting uses of do-applescript, can’t you?

Emacs on the spotlight

I’ve been writing lately several snippets to improve the communication of Emacs with OS X. One of them is this quick and dirty mdfind mode that provides access, within an Emacs buffer, to the results of mdfind commands (the CLI to OS X’s Spotlight). Just put the above file somewhere in your load path, (require 'mdfind) in your init file and invoke M-x mdfind. You’ll be asked for a directory and a search string to perform in that directory. Under the rug, this shell command gets executed:

mdfind -onlyin directory query

The results (a file list) are collected in a special buffer in a new major mode (creatively dubbed mdfind-mode) that inherits from org-mode (this is Emacs 22; if you haven’t yet, take a look at org-mode: it is simply awesome), and that displays the files nicely fontified as links. See the comments at the beginning of mdfind.el for a list of available shortcuts that you can use to navigate and open (using OS X’s default handlers) the files in the list.

The functionality offered is right now limited and there’re many venues for improvement, so i guess i’ll keep adding features as i need them. But you’re encouraged to take this quick hack as an starting point to get the functionality that you deem important (and maybe share the results ๐Ÿ™‚ ). Or, alternatively, to leave your suggestions in the comments section.

mdfind in action

An Emacs Client for Google Services

If you use Google’s Blogger, GCal and/or Reader, run-don’t-walk and grab the new Emacs Client For Google Services. Awesome!.

Yet another illustrated primer

This one, called Living in Emacs (PDF), covers the very basics of using Emacs as your working environment:

Getting started with Emacs requires navigating a steep learning curve. Our goal is to help you past the initially unfamiliar interface so that the power and utility of Emacs become apparent. Then you’ll be ready to explore further on your own, following up on the resources and tips at the end of the tutorial.

The 25-pages long tutorial closes with a good piece of advice:

Use Emacs. Live in it for a while, learn to love it a little bit. Like any complex program, it will take time for you to fully grok it, but the effort’s worthwhile: you’ll have become fluent in one of the most common UNIX programming utilities and picked up a fundamentally marketable skill to boot!

Worth a look if you’re just getting started.

Emacs-friendly Firefox

When i use Firefox, there’s nothing more annoying than editing a textarea. On a Mac, one has at least some Emacs-like shortcuts. Incomprehensibly, on GTK+ 2.0 Emacs shortcuts are no longer the default, and one has to put something like

include "/usr/share/themes/Emacs/gtk-2.0-key/gtkrc"

in ~/.gtkrc-2.0 to restore a minimum of sanity.

It's All Text!But still, what i really want is to edit those textareas using the real thing. I just stumbled upon the answer to my prayers: It’s All Text! is a Firefox add-on that provides an edit button on any text box. You click on it and, the first time, you’re asked for your editor of choice. As you’ll notice, the default option is wrong. Change it by /usr/bin/emacsclient (Emacs 21 users may use gnuclient instead), and don’t forget to start the Emacs server with (server-start) somewhere in your initialisation file.

Better, no?

MozexUpdate: Well, things can be even better, as pointed out by Victor below. The Mozex extension lets you not only edit textareas, but also assign shortcuts, view sources or choose the editor for mailto URLs. For some reason, using just emacsclient -e '(compose-mail "%a" "%s")' didn’t work for me, so i’ve created a simple shell script, gnumail:

    #!/bin/sh
    exec emacsclient -e "(compose-mail \"$1\" \"$2\")"

and told Mozex to use it. Don’t forget to set the variable mail-user-agent to something reasonable (for instance, since i use Gnus, i’ve got (setq mail-user-agent 'gnus-user-agent) in my configuration files).

Thanks, Victor!