lisp/image-mode.el

   1 ;;; image-mode.el --- support for visiting image files
   2 ;;
   3 ;; Copyright (C) 2005-2011 Free Software Foundation, Inc.
   4 ;;
   5 ;; Author: Richard Stallman <rms@gnu.org>
   6 ;; Keywords: multimedia
   7 ;; Package: emacs
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; Defines a major mode for visiting image files
  27 ;; that allows conversion between viewing the text of the file
  28 ;; and viewing the file as an image.  Viewing the image
  29 ;; works by putting a `display' text-property on the
  30 ;; image data, with the image-data still present underneath; if the
  31 ;; resulting buffer file is saved to another name it will correctly save
  32 ;; the image data to the new file.
  33
  34 ;;; Code:
  35
  36 (require 'image)
  37 (eval-when-compile (require 'cl))
  38
  39 ;;; Image mode window-info management.
  40
  41 (defvar image-mode-winprops-alist t)
  42 (make-variable-buffer-local 'image-mode-winprops-alist)
  43
  44 (defvar image-mode-new-window-functions nil
  45   "Special hook run when image data is requested in a new window.
  46 It is called with one argument, the initial WINPROPS.")
  47
  48 (defun image-mode-winprops (&optional window cleanup)
  49   "Return winprops of WINDOW.
  50 A winprops object has the shape (WINDOW . ALIST)."
  51   (cond ((null window)
  52          (setq window (selected-window)))
  53         ((not (windowp window))
  54          (error "Not a window: %s" window)))
  55   (when cleanup
  56     (setq image-mode-winprops-alist
  57           (delq nil (mapcar (lambda (winprop)
  58                               (if (window-live-p (car-safe winprop))
  59                                   winprop))
  60                             image-mode-winprops-alist))))
  61   (let ((winprops (assq window image-mode-winprops-alist)))
  62     ;; For new windows, set defaults from the latest.
  63     (unless winprops
  64       (setq winprops (cons window
  65                            (copy-alist (cdar image-mode-winprops-alist))))
  66       (run-hook-with-args 'image-mode-new-window-functions winprops))
  67     ;; Move window to front.
  68     (setq image-mode-winprops-alist
  69           (cons winprops (delq winprops image-mode-winprops-alist)))
  70     winprops))
  71
  72 (defun image-mode-window-get (prop &optional winprops)
  73   (unless (consp winprops) (setq winprops (image-mode-winprops winprops)))
  74   (cdr (assq prop (cdr winprops))))
  75
  76 (defsetf image-mode-window-get (prop &optional winprops) (val)
  77   `(image-mode-window-put ,prop ,val ,winprops))
  78
  79 (defun image-mode-window-put (prop val &optional winprops)
  80   (unless (consp winprops) (setq winprops (image-mode-winprops winprops)))
  81   (setcdr winprops (cons (cons prop val)
  82                          (delq (assq prop (cdr winprops)) (cdr winprops)))))
  83
  84 (defun image-set-window-vscroll (vscroll)
  85   (setf (image-mode-window-get 'vscroll) vscroll)
  86   (set-window-vscroll (selected-window) vscroll))
  87
  88 (defun image-set-window-hscroll (ncol)
  89   (setf (image-mode-window-get 'hscroll) ncol)
  90   (set-window-hscroll (selected-window) ncol))
  91
  92 (defun image-mode-reapply-winprops ()
  93   ;; When set-window-buffer, set hscroll and vscroll to what they were
  94   ;; last time the image was displayed in this window.
  95   (when (and (image-get-display-property)
  96              (listp image-mode-winprops-alist))
  97     (let* ((winprops (image-mode-winprops nil t))
  98            (hscroll (image-mode-window-get 'hscroll winprops))
  99            (vscroll (image-mode-window-get 'vscroll winprops)))
 100       (if hscroll (set-window-hscroll (selected-window) hscroll))
 101       (if vscroll (set-window-vscroll (selected-window) vscroll)))))
 102
 103 (defun image-mode-setup-winprops ()
 104   ;; Record current scroll settings.
 105   (unless (listp image-mode-winprops-alist)
 106     (setq image-mode-winprops-alist nil))
 107   (add-hook 'window-configuration-change-hook
 108             'image-mode-reapply-winprops nil t))
 109
 110 ;;; Image scrolling functions
 111
 112 (defun image-get-display-property ()
 113   (get-char-property (point-min) 'display
 114                      ;; There might be different images for different displays.
 115                      (if (eq (window-buffer) (current-buffer))
 116                          (selected-window))))
 117
 118 (declare-function image-size "image.c" (spec &optional pixels frame))
 119
 120 (defun image-display-size (spec &optional pixels frame)
 121   "Wrapper around `image-size', handling slice display properties.
 122 Like `image-size', the return value is (WIDTH . HEIGHT).
 123 WIDTH and HEIGHT are in canonical character units if PIXELS is
 124 nil, and in pixel units if PIXELS is non-nil.
 125
 126 If SPEC is an image display property, this function is equivalent
 127 to `image-size'.  If SPEC is a list of properties containing
 128 `image' and `slice' properties, return the display size taking
 129 the slice property into account.  If the list contains `image'
 130 but not `slice', return the `image-size' of the specified image."
 131   (if (eq (car spec) 'image)
 132       (image-size spec pixels frame)
 133     (let ((image (assoc 'image spec))
 134           (slice (assoc 'slice spec)))
 135       (cond ((and image slice)
 136              (if pixels
 137                  (cons (nth 3 slice) (nth 4 slice))
 138                (cons (/ (float (nth 3 slice)) (frame-char-width frame))
 139                      (/ (float (nth 4 slice)) (frame-char-height frame)))))
 140             (image
 141              (image-size image pixels frame))
 142             (t
 143              (error "Invalid image specification: %s" spec))))))
 144
 145 (defun image-forward-hscroll (&optional n)
 146   "Scroll image in current window to the left by N character widths.
 147 Stop if the right edge of the image is reached."
 148   (interactive "p")
 149   (cond ((= n 0) nil)
 150         ((< n 0)
 151          (image-set-window-hscroll (max 0 (+ (window-hscroll) n))))
 152         (t
 153          (let* ((image (image-get-display-property))
 154                 (edges (window-inside-edges))
 155                 (win-width (- (nth 2 edges) (nth 0 edges)))
 156                 (img-width (ceiling (car (image-display-size image)))))
 157            (image-set-window-hscroll (min (max 0 (- img-width win-width))
 158                                           (+ n (window-hscroll))))))))
 159
 160 (defun image-backward-hscroll (&optional n)
 161   "Scroll image in current window to the right by N character widths.
 162 Stop if the left edge of the image is reached."
 163   (interactive "p")
 164   (image-forward-hscroll (- n)))
 165
 166 (defun image-next-line (n)
 167   "Scroll image in current window upward by N lines.
 168 Stop if the bottom edge of the image is reached."
 169   (interactive "p")
 170   (cond ((= n 0) nil)
 171         ((< n 0)
 172          (image-set-window-vscroll (max 0 (+ (window-vscroll) n))))
 173         (t
 174          (let* ((image (image-get-display-property))
 175                 (edges (window-inside-edges))
 176                 (win-height (- (nth 3 edges) (nth 1 edges)))
 177                 (img-height (ceiling (cdr (image-display-size image)))))
 178            (image-set-window-vscroll (min (max 0 (- img-height win-height))
 179                                           (+ n (window-vscroll))))))))
 180
 181 (defun image-previous-line (&optional n)
 182   "Scroll image in current window downward by N lines.
 183 Stop if the top edge of the image is reached."
 184   (interactive "p")
 185   (image-next-line (- n)))
 186
 187 (defun image-scroll-up (&optional n)
 188   "Scroll image in current window upward by N lines.
 189 Stop if the bottom edge of the image is reached.
 190 If ARG is omitted or nil, scroll upward by a near full screen.
 191 A near full screen is `next-screen-context-lines' less than a full screen.
 192 Negative ARG means scroll downward.
 193 If ARG is the atom `-', scroll downward by nearly full screen.
 194 When calling from a program, supply as argument a number, nil, or `-'."
 195   (interactive "P")
 196   (cond ((null n)
 197          (let* ((edges (window-inside-edges))
 198                 (win-height (- (nth 3 edges) (nth 1 edges))))
 199            (image-next-line
 200             (max 0 (- win-height next-screen-context-lines)))))
 201         ((eq n '-)
 202          (let* ((edges (window-inside-edges))
 203                 (win-height (- (nth 3 edges) (nth 1 edges))))
 204            (image-next-line
 205             (min 0 (- next-screen-context-lines win-height)))))
 206         (t (image-next-line (prefix-numeric-value n)))))
 207
 208 (defun image-scroll-down (&optional n)
 209   "Scroll image in current window downward by N lines.
 210 Stop if the top edge of the image is reached.
 211 If ARG is omitted or nil, scroll downward by a near full screen.
 212 A near full screen is `next-screen-context-lines' less than a full screen.
 213 Negative ARG means scroll upward.
 214 If ARG is the atom `-', scroll upward by nearly full screen.
 215 When calling from a program, supply as argument a number, nil, or `-'."
 216   (interactive "P")
 217   (cond ((null n)
 218          (let* ((edges (window-inside-edges))
 219                 (win-height (- (nth 3 edges) (nth 1 edges))))
 220            (image-next-line
 221             (min 0 (- next-screen-context-lines win-height)))))
 222         ((eq n '-)
 223          (let* ((edges (window-inside-edges))
 224                 (win-height (- (nth 3 edges) (nth 1 edges))))
 225            (image-next-line
 226             (max 0 (- win-height next-screen-context-lines)))))
 227         (t (image-next-line (- (prefix-numeric-value n))))))
 228
 229 (defun image-bol (arg)
 230   "Scroll horizontally to the left edge of the image in the current window.
 231 With argument ARG not nil or 1, move forward ARG - 1 lines first,
 232 stopping if the top or bottom edge of the image is reached."
 233   (interactive "p")
 234   (and arg
 235        (/= (setq arg (prefix-numeric-value arg)) 1)
 236        (image-next-line (- arg 1)))
 237   (image-set-window-hscroll 0))
 238
 239 (defun image-eol (arg)
 240   "Scroll horizontally to the right edge of the image in the current window.
 241 With argument ARG not nil or 1, move forward ARG - 1 lines first,
 242 stopping if the top or bottom edge of the image is reached."
 243   (interactive "p")
 244   (and arg
 245        (/= (setq arg (prefix-numeric-value arg)) 1)
 246        (image-next-line (- arg 1)))
 247   (let* ((image (image-get-display-property))
 248          (edges (window-inside-edges))
 249          (win-width (- (nth 2 edges) (nth 0 edges)))
 250          (img-width (ceiling (car (image-display-size image)))))
 251     (image-set-window-hscroll (max 0 (- img-width win-width)))))
 252
 253 (defun image-bob ()
 254   "Scroll to the top-left corner of the image in the current window."
 255   (interactive)
 256   (image-set-window-hscroll 0)
 257   (image-set-window-vscroll 0))
 258
 259 (defun image-eob ()
 260   "Scroll to the bottom-right corner of the image in the current window."
 261   (interactive)
 262   (let* ((image (image-get-display-property))
 263          (edges (window-inside-edges))
 264          (win-width (- (nth 2 edges) (nth 0 edges)))
 265          (img-width (ceiling (car (image-display-size image))))
 266          (win-height (- (nth 3 edges) (nth 1 edges)))
 267          (img-height (ceiling (cdr (image-display-size image)))))
 268     (image-set-window-hscroll (max 0 (- img-width win-width)))
 269     (image-set-window-vscroll (max 0 (- img-height win-height)))))
 270
 271 ;; Adjust frame and image size.
 272
 273 (defun image-mode-fit-frame ()
 274   "Toggle whether to fit the frame to the current image.
 275 This function assumes the current frame has only one window."
 276   ;; FIXME: This does not take into account decorations like mode-line,
 277   ;; minibuffer, header-line, ...
 278   (interactive)
 279   (let* ((saved (frame-parameter nil 'image-mode-saved-size))
 280          (display (image-get-display-property))
 281          (size (image-display-size display)))
 282     (if (and saved
 283              (eq (caar saved) (frame-width))
 284              (eq (cdar saved) (frame-height)))
 285         (progn ;; Toggle back to previous non-fitted size.
 286           (set-frame-parameter nil 'image-mode-saved-size nil)
 287           (setq size (cdr saved)))
 288       ;; Round up size, and save current size so we can toggle back to it.
 289       (setcar size (ceiling (car size)))
 290       (setcdr size (ceiling (cdr size)))
 291       (set-frame-parameter nil 'image-mode-saved-size
 292                            (cons size (cons (frame-width) (frame-height)))))
 293     (set-frame-width  (selected-frame) (car size))
 294     (set-frame-height (selected-frame) (cdr size))))
 295
 296 ;;; Image Mode setup
 297
 298 (defvar image-type nil
 299   "The image type for the current Image mode buffer.")
 300 (make-variable-buffer-local 'image-type)
 301
 302 (defvar image-mode-previous-major-mode nil
 303   "Internal variable to keep the previous non-image major mode.")
 304
 305 (defvar image-mode-map
 306   (let ((map (make-sparse-keymap)))
 307     (set-keymap-parent map special-mode-map)
 308     (define-key map "\C-c\C-c" 'image-toggle-display)
 309     (define-key map (kbd "SPC")       'image-scroll-up)
 310     (define-key map (kbd "DEL")       'image-scroll-down)
 311     (define-key map (kbd "RET")       'image-toggle-animation)
 312     (define-key map [remap forward-char] 'image-forward-hscroll)
 313     (define-key map [remap backward-char] 'image-backward-hscroll)
 314     (define-key map [remap right-char] 'image-forward-hscroll)
 315     (define-key map [remap left-char] 'image-backward-hscroll)
 316     (define-key map [remap previous-line] 'image-previous-line)
 317     (define-key map [remap next-line] 'image-next-line)
 318     (define-key map [remap scroll-up] 'image-scroll-up)
 319     (define-key map [remap scroll-down] 'image-scroll-down)
 320     (define-key map [remap scroll-up-command] 'image-scroll-up)
 321     (define-key map [remap scroll-down-command] 'image-scroll-down)
 322     (define-key map [remap move-beginning-of-line] 'image-bol)
 323     (define-key map [remap move-end-of-line] 'image-eol)
 324     (define-key map [remap beginning-of-buffer] 'image-bob)
 325     (define-key map [remap end-of-buffer] 'image-eob)
 326     map)
 327   "Mode keymap for `image-mode'.")
 328
 329 (defvar image-minor-mode-map
 330   (let ((map (make-sparse-keymap)))
 331     (define-key map "\C-c\C-c" 'image-toggle-display)
 332     map)
 333   "Mode keymap for `image-minor-mode'.")
 334
 335 (defvar bookmark-make-record-function)
 336
 337 (put 'image-mode 'mode-class 'special)
 338
 339 ;;;###autoload
 340 (defun image-mode ()
 341   "Major mode for image files.
 342 You can use \\<image-mode-map>\\[image-toggle-display]
 343 to toggle between display as an image and display as text."
 344   (interactive)
 345   (condition-case err
 346       (progn
 347         (unless (display-images-p)
 348           (error "Display does not support images"))
 349
 350         (kill-all-local-variables)
 351         (setq major-mode 'image-mode)
 352
 353         (if (not (image-get-display-property))
 354             (progn
 355               (image-toggle-display-image)
 356               ;; If attempt to display the image fails.
 357               (if (not (image-get-display-property))
 358                   (error "Invalid image")))
 359           ;; Set next vars when image is already displayed but local
 360           ;; variables were cleared by kill-all-local-variables
 361           (setq cursor-type nil truncate-lines t
 362                 image-type (plist-get (cdr (image-get-display-property)) :type)))
 363
 364         (setq mode-name (if image-type (format "Image[%s]" image-type) "Image"))
 365         (use-local-map image-mode-map)
 366
 367         ;; Use our own bookmarking function for images.
 368         (set (make-local-variable 'bookmark-make-record-function)
 369              'image-bookmark-make-record)
 370
 371         ;; Keep track of [vh]scroll when switching buffers
 372         (image-mode-setup-winprops)
 373
 374         (add-hook 'change-major-mode-hook 'image-toggle-display-text nil t)
 375         (add-hook 'after-revert-hook 'image-after-revert-hook nil t)
 376         (run-mode-hooks 'image-mode-hook)
 377         (let ((image (image-get-display-property))
 378               (msg1 (substitute-command-keys
 379                      "Type \\[image-toggle-display] to view the image as ")))
 380           (cond
 381            ((null image)
 382             (message "%s" (concat msg1 "an image.")))
 383            ((image-animated-p image)
 384             (message "%s"
 385                      (concat msg1 "text, or "
 386                              (substitute-command-keys
 387                               "\\[image-toggle-animation] to animate."))))
 388            (t
 389             (message "%s" (concat msg1 "text."))))))
 390
 391     (error
 392      (image-mode-as-text)
 393      (funcall
 394       (if (called-interactively-p 'any) 'error 'message)
 395       "Cannot display image: %s" (cdr err)))))
 396
 397 ;;;###autoload
 398 (define-minor-mode image-minor-mode
 399   "Toggle Image minor mode.
 400 With arg, turn Image minor mode on if arg is positive, off otherwise.
 401 It provides the key \\<image-mode-map>\\[image-toggle-display] \
 402 to switch back to `image-mode'
 403 to display an image file as the actual image."
 404   nil (:eval (if image-type (format " Image[%s]" image-type) " Image"))
 405   image-minor-mode-map
 406   :group 'image
 407   :version "22.1"
 408   (if image-minor-mode
 409       (add-hook 'change-major-mode-hook (lambda () (image-minor-mode -1)) nil t)))
 410
 411 ;;;###autoload
 412 (defun image-mode-as-text ()
 413   "Set a non-image mode as major mode in combination with image minor mode.
 414 A non-image major mode found from `auto-mode-alist' or Fundamental mode
 415 displays an image file as text.  `image-minor-mode' provides the key
 416 \\<image-mode-map>\\[image-toggle-display] to switch back to `image-mode'
 417 to display an image file as the actual image.
 418
 419 You can use `image-mode-as-text' in `auto-mode-alist' when you want
 420 to display an image file as text initially.
 421
 422 See commands `image-mode' and `image-minor-mode' for more information
 423 on these modes."
 424   (interactive)
 425   ;; image-mode-as-text = normal-mode + image-minor-mode
 426   (let ((previous-image-type image-type)) ; preserve `image-type'
 427     (if image-mode-previous-major-mode
 428         ;; Restore previous major mode that was already found by this
 429         ;; function and cached in `image-mode-previous-major-mode'
 430         (funcall image-mode-previous-major-mode)
 431       (let ((auto-mode-alist
 432              (delq nil (mapcar
 433                         (lambda (elt)
 434                           (unless (memq (or (car-safe (cdr elt)) (cdr elt))
 435                                         '(image-mode image-mode-maybe image-mode-as-text))
 436                             elt))
 437                         auto-mode-alist)))
 438             (magic-fallback-mode-alist
 439              (delq nil (mapcar
 440                         (lambda (elt)
 441                           (unless (memq (or (car-safe (cdr elt)) (cdr elt))
 442                                         '(image-mode image-mode-maybe image-mode-as-text))
 443                             elt))
 444                         magic-fallback-mode-alist))))
 445         (normal-mode)
 446         (set (make-local-variable 'image-mode-previous-major-mode) major-mode)))
 447     ;; Restore `image-type' after `kill-all-local-variables' in `normal-mode'.
 448     (setq image-type previous-image-type)
 449     ;; Enable image minor mode with `C-c C-c'.
 450     (image-minor-mode 1)
 451     ;; Show the image file as text.
 452     (image-toggle-display-text)
 453     (message "%s" (concat
 454                    (substitute-command-keys
 455                     "Type \\[image-toggle-display] to view the image as ")
 456                    (if (image-get-display-property)
 457                        "text" "an image") "."))))
 458
 459 (define-obsolete-function-alias 'image-mode-maybe 'image-mode "23.2")
 460
 461 (defun image-toggle-display-text ()
 462   "Show the image file as text.
 463 Remove text properties that display the image."
 464   (let ((inhibit-read-only t)
 465         (buffer-undo-list t)
 466         (modified (buffer-modified-p)))
 467     (remove-list-of-text-properties (point-min) (point-max)
 468                                     '(display read-nonsticky ;; intangible
 469                                               read-only front-sticky))
 470     (set-buffer-modified-p modified)
 471     (if (called-interactively-p 'any)
 472         (message "Repeat this command to go back to displaying the image"))))
 473
 474 (defvar archive-superior-buffer)
 475 (defvar tar-superior-buffer)
 476 (declare-function image-flush "image.c" (spec &optional frame))
 477
 478 (defun image-toggle-display-image ()
 479   "Show the image of the image file.
 480 Turn the image data into a real image, but only if the whole file
 481 was inserted."
 482   (unless (derived-mode-p 'image-mode major-mode)
 483     (error "The buffer is not in Image mode"))
 484   (let* ((filename (buffer-file-name))
 485          (data-p (not (and filename
 486                            (file-readable-p filename)
 487                            (not (file-remote-p filename))
 488                            (not (buffer-modified-p))
 489                            (not (and (boundp 'archive-superior-buffer)
 490                                      archive-superior-buffer))
 491                            (not (and (boundp 'tar-superior-buffer)
 492                                      tar-superior-buffer)))))
 493          (file-or-data (if data-p
 494                            (string-make-unibyte
 495                             (buffer-substring-no-properties (point-min) (point-max)))
 496                          filename))
 497          (type (image-type file-or-data nil data-p))
 498          (image (create-image file-or-data type data-p))
 499          (inhibit-read-only t)
 500          (buffer-undo-list t)
 501          (modified (buffer-modified-p))
 502          props)
 503
 504     ;; Discard any stale image data before looking it up again.
 505     (image-flush image)
 506     (setq image (append image (image-transform-properties image)))
 507     (setq props
 508           `(display ,image
 509                     ;; intangible ,image
 510                     rear-nonsticky (display) ;; intangible
 511                     read-only t front-sticky (read-only)))
 512
 513     (let ((buffer-file-truename nil)) ; avoid changing dir mtime by lock_file
 514       (add-text-properties (point-min) (point-max) props)
 515       (restore-buffer-modified-p modified))
 516     ;; Inhibit the cursor when the buffer contains only an image,
 517     ;; because cursors look very strange on top of images.
 518     (setq cursor-type nil)
 519     ;; This just makes the arrow displayed in the right fringe
 520     ;; area look correct when the image is wider than the window.
 521     (setq truncate-lines t)
 522     ;; Disable adding a newline at the end of the image file when it
 523     ;; is written with, e.g., C-x C-w.
 524     (if (coding-system-equal (coding-system-base buffer-file-coding-system)
 525                              'no-conversion)
 526         (set (make-local-variable 'find-file-literally) t))
 527     ;; Allow navigation of large images
 528     (set (make-local-variable 'auto-hscroll-mode) nil)
 529     (setq image-type type)
 530     (if (eq major-mode 'image-mode)
 531         (setq mode-name (format "Image[%s]" type)))
 532     (if (called-interactively-p 'any)
 533         (message "Repeat this command to go back to displaying the file as text"))))
 534
 535 (defun image-toggle-display ()
 536   "Toggle between image and text display.
 537 If the current buffer is displaying an image file as an image,
 538 call `image-mode-as-text' to switch to text.  Otherwise, display
 539 the image by calling `image-mode'."
 540   (interactive)
 541   (if (image-get-display-property)
 542       (image-mode-as-text)
 543     (image-mode)))
 544
 545 (defun image-after-revert-hook ()
 546   (when (image-get-display-property)
 547     (image-toggle-display-text)
 548     ;; Update image display.
 549     (mapc (lambda (window) (redraw-frame (window-frame window)))
 550           (get-buffer-window-list (current-buffer) 'nomini 'visible))
 551     (image-toggle-display-image)))
 552
 553 \f
 554 ;;; Animated images
 555
 556 (defcustom image-animate-loop nil
 557   "Whether to play animated images on a loop in Image mode."
 558   :type 'boolean
 559   :version "24.1"
 560   :group 'image)
 561
 562 (defun image-toggle-animation ()
 563   "Start or stop animating the current image."
 564   (interactive)
 565   (let ((image (image-get-display-property))
 566         animation)
 567     (cond
 568      ((null image)
 569       (error "No image is present"))
 570      ((null (setq animation (image-animated-p image)))
 571       (message "No image animation."))
 572      (t
 573       (let ((timer (image-animate-timer image)))
 574         (if timer
 575             (cancel-timer timer)
 576           (let ((index (plist-get (cdr image) :index)))
 577             ;; If we're at the end, restart.
 578             (and index
 579                  (>= index (1- (car animation)))
 580                  (setq index nil))
 581             (image-animate image index
 582                            (if image-animate-loop t)))))))))
 583
 584 \f
 585 ;;; Support for bookmark.el
 586 (declare-function bookmark-make-record-default
 587                   "bookmark" (&optional no-file no-context posn))
 588 (declare-function bookmark-prop-get "bookmark" (bookmark prop))
 589 (declare-function bookmark-default-handler "bookmark" (bmk))
 590
 591 (defun image-bookmark-make-record ()
 592   `(,@(bookmark-make-record-default nil 'no-context 0)
 593       (image-type . ,image-type)
 594       (handler    . image-bookmark-jump)))
 595
 596 ;;;###autoload
 597 (defun image-bookmark-jump (bmk)
 598   ;; This implements the `handler' function interface for record type
 599   ;; returned by `bookmark-make-record-function', which see.
 600   (prog1 (bookmark-default-handler bmk)
 601     (when (not (string= image-type (bookmark-prop-get bmk 'image-type)))
 602       (image-toggle-display))))
 603 \f
 604
 605 (defvar image-transform-minor-mode-map
 606   (let ((map (make-sparse-keymap)))
 607     ;; (define-key map  [(control ?+)] 'image-scale-in)
 608     ;; (define-key map  [(control ?-)] 'image-scale-out)
 609     ;; (define-key map  [(control ?=)] 'image-scale-none)
 610     ;; (define-key map "c f h" 'image-scale-fit-height)
 611     ;; (define-key map "c ]" 'image-rotate-right)
 612     map)
 613   "Minor mode keymap `image-transform-mode'.")
 614
 615 (define-minor-mode image-transform-mode
 616   "Minor mode for scaling and rotating images.
 617 This minor mode has no effect unless Emacs is compiled with
 618 ImageMagick support."
 619   nil "image-transform" image-transform-minor-mode-map)
 620
 621 (defvar image-transform-resize nil
 622   "The image resize operation.
 623 Its value should be one of the following:
 624  - nil, meaning no resizing.
 625  - `fit-height', meaning to fit the image to the window height.
 626  - `fit-width', meaning to fit the image to the window width.
 627  - A number, which is a scale factor (the default size is 100).")
 628
 629 (defvar image-transform-rotation 0.0
 630   "Rotation angle for the image in the current Image mode buffer.")
 631
 632 (defun image-transform-properties (spec)
 633   "Return rescaling/rotation properties for image SPEC.
 634 These properties are determined by the Image mode variables
 635 `image-transform-resize' and `image-transform-rotation'.  The
 636 return value is suitable for appending to an image spec.
 637
 638 Recaling and rotation properties only take effect if Emacs is
 639 compiled with ImageMagick support."
 640   (when (or image-transform-resize
 641             (not (equal image-transform-rotation 0.0)))
 642     ;; Note: `image-size' looks up and thus caches the untransformed
 643     ;; image.  There's no easy way to prevent that.
 644     (let* ((size (image-size spec t))
 645            (height
 646             (cond
 647              ((numberp image-transform-resize)
 648               (unless (= image-transform-resize 100)
 649                 (* image-transform-resize (cdr size))))
 650              ((eq image-transform-resize 'fit-height)
 651               (- (nth 3 (window-inside-pixel-edges))
 652                  (nth 1 (window-inside-pixel-edges))))))
 653            (width (if (eq image-transform-resize 'fit-width)
 654                       (- (nth 2 (window-inside-pixel-edges))
 655                          (nth 0 (window-inside-pixel-edges))))))
 656       ;;TODO fit-to-* should consider the rotation angle
 657       `(,@(if height (list :height height))
 658         ,@(if width (list :width width))
 659         ,@(if (not (equal 0.0 image-transform-rotation))
 660               (list :rotation image-transform-rotation))))))
 661
 662 (defun image-transform-set-scale (scale)
 663   "Prompt for a number, and resize the current image by that amount.
 664 This command has no effect unless Emacs is compiled with
 665 ImageMagick support."
 666   (interactive "nScale: ")
 667   (setq image-transform-resize scale)
 668   (image-toggle-display-image))
 669
 670 (defun image-transform-fit-to-height ()
 671   "Fit the current image to the height of the current window.
 672 This command has no effect unless Emacs is compiled with
 673 ImageMagick support."
 674   (interactive)
 675   (setq image-transform-resize 'fit-height)
 676   (image-toggle-display-image))
 677
 678 (defun image-transform-fit-to-width ()
 679   "Fit the current image to the width of the current window.
 680 This command has no effect unless Emacs is compiled with
 681 ImageMagick support."
 682   (interactive)
 683   (setq image-transform-resize 'fit-width)
 684   (image-toggle-display-image))
 685
 686 (defun image-transform-set-rotation (rotation)
 687   "Prompt for an angle ROTATION, and rotate the image by that amount.
 688 ROTATION should be in degrees.  This command has no effect unless
 689 Emacs is compiled with ImageMagick support."
 690   (interactive "nRotation angle (in degrees): ")
 691   ;;TODO 0 90 180 270 degrees are the only reasonable angles here
 692   ;;otherwise combining with rescaling will get very awkward
 693   (setq image-transform-rotation (float rotation))
 694   (image-toggle-display-image))
 695
 696 (provide 'image-mode)
 697
 698 ;;; image-mode.el ends here