tumme.el 0.3

[Mathias Dahl]

Quite many changes, see history below:

;;; tumme.el --- use dired to browse your images as thumbnails

;; Copyright (C) 2005 Mathias Dahl

;; Version: 0.3
;; Keywords: images, thumbnails, dired
;; Author: Mathias Dahl <address@hidden>
;; Maintainer: Mathias Dahl
;; URL: http://www.emacswiki.org/cgi-bin/wiki/Tumme

;; This file is not part of GNU Emacs.

;; This is free software; you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;;
;; This is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
;; License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;;  About the name: tumme means thumb in Swedish. Google did not give
;; me any hits for "tumme.el" so I thought it would be safe to use.
;;
;;  I needed a program to browse, organize and tag my pictures. I
;; got tired of the old gallery program I used as it did not allow
;; multi-file operations easily. Also, it put things out of my
;; control. Programs that did allow multi-file operations did not do
;; what I wanted it to.
;;
;;  So, I got the idea to use the wonderful functionality of emacs and
;; `dired' to do it. It would allow me to do almost anything I wanted,
;; which is basically just to browse all my pictures in an easy way,
;; letting me manipulate and tag them in various ways. `dired' already
;; provide all the file handling and navigation facilities; I only
;; needed to add some functions to display the images.
;;
;;  I briefly tried out thumbs.el, and although it seemed more
;; powerful than this package, it did not work the way I wanted to. It
;; was too slow to created thumbnails of all files in a directory (I
;; currently keep all my 2000+ images in the same directory) and
;; browsing the thumbnail buffer was slow too. tumme.el will not
;; create thumbnails until they are needed and the browsing is done
;; quickly and easily in dired. I copied a great deal of ideas and
;; code from there though... :)
;;
;;  `tumme' stores the thumbnail files in `tumme-dir' using the file
;; name format ORIGNAME.thumb.ORIGEXT. For example
;; ~/.tumme/myimage01.thumb.jpg and the "database" is for now just a
;; plain text file with the following format:
;;
;; file-name-non-directory;tag1;tag2;tag3;...;tagn
;;

;;; Feedback

;; Feedback is welcome.

;;; Prerequisites:

;; * The convert program from the ImageMagick package

;;; Usage:

;; First, do M-x tumme-dired-folder RET. This will setup a useful
;; window- and buffer-configuration for you.
;;
;; Next, do M-x tumme-setup-dired-keybindings RET, which will set up
;; keybindings in dired mode that works quite well.

;;; History:

;; Version 0.1, 2005-04-16

;; * First release, only browsing support for now.

;; Version 0.2, 2005-04-21

;; * Changed calls to dired-filename-at-point to dired-get-filename

;; Version 0.3, 2005-04-25

;;   Quite a lot of changes:

;; * Added basic image tagging support. No commands that make use of
;;   it yet.

;; * Added text properties for the thumbnail images to be able to
;;   track where they came from originally. Used in `tumme-mode'.

;; * Added `tumme-mode' to be used when navigating the thumbnail
;;   buffer.  Currently, there are commands to mark, unmark, flag and
;;   jump to the original file in associated dired buffer.

;; * When moving around in the thumbnail buffer (in `tumme-mode'), the
;;   user can turn on tracking of the movements and let them be
;;   mirrored in the associated dired buffer.

;; * In this version I have been looking at some ideas in thumbs.el,
;;   for example the image margin and relief and the `thumbs-mode'
;;   which I copied and made the `tumme-mode' from.

;;; Bugs:

;; I'm not sure if I really consider this a bug, but in order to work
;; well, `tumme' require that all your images have unique names. The
;; reason is the way thumbnail file names are generated. I will
;; probably not fix this problem as my images all have unique names.

;;; Todo:

;; - Commands to open the images in full size, either in an emacs
;; buffer or external program, or both.
;;
;; - Find some way of toggling on and off really nice keybindings (for
;; example, using C-n or <down> instead of C-S-n) to the interactive
;; functions.
;;
;; - Functionality to display the various tags.
;;
;; - Command to refresh thumbnail images. For now, you have to delete
;; the old files manually.
;;
;; - Commands to create simple HTML-albums, where the images will be
;; browsable per tag, date file name etc.
;;
;; - Some sort of EXIF support using an external EXIF tool.
;;
;; - Rewrite `tumme-modify-mark-on-thumb-original-file' to be less
;; ugly and more stable.
;;
;; - In some way keep track of buffers and windows and stuff so that
;; it works as the user expects.
;;
;; - Functionality to use tags for marking files in dired buffer.
;;
;; - Fix other ugly things.
;;

;;; Code:

(defgroup tumme nil
  "Use dired to browse your images as thumbnails"
  :prefix "tumme-"
  :group 'files)

(defcustom tumme-dir "~/.tumme/"
  "*Directory where thumbnail images for are stored."
  :type 'string
  :group 'tumme)

(defcustom tumme-db-file "~/.tumme_db"
  "*Database file where file names and their associated tags are stored."
  :type 'string
  :group 'tumme)

(defcustom tumme-tags-file "~/.tumme_tags"
  "*Database file where the tags are stored."
  :type 'string
  :group 'tumme)

(defcustom tumme-file-name-display-format "\n%s"
  "*Format used to display the file name to the right of the
picture. `%s' is the file name. If you want extra space between each
thumbnail, add extra newlines at the end of the format. If you want to
have the file name next to the thumbnail, use no newline at all."
  :type 'string
  :group 'tumme)

(defcustom tumme-thumb-size 100
  "Size of thumbnails, in pixels"
  :type 'integer
  :group 'tumme)

(defcustom tumme-thumb-relief 2
  "*Size of button-like border around thumbnails."
  :type 'integer
  :group 'tumme)

(defcustom tumme-thumb-margin 2
  "*Size of the margin around thumbnails.
This is where you see the cursor."
  :type 'integer
  :group 'tumme)

(defcustom tumme-thumbs-per-row 3
  "*Number of thumbnails to display per row in thumb buffer."
  :type 'integer
  :group 'tumme)

(defcustom tumme-track-movement nil
  "The current state of the tracking and mirroring. For more
information, see the documentation for
`tumme-track-movement-in-dired'"
  :type 'boolean
  :group 'tumme)

(defun tumme-ins-img (file original-file-base-name 
                           associated-dired-buffer)
  "Insert thumbnail image."
  (let (beg end
            (i `(image :type ,'jpeg
                       :file ,file
                       :relief ,tumme-thumb-relief
                       :margin ,tumme-thumb-margin)))
    (setq beg (point))
    (insert-image i)
    (setq end (point))
    (add-text-properties
     beg end
     (list 'original-file-base-name original-file-base-name
           'associated-dired-buffer associated-dired-buffer))))

(defun tumme-thumb-name (file)
  "Return thumbnail file name for FILE"
  (format "%s%s.thumb.%s"
          (expand-file-name tumme-dir)
          (file-name-sans-extension (file-name-nondirectory file))
          (file-name-extension file)))

(defun tumme-create-thumb (file)
  "Using the convert program, create thumbnail image for FILE and
place it in `tumme-dir'"
  (let* ((size (int-to-string tumme-thumb-size))
         (command
          (format
           "convert -size %sx%s %s -resize %sx%s +profile \"*\" %s"
           size
           size
           file
           size
           size
           (tumme-thumb-name file))))
    (if (file-exists-p tumme-dir)
        (if (not (file-directory-p tumme-dir))
            (error "%s exists but is not a directory!" tumme-dir))
      (make-directory tumme-dir))
    (shell-command command nil)))

(defun tumme-next-line-and-display ()
  "Move to next dired line and display thumbnail image"
  (interactive)
  (dired-next-line 1)
  (tumme-display-thumbs t))

(defun tumme-previous-line-and-display ()
  "Move to previous dired line and display thumbnail image"
  (interactive)
  (dired-previous-line 1)
  (tumme-display-thumbs t))

(defun tumme-create-thumb-buffer ()
  "Create thumb buffer and set `tumme-mode'"
  (let ((buf (get-buffer-create "*tumme*")))
    (save-excursion
      (set-buffer buf)
      (setq buffer-read-only t)
      (if (not (eq major-mode 'tumme-mode))
          (tumme-mode)))
    buf))

(defun tumme-dired-folder ()
  "Convenience command that:

 - Opens dired in folder specified by the user
 - Splits the window horizontally
 - Set truncate-lines to t
"
  (interactive)
  (let ((buf (tumme-create-thumb-buffer)))
    (call-interactively 'dired)
    (split-window-horizontally)
    (setq truncate-lines t)
    (save-excursion
      (other-window 1)
      (switch-to-buffer buf)
      (other-window -1))))

(defun tumme-display-thumbs (&optional arg no-file-name)
  "Display thumbnail images of all marked files in buffer *tumme*. If
a thumbnail image does not exist for a file, it is created on the
fly. With prefix arg, display only thumbnail for file at point (this
is useful if you have marked some files but want to show another
one).

Recommended usage is to split the current frame horizontally so that
you have the dired buffer in the left window and the *tumme* buffer in
the right window.
"
  (interactive "P")
  (let ((buf (tumme-create-thumb-buffer))
        curr-file thumb-name files count dired-buf)
    (if arg
        (setq files (list (dired-get-filename)))
      (setq files (dired-get-marked-files)))
    (setq dired-buf (current-buffer))
    (save-excursion
      (set-buffer buf)
      (setq inhibit-read-only t)
      (erase-buffer)
      (setq count 0)
      (mapcar
       (lambda (curr-file)
         (setq thumb-name (tumme-thumb-name curr-file))
         (if (not (file-exists-p thumb-name))
             (if (not (= 0 (tumme-create-thumb curr-file)))
                 (error "Thumb could not be created")))
         (tumme-ins-img thumb-name (file-name-nondirectory curr-file) 
                        dired-buf)
         (end-of-line)
         (if (= tumme-thumbs-per-row 1)
             (insert (format tumme-file-name-display-format
                             (file-name-nondirectory curr-file))))
         (goto-char (point-max))
         (setq count (1+ count))
         (if (= count tumme-thumbs-per-row)
             (progn
               (insert "\n")
               (setq count 0))))
       files)
      (setq inhibit-read-only nil))))

(defun tumme-write-tag (file tag)
  "Internal function that write tag TAG for image file FILE to the
image database."
  (let (end buf)
    (setq buf (find-file tumme-db-file))
    (goto-char (point-min))
    (if (search-forward-regexp
         (format "^%s"
                 (file-name-nondirectory file))
         nil t)
        (progn
          (end-of-line)
          (setq end (point))
          (beginning-of-line)
          (if (not (search-forward (format ";%s" tag) end t))
              (progn
                (end-of-line)
                (insert (format ";%s" tag)))))
      (goto-char (point-max))
      (insert (format "\n%s;%s" (file-name-nondirectory file) tag)))
    (save-buffer)
    (kill-buffer buf)))

(defun tumme-tag-files (arg)
  "Simple tag functionality. Whatever you enter as tag will be added,
if it does not exist, to the image database."
  (interactive "P")
  (let ((tag (read-string "Tag: "))
        curr-file files)
    (if arg
        (setq files (list (dired-get-filename)))
      (setq files (dired-get-marked-files)))
    (mapcar
     (lambda (curr-file)
       (tumme-write-tag curr-file tag))
     files)))

(defun tumme-track-original-file ()
  "Track the original file in the associated dired buffer. See
documentation for `tumme-track-movement-in-dired'"
  (interactive)
  (let ((old-buf (current-buffer))
        (dired-buf (get-text-property (point) 'associated-dired-buffer))
        (file-name (get-text-property (point) 'original-file-base-name)))
    (if (and dired-buf file-name)
        (progn
          (switch-to-buffer-other-window dired-buf)
          (goto-char (point-min))
          (if (not (search-forward file-name nil t))
              (message "Could not track file")
            (dired-move-to-filename))
          (switch-to-buffer-other-window old-buf)))))

(defun tumme-track-movement-in-dired ()
  "Turn on and off tracking of the movements in the thumbnail buffer
so that they are \"mirrored\" in the associated dired buffer. When
this is on, moving around in the thumbnail buffer will find the
original file in the associated dired buffer (where the
image-insertion was done from) and place the cursor on the correct
file."
  (interactive)
  (setq tumme-track-movement (not tumme-track-movement))
  (message "Tracking %s" (if tumme-track-movement
                             "on"
                           "off")))

(defun tumme-forward-char ()
  "Move to next image and display properties"
  (interactive)
  (forward-char)
  (if tumme-track-movement
      (tumme-track-original-file))
  (tumme-display-thumb-properties))

(defun tumme-backward-char ()
  "Move to previous image and display properties"
  (interactive)
  (backward-char)
  (if tumme-track-movement
      (tumme-track-original-file))
  (tumme-display-thumb-properties))

(defun tumme-next-line ()
  "Move to next line and display properties"
  (interactive)
  (next-line 1)
  (if tumme-track-movement
      (tumme-track-original-file))
  (tumme-display-thumb-properties))

(defun tumme-previous-line ()
  "Move to previous line and display properties"
  (interactive)
  (previous-line 1)
  (if tumme-track-movement
      (tumme-track-original-file))
  (tumme-display-thumb-properties))

(defun tumme-display-thumb-properties ()
  "Display thumbnail properties in the echo area"
  (let ((file-name (get-text-property (point) 'original-file-base-name))
        (dired-buf (get-text-property (point) 'associated-dired-buffer)))
    (if (and file-name dired-buf)
        (message "%s: %s" dired-buf file-name))))

(defun tumme-modify-mark-on-thumb-original-file (command)
  "This is quite ugly but I don't know how to implemented in a better
way."
  (let ((dired-buf (get-text-property (point) 'associated-dired-buffer))
        (file-name (get-text-property (point) 'original-file-base-name)))
    (if (not (and dired-buf file-name))
        (message "No image, or image with correct properties, at point.")
      (save-excursion
        (set-buffer dired-buf)
        (goto-char (point-min))
        (if (search-forward file-name nil t)
            (cond ((eq command 'mark) (dired-mark 1))
                  ((eq command 'unmark) (dired-unmark 1))
                  ((eq command 'flag) (dired-flag-file-deletion 1))))))))

(defun tumme-mark-thumb-original-file ()
  "Mark original image file in associated dired buffer"
  (interactive)
  (tumme-modify-mark-on-thumb-original-file 'mark))

(defun tumme-unmark-thumb-original-file ()
  "Unmark original image file in associated dired buffer"
  (interactive)
  (tumme-modify-mark-on-thumb-original-file 'unmark))

(defun tumme-flag-thumb-original-file ()
  "Flag original image file for deletion in associated dired buffer"
  (interactive)
  (tumme-modify-mark-on-thumb-original-file 'flag))

(defun tumme-jump-thumb-original-dired-buffer ()
  "Jump to the dired buffer associated with the current image
file. You probably want to use this together with
`tumme-track-original-file'"
  (interactive)
  (let ((dired-buf (get-text-property (point) 'associated-dired-buffer)))
        (switch-to-buffer-other-window dired-buf)))

(defvar tumme-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map [right] 'tumme-forward-char)
    (define-key map [left] 'tumme-backward-char)
    (define-key map [up] 'tumme-previous-line)
    (define-key map [down] 'tumme-next-line)
    (define-key map "\C-f" 'tumme-forward-char)
    (define-key map "\C-b" 'tumme-backward-char)
    (define-key map "\C-p" 'tumme-previous-line)
    (define-key map "\C-n" 'tumme-next-line)
    (define-key map "d" 'tumme-flag-thumb-original-file)
    (define-key map "m" 'tumme-mark-thumb-original-file)
    (define-key map "u" 'tumme-unmark-thumb-original-file)
    (define-key map "." 'tumme-track-original-file)
    (define-key map "j" 'tumme-jump-thumb-original-dired-buffer)
    map)
  "Keymap for `tumme-mode'.")

(define-derived-mode tumme-mode
  fundamental-mode "tumme"
  "Browse and manipulate thumbnail images using dired")

(defun tumme-setup-dired-keybindings ()
  "Setup easy-to-use keybindings for the commands to be used in dired
mode."
  (interactive)
  (define-key dired-mode-map (kbd "C-S-n") 'tumme-next-line-and-display)
  (define-key dired-mode-map (kbd "C-S-p") 'tumme-previous-line-and-display)
  (define-key dired-mode-map (kbd "C-S-<return>") 'tumme-display-thumbs)
  (define-key dired-mode-map (kbd "C-S-t") 'tumme-tag-files))

(provide 'tumme)

;;; tumme.el ends here