tumme.el 0.4.3

[Mathias Dahl]

Version 0.4.1, 2005-05-05

 * Fixed bug in `tumme-flag-thumb-original-file'

 * Added commands to display original image in external viewer
   (`tumme-display-external') and in a Emacs buffer
   (`tumme-display-image').

 * Minor code clean-up

 * Renamed some functions back again...

 * Added rotation of thumbnail images (90 degrees left and right)

 Version 0.4.2, 2005-05-06

 * Removed need for `tumme-display-image-size' in
   `tumme-display-image'. Now, the maximum image size that fits in
   *tumme-display* is calculated automatically. Introduced two
   correction variables, `tumme-display-window-width-correction' and
   `tumme-display-window-height-correction' to be used to correct
   width and height depending on width and height of window
   decorations, fringes etc. This works really well!

 Version 0.4.3, 2005-05-07

 * Added menus to `dired-mode' and `tumme-mode'

 * Added `tumme-mark-and-display-next'

 * Added `tumme-jump-thumbnail-buffer'

 * Bound TAB in `dired-mode-map' and `tumme-mode-map' to
   `tumme-jump-thumbnail-buffer' and
   `tumme-jump-original-dired-buffer', respectively.

 * Changed `tumme-display-image' to be more general. Now, it can be
   used from both thumbnail buffer and dired buffer by calling
   `tumme-display-thumbnail-original-image' and
   `tumme-display-dired-image', respectively.

/Mathias

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

;; Copyright (C) 2005 Mathias Dahl

;; Version: 0.4.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 ImageMagick package

;;; Usage:

;; First, do M-x tumme-dired-folder RET. This will setup a useful
;; window configuration for you.
;;
;; Next, do M-x tumme-setup-dired-keybindings RET, which will set up
;; keybindings in dired mode that works quite well.
;;
;; Next, try `tumme-display-thumbs', bound to C-S-return. If no file
;; is marked, one thumbnail will show up in the *tumme* buffer. If one
;; or more files are marked, all of them will be displayed.
;;
;; Also try C-S-n and C-S-p to go up and down in the dired buffer
;; while at the same time displaying a thumbnail image.
;;
;; A better tutorial will come when tumme is more finished...
;;

;;; 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.

;; Version 0.4, 2005-05-02

;; * Renamed the functions that are to be used in `tumme-mode' in the
;;   thumbnail buffer.

;; * The mark, unmark and flag commands in `tumme-mode' now also moves
;;   to next thumbnail, like how dired normally works.

;; * Added `tumme-mode-line-up', `tumme-display-thumbs-append' and
;;   `tumme-mode-delete-char'.

;; * Each thumbnail's tags is now displayed when navigating among the
;;   thumbnails in the thumbnail buffer.

;; * Added simple slideshow functionality.

;; Version 0.4.1, 2005-05-05

;; * Fixed bug in `tumme-flag-thumb-original-file'

;; * Added commands to display original image in external viewer
;;   (`tumme-display-external') and in a Emacs buffer
;;   (`tumme-display-image').

;; * Minor code clean-up

;; * Renamed some functions back again...

;; * Added rotation of thumbnail images (90 degrees left and right)

;; Version 0.4.2, 2005-05-06

;; * Removed need for `tumme-display-image-size' in
;;   `tumme-display-image'. Now, the maximum image size that fits in
;;   *tumme-display* is calculated automatically. Introduced two
;;   correction variables, `tumme-display-window-width-correction' and
;;   `tumme-display-window-height-correction' to be used to correct
;;   width and height depending on width and height of window
;;   decorations, fringes etc. This works really well!

;; Version 0.4.3, 2005-05-07

;; * Added menus to `dired-mode' and `tumme-mode'

;; * Added `tumme-mark-and-display-next'

;; * Added `tumme-jump-thumbnail-buffer'

;; * Bound TAB in `dired-mode-map' and `tumme-mode-map' to
;;   `tumme-jump-thumbnail-buffer' and
;;   `tumme-jump-original-dired-buffer', respectively.

;; * Changed `tumme-display-image' to be more general. Now, it can be
;;   used from both thumbnail buffer and dired buffer by calling
;;   `tumme-display-thumbnail-original-image' and
;;   `tumme-display-dired-image', respectively.

;;; 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.
;;
;; - 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.
;;
;; - Lossless rotate of JPEG files using JpegTRAN
;;
;; - Support other formats than JPEG
;;

;;; 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/.tumme_db"
  "*Database file where file names and their associated tags are stored."
  :type 'string
  :group 'tumme)

(defcustom tumme-temp-image-file "~/.tumme/.tumme_temp"
  "*Name of temporary image file use by
`tumme-display-in-image-buffer'"
  :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-display-window-width-correction 17
  "*Number to be used to correct window width calculation. This value
depends on window decorations and other variable GUI components. You
have to experiment to see which value fits your setup."
  :type 'integer
  :group 'tumme)

(defcustom tumme-display-window-height-correction 30
  "*Number to be used to correct window height calculation. This value
depends on window decorations and other variable GUI components. You
have to experiment to see which value fits your setup."
  :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)

(defcustom tumme-external-viewer "qiv -t"
  "*Name of external viewer, including parameters, to use when
displaying original image from `tumme-mode'"
  :type 'string
  :group 'tumme)

(defun tumme-ins-img (file original-file-name
                           associated-dired-buffer)
  "Insert thumbnail image."
  (let ((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 'tumme-thumbnail t
           'original-file-name original-file-name
           'associated-dired-buffer associated-dired-buffer
           'tags (tumme-list-tags original-file-name)))))

(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-mark-and-display-next ()
  "Mark current file, move to next dired line and display thumbnail
image"
  (interactive)
  (dired-mark 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 windows in most useful (?) way
 - Set truncate-lines to t
"
  (interactive)
  (let ((buf (tumme-create-thumb-buffer))
        (buf2 (get-buffer-create "*tumme-display*")))
    (call-interactively 'dired)
    (split-window-horizontally)
    (setq truncate-lines t)
    (save-excursion
      (other-window 1)
      (switch-to-buffer buf)
      (split-window-vertically)
      (other-window 1)
      (switch-to-buffer buf2)
      (other-window -2))))

(defun tumme-display-thumbs (&optional arg append)
  "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 beg)
    (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)
      (if (not append)
          (progn
            (erase-buffer)
            (setq count 0))
        (goto-char (point-max))
        (beginning-of-line)
        (setq beg (point))
        (end-of-line)
        (setq
         count
         (length (buffer-substring-no-properties beg (point)))))
      (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 curr-file
                        dired-buf)
         (end-of-line)
         (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."
  (save-excursion
    (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-list-tags (file)
  "Internal function that reads all tags for image file FILE from the
image database."
  (save-excursion
    (let (end buf (tags ""))
      (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 (search-forward ";") end t)
            (setq tags (buffer-substring (point) end))))
      (kill-buffer buf)
      (split-string tags ";"))))

(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-original-file-name ()
  (get-text-property (point) 'original-file-name))

(defun tumme-associated-dired-buffer ()
  (get-text-property (point) 'associated-dired-buffer))

(defun tumme-track-original-file ()
  "Track the original file in the associated dired buffer. See
documentation for `tumme-track-movement-in-dired'. Interactive use
only useful if `tumme-track-movement' is off."
  (interactive)
  (let ((old-buf (current-buffer))
        (dired-buf (tumme-associated-dired-buffer))
        (file-name (tumme-original-file-name)))
    (if (and dired-buf file-name)
        (progn
          (setq file-name (file-name-nondirectory file-name))
          (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 `tumme-track-movement' - 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 (looking-at "\n")
      (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 (looking-at "\n")
      (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"
  (if (not (eobp))
      (let ((file-name (tumme-original-file-name))
            (dired-buf (tumme-associated-dired-buffer))
            (props  (get-text-property (point) 'tags)))
        (if file-name
            (message
             "%s %s"
             (file-name-nondirectory
              file-name) (or props "(no tags)"))))))

(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 ((file-name (tumme-original-file-name))
        (dired-buf (tumme-associated-dired-buffer)))
    (if (not (and dired-buf file-name))
        (message "No image, or image with correct properties, at point.")
      (save-excursion
        (message file-name)
        (setq file-name (file-name-nondirectory file-name))
        (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)
  (tumme-forward-char))

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

(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)
  (tumme-forward-char))

(defun tumme-jump-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)
  (switch-to-buffer-other-window
   (tumme-associated-dired-buffer)))

(defun tumme-jump-thumbnail-buffer ()
  "Jump to thumbnail buffer"
  (interactive)
  (switch-to-buffer-other-window "*tumme*"))

(defvar tumme-mode-map (make-sparse-keymap)
  "Keymap for `tumme-mode'")

(defun tumme-define-keymap ()

  ;; Keys
  (define-key tumme-mode-map [right] 'tumme-forward-char)
  (define-key tumme-mode-map [left] 'tumme-backward-char)
  (define-key tumme-mode-map [up] 'tumme-previous-line)
  (define-key tumme-mode-map [down] 'tumme-next-line)
  (define-key tumme-mode-map "\C-f" 'tumme-forward-char)
  (define-key tumme-mode-map "\C-b" 'tumme-backward-char)
  (define-key tumme-mode-map "\C-p" 'tumme-previous-line)
  (define-key tumme-mode-map "\C-n" 'tumme-next-line)

  (define-key tumme-mode-map "d" 'tumme-flag-thumb-original-file)
  (define-key tumme-mode-map [delete] 'tumme-flag-thumb-original-file)
  (define-key tumme-mode-map "m" 'tumme-mark-thumb-original-file)
  (define-key tumme-mode-map "u" 'tumme-unmark-thumb-original-file)
  (define-key tumme-mode-map "." 'tumme-track-original-file)
  (define-key tumme-mode-map [tab] 'tumme-jump-original-dired-buffer)
  (define-key tumme-mode-map "g" 'tumme-line-up)
  (define-key tumme-mode-map "\C-m" 'tumme-display-thumbnail-original-image)
  (define-key tumme-mode-map [C-return] 'tumme-display-external)
  (define-key tumme-mode-map "l" 'tumme-rotate-thumbnail-left)
  (define-key tumme-mode-map "r" 'tumme-rotate-thumbnail-right)
  (define-key tumme-mode-map "\C-d" 'tumme-delete-char)

  ;; Menu
  (define-key tumme-mode-map [menu-bar tumme]
    (cons "Tumme" (make-sparse-keymap "Tumme")))

  (define-key tumme-mode-map [menu-bar tumme tumme-delete-char]
    '("Delete thumbnail from buffer" . tumme-delete-char))

  (define-key tumme-mode-map [menu-bar tumme tumme-refresh-thumb]
    '("Refresh thumb" . tumme-refresh-thumb))
  (define-key tumme-mode-map [menu-bar tumme tumme-line-up]
    '("Line up thumbnails" . tumme-line-up))

  (define-key tumme-mode-map [menu-bar tumme tumme-rotate-thumbnail-left]
    '("Rotate thumbnail left" . tumme-rotate-thumbnail-left))
  (define-key tumme-mode-map [menu-bar tumme tumme-rotate-thumbnail-right]
    '("Rotate thumbnail right" . tumme-rotate-thumbnail-right))

  (define-key tumme-mode-map [menu-bar tumme tumme-track-movement-in-dired]
    '("Toggle movement tracking on/off" . tumme-track-movement-in-dired))

  (define-key tumme-mode-map [menu-bar tumme tumme-jump-original-dired-buffer]
    '("Jump to dired buffer" . tumme-jump-original-dired-buffer))
  (define-key tumme-mode-map [menu-bar tumme tumme-track-original-file]
    '("Track original" . tumme-track-original-file))

  (define-key tumme-mode-map [menu-bar tumme tumme-flag-thumb-original-file]
    '("Flag original for deletion" . tumme-flag-thumb-original-file))
  (define-key tumme-mode-map [menu-bar tumme tumme-unmark-thumb-original-file]
    '("Unmark original" . tumme-unmark-thumb-original-file))
  (define-key tumme-mode-map [menu-bar tumme tumme-mark-thumb-original-file]
    '("Mark original" . tumme-mark-thumb-original-file))

  (define-key tumme-mode-map [menu-bar tumme tumme-display-external]
    '("Display in external viewer" . tumme-display-external))
  (define-key tumme-mode-map [menu-bar tumme 
        tumme-display-thumbnail-original-image]
    '("Display image" . tumme-display-thumbnail-original-image)))

(define-derived-mode tumme-mode
  fundamental-mode "tumme"
  "Browse and manipulate thumbnail images using dired. Use
`tumme-dired-folder' and `tumme-setup-dired-keybindings' to get a nice
setup to start with."
  (tumme-define-keymap)
  (message "tumme-mode enabled"))

(defun tumme-setup-dired-keybindings ()
  "Setup easy-to-use keybindings for the commands to be used in dired
mode."
  (interactive)

  (require 'dired)

  (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-m") 'tumme-mark-and-display-next)
  (define-key dired-mode-map (kbd "C-S-<return>") 'tumme-display-thumbs)
  (define-key dired-mode-map (kbd "C-S-t") 'tumme-tag-files)
  (define-key dired-mode-map (kbd "<tab>") 'tumme-jump-thumbnail-buffer)
  (define-key dired-mode-map (kbd "C-S-d") 'tumme-display-dired-image)
  (define-key dired-mode-map (kbd "C-S-a") 'tumme-display-thumbs-append)
  (define-key dired-mode-map (kbd "C-:") 'tumme-display-thumb)

  ;; Menu for dired
  (define-key dired-mode-map [menu-bar tumme]
    (cons "Tumme" (make-sparse-keymap "Tumme")))

  (define-key dired-mode-map [menu-bar tumme tumme-tag-files]
    '("Tag files" . tumme-tag-files))

  (define-key dired-mode-map [menu-bar tumme tumme-jump-thumbnail-buffer]
    '("Jump to thumbnail buffer" . tumme-jump-thumbnail-buffer))

  (define-key dired-mode-map [menu-bar tumme tumme-display-dired-image]
    '("Display image" . tumme-display-dired-image))
  (define-key dired-mode-map [menu-bar tumme tumme-display-thumb]
    '("Display this thumbnail" . tumme-display-thumb))
  (define-key dired-mode-map [menu-bar tumme tumme-display-thumbs-append]
    '("Display thumbnails append" . tumme-display-thumbs-append))
  (define-key dired-mode-map [menu-bar tumme tumme-display-thumbs]
    '("Display thumbnails" . tumme-display-thumbs))

  (define-key dired-mode-map [menu-bar tumme tumme-mark-and-display-next]
    '("Mark and display next" . tumme-mark-and-display-next))

  (define-key dired-mode-map [menu-bar tumme tumme-previous-line-and-display]
    '("Display thumb for previous file" . tumme-previous-line-and-display))
  (define-key dired-mode-map [menu-bar tumme tumme-next-line-and-display]
    '("Display thumb for next file" . tumme-next-line-and-display)))

(defun tumme-create-thumbs (&optional arg)
  "Create thumbnail images for all marked files in dired. With prefix
arg, create thumbnails even if they already exist."
  (interactive "P")
  (let (curr-file thumb-name files count)
    (setq files (dired-get-marked-files))
    (mapcar
     (lambda (curr-file)
       (setq thumb-name (tumme-thumb-name curr-file))
       ;; If the user overrides the exist check, we must clear the
       ;; image cache so that if the user wants to display the
       ;; thumnail, it is not fetched from cache.
       (if arg
           (clear-image-cache))
       (if (or (not (file-exists-p thumb-name))
               arg)
           (if (not (= 0 (tumme-create-thumb curr-file)))
               (error "Thumb could not be created"))))
     files)))

(defvar tumme-slideshow-timer nil
  "Slideshow timer")

(defvar tumme-slideshow-count 0
  "Counter to keep track on how many pictures that have been displayed
during this slideshow")

(defvar tumme-slideshow-times 0
  "Number of pictures to display in slideshow")

(defun tumme-slideshow-step ()
  "Step to next file, if `tumme-slideshow-times' has not been
reached."
  (if (< tumme-slideshow-count tumme-slideshow-times)
      (progn
        (message "%s" (1+ tumme-slideshow-count))
        (setq tumme-slideshow-count (1+ tumme-slideshow-count))
        (tumme-next-line-and-display))
    (tumme-slideshow-stop)))

(defun tumme-slideshow-start ()
  "Start slideshow. Ask user for number of images to show and the
delay in between."
  (interactive)
  (setq tumme-slideshow-count 0)
  (setq tumme-slideshow-times (string-to-int (read-string "How many: ")))
  (let ((repeat (string-to-number
                 (read-string
                  "Delay, in seconds. Decimals are accepted : " "1"))))
    (setq tumme-slideshow-timer
          (run-with-timer
           0 repeat
           'tumme-slideshow-step))))

(defun tumme-slideshow-stop ()
  "Cancel slideshow"
  (interactive)
  (cancel-timer tumme-slideshow-timer))

(defun tumme-delete-char ()
  "Remove current thumbnail from thumbnail buffer and try to be
smart."
  (interactive)
  (setq inhibit-read-only t)
  (delete-char 1)
  (if (and (looking-at "$")
           (not (eobp)))
      (delete-char 1))
  (if (eobp)
      (tumme-backward-char))
  (setq inhibit-read-only nil))

(defun tumme-display-thumbs-append ()
  "Like `tumme-display-thumbs', but append instead of replace
thumbnails."
  (interactive)
  (tumme-display-thumbs nil t))

(defun tumme-display-thumb ()
  "Shorthard for `tumme-display-thumbs' with prefix argument"
  (interactive)
  (tumme-display-thumbs t))

(defun tumme-line-up ()
  "Line up thumbnails according to `tumme-thumbs-per-row'"
  (interactive)
  (setq inhibit-read-only t)
  (goto-char (point-min))
  (while (search-forward "\n" nil t)
    (replace-match ""))
  (goto-char (point-min))
  (let ((count 0))
    (while (not (eobp))
      (forward-char)
      (setq count (1+ count))
      (if (= count tumme-thumbs-per-row)
          (progn
            (insert "\n")
            (setq count 0)))))
  (goto-char (point-min))
  (setq inhibit-read-only nil))

(defun tumme-display-external ()
  "Display original image for thumbnail at point using external
viewer"
  (interactive)
  (let ((file (tumme-original-file-name)))
    (if (not (tumme-image-at-point-p))
        (message "No thumbnail at point")
      (if (not file)
          (message "No original file name found")
        (shell-command (format "%s %s"
                               tumme-external-viewer
                               (tumme-original-file-name)))))))

(defun tumme-window-width-pixels (window)
  "Calculate window width in pixels."
  (let ((column-pixel-width-ratio 
        (/ (float (frame-pixel-width)) (frame-width))))
    (truncate (* (window-width window) column-pixel-width-ratio))))

(defun tumme-window-height-pixels (window)
  "Calculate window height in pixels."
  (let ((line-pixel-height-ratio 
        (/ (float (frame-pixel-height)) (frame-height))))
    (truncate (* (window-height window) line-pixel-height-ratio))))

(defun tumme-display-window ()
  "Return window where *tumme-display* is visible"
  (get-window-with-predicate
   (lambda (window)
     (equal (buffer-name (window-buffer window)) "*tumme-display*"))))

(defun tumme-display-window-width ()
  "Return width, in pixels, of tumme's image display window"
  (- (tumme-window-width-pixels (tumme-display-window))
     tumme-display-window-width-correction))

(defun tumme-display-window-height ()
  "Return height, in pixels, of tumme's image display window"
  (- (tumme-window-height-pixels (tumme-display-window))
     tumme-display-window-height-correction))

(defun tumme-display-image (file)
  "Display image in image buffer. Use this when you want to display
the image, semi sized, in a window next to the thumbnail window -
typically a three-window configuration with dired to the left,
thumbnail window to the upper right and image window to the lower
right. The image is sized to fit the display window (using a temporary
file, don't worry). Because of this, it will not be as quick as
opening it directly, but on most modern systems it should feel snappy
enough."
  (let ((size-x (tumme-display-window-width))
        (size-y (tumme-display-window-height))
        command)
    (save-excursion
      (set-buffer "*tumme-display*")
      (erase-buffer)
      (setq command
            (format
             "convert -size %sx%s %s -resize %sx%s +profile \"*\" %s"
             size-x size-y
             file
             size-x size-y
             tumme-temp-image-file))
      (shell-command command nil)
      (insert-image-file tumme-temp-image-file))))

(defun tumme-display-thumbnail-original-image ()
  "Display current thumbnail's original image. See documentation for
`tumme-display-image' for more information."
  (interactive)
  (let ((file (tumme-original-file-name)))
    (if (not (string-equal major-mode "tumme-mode"))
        (message "Not in tumme-mode")
      (if (not (tumme-image-at-point-p))
          (message "No thumbnail at point")
        (if (not file)
            (message "No original file name found")
          (tumme-display-image file))))))

(defun tumme-display-dired-image ()
  "Display current image file. See documentation for
`tumme-display-image' for more information."
  (interactive)
  (tumme-display-image (dired-get-filename)))

(defun tumme-image-at-point-p ()
  "Return true if there is a tumme thumbnail at point"
  (get-text-property (point) 'tumme-thumbnail))

(defun tumme-rotate-thumbnail (degrees)
  "Rotate thumbnail DEGREES degrees"
  (if (not (tumme-image-at-point-p))
      (message "No thumbnail at point")
    (let ((file (tumme-thumb-name (tumme-original-file-name)))
          command)
      (setq command (format "mogrify -rotate %s %s" degrees file))
      (shell-command command nil)
      ;; Clear the cache to refresh image. I wish I could just refresh
      ;; the current file but I do not know how to do that. Yet...
      (clear-image-cache))))

(defun tumme-rotate-thumbnail-left ()
  "Rotate thumbnail left (counter clockwise) 90 degrees"
  (interactive)
  (tumme-rotate-thumbnail "-90"))

(defun tumme-rotate-thumbnail-right ()
  "Rotate thumbnail counter right (clockwise) 90 degrees"
  (interactive)
  (tumme-rotate-thumbnail "90"))

(defun tumme-refresh-thumb ()
  "Force creation of new image for current thumbnail"
  (interactive)
  (clear-image-cache)
  (tumme-create-thumb (tumme-original-file-name)))

(provide 'tumme)

;;; tumme.el ends here