429 lines
14 KiB
EmacsLisp
429 lines
14 KiB
EmacsLisp
;;; inlimg.el --- Display images inline
|
|
;;
|
|
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
|
|
;; Created: 2008-09-27
|
|
(defconst inlimg:version "0.7") ;; Version:
|
|
;; Last-Updated: 2009-07-14 Tue
|
|
;; URL:
|
|
;; Keywords:
|
|
;; Compatibility:
|
|
;;
|
|
;; Features that might be required by this library:
|
|
;;
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;; Display images inline. See `inlimg-mode' for more information.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Change log:
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; This program 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 program 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 this program; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
;; Floor, Boston, MA 02110-1301, USA.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Code:
|
|
|
|
(eval-when-compile (require 'cl))
|
|
(eval-when-compile (require 'mumamo nil t))
|
|
(eval-when-compile (require 'ourcomments-util nil t))
|
|
|
|
(defvar inlimg-assoc-ext
|
|
'((png (".png"))
|
|
(gif (".gif"))
|
|
(tiff (".tiff"))
|
|
(jpeg (".jpg" ".jpeg"))
|
|
(xpm (".xpm"))
|
|
(xbm (".xbm"))
|
|
(pbm (".pbm"))))
|
|
|
|
(defvar inlimg-img-regexp nil)
|
|
(make-variable-buffer-local 'inlimg-img-regexp)
|
|
(put 'inlimg-img-regexp 'permanent-local t)
|
|
|
|
(defvar inlimg-img-regexp-html
|
|
(rx (or (and "<img"
|
|
(1+ space)
|
|
(0+ (1+ (not (any " <>")))
|
|
(1+ space))
|
|
"src=\""
|
|
(group (1+ (not (any "\""))))
|
|
"\""
|
|
(*? anything)
|
|
"/>")
|
|
(and "url("
|
|
?\"
|
|
(group (1+ (not (any "\)"))))
|
|
?\"
|
|
")"
|
|
)
|
|
(and "url("
|
|
(group (+? (not (any ")"))))
|
|
")"
|
|
)
|
|
)))
|
|
|
|
(defvar inlimg-img-regexp-org
|
|
(rx-to-string
|
|
`(and "[[file:"
|
|
(group (+? (not (any "\]")))
|
|
,(let ((types nil))
|
|
(dolist (typ image-types)
|
|
(when (image-type-available-p typ)
|
|
(dolist (ext (cadr (assoc typ inlimg-assoc-ext)))
|
|
(setq types (cons ext types)))))
|
|
(cons 'or types)))
|
|
"]"
|
|
(optional "["
|
|
(+? (not (any "\]")))
|
|
"]")
|
|
"]"
|
|
)))
|
|
|
|
(defconst inlimg-modes-img-values
|
|
'(
|
|
(html-mode inlimg-img-regexp-html)
|
|
(org-mode inlimg-img-regexp-org)
|
|
))
|
|
|
|
(defun inlimg-img-spec-p (spec)
|
|
(assoc spec inlimg-modes-img-values))
|
|
|
|
;;;###autoload
|
|
(defgroup inlimg nil
|
|
"Customization group for inlimg."
|
|
:group 'nxhtml)
|
|
|
|
(defcustom inlimg-margins '(50 . 5)
|
|
"Margins when displaying image."
|
|
:type '(cons (integer :tag "Left margin")
|
|
(integer :tag "Top margin"))
|
|
:set (lambda (sym val)
|
|
(set-default sym val)
|
|
(when (fboundp 'inlimg-update-all-buffers)
|
|
(inlimg-update-all-buffers)))
|
|
:group 'inlimg)
|
|
|
|
(defcustom inlimg-slice '(0 0 400 100)
|
|
"How to slice images."
|
|
:type '(choice (const :tag "Show whole images" nil)
|
|
(list :tag "Show slice of image"
|
|
(integer :tag "Top")
|
|
(integer :tag "Left")
|
|
(integer :tag "Width")
|
|
(integer :tag "Height")))
|
|
:set (lambda (sym val)
|
|
(set-default sym val)
|
|
(when (fboundp 'inlimg-update-all-buffers)
|
|
(inlimg-update-all-buffers)))
|
|
:group 'inlimg)
|
|
|
|
(define-widget 'inlimg-spec-widget 'symbol
|
|
"An inline image specification."
|
|
:complete-function (lambda ()
|
|
(interactive)
|
|
(lisp-complete-symbol 'inlimg-img-spec-p))
|
|
:prompt-match 'inlimg-img-spec-p
|
|
:prompt-history 'widget-function-prompt-value-history
|
|
:match-alternatives '(inlimg-img-spec-p)
|
|
:validate (lambda (widget)
|
|
(unless (inlimg-img-spec-p (widget-value widget))
|
|
(widget-put widget :error (format "Invalid function: %S"
|
|
(widget-value widget)))
|
|
widget))
|
|
:value 'org-mode
|
|
:tag "Inlimg image values spec name")
|
|
|
|
;; (customize-option 'inlimg-mode-specs)
|
|
(defcustom inlimg-mode-specs
|
|
'(
|
|
(xml-mode html-mode)
|
|
(sgml-mode html-mode)
|
|
(nxml-mode html-mode)
|
|
(php-mode html-mode)
|
|
(css-mode html-mode)
|
|
)
|
|
"Equivalent mode for image tag search.
|
|
Note that derived modes \(see info) are recognized by default.
|
|
|
|
To add new image tag patterns modify `inlimg-modes-img-values'."
|
|
:type '(repeat
|
|
(list (major-mode-function :tag "Major mode")
|
|
(inlimg-spec-widget :tag "Use tags as specified in")))
|
|
:group 'inlimg)
|
|
|
|
(defface inlimg-img-tag '((t :inherit 'lazy-highlight))
|
|
"Face added to img tag when displaying image."
|
|
:group 'inlimg)
|
|
|
|
(defface inlimg-img-remote '((t :inherit 'isearch-fail))
|
|
"Face used for notes telling image is remote."
|
|
:group 'inlimg)
|
|
|
|
(defface inlimg-img-missing '((t :inherit 'trailing-whitespace))
|
|
"Face used for notes telling image is missing."
|
|
:group 'inlimg)
|
|
|
|
(defvar inlimg-img-keymap
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map [(control ?c) ?+] 'inlimg-toggle-display)
|
|
(define-key map [(control ?c) ?%] 'inlimg-toggle-slicing)
|
|
map)
|
|
"Keymap on image overlay.")
|
|
|
|
(eval-after-load 'gimp
|
|
'(gimp-add-point-bindings inlimg-img-keymap))
|
|
|
|
(defsubst inlimg-ovl-p (ovl)
|
|
"Return non-nil if OVL is an inlimg image overlay."
|
|
(overlay-get ovl 'inlimg-img))
|
|
|
|
(defun inlimg-ovl-valid-p (ovl)
|
|
(and (overlay-get ovl 'inlimg-img)
|
|
inlimg-img-regexp
|
|
(save-match-data
|
|
(let ((here (point)))
|
|
(goto-char (overlay-start ovl))
|
|
(prog1
|
|
(looking-at (symbol-value inlimg-img-regexp))
|
|
(goto-char here))))))
|
|
|
|
(defun inlimg-next (pt display-image)
|
|
"Display or hide next image after point PT.
|
|
If DISPLAY-IMAGE is non-nil then display image, otherwise hide it.
|
|
|
|
Return non-nil if an img tag was found."
|
|
(when inlimg-img-regexp
|
|
(let (src dir beg end img ovl remote beg-face)
|
|
(goto-char pt)
|
|
(save-match-data
|
|
(when (re-search-forward (symbol-value inlimg-img-regexp) nil t)
|
|
(setq src (or (match-string-no-properties 1)
|
|
(match-string-no-properties 2)
|
|
(match-string-no-properties 3)))
|
|
(setq beg (match-beginning 0))
|
|
(setq beg-face (get-text-property beg 'face))
|
|
(setq remote (string-match "^https?://" src))
|
|
(setq end (- (line-end-position) 0))
|
|
(setq ovl (catch 'old-ovl
|
|
(dolist (ovl (overlays-at beg))
|
|
(when (inlimg-ovl-p ovl)
|
|
(throw 'old-ovl ovl)))
|
|
nil))
|
|
(unless ovl
|
|
(setq ovl (make-overlay beg end))
|
|
(overlay-put ovl 'inlimg-img t)
|
|
(overlay-put ovl 'priority 100)
|
|
(overlay-put ovl 'face 'inlimg-img-tag)
|
|
(overlay-put ovl 'keymap inlimg-img-keymap))
|
|
(overlay-put ovl 'image-file src)
|
|
(overlay-put ovl 'inlimg-slice inlimg-slice)
|
|
(if display-image
|
|
(unless (memq beg-face '(font-lock-comment-face font-lock-string-face))
|
|
(unless remote
|
|
(setq dir (if (buffer-file-name)
|
|
(file-name-directory (buffer-file-name))
|
|
default-directory))
|
|
(setq src (expand-file-name src dir)))
|
|
(if (or remote (not (file-exists-p src)))
|
|
(setq img (propertize
|
|
(if remote " Image is on the web " " Image not found ")
|
|
'face (if remote 'inlimg-img-remote 'inlimg-img-missing)))
|
|
(setq img (create-image src nil nil
|
|
:relief 5
|
|
:margin inlimg-margins))
|
|
(setq img (inlimg-slice-img img inlimg-slice)))
|
|
(let ((str (copy-sequence "\nX")))
|
|
(setq str (propertize str 'face 'inlimg-img-tag))
|
|
(put-text-property 1 2 'display img str)
|
|
(overlay-put ovl 'after-string str)))
|
|
(overlay-put ovl 'after-string nil))))
|
|
ovl)))
|
|
|
|
(defun inlimg-slice-img (img slice)
|
|
(if (not slice)
|
|
img
|
|
(let* ((sizes (image-size img t))
|
|
(width (car sizes))
|
|
(height (cdr sizes))
|
|
(sl-left (nth 0 slice))
|
|
(sl-top (nth 1 slice))
|
|
(sl-width (nth 2 slice))
|
|
(sl-height (nth 3 slice)))
|
|
(when (> sl-left width) (setq sl-left 0))
|
|
(when (> (+ sl-left sl-width) width) (setq sl-width (- width sl-left)))
|
|
(when (> sl-top height) (setq sl-top 0))
|
|
(when (> (+ sl-top sl-height) height) (setq sl-height (- height sl-top)))
|
|
(setq img (list img))
|
|
(setq img (cons (append '(slice)
|
|
slice
|
|
(list sl-top sl-left sl-width sl-height)
|
|
nil)
|
|
img)))))
|
|
|
|
;;;###autoload
|
|
(define-minor-mode inlimg-mode
|
|
"Display images inline.
|
|
Search buffer for image tags. Display found images.
|
|
|
|
Image tags are setup per major mode in `inlimg-mode-specs'.
|
|
|
|
Images are displayed on a line below the tag referencing them.
|
|
The whole image or a slice of it may be displayed, see
|
|
`inlimg-slice'. Margins relative text are specified in
|
|
`inlimg-margins'.
|
|
|
|
See also the commands `inlimg-toggle-display' and
|
|
`inlimg-toggle-slicing'.
|
|
|
|
Note: This minor mode uses `font-lock-mode'."
|
|
:keymap nil
|
|
:group 'inlimg
|
|
(if inlimg-mode
|
|
(progn
|
|
(let ((major-mode (or (and (boundp 'mumamo-multi-major-mode)
|
|
mumamo-multi-major-mode
|
|
(fboundp 'mumamo-main-major-mode)
|
|
(mumamo-main-major-mode))
|
|
major-mode)))
|
|
(inlimg-get-buffer-img-values)
|
|
(unless inlimg-img-regexp
|
|
(message "inlim-mode: No image spec, can't do anything"))
|
|
(add-hook 'font-lock-mode-hook 'inlimg-on-font-lock-off))
|
|
(inlimg-font-lock t))
|
|
(inlimg-font-lock nil)
|
|
(inlimg-delete-overlays)))
|
|
(put 'inlimg-mode 'permanent-local t)
|
|
|
|
(defun inlimg-delete-overlays ()
|
|
(save-restriction
|
|
(widen)
|
|
(let (ovl)
|
|
(dolist (ovl (overlays-in (point-min) (point-max)))
|
|
(when (inlimg-ovl-p ovl)
|
|
(delete-overlay ovl))))))
|
|
|
|
(defun inlimg-get-buffer-img-values ()
|
|
(let* (rec
|
|
(spec (or (catch 'spec
|
|
(dolist (rec inlimg-mode-specs)
|
|
(when (derived-mode-p (car rec))
|
|
(throw 'spec (nth 1 rec)))))
|
|
major-mode))
|
|
(values (when spec (nth 1 (assoc spec inlimg-modes-img-values))))
|
|
)
|
|
(setq inlimg-img-regexp values)
|
|
))
|
|
|
|
(defun inlimg--global-turn-on ()
|
|
(inlimg-get-buffer-img-values)
|
|
(when inlimg-img-regexp
|
|
(inlimg-mode 1)))
|
|
|
|
;;;###autoload
|
|
(define-globalized-minor-mode inlimg-global-mode inlimg-mode inlimg--global-turn-on)
|
|
|
|
;;;###autoload
|
|
(defun inlimg-toggle-display (point)
|
|
"Toggle display of image at point POINT.
|
|
See also the command `inlimg-mode'."
|
|
(interactive (list (point)))
|
|
(let ((here (point))
|
|
(ovl
|
|
(catch 'ovl
|
|
(dolist (ovl (overlays-at (point)))
|
|
(when (inlimg-ovl-p ovl)
|
|
(throw 'ovl ovl)))))
|
|
is-displayed)
|
|
(if (not ovl)
|
|
(message "No image at point %s" here)
|
|
(setq is-displayed (overlay-get ovl 'after-string))
|
|
(inlimg-next (overlay-start ovl) (not is-displayed))
|
|
(goto-char here))))
|
|
|
|
;;;###autoload
|
|
(defun inlimg-toggle-slicing (point)
|
|
"Toggle slicing of image at point POINT.
|
|
See also the command `inlimg-mode'."
|
|
(interactive (list (point)))
|
|
(let* ((here (point))
|
|
(ovl
|
|
(catch 'ovl
|
|
(dolist (ovl (overlays-at (point)))
|
|
(when (inlimg-ovl-p ovl)
|
|
(throw 'ovl ovl)))))
|
|
(inlimg-slice inlimg-slice)
|
|
is-displayed)
|
|
(if (not ovl)
|
|
(message "No image at point %s" here)
|
|
(setq is-displayed (overlay-get ovl 'after-string))
|
|
(when (overlay-get ovl 'inlimg-slice)
|
|
(setq inlimg-slice nil))
|
|
(inlimg-next (overlay-start ovl) is-displayed)
|
|
(goto-char here))))
|
|
|
|
|
|
(defun inlimg-font-lock-fun (bound)
|
|
(let ((here (point))
|
|
old-ovls new-ovls ovl)
|
|
(goto-char (line-beginning-position))
|
|
(dolist (ovl (overlays-in (point) bound))
|
|
(when (inlimg-ovl-p ovl)
|
|
(setq old-ovls (cons ovl old-ovls))))
|
|
(while (and (< (point) bound)
|
|
(setq ovl (inlimg-next (point) t)))
|
|
(setq new-ovls (cons ovl new-ovls)))
|
|
(dolist (ovl old-ovls)
|
|
(unless (inlimg-ovl-valid-p ovl)
|
|
(delete-overlay ovl)
|
|
))))
|
|
|
|
;; Fix-me: This stops working for changes with nxhtml-mumamo-mode, but
|
|
;; works for nxhtml-mode and html-mumamo-mode...
|
|
(defvar inlimg-this-is-not-font-lock-off nil)
|
|
(defun inlimg-font-lock (on)
|
|
(let ((add-or-remove (if on 'font-lock-add-keywords 'font-lock-remove-keywords))
|
|
(link-fun))
|
|
(funcall add-or-remove nil
|
|
`((inlimg-font-lock-fun
|
|
1
|
|
mlinks-link
|
|
prepend)))
|
|
(let ((inlimg-this-is-not-font-lock-off t)
|
|
(mumamo-multi-major-mode nil))
|
|
(font-lock-mode -1)
|
|
(font-lock-mode 1))))
|
|
|
|
(defun inlimg-on-font-lock-off ()
|
|
(unless (or inlimg-this-is-not-font-lock-off
|
|
(and (boundp 'mumamo-multi-major-mode)
|
|
mumamo-multi-major-mode))
|
|
(when inlimg-mode
|
|
(inlimg-mode -1)
|
|
)))
|
|
(put 'inlimg-on-font-lock-off 'permanent-local-hook t)
|
|
|
|
|
|
(provide 'inlimg)
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; inlimg.el ends here
|