Most window managers have some facility to arrange the visible windows. With Emacs, you cna programmatically manipulate a frame’s size and position from Lisp.

There are a few ways I like to arrange my Emacs frames. I generally use one or two – more are harder to manage – and dedicate them to specific purposes. One always has code buffers in it, and the other can have compilation buffers, IRC, w3m, unit test output, or any other variety of programming-related tools.

When I work with a single frame, I like it to be centered on my screen. When I have two, I like them to be next to each other, in the center. Since it’s hard to align by hand, I wrote some code do to it for me.

(defun screen-usable-height (&optional display)
  "Return the usable height of the display.

Some window-systems have portions of the screen which Emacs
cannot address. This function should return the height of the
screen, minus anything which is not usable."
  (- (display-pixel-height display)
     (cond ((eq window-system 'ns) 22)
           (t 0))))

(defun screen-usable-width (&optional display)
  "Return the usable width of the display.

This works like `screen-usable-height', but for the width of the display."
  (display-pixel-width display))

(defun frame-sort-ltr (frames)
  "Sort frames by their visual order, left to right.

This method takes a list of frames, and returns that list, sorted
by the visual display order. This is determined by comparing the
left position of the frames; the leftmost frames are returned
first."
  (sort frames (lambda (framea frameb)
                 (< (frame-parameter framea 'left)
                    (frame-parameter frameb 'left)))))

(defun frame-box-get-center (w h cw ch)
  "Center a box inside another box.

Returns a list of `(TOP LEFT)' representing the centered position
of the box `(w h)' inside the box `(cw ch)'."
  (list (/ (- cw w) 2) (/ (- ch h) 2)))

(defun frame-get-center (frame)
  "Return the center position of FRAME on its display."
  (frame-box-get-center (frame-pixel-width frame) (frame-pixel-height frame)
                        (screen-usable-width) (screen-usable-height)))

(defun frame-center (&optional frame)
  "Center a frame on the screen."
  (interactive)
  (apply 'set-frame-position
         `(,(or frame (selected-frame)) ,@(frame-get-center frame))))

(defun frame-tile-horizonal ()
  "Tile visible frames horizontally.

This function tiles visible frames, distributing them evenly
across the display, and centering them vertically.

It doesn't know about multi-head displays, and will probably fail
dramatically if used in such an environment."
  (interactive)
  (let ((pos)
        (offset 0)
        (vwidth (/ (screen-usable-width) (length (visible-frame-list)))))
    (dolist (frame (frame-sort-ltr (visible-frame-list)))
      (setq pos (frame-box-get-center (frame-pixel-width frame)
                                      (frame-pixel-height frame)
                                      vwidth (screen-usable-height)))
      (set-frame-position frame (+ offset (car pos)) (cadr pos))
      (incf offset vwidth))))

(defun frame-tile-center-horizonal ()
  "Tile visible frames horizontally, center-weighted.

Rather than tiling frames evenly across the available width of
the display, this function tiles them into the center of the
display, adding a 2% margin in between frames.

It doesn't know about multi-head displays, and will probably fail
dramatically if used in such an environment."
  (interactive)
  (let* ((framewidth (apply '+ (mapcar 'frame-pixel-width (visible-frame-list))))
         (margin (/ (screen-usable-width) 50)) ;; = (/ s-u-w *.02) = 2%
         (totalwidth (+ framewidth (* margin
                                      (- (length (visible-frame-list)) 1))))
         (offset (car (frame-box-get-center totalwidth 0 (screen-usable-width)
                                            (screen-usable-height)))))

    (dolist (frame (frame-sort-ltr (visible-frame-list)))
      (set-frame-position frame offset (cadr (frame-get-center frame)))
      (incf offset (+ margin (frame-pixel-width frame))))))

(defun frame-restore-defaults (frame)
  (modify-frame-parameters frame default-frame-alist))

(defun frame-default ()
  (interactive)
  (mapcar 'frame-restore-defaults (frame-list))
  (if (> (length (frame-list)) 1)
      (frame-tile-center-horizonal)
    (frame-center)))

(provide 'ime-frame)

You can also call M-x frame-tile-center-horizonal or M-x frame-center by hand, if you like.

Ordinarily, you’d use *scratch*, but it’s useful to have your scratch buffer use mode for the language you want to write code in, and *scratch* doesn’t fulfill this unless you’re hacking on emacs-lisp.

To this end, I created scratch-el, a bit of code for doing just this.

When you invoke it with M-x scratch, it gives you a scratch buffer with the same mode as your current buffer. So if you’re editing Python code, you get a *python* buffer which uses python-mode. If you’re in a shell, you get a shell-script-mode buffer, and so on.

If you invoke it with a prefix argument, as C-u M-x scratch, it will prompt you for the mode to use, which can be helpful if you want to noodle on a SQL query while editing your app code. There is tab completion support for all known major modes.

If you want to save the resulting work, it’s just a C-x C-w away.

Piece of Cake

The first component we’re going to work with is smerge. SMerge is invaluable; it’s a minor mode which allows you to quickly navigate between conflicts and choose which you’d like to keep. Normally, you must invoke it explicitly with M-x smerge-mode, but there’s an easier way.

(defun sm-try-smerge ()
  (save-excursion
    (goto-char (point-min))
    (when (re-search-forward "^<<<<<<< " nil t)
      (smerge-mode 1))))

(add-hook 'find-file-hook 'sm-try-smerge t)

Throw this in your .emacs, and smerge-mode will be enabled for files which contain conflict markers. If you’re a Git user (and you should be), the markers will have the branch names they came from tacked on the end. The minor mode will disable itself when there are no more conflicts left in the buffer.

All SMerge’s bindings start with a shared prefix, which is C-c ^ by default. This is somewhat cumbersome, but you can change it in customize (M-x customize-variable RET smerge-command-prefix RET). The bindings you’ll want to be familiar with are:

• C-c ^ n – Move to the next conflict.
• C-c ^ p – Move to the previous conflict.
• C-c ^ RET – Keep the version of the code point resides in.
• C-c ^ m – Keep my version of the code. This is the version that was in the branch you merged to.
• C-c ^ o – Keep the other version of the code. This is the version that was in the branch you merged from.
• C-c ^ a – Keep all versions of the code. You’ll probably need to edit it to completely resolve the conflict.

Another Slice

Let’s say that you have a file where you want to resolve each conflict the same way. You either want to keep the changes from the branch you merged, or the changes you've made in your branch. SMerge helps a lot with this, but there’s not reason to kill your fingers when you have KMacro. Let’s assume that you want changes in the branch you merged to take precedence.

1. C-x ( – Start recording a keyboard macro.
2. C-x ^ n – Move to the next conflict.
3. C-x ^ o – Resolve the conflict by choosing the other version.
4. C-x ) – Stop recording the macro.

Now, you can apply this macro as many times as you like with:

1. M-x kmacro-call-macro RET – Run the macro.
2. RET – Run the macro again; repeat until all conflicts are resolved.

They should be back soon, hosted on Amazon S3 like the official 23.1 release.

Compile.el is really great for this kind of thing, since it lets you quickly navigate over the lines mentioned in the program’s output. It’s quite efficient, and I enjoy it immensely. One note of interest: pep8.py doesn’t output line numbers in order, which confuses compile-mode. I just pipe the output through sort to work around this.

The code is on GitHub: python-pep8.el and python-pylint.el.

If you hit M-h in Emacs, it runs mark-paragraph, which is good, but means that you can’t hide Emacs. However, if you hit ⌘tab to trigger the app switcher, then select Emacs, then hit ⌘H, it will hide instead.

Alternately, you could bind ns-do-hide-emacs to some other key combination.

Moving forward, I hope to transition the nightlies to S3 and build them from Git instead of CVS.

Cocoa Emacs 23.1

For people who prefer the stable release, I built Cocoa Emacs 23.1. This is a vanilla build of the official release.

What’s wrong with the NS port?

Lots. It’s significantly slower, less stable, and lacks features which were in the 22.x Carbon port, like fullscreen. It’s really not ready for prime time, and it sucks that people will get such a bad experience on OS X. What sucks even more is that new users will get a bad first impression. This could have been a chance to turn people on to Emacs and GNU software, but it’s more likely to alienate them instead.

The Carbon port was discontinued in the hopes that a single NextStep port could work on OS X and GNUStep. Unfortunately, relatively few people cared to work on it, and the result is that the stable Carbon port is dead and it’s replacement just isn’t as good. I also hear that the GNUstep builds are completely broken, though I haven’t personally verified such.

The politics of GNU bear some of the blame, too. Non-free platforms like Macintosh are second class citizens in their eyes, and there is very little desire to improve the experience of GNU software on them. The idea being that if they want things to work well, they should use GNU/Linux instead.

This is backwards, painfully stupid and wrong. If a user tries some of your software and it sucks, they’re going to stop using all of your software. Nobody is going to use crap software and think it’s a great idea to switch to a whole platform of it.

One of my gripes is that when I define abbrevs for a programming mode like python-mode, the abbrevs don’t get used when I use the REPL via run-python.

This is pretty straightforward to fix:

(eval-after-load 'python
  '(progn
     (derived-mode-merge-abbrev-tables python-mode-abbrev-table
                                       inferior-python-mode-abbrev-table)))

This tells Emacs to merge the python-mode abbrevs into the inferior-python-mode abbrev table. Now, when I fire up Python in Emacs, I have all my usual abbrevs. This may be inadvisable if you’re using abbrev to hook into auto-insert or to trigger behavior which expects a non-interactive environment, but it’s perfect when you just want to type “imp” instead of “import.”

I forked php-mode. I don’t have anything major planned, but I fixed the fontification of docblock comments.

I added PHPUnit support to test-case-mode. Consider phpunit-el deprecated.

There are a couple things missing vs. phpunit-el, some of which may need some changes to test-case-mode.

Multi-file search and replace is a perfect example of this kind of infrequently painful process. After messing around with for loops and sed in the shell, I finally sucked it up and got familiar with the Emacs way of doing it. It’s a great example of the synergy of Emacs tools, since it combines familiar features in a new way.

Search and replace in a single file

The facility for one-file S&R is called query-replace, and it’s bound to M-% (plain strings) and C-M-% (regexes) by default. As you’d expect, it prompts for search and replacement text, then replaces it in your buffer. When using regular expressions, you have the full power of them, with the ability to capture sub-expressions and use them in your replacement.

Directory editing

Dired is the Emacs file management package, and it’s quite powerful. You can invoke it with C-x d, or by pointing find-file (C-x C-f) at a directory.

Dired lets you mark files with m, or files matching a regular expression with % m. Pressing Q runs query-replace over the contents of those files.

Dired only shows files in one directory, so this doesn’t work if you want to replace in files which span directories.

Find with dired

This can be mostly solved with find-dired. As the name implies, it runs find, putting the results in a dired buffer. Once you have that, you can use Q to S&R in the matched files.

This is good if you need to replace a string in every file under a subdirectory, or in every file whose name matches a pattern. Where it fails is when you need to replace a string in files which contain that string.

Grep

Emacs has excellent integration with grep, in several flavors:

• grep. Basic grepping, with results placed in *grep*. The buffer shows filenames, line numbers, and the content from the file which matched.
• rgrep. My favorite, rgrep performs a recursive grep and filters out unwanted files, such as backups, stuff in .svn, etc.
• lgrep. Just like rgrep, but not recursive.
• find-grep. Getting close to what we want, find-grep runs grep on files located with find. And finally…
• find-grep-dired. Just like find-grep, but puts the results in a dired buffer instead.

As you’ve no doubt figured out, we’ll be using find-grep-dired for this task.

Putting it together

Now we have all the pieces, let’s put them together. As an example, let’s say that we renamed an exception and need to change the catch blocks in every .php file in package.

We start by running find-grep-dired:

M-x find-grep-dired RET catch (FooException RET

This gives us a buffer of files containing catch (FooException. It includes stuff in .svn; we only want .php files, so we can mark those:

% m .php$ RET

Now that they’re marked, run query-replace on them:

Q catch (FooException RET catch (BarException RET

At this point, Emacs will cycle through every match in every file and ask you to confirm the replacement. If you press !, it will replace the rest of the matches in the current file, and start prompting you for the next; Y will replace every match in every file with no further prompting. Then you’ll need to save the files:

C-x s

This saves every modified file at once, and we’re done.