I avoided using Microsoft Windows for almost 15 years, but with my
new job at a Microsoft-enthralled development shop, those idyllic
days have come to an abrupt end. Because in the past I could always
use my trusty Linux and OS X machines, I never did push past the
hurdles of using Emacs on Windows. My utter reliance on Org-mode,
TRAMP, and Ediff (to name a few) made it essential to get Emacs
working on Windows if at all possible.

Now I am using Emacs on Windows XP and Windows 7 on a daily basis,
and am quite happy with the results. It was not easy to get to the
point of full functionality, so I wanted to share the magic that
makes it all work.

I have decided against using the Cygwin Emacs package for several reasons:

• Running a windowed/multi-frame/pretty version requires running
  Cygwin-X, which is quite a lot of overhead just to run Emacs. I
  have had a few interface and display problems lately with Cygwin-X
  also.
• Cool-though-seldom-used features that work in the native port do
  not work in the Cygwin port: Window opacity control, for example
• Using the native port means I can always be running the latest
  released version from gnu.org
• The native port just runs faster

On the other hand, Cygwin does play a crucial role in making the
native Emacs port work properly. I have tried and hated using PuTTY
and Plink, and various one-off ports of standard Unix commands.
Using Cygwin and its package management makes all this
much simpler and more reliable.

So all the hints given here use the “official” Emacs for Windows
(sometimes referred to as NTEmacs), as well as Cygwin (with no
dependency on Cygwin-X).

I really hope this helps some poor beleaguered Linux/OS X Emacs user
make the giant backwards leap. With these tips and little helpers like
Launchy, you won’t even have to
acknowledge that you’re running Windows!

Software download links

Here’s where you will find all the software referenced in the tips:

• Emacs for Windows
• Cygwin
• GnuWin32 for image libraries
• ISpell package
• Maxframe.el
• GSView

Tip #1: General Usage

• Execute runemacs.exe or emacsclientw.exe. On your Linux and OS X
  systems, the binary names or emacs and emacsclient: just use the
  windows-specific wrappers included in the standard port when on MS Windows.
• Add Cygwin /bin to exec-path.

        (if (file-directory-p "c:/cygwin/bin")
        (add-to-list 'exec-path "c:/cygwin/bin"))

Tip #2: Make TRAMP work nicely — and without PuTTY

There are people using PuTTY and Plink.exe to get this working, but
I like using good old OpenSSH much better: no translation required
for the keys I use, and I have it installed anyway in Cygwin.

• Install Cygwin, including the OpenSSH package
• In your Emacs init, set shell to bash

        (setq shell-file-name "bash")
        (setq explicit-shell-file-name shell-file-name)

• In Emacs init, set tramp-default-method to “sshx” or “scpx”

        (cond  ((eq window-system 'w32)
        (setq tramp-default-method "scpx"))
        (t
        (setq tramp-default-method "scpc")))

• Windows 7 note:   I was unable to get this to work on Win7 until I set the runemacs.exe binary to run in Windows XP (Service Pack 3) compatibility mode.
• Test: Try M-x shell, then visit a TRAMP site such as /user@site: and try M-x shell from there!

Tip #3: Use SVN and GIT without tears

Version control should work out of the box — but SSH problems can
interfere sometimes. So once you get TRAMP working properly, you
should have no problems with VC.

• Install subversion and git from Cygwin
• Use built-in vc-dir, or psvn.el and magit.el

Tip #4: Display images in buffers, including doc-view

You may have noticed that your Windows Emacs has no ability to
display images. This is simply due to the fact that the port is
not distributed with the libraries necessary to display them.

The solution is to visit the GnuWin32 link above, download the
packages relevant to the types of images you want to display
(including zlib1 for compressed images), and copy the DLLs into the
bin directory of your Emacs installation (e.g, C:\Program
Files\emacs23-2\bin).

Images will only be displayed after restarting Emacs.

Here’s a list of DLLs that I now have in my installation:

• jpeg62.dll
• libXpm.dll
• libjpeg-62.dll
• libpng-bcc.lib
• libpng.dll.a
• libpng.la
• libpng.lib
• libpng12-0.dll
• libpng12.def
• libpng12.dll
• libpng12.dll.a
• libpng12.la
• libtiff3.dll
• zlib1.dll (for compression, not images)

Tip #5: Use W3M

The W3M web browser works fine once you install the w3m binary –
and once the image display step above is working, you will be able
to display images in the W3M buffers as well.

• Install w3m from Cygwin
• Test image display by hitting T (w3m-toggle-inline-images)
• Example screenshot:
  

Tip #6: Bring back Ediff and Smerge

Ediff is yet another thing which doesn’t work as it should. You
will get an error complaining about Dos-style versus Unix-style
paths. Fixing it is a simple matter of setting an environment variable.

• Assure you have Cygwin’s diff package installed
• Set the Windows environment variable nodosfilewarning=1
• Restart Emacs, and verify that the environment variable is set by executing M-x shell, then typing env | grep dos, for example
• Always, prior to running ediff, execute M-x shell

Tip #7: Spell using ISpell or Aspell

Fortunately very easy to get working by following Brian Wood’s directions using the ISpell package for Cygwin linked above.

Note added later:

Aspell is even easier to use: just install aspell and the correct language(s) in Cygwin, then use the following in your emacs init:

(setq-default ispell-program-name "aspell")

Tip #8: Maximized frame works using maxframe.el

Those of us who practice Distraction-Free Emacsing, or DFE, will
lament the inability to maximize the frame as we can do on other
systems (ie, a true maximized windows, with no OS window
decoration). The solution is provided by maxfame.el, linked above.

After loading maxframe.el, use M-x maximize-frame and M-x restore-frame

Tip #9: Print on PostScript printers

And finally, printing. Even this just didn’t work out of the box
for me. The solution was to use a nice little utility called
GSPrint from the GSView package linked above.

• Install Ghostscript in Cygwin
• Install GSView

        (when (and (string= (window-system) "w32") (file-exists-p "c:/Program Files/Ghostgum/gsview/gsprint.exe"))
        (progn
        ;;  Windows printer
        (setq-default ps-lpr-command (expand-file-name "c:/Program Files/Ghostgum/gsview/gsprint.exe"))
        (setq-default ps-printer-name t)
        (setq-default ps-printer-name-option nil)
        (setq ps-lpr-switches '("-query")) ; show printer dialog
        (setq ps-right-header '("/pagenumberstring load" ps-time-stamp-mon-dd-yyyy))))
        (if (eq window-system 'x)
        (setq ps-lpr-command "gtklp"))

Tip #10: Some things Just Work™: Nifty Emacs 23 features that work “out of the box”

Bonus tip — some things work already, no fiddling required!

Select any font you want

• M-x menu-set-font (choose something lovely like Consolas or Inconsolata … or Comic Sans MS)
• Example font selection, cross-OS

        ;;* Font selection
        (cond ((or (eq window-system 'mac) (eq window-system 'ns))
        (set-face-font 'default '"-apple-inconsolata-medium-r-normal--16-0-72-72-m-0-iso10646-1"))
        ((eq window-system 'w32)
        (set-face-font 'default '"-outline-Inconsolata-normal-normal-normal-mono-16-*-*-*-c-*-iso8859-1"))
        ((and (eq window-system 'x) (eq emacs-major-version 23))
        (set-face-font 'default '"-unknown-Inconsolata-normal-normal-normal-*-16-*-*-*-m-0-iso10646-1")
        (add-to-list 'default-frame-alist '(font . "-unknown-Inconsolata-normal-normal-normal-*-16-*-*-*-m-0-iso10646-1"))
        )
        ((eq window-system 'x)
        (set-face-font 'default '"10x20")))
   
        (add-hook 'before-make-frame-hook
        (lambda ()
        (set-frame-font "-unknown-Inconsolata-normal-normal-normal-*-16-*-*-*-m-0-iso10646-1")
        ))

• M-x grep, M-x grep-find, M-x rgrep and friends (as long as
  you have the grep and find commands installed!)
• M-x tetris, M-x doctor, M-x yow, M-x butterfly

Frame transparency

• Transparent windows are not my favorite thing, as they tend to
  hamper DFE (see above). But there are occasions, like copying text from a
  web page into an Emacs buffer, where it can come in quite handy.

        (defun set-transparency (alpha-level)
        (interactive "p")
        (message (format "Alpha level passed in: %s" alpha-level))
        (let ((alpha-level (if (< alpha-level 2)
  				(read-number "Opacity percentage: " 85)
  				alpha-level))
  				(myalpha (frame-parameter nil 'alpha)))
  				(set-frame-parameter nil 'alpha alpha-level))
  				(message (format "Alpha level is %d" (frame-parameter nil 'alpha))))

The YASnippet package for Emacs has some pretty awesome power for the developer, especially when you utilize the power of Emacs Lisp.

YASnippet was inspired by TextMate, which was inspired by Emacs, in a highly-out-of-equilibrium whirlwind of self-referential creativity.

The screencast above uses a set of snippets I originally took from this WordPress TextMate bundle, created by Shawn Parker and Gordon Brander

The first snippet in the screencast illustrates YASnippet’s mirrors with transformation, in a WordPress plugin template. The snippet calls Emacs Lisp functions as the plugin name is filled in to create the plugin URI, the “namespace” (used here as a prefix for function and variable names), and the primary class name for the plugin.

The second snippet writes a function skeleton, then calls Emacs Lisp at the end to move the generated function outside the current scope into a correct position in the file. This snippet uses YASnippet’s fields with transformations syntax, but to do a sneaky thing: not transform the field, but move a region of generated text!

Following is the code for the snippets shown in the screencast, with no commentary. So pipe up in the comments if you’re curious about how something works!

# -*- mode: snippet -*-
# name: WP Plugin
# key: plugin
# --
/*
Plugin Name: ${1:Plugin Name}
Plugin URI: http://${2:dynapse.com/plugins/}${1:$(gjg/sanitize text)}/
Description: ${3:Description}
Version: ${4:1.0}
Author: ${5:Gregory Grubbs}
Author URI: http://${6:gregorygrubbs.com/}
Namespace: ${1:$(gjg/acronyminize text)}_
*/
 
class ${1:$(gjg/whitespace-to-underscore text)} {
	/**
	 * constructor for $1
	 *
	 * The constructor is responsible for registering all hooks used
	 * by this class as as WordPress plugin
	 */
	function __construct() {
		 $0
	} // constructor
 
}
$${1:$(gjg/acronyminize text)} = new ${1:$(gjg/whitespace-to-underscore text)}();

Next, the add_action snippet, which moves a generated function at the end:

# -*- mode: snippet -*-
# name: add_action
# key: add_action
# --
add_action('${1:init}', array($this, 'my_${2:$1}'));
${3:$$(gjg/move-next-sexp-past-current-scope)}
function my_$1 () {
}

And finally, (some of) the Emacs Lisp functions that the snippets call:

(defun gjg/acronyminize (text &optional do-capitalize)
  "Make an acronym from the text 
do-capitalize: t means run text through capitalize function, nil will respect CamelCase
"
  (save-excursion
    (setq case-fold-search nil)
    (downcase
     (replace-regexp-in-string
      "[^A-Z]" ""
      (if do-capitalize (capitalize text) text) nil t))))
(defun gjg/move-next-sexp-past-current-scope ()
  "kill sexp following point, move past current scope/sexp/function"
  (beginning-of-line)
  (let ((beg (point)))
    (re-search-forward "^[ \t]*function[ \t]+[^}]+?}" (point-max) nil)
    (mark-defun)
	(kill-region (point) (mark)))
  (forward-line)
  (yank)
  (indent-region (mark) (point)))

One of the things that makes daily Emacs use so enjoyable is the availability of brilliant add-ons designed to make you work faster.

Emacs with ido-mode fuzzy matching (or flex matching) makes it incredibly quick to navigate the file system using only the keyboard. But it does far more than that, allowing the emacs pilot to quickly find help, commands, variables and much more. This video shows the finer points of using ido-mode with flex matching.

It’s all in the video – enjoy.

Here are my current settings for ido-mode

;; do not confirm a new file or buffer
(setq confirm-nonexistent-file-or-buffer nil)
(require 'ido)
(ido-mode 1)
(ido-everywhere 1)
(setq ido-enable-flex-matching t)
(setq ido-create-new-buffer 'always)
(setq ido-enable-tramp-completion nil)
(setq ido-enable-last-directory-history nil)
(setq ido-confirm-unique-completion nil) ;; wait for RET, even for unique?
(setq ido-show-dot-for-dired t) ;; put . as the first item
(setq ido-use-filename-at-point t) ;; prefer file names near point

Emacs file and directory browsing

Emacs has Dired, a great method for browsing directories; especially in combination with ido-mode, I prefer it to Windows Explorer, OS X Finder, Gnome Nautilus, or anything else I’ve used over the decades to browse file systems. You can quickly begin entering paths, and Dired helps you with directory and file name completion.

As you browse directories, emacs lets you bookmark any path you may visit again. A very cool feature of emacs is the wide variety of shell-based modes: shell, term, interactive SQL, version control, recursive grep, and more. When you are looking at a Dired buffer and invoke any of those commands, the shell is started in the directory you are looking at.

TRAMP: powerful remote file server access

An emacs user will eventually discover that Dired becomes even more powerful with the built-in power of TRAMP (Transparent Remote (file) Access, Multiple Protocol). This extends directory path syntax to include FTP, SSH, Rsync and other protocols for accessing remote files.

An example of accessing a remote file on my development server smeagol from my laptop:

/ssh:gregj@smeagol:work/client1/web/index.php

A directory on an FTP server is accessed the same way:

/ftp:ftpuser@ftp.example.com:

Even sudo is considered a ‘protocol’; so to gain root access without leaving the comfort of your emacs session, use

/sudo::/etc/hosts

Emacs even helps you browse remote servers, providing the same name completion you get on your local directories.

The amazing combo of TRAMP and shell commands

As wonderful as all this is, we are still in the realm of “mere” GUI editors that can browse remote servers. But we are dealing with emacs, the superset of all editors, so we expect even more.

Imagine we are looking at a directory on a remote server at /ssh:myuser@remote.com:web/public_html, and decide to type

M-x shell

What happens? Why, emacs looks at our current directory, sees that it is a TRAMP remote path, and just does the Right Thing™: in this case, invokes ssh, sets the directory on the remote server to ~myuser/web/public_html, and sets us at the shell prompt.

Similarly, if we invoke version control (vc-dir, for example), or recursive grep (rgrep), or most other shell-based commands, emacs will open a secure shell first, then run the vc command (svn, git, etc) or grep on the remote server!! So for example, if I innocently invoke rgrep at the root of a remote WordPress installation, the grep command looks through all the files from the remote server. If on the other hand I were accessing the server using something like SSHFS, all those files would be transferred to my local machine first and then searched!

Some examples

I’ll save my favorite uses of this magic called Dired with TRAMP for last. I often need to access a development system or a live WordPress installation remotely. To access the SQL client, I found I often had to browse for the WordPress config file, open it, search for the database access info, open a SQL session using M-x sql-mysql and fill in all the prompts to authenticate to the MySQL server. It’s great that emacs with TRAMP starts a shell on the remote machine, and initiates the mysql client on that machine. But emacs allows you to do damn near anything you can imagine, so I realized I could write a function that does the following:

1. Looks for wp-config.php in the current directory
2. If not found, moves up a directory until it either finds the file or reaches the root of the filesystem
3. If found, opens the config file and parses the database authentication parameters
4. Feeds those parameters to the sql-mysql function and
5. plops me into the MySQL prompt all logged in and ready to go!

Another example: my iPod Touch has an SSH server running on it (don’t ask me how it got there). I have discovered that many apps use SQLite to store their data. I have been losing weight lately, and have been using the excellent Lose It! app to track my meals and exercise. The app gives me nice weekly summaries of my caloric intake, but does not give a weekly summary of my aerobic exercise. Here’s how I get that information now:

1. I have a nice bookmark to the Lose It! application directory at
   /scpc:mobile@172.16.17.118:/var/mobile/Applications/C6503545-700B-4395-9C8B-FE5B75CF6CD8/,
   so I hit the Return key on that bookmark and wait for Dired to show me the files there.
2. Browse to the Documents directory, wherein is stored the database for my personal history
3. Invoke M-x sql-sqlite and enter the database file UserDatabaseV1.sql (using dabbrev as a shortcut)
4. Wait for the SQLite prompt to appear, and run a lovely little SQL query using a YASnippets shortcut:

SELECT date('2001-01-01', '+' || Date || ' day', '-1 day', 'weekday 1', '-7 day') AS Weekdate, strftime('%W',date('2001-01-01', '+' || Date || ' day', '-1 day')) AS Week,   ExerciseName, ExerciseCategoryId, SUM(Minutes), SUM(CaloriesBurned)   FROM ExerciseLogEntries  GROUP BY Week;

Summary

I hope that this post gives an idea of the power of TRAMP on emacs. It should at least explain the occasional ecstatic post you may see from your geekier tweeps.

As a bonus, here’s what the above examples look like in use: it’s unbelievable how fast emacs makes you after a quick 15 years of study.

And here’s my emacs lisp code that opens up a SQL prompt for any WordPress installation. To use, eval the code and invoke M-x gjg/sql-mysql-wordpress

(defun gjg/parse-wp-config-db (wpconfig-path)
  "Read in and parse the DB settings from a WordPress config file; binds 'global' vars for use by sql-mode"
  (save-excursion ;; will restore current buffer and default dir afterwards
      (set-buffer (get-buffer-create (generate-new-buffer-name " wp-config.php")))
  (insert-file-contents wpconfig-path)
  ;; in regex: subexpr 1 is variable name, subexpr 3 is value: DB_{HOST,NAME,PASSWORD,USER}
      (while (search-forward-regexp "define\s*(\s*['\"]\\(DB_\\(HOST\\|NAME\\|PASSWORD\\|USER\\)\\)['\"]\s*,\s*['\"]\\([^'\"]*\\)['\"]\s*)" (point-max) 42   )
  (cond
  ((equal "DB_HOST" (match-string-no-properties 1))
  (setq sql-server (match-string-no-properties 3)))
  ((equal "DB_NAME" (match-string-no-properties 1))
  (setq sql-database (match-string-no-properties 3)))
  ((equal "DB_PASSWORD" (match-string-no-properties 1))
  (setq sql-password (match-string-no-properties 3)))
  ((equal "DB_USER" (match-string-no-properties 1))
  (setq sql-user (match-string-no-properties 3)))))
  (kill-buffer )))

  (defun gjg/sql-mysql-wordpress ()
  "Find WordPress config file in current tree, log into WP database if found."
  (interactive)
  (let ((mypath (locate-dominating-file default-directory "wp-config.php")))
  (if mypath
  (progn
  (gjg/parse-wp-config-db (concat mypath "wp-config.php"))
  (pop-to-buffer (sql-connect-mysql))
  (setq sql-interactive-product 'mysql)
  (setq sql-buffer (current-buffer))
  (sql-interactive-mode)
  (let* ((match (string-match (nth 0 tramp-file-name-structure) mypath))
  (myformat (if (eq nil match)
  (format " WordPress: local; %s; dbhost %s "
  mypath
  sql-server
  )
  (format " WordPress: Remote %s@%s %s; dbhost %s "
  (match-string (nth 2 tramp-file-name-structure) mypath)
  (match-string (nth 3 tramp-file-name-structure) mypath)
  (match-string (nth 4 tramp-file-name-structure) mypath)
  sql-server))))
  (setq header-line-format myformat))
  )
  (message "Did not find wp-config.php in current path"))
  ))

LocalWords: Dired emacs SQL Rsync smeagol pre rgrep WordPress MySQL iPod
LocalWords: SQLite