image-mode.el 32.2 KB
Newer Older
1
;;; image-mode.el --- support for visiting image files  -*- lexical-binding: t -*-
2
;;
3
;; Copyright (C) 2005-2012 Free Software Foundation, Inc.
4 5 6
;;
;; Author: Richard Stallman <rms@gnu.org>
;; Keywords: multimedia
7
;; Package: emacs
8 9 10

;; This file is part of GNU Emacs.

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 14
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
15 16 17 18 19 20 21

;; GNU Emacs 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
22
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
23 24 25 26 27 28 29 30 31 32 33

;;; Commentary:

;; Defines a major mode for visiting image files
;; that allows conversion between viewing the text of the file
;; and viewing the file as an image.  Viewing the image
;; works by putting a `display' text-property on the
;; image data, with the image-data still present underneath; if the
;; resulting buffer file is saved to another name it will correctly save
;; the image data to the new file.

34 35 36 37 38
;; Todo:

;; Consolidate with doc-view to make them work on directories of images or on
;; image files containing various "pages".

39 40 41
;;; Code:

(require 'image)
Stefan Monnier's avatar
Stefan Monnier committed
42
(eval-when-compile (require 'cl-lib))
43

44 45
;;; Image mode window-info management.

46
(defvar-local image-mode-winprops-alist t)
47 48 49 50 51

(defvar image-mode-new-window-functions nil
  "Special hook run when image data is requested in a new window.
It is called with one argument, the initial WINPROPS.")

52
(defun image-mode-winprops (&optional window cleanup)
53
  "Return winprops of WINDOW.
54 55 56
A winprops object has the shape (WINDOW . ALIST).
WINDOW defaults to `selected-window' if it displays the current buffer, and
otherwise it defaults to t, used for times when the buffer is not displayed."
57
  (cond ((null window)
58 59 60
         (setq window
               (if (eq (current-buffer) (window-buffer)) (selected-window) t)))
        ((eq window t))
61 62 63 64 65 66 67 68
	((not (windowp window))
	 (error "Not a window: %s" window)))
  (when cleanup
    (setq image-mode-winprops-alist
  	  (delq nil (mapcar (lambda (winprop)
  			      (if (window-live-p (car-safe winprop))
  				  winprop))
  			    image-mode-winprops-alist))))
69 70 71 72 73 74 75 76 77 78 79 80
  (let ((winprops (assq window image-mode-winprops-alist)))
    ;; For new windows, set defaults from the latest.
    (unless winprops
      (setq winprops (cons window
                           (copy-alist (cdar image-mode-winprops-alist))))
      (run-hook-with-args 'image-mode-new-window-functions winprops))
    ;; Move window to front.
    (setq image-mode-winprops-alist
          (cons winprops (delq winprops image-mode-winprops-alist)))
    winprops))

(defun image-mode-window-get (prop &optional winprops)
Stefan Monnier's avatar
Stefan Monnier committed
81 82
  (declare (gv-setter (lambda (val)
                        `(image-mode-window-put ,prop ,val ,winprops))))
83 84 85 86 87 88 89 90 91 92 93 94 95
  (unless (consp winprops) (setq winprops (image-mode-winprops winprops)))
  (cdr (assq prop (cdr winprops))))

(defun image-mode-window-put (prop val &optional winprops)
  (unless (consp winprops) (setq winprops (image-mode-winprops winprops)))
  (setcdr winprops (cons (cons prop val)
                         (delq (assq prop (cdr winprops)) (cdr winprops)))))

(defun image-set-window-vscroll (vscroll)
  (setf (image-mode-window-get 'vscroll) vscroll)
  (set-window-vscroll (selected-window) vscroll))

(defun image-set-window-hscroll (ncol)
96
  (setf (image-mode-window-get 'hscroll) ncol)
97 98 99
  (set-window-hscroll (selected-window) ncol))

(defun image-mode-reapply-winprops ()
100 101
  ;; When set-window-buffer, set hscroll and vscroll to what they were
  ;; last time the image was displayed in this window.
102 103 104
  (when (and (image-get-display-property)
	     (listp image-mode-winprops-alist))
    (let* ((winprops (image-mode-winprops nil t))
105 106
           (hscroll (image-mode-window-get 'hscroll winprops))
           (vscroll (image-mode-window-get 'vscroll winprops)))
107 108
      (if hscroll (set-window-hscroll (selected-window) hscroll))
      (if vscroll (set-window-vscroll (selected-window) vscroll)))))
109

110 111 112 113 114 115 116 117 118
(defun image-mode-setup-winprops ()
  ;; Record current scroll settings.
  (unless (listp image-mode-winprops-alist)
    (setq image-mode-winprops-alist nil))
  (add-hook 'window-configuration-change-hook
 	    'image-mode-reapply-winprops nil t))

;;; Image scrolling functions

119 120 121 122 123 124
(defun image-get-display-property ()
  (get-char-property (point-min) 'display
                     ;; There might be different images for different displays.
                     (if (eq (window-buffer) (current-buffer))
                         (selected-window))))

125 126
(declare-function image-size "image.c" (spec &optional pixels frame))

127
(defun image-display-size (spec &optional pixels frame)
128 129 130 131 132 133 134 135 136 137
  "Wrapper around `image-size', handling slice display properties.
Like `image-size', the return value is (WIDTH . HEIGHT).
WIDTH and HEIGHT are in canonical character units if PIXELS is
nil, and in pixel units if PIXELS is non-nil.

If SPEC is an image display property, this function is equivalent
to `image-size'.  If SPEC is a list of properties containing
`image' and `slice' properties, return the display size taking
the slice property into account.  If the list contains `image'
but not `slice', return the `image-size' of the specified image."
138 139 140 141 142 143 144 145 146 147 148 149 150 151
  (if (eq (car spec) 'image)
      (image-size spec pixels frame)
    (let ((image (assoc 'image spec))
	  (slice (assoc 'slice spec)))
      (cond ((and image slice)
	     (if pixels
		 (cons (nth 3 slice) (nth 4 slice))
	       (cons (/ (float (nth 3 slice)) (frame-char-width frame))
		     (/ (float (nth 4 slice)) (frame-char-height frame)))))
	    (image
	     (image-size image pixels frame))
	    (t
	     (error "Invalid image specification: %s" spec))))))

152 153 154 155 156 157
(defun image-forward-hscroll (&optional n)
  "Scroll image in current window to the left by N character widths.
Stop if the right edge of the image is reached."
  (interactive "p")
  (cond ((= n 0) nil)
	((< n 0)
158
	 (image-set-window-hscroll (max 0 (+ (window-hscroll) n))))
159
	(t
160
	 (let* ((image (image-get-display-property))
161 162
		(edges (window-inside-edges))
		(win-width (- (nth 2 edges) (nth 0 edges)))
163
		(img-width (ceiling (car (image-display-size image)))))
164
	   (image-set-window-hscroll (min (max 0 (- img-width win-width))
165
					  (+ n (window-hscroll))))))))
166 167 168 169 170 171 172

(defun image-backward-hscroll (&optional n)
  "Scroll image in current window to the right by N character widths.
Stop if the left edge of the image is reached."
  (interactive "p")
  (image-forward-hscroll (- n)))

173
(defun image-next-line (n)
174 175 176 177 178
  "Scroll image in current window upward by N lines.
Stop if the bottom edge of the image is reached."
  (interactive "p")
  (cond ((= n 0) nil)
	((< n 0)
179
	 (image-set-window-vscroll (max 0 (+ (window-vscroll) n))))
180
	(t
181
	 (let* ((image (image-get-display-property))
182 183
		(edges (window-inside-edges))
		(win-height (- (nth 3 edges) (nth 1 edges)))
184
		(img-height (ceiling (cdr (image-display-size image)))))
185
	   (image-set-window-vscroll (min (max 0 (- img-height win-height))
186
					  (+ n (window-vscroll))))))))
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

(defun image-previous-line (&optional n)
  "Scroll image in current window downward by N lines.
Stop if the top edge of the image is reached."
  (interactive "p")
  (image-next-line (- n)))

(defun image-scroll-up (&optional n)
  "Scroll image in current window upward by N lines.
Stop if the bottom edge of the image is reached.
If ARG is omitted or nil, scroll upward by a near full screen.
A near full screen is `next-screen-context-lines' less than a full screen.
Negative ARG means scroll downward.
If ARG is the atom `-', scroll downward by nearly full screen.
When calling from a program, supply as argument a number, nil, or `-'."
  (interactive "P")
  (cond ((null n)
	 (let* ((edges (window-inside-edges))
		(win-height (- (nth 3 edges) (nth 1 edges))))
	   (image-next-line
	    (max 0 (- win-height next-screen-context-lines)))))
	((eq n '-)
	 (let* ((edges (window-inside-edges))
		(win-height (- (nth 3 edges) (nth 1 edges))))
	   (image-next-line
	    (min 0 (- next-screen-context-lines win-height)))))
	(t (image-next-line (prefix-numeric-value n)))))

(defun image-scroll-down (&optional n)
216
  "Scroll image in current window downward by N lines.
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
Stop if the top edge of the image is reached.
If ARG is omitted or nil, scroll downward by a near full screen.
A near full screen is `next-screen-context-lines' less than a full screen.
Negative ARG means scroll upward.
If ARG is the atom `-', scroll upward by nearly full screen.
When calling from a program, supply as argument a number, nil, or `-'."
  (interactive "P")
  (cond ((null n)
	 (let* ((edges (window-inside-edges))
		(win-height (- (nth 3 edges) (nth 1 edges))))
	   (image-next-line
	    (min 0 (- next-screen-context-lines win-height)))))
	((eq n '-)
	 (let* ((edges (window-inside-edges))
		(win-height (- (nth 3 edges) (nth 1 edges))))
	   (image-next-line
	    (max 0 (- win-height next-screen-context-lines)))))
	(t (image-next-line (- (prefix-numeric-value n))))))

(defun image-bol (arg)
  "Scroll horizontally to the left edge of the image in the current window.
With argument ARG not nil or 1, move forward ARG - 1 lines first,
stopping if the top or bottom edge of the image is reached."
  (interactive "p")
  (and arg
       (/= (setq arg (prefix-numeric-value arg)) 1)
       (image-next-line (- arg 1)))
244
  (image-set-window-hscroll 0))
245 246 247 248 249 250 251 252 253

(defun image-eol (arg)
  "Scroll horizontally to the right edge of the image in the current window.
With argument ARG not nil or 1, move forward ARG - 1 lines first,
stopping if the top or bottom edge of the image is reached."
  (interactive "p")
  (and arg
       (/= (setq arg (prefix-numeric-value arg)) 1)
       (image-next-line (- arg 1)))
254
  (let* ((image (image-get-display-property))
255 256
	 (edges (window-inside-edges))
	 (win-width (- (nth 2 edges) (nth 0 edges)))
257
	 (img-width (ceiling (car (image-display-size image)))))
258
    (image-set-window-hscroll (max 0 (- img-width win-width)))))
259 260 261 262

(defun image-bob ()
  "Scroll to the top-left corner of the image in the current window."
  (interactive)
263 264
  (image-set-window-hscroll 0)
  (image-set-window-vscroll 0))
265 266 267 268

(defun image-eob ()
  "Scroll to the bottom-right corner of the image in the current window."
  (interactive)
269
  (let* ((image (image-get-display-property))
270 271
	 (edges (window-inside-edges))
	 (win-width (- (nth 2 edges) (nth 0 edges)))
272
	 (img-width (ceiling (car (image-display-size image))))
273
	 (win-height (- (nth 3 edges) (nth 1 edges)))
274
	 (img-height (ceiling (cdr (image-display-size image)))))
275 276
    (image-set-window-hscroll (max 0 (- img-width win-width)))
    (image-set-window-vscroll (max 0 (- img-height win-height)))))
277

278 279 280
;; Adjust frame and image size.

(defun image-mode-fit-frame ()
281
  "Toggle whether to fit the frame to the current image.
282 283 284 285 286 287
This function assumes the current frame has only one window."
  ;; FIXME: This does not take into account decorations like mode-line,
  ;; minibuffer, header-line, ...
  (interactive)
  (let* ((saved (frame-parameter nil 'image-mode-saved-size))
         (display (image-get-display-property))
288
         (size (image-display-size display)))
289 290 291 292 293 294 295 296 297 298 299 300 301 302
    (if (and saved
             (eq (caar saved) (frame-width))
             (eq (cdar saved) (frame-height)))
        (progn ;; Toggle back to previous non-fitted size.
          (set-frame-parameter nil 'image-mode-saved-size nil)
          (setq size (cdr saved)))
      ;; Round up size, and save current size so we can toggle back to it.
      (setcar size (ceiling (car size)))
      (setcdr size (ceiling (cdr size)))
      (set-frame-parameter nil 'image-mode-saved-size
                           (cons size (cons (frame-width) (frame-height)))))
    (set-frame-width  (selected-frame) (car size))
    (set-frame-height (selected-frame) (cdr size))))

303 304
;;; Image Mode setup

Juri Linkov's avatar
Juri Linkov committed
305
(defvar image-type nil
306
  "The image type for the current Image mode buffer.")
Juri Linkov's avatar
Juri Linkov committed
307 308
(make-variable-buffer-local 'image-type)

309 310 311
(defvar image-mode-previous-major-mode nil
  "Internal variable to keep the previous non-image major mode.")

312
(defvar image-mode-map
313
  (let ((map (make-sparse-keymap)))
314
    (set-keymap-parent map special-mode-map)
315
    (define-key map "\C-c\C-c" 'image-toggle-display)
316 317
    (define-key map (kbd "SPC")       'image-scroll-up)
    (define-key map (kbd "DEL")       'image-scroll-down)
318
    (define-key map (kbd "RET")       'image-toggle-animation)
319 320
    (define-key map [remap forward-char] 'image-forward-hscroll)
    (define-key map [remap backward-char] 'image-backward-hscroll)
321 322
    (define-key map [remap right-char] 'image-forward-hscroll)
    (define-key map [remap left-char] 'image-backward-hscroll)
323 324 325 326
    (define-key map [remap previous-line] 'image-previous-line)
    (define-key map [remap next-line] 'image-next-line)
    (define-key map [remap scroll-up] 'image-scroll-up)
    (define-key map [remap scroll-down] 'image-scroll-down)
327 328
    (define-key map [remap scroll-up-command] 'image-scroll-up)
    (define-key map [remap scroll-down-command] 'image-scroll-down)
329 330 331 332 333
    (define-key map [remap move-beginning-of-line] 'image-bol)
    (define-key map [remap move-end-of-line] 'image-eol)
    (define-key map [remap beginning-of-buffer] 'image-bob)
    (define-key map [remap end-of-buffer] 'image-eob)
    map)
334
  "Mode keymap for `image-mode'.")
335

336
(defvar image-minor-mode-map
337 338 339
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-c\C-c" 'image-toggle-display)
    map)
340
  "Mode keymap for `image-minor-mode'.")
341

342
(defvar bookmark-make-record-function)
Glenn Morris's avatar
Glenn Morris committed
343

Juri Linkov's avatar
Juri Linkov committed
344 345
(put 'image-mode 'mode-class 'special)

346 347 348 349 350 351
;;;###autoload
(defun image-mode ()
  "Major mode for image files.
You can use \\<image-mode-map>\\[image-toggle-display]
to toggle between display as an image and display as text."
  (interactive)
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
  (condition-case err
      (progn
	(unless (display-images-p)
	  (error "Display does not support images"))

	(kill-all-local-variables)
	(setq major-mode 'image-mode)

	(if (not (image-get-display-property))
	    (progn
	      (image-toggle-display-image)
	      ;; If attempt to display the image fails.
	      (if (not (image-get-display-property))
		  (error "Invalid image")))
	  ;; Set next vars when image is already displayed but local
	  ;; variables were cleared by kill-all-local-variables
	  (setq cursor-type nil truncate-lines t
		image-type (plist-get (cdr (image-get-display-property)) :type)))

	(setq mode-name (if image-type (format "Image[%s]" image-type) "Image"))
372
	(use-local-map image-mode-map)
373 374 375 376 377 378 379 380 381

	;; Use our own bookmarking function for images.
	(set (make-local-variable 'bookmark-make-record-function)
	     'image-bookmark-make-record)

	;; Keep track of [vh]scroll when switching buffers
	(image-mode-setup-winprops)

	(add-hook 'change-major-mode-hook 'image-toggle-display-text nil t)
382
	(add-hook 'after-revert-hook 'image-after-revert-hook nil t)
383
	(run-mode-hooks 'image-mode-hook)
384 385 386 387 388 389 390 391 392 393 394 395 396 397
	(let ((image (image-get-display-property))
	      (msg1 (substitute-command-keys
		     "Type \\[image-toggle-display] to view the image as ")))
	  (cond
	   ((null image)
	    (message "%s" (concat msg1 "an image.")))
	   ((image-animated-p image)
	    (message "%s"
		     (concat msg1 "text, or "
			     (substitute-command-keys
			      "\\[image-toggle-animation] to animate."))))
	   (t
	    (message "%s" (concat msg1 "text."))))))

398 399 400 401 402
    (error
     (image-mode-as-text)
     (funcall
      (if (called-interactively-p 'any) 'error 'message)
      "Cannot display image: %s" (cdr err)))))
403

404 405
;;;###autoload
(define-minor-mode image-minor-mode
406 407 408 409 410 411 412 413
  "Toggle Image minor mode in this buffer.
With a prefix argument ARG, enable Image minor mode if ARG is
positive, and disable it otherwise.  If called from Lisp, enable
the mode if ARG is omitted or nil.

Image minor mode provides the key \\<image-mode-map>\\[image-toggle-display],
to switch back to `image-mode' and display an image file as the
actual image."
414 415
  nil (:eval (if image-type (format " Image[%s]" image-type) " Image"))
  image-minor-mode-map
416 417
  :group 'image
  :version "22.1"
418 419
  (if image-minor-mode
      (add-hook 'change-major-mode-hook (lambda () (image-minor-mode -1)) nil t)))
420 421

;;;###autoload
422 423 424 425 426 427 428 429
(defun image-mode-as-text ()
  "Set a non-image mode as major mode in combination with image minor mode.
A non-image major mode found from `auto-mode-alist' or Fundamental mode
displays an image file as text.  `image-minor-mode' provides the key
\\<image-mode-map>\\[image-toggle-display] to switch back to `image-mode'
to display an image file as the actual image.

You can use `image-mode-as-text' in `auto-mode-alist' when you want
Juri Linkov's avatar
Juri Linkov committed
430
to display an image file as text initially.
431 432 433

See commands `image-mode' and `image-minor-mode' for more information
on these modes."
434
  (interactive)
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
  ;; image-mode-as-text = normal-mode + image-minor-mode
  (let ((previous-image-type image-type)) ; preserve `image-type'
    (if image-mode-previous-major-mode
	;; Restore previous major mode that was already found by this
	;; function and cached in `image-mode-previous-major-mode'
	(funcall image-mode-previous-major-mode)
      (let ((auto-mode-alist
	     (delq nil (mapcar
			(lambda (elt)
			  (unless (memq (or (car-safe (cdr elt)) (cdr elt))
					'(image-mode image-mode-maybe image-mode-as-text))
			    elt))
			auto-mode-alist)))
	    (magic-fallback-mode-alist
	     (delq nil (mapcar
			(lambda (elt)
			  (unless (memq (or (car-safe (cdr elt)) (cdr elt))
					'(image-mode image-mode-maybe image-mode-as-text))
			    elt))
			magic-fallback-mode-alist))))
	(normal-mode)
	(set (make-local-variable 'image-mode-previous-major-mode) major-mode)))
    ;; Restore `image-type' after `kill-all-local-variables' in `normal-mode'.
    (setq image-type previous-image-type)
    ;; Enable image minor mode with `C-c C-c'.
    (image-minor-mode 1)
    ;; Show the image file as text.
    (image-toggle-display-text)
    (message "%s" (concat
		   (substitute-command-keys
		    "Type \\[image-toggle-display] to view the image as ")
		   (if (image-get-display-property)
		       "text" "an image") "."))))

(define-obsolete-function-alias 'image-mode-maybe 'image-mode "23.2")
470 471

(defun image-toggle-display-text ()
472 473 474 475 476 477
  "Show the image file as text.
Remove text properties that display the image."
  (let ((inhibit-read-only t)
	(buffer-undo-list t)
	(modified (buffer-modified-p)))
    (remove-list-of-text-properties (point-min) (point-max)
478
				    '(display read-nonsticky ;; intangible
479 480 481 482
					      read-only front-sticky))
    (set-buffer-modified-p modified)
    (if (called-interactively-p 'any)
	(message "Repeat this command to go back to displaying the image"))))
483

484 485
(defvar archive-superior-buffer)
(defvar tar-superior-buffer)
486
(declare-function image-flush "image.c" (spec &optional frame))
487

488 489 490 491
(defun image-toggle-display-image ()
  "Show the image of the image file.
Turn the image data into a real image, but only if the whole file
was inserted."
492
  (unless (derived-mode-p 'image-mode)
493
    (error "The buffer is not in Image mode"))
494 495 496 497 498 499 500 501 502 503 504 505 506 507
  (let* ((filename (buffer-file-name))
	 (data-p (not (and filename
			   (file-readable-p filename)
			   (not (file-remote-p filename))
			   (not (buffer-modified-p))
			   (not (and (boundp 'archive-superior-buffer)
				     archive-superior-buffer))
			   (not (and (boundp 'tar-superior-buffer)
				     tar-superior-buffer)))))
	 (file-or-data (if data-p
			   (string-make-unibyte
			    (buffer-substring-no-properties (point-min) (point-max)))
			 filename))
	 (type (image-type file-or-data nil data-p))
Chong Yidong's avatar
Chong Yidong committed
508 509 510 511 512 513
	 (image (create-image file-or-data type data-p))
	 (inhibit-read-only t)
	 (buffer-undo-list t)
	 (modified (buffer-modified-p))
	 props)

514 515
    ;; Discard any stale image data before looking it up again.
    (image-flush image)
Chong Yidong's avatar
Chong Yidong committed
516 517
    (setq image (append image (image-transform-properties image)))
    (setq props
518
	  `(display ,image
519 520
		    ;; intangible ,image
		    rear-nonsticky (display) ;; intangible
521
		    read-only t front-sticky (read-only)))
Chong Yidong's avatar
Chong Yidong committed
522

523 524 525 526 527 528 529 530 531
    (let ((buffer-file-truename nil)) ; avoid changing dir mtime by lock_file
      (add-text-properties (point-min) (point-max) props)
      (restore-buffer-modified-p modified))
    ;; Inhibit the cursor when the buffer contains only an image,
    ;; because cursors look very strange on top of images.
    (setq cursor-type nil)
    ;; This just makes the arrow displayed in the right fringe
    ;; area look correct when the image is wider than the window.
    (setq truncate-lines t)
532 533 534 535 536
    ;; Disable adding a newline at the end of the image file when it
    ;; is written with, e.g., C-x C-w.
    (if (coding-system-equal (coding-system-base buffer-file-coding-system)
			     'no-conversion)
	(set (make-local-variable 'find-file-literally) t))
537 538 539 540 541
    ;; Allow navigation of large images
    (set (make-local-variable 'auto-hscroll-mode) nil)
    (setq image-type type)
    (if (eq major-mode 'image-mode)
	(setq mode-name (format "Image[%s]" type)))
542
    (image-transform-check-size)
543 544 545
    (if (called-interactively-p 'any)
	(message "Repeat this command to go back to displaying the file as text"))))

546
(defun image-toggle-display ()
547 548 549 550
  "Toggle between image and text display.
If the current buffer is displaying an image file as an image,
call `image-mode-as-text' to switch to text.  Otherwise, display
the image by calling `image-mode'."
551
  (interactive)
552
  (if (image-get-display-property)
553 554
      (image-mode-as-text)
    (image-mode)))
555 556 557 558 559

(defun image-after-revert-hook ()
  (when (image-get-display-property)
    (image-toggle-display-text)
    ;; Update image display.
Glenn Morris's avatar
Glenn Morris committed
560 561
    (mapc (lambda (window) (redraw-frame (window-frame window)))
          (get-buffer-window-list (current-buffer) 'nomini 'visible))
562 563
    (image-toggle-display-image)))

564 565 566 567

;;; Animated images

(defcustom image-animate-loop nil
Glenn Morris's avatar
Glenn Morris committed
568
  "Non-nil means animated images loop forever, rather than playing once."
569 570 571 572 573
  :type 'boolean
  :version "24.1"
  :group 'image)

(defun image-toggle-animation ()
Glenn Morris's avatar
Glenn Morris committed
574 575 576
  "Start or stop animating the current image.
If `image-animate-loop' is non-nil, animation loops forever.
Otherwise it plays once, then stops."
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
  (interactive)
  (let ((image (image-get-display-property))
	animation)
    (cond
     ((null image)
      (error "No image is present"))
     ((null (setq animation (image-animated-p image)))
      (message "No image animation."))
     (t
      (let ((timer (image-animate-timer image)))
	(if timer
	    (cancel-timer timer)
	  (let ((index (plist-get (cdr image) :index)))
	    ;; If we're at the end, restart.
	    (and index
		 (>= index (1- (car animation)))
		 (setq index nil))
	    (image-animate image index
			   (if image-animate-loop t)))))))))

597

598
;;; Support for bookmark.el
599 600
(declare-function bookmark-make-record-default
                  "bookmark" (&optional no-file no-context posn))
601 602
(declare-function bookmark-prop-get "bookmark" (bookmark prop))
(declare-function bookmark-default-handler "bookmark" (bmk))
603

604
(defun image-bookmark-make-record ()
605 606 607
  `(,@(bookmark-make-record-default nil 'no-context 0)
      (image-type . ,image-type)
      (handler    . image-bookmark-jump)))
608 609 610

;;;###autoload
(defun image-bookmark-jump (bmk)
611
  ;; This implements the `handler' function interface for record type
612
  ;; returned by `bookmark-make-record-function', which see.
613 614 615
  (prog1 (bookmark-default-handler bmk)
    (when (not (string= image-type (bookmark-prop-get bmk 'image-type)))
      (image-toggle-display))))
616

617

618
;; Not yet implemented.
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
;; (defvar image-transform-minor-mode-map
;;   (let ((map (make-sparse-keymap)))
;;     ;; (define-key map  [(control ?+)] 'image-scale-in)
;;     ;; (define-key map  [(control ?-)] 'image-scale-out)
;;     ;; (define-key map  [(control ?=)] 'image-scale-none)
;;     ;; (define-key map "c f h" 'image-scale-fit-height)
;;     ;; (define-key map "c ]" 'image-rotate-right)
;;     map)
;;   "Minor mode keymap `image-transform-mode'.")
;;
;; (define-minor-mode image-transform-mode
;;   "Minor mode for scaling and rotating images.
;; With a prefix argument ARG, enable the mode if ARG is positive,
;; and disable it otherwise.  If called from Lisp, enable the mode
;; if ARG is omitted or nil.  This minor mode requires Emacs to have
;; been compiled with ImageMagick support."
;;   nil "image-transform" image-transform-minor-mode-map)
636 637 638


;; FIXME this doesn't seem mature yet. Document in manual when it is.
639 640 641 642 643 644
(defvar image-transform-resize nil
  "The image resize operation.
Its value should be one of the following:
 - nil, meaning no resizing.
 - `fit-height', meaning to fit the image to the window height.
 - `fit-width', meaning to fit the image to the window width.
645
 - A number, which is a scale factor (the default size is 1).")
646

647 648 649
(defvar image-transform-scale 1.0
  "The scale factor of the image being displayed.")

650 651
(defvar image-transform-rotation 0.0
  "Rotation angle for the image in the current Image mode buffer.")
652

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
(defvar image-transform-right-angle-fudge 0.0001
  "Snap distance to a multiple of a right angle.
There's no deep theory behind the default value, it should just
be somewhat larger than ImageMagick's MagickEpsilon.")

(defsubst image-transform-width (width height)
  "Return the bounding box width of a rotated WIDTH x HEIGHT rectangle.
The rotation angle is the value of `image-transform-rotation' in degrees."
  (let ((angle (degrees-to-radians image-transform-rotation)))
    ;; Assume, w.l.o.g., that the vertices of the rectangle have the
    ;; coordinates (+-w/2, +-h/2) and that (0, 0) is the center of the
    ;; rotation by the angle A.  The projections onto the first axis
    ;; of the vertices of the rotated rectangle are +- (w/2) cos A +-
    ;; (h/2) sin A, and the difference between the largest and the
    ;; smallest of the four values is the expression below.
    (+ (* width (abs (cos angle))) (* height (abs (sin angle))))))

;; The following comment and code snippet are from
;; ImageMagick-6.7.4-4/magick/distort.c

Paul Eggert's avatar
Paul Eggert committed
673
;;    /* Set the output image geometry to calculated 'best fit'.
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
;;       Yes this tends to 'over do' the file image size, ON PURPOSE!
;;       Do not do this for DePolar which needs to be exact for virtual tiling.
;;    */
;;    if ( fix_bounds ) {
;;      geometry.x = (ssize_t) floor(min.x-0.5);
;;      geometry.y = (ssize_t) floor(min.y-0.5);
;;      geometry.width=(size_t) ceil(max.x-geometry.x+0.5);
;;      geometry.height=(size_t) ceil(max.y-geometry.y+0.5);
;;    }

;; Other parts of the same file show that here the origin is in the
;; left lower corner of the image rectangle, the center of the
;; rotation is the center of the rectangle and min.x and max.x
;; (resp. min.y and max.y) are the smallest and the largest of the
;; projections of the vertices onto the first (resp. second) axis.

(defun image-transform-fit-width (width height length)
  "Return (w . h) so that a rotated w x h image has exactly width LENGTH.
The rotation angle is the value of `image-transform-rotation'.
Write W for WIDTH and H for HEIGHT.  Then the w x h rectangle is
an \"approximately uniformly\" scaled W x H rectangle, which
currently means that w is one of floor(s W) + {0, 1, -1} and h is
floor(s H), where s can be recovered as the value of `image-transform-scale'.
The value of `image-transform-rotation' may be replaced by
a slightly different angle.  Currently this is done for values
close to a multiple of 90, see `image-transform-right-angle-fudge'."
  (cond ((< (abs (- (mod (+ image-transform-rotation 90) 180) 90))
	    image-transform-right-angle-fudge)
Stefan Monnier's avatar
Stefan Monnier committed
702
	 (cl-assert (not (zerop width)) t)
703 704 705 706 707 708
	 (setq image-transform-rotation
	       (float (round image-transform-rotation))
	       image-transform-scale (/ (float length) width))
	 (cons length nil))
	((< (abs (- (mod (+ image-transform-rotation 45) 90) 45))
	    image-transform-right-angle-fudge)
Stefan Monnier's avatar
Stefan Monnier committed
709
	 (cl-assert (not (zerop height)) t)
710 711 712 713 714
	 (setq image-transform-rotation
	       (float (round image-transform-rotation))
	       image-transform-scale (/ (float length) height))
	 (cons nil length))
	(t
Stefan Monnier's avatar
Stefan Monnier committed
715
	 (cl-assert (not (and (zerop width) (zerop height))) t)
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
	 (setq image-transform-scale
	       (/ (float (1- length)) (image-transform-width width height)))
	 ;; Assume we have a w x h image and an angle A, and let l =
	 ;; l(w, h) = w |cos A| + h |sin A|, which is the actual width
	 ;; of the bounding box of the rotated image, as calculated by
	 ;; `image-transform-width'.  The code snippet quoted above
	 ;; means that ImageMagick puts the rotated image in
	 ;; a bounding box of width L = 2 ceil((w+l+1)/2) - w.
	 ;; Elementary considerations show that this is equivalent to
	 ;; L - w being even and L-3 < l(w, h) <= L-1.  In our case, L is
	 ;; the given `length' parameter and our job is to determine
	 ;; reasonable values for w and h which satisfy these
	 ;; conditions.
	 (let ((w (floor (* image-transform-scale width)))
	       (h (floor (* image-transform-scale height))))
	   ;; Let w and h as bound above.  Then l(w, h) <= l(s W, s H)
	   ;; = L-1 < l(w+1, h+1) = l(w, h) + l(1, 1) <= l(w, h) + 2,
	   ;; hence l(w, h) > (L-1) - 2 = L-3.
	   (cons
	    (cond ((= (mod w 2) (mod length 2))
		   w)
		  ;; l(w+1, h) >= l(w, h) > L-3, but does l(w+1, h) <=
		  ;; L-1 hold?
		  ((<= (image-transform-width (1+ w) h) (1- length))
		   (1+ w))
		  ;; No, it doesn't, but this implies that l(w-1, h) =
		  ;; l(w+1, h) - l(2, 0) >= l(w+1, h) - 2 > (L-1) -
		  ;; 2 = L-3.  Clearly, l(w-1, h) <= l(w, h) <= L-1.
		  (t
		   (1- w)))
	    h)))))

(defun image-transform-check-size ()
  "Check that the image exactly fits the width/height of the window."
  (unless (numberp image-transform-resize)
    (let ((size (image-display-size (image-get-display-property) t)))
      (cond ((eq image-transform-resize 'fit-width)
Stefan Monnier's avatar
Stefan Monnier committed
753
	     (cl-assert (= (car size)
754 755 756 757
			(- (nth 2 (window-inside-pixel-edges))
			   (nth 0 (window-inside-pixel-edges))))
		     t))
	    ((eq image-transform-resize 'fit-height)
Stefan Monnier's avatar
Stefan Monnier committed
758
	     (cl-assert (= (cdr size)
759 760 761 762
			(- (nth 3 (window-inside-pixel-edges))
			   (nth 1 (window-inside-pixel-edges))))
		     t))))))

763 764 765 766 767
(defun image-transform-properties (spec)
  "Return rescaling/rotation properties for image SPEC.
These properties are determined by the Image mode variables
`image-transform-resize' and `image-transform-rotation'.  The
return value is suitable for appending to an image spec.
Chong Yidong's avatar
Chong Yidong committed
768

Paul Eggert's avatar
Paul Eggert committed
769
Rescaling and rotation properties only take effect if Emacs is
Chong Yidong's avatar
Chong Yidong committed
770
compiled with ImageMagick support."
771
  (setq image-transform-scale 1.0)
772
  (when (or image-transform-resize
773
	    (/= image-transform-rotation 0.0))
774 775 776
    ;; Note: `image-size' looks up and thus caches the untransformed
    ;; image.  There's no easy way to prevent that.
    (let* ((size (image-size spec t))
777
	   (resized
778 779
	    (cond
	     ((numberp image-transform-resize)
780
	      (unless (= image-transform-resize 1)
781 782 783 784 785 786 787
		(setq image-transform-scale image-transform-resize)
		(cons nil (floor (* image-transform-resize (cdr size))))))
	     ((eq image-transform-resize 'fit-width)
	      (image-transform-fit-width
	       (car size) (cdr size)
	       (- (nth 2 (window-inside-pixel-edges))
		  (nth 0 (window-inside-pixel-edges)))))
788
	     ((eq image-transform-resize 'fit-height)
789 790 791 792 793 794 795 796 797 798 799
	      (let ((res (image-transform-fit-width
			  (cdr size) (car size)
			  (- (nth 3 (window-inside-pixel-edges))
			     (nth 1 (window-inside-pixel-edges))))))
		(cons (cdr res) (car res)))))))
      `(,@(when (car resized)
	    (list :width (car resized)))
	,@(when (cdr resized)
	    (list :height (cdr resized)))
	,@(unless (= 0.0 image-transform-rotation)
	    (list :rotation image-transform-rotation))))))
800 801

(defun image-transform-set-scale (scale)
802 803 804 805
  "Prompt for a number, and resize the current image by that amount.
This command has no effect unless Emacs is compiled with
ImageMagick support."
  (interactive "nScale: ")
806
  (setq image-transform-resize scale)
807
  (image-toggle-display-image))
808 809

(defun image-transform-fit-to-height ()
810 811 812
  "Fit the current image to the height of the current window.
This command has no effect unless Emacs is compiled with
ImageMagick support."
813
  (interactive)
814 815
  (setq image-transform-resize 'fit-height)
  (image-toggle-display-image))
816

Joakim Verona's avatar
Joakim Verona committed
817
(defun image-transform-fit-to-width ()
818 819 820
  "Fit the current image to the width of the current window.
This command has no effect unless Emacs is compiled with
ImageMagick support."
Joakim Verona's avatar
Joakim Verona committed
821
  (interactive)
822 823
  (setq image-transform-resize 'fit-width)
  (image-toggle-display-image))
824 825

(defun image-transform-set-rotation (rotation)
826 827 828 829
  "Prompt for an angle ROTATION, and rotate the image by that amount.
ROTATION should be in degrees.  This command has no effect unless
Emacs is compiled with ImageMagick support."
  (interactive "nRotation angle (in degrees): ")
830
  (setq image-transform-rotation (float (mod rotation 360)))
831
  (image-toggle-display-image))
832

833 834 835
(provide 'image-mode)

;;; image-mode.el ends here