Commit 7840ced1 authored by Gerd Moellmann's avatar Gerd Moellmann

New file.

parent a168702a
;;; gs.el --- interface to Ghostscript
;; Copyright (C) 1998 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: internal
;; This file is part of GNU Emacs.
;; GNU Emacs 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.
;; 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
;; 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:
;; This code is experimental. Don't use it.
;;; Code:
(defvar gs-program "gs"
"The name of the Ghostscript interpreter.")
(defvar gs-device "x11"
"The Ghostscript device to use to produce images.")
(defvar gs-options
'("-q"
;"-dNOPAUSE"
"-dBATCH"
"-sDEVICE=<device>"
"<file>")
"List of command line arguments to pass to Ghostscript.
Arguments may contain place-holders `<file>' for the name of the
input file, and `<device>' for the device to use.")
(defun gs-replace-in-string (string find repl)
"Return STRING with all occurrences of FIND replaced by REPL.
FIND is a regular expression."
(while (string-match find string)
(setq string (replace-match repl nil t string)))
string)
(defun gs-options (device file)
"Return a list of command line options with place-holders replaced.
DEVICE is the value to substitute for the place-holder `<device>',
FILE is the value to substitute for the place-holder `<file>'."
(mapcar #'(lambda (option)
(setq option (gs-replace-in-string option "<device>" device)
option (gs-replace-in-string option "<file>" file)))
gs-options))
;; The GHOSTVIEW property (taken from gv 3.5.8).
;;
;; Type:
;;
;; STRING
;;
;; Parameters:
;;
;; BPIXMAP ORIENT LLX LLY URX URY XDPI YDPI [LEFT BOTTOM TOP RIGHT]
;;
;; Scanf format: "%d %d %d %d %d %d %f %f %d %d %d %d"
;;
;; Explanation of parameters:
;;
;; BPIXMAP: pixmap id of the backing pixmap for the window. If no
;; pixmap is to be used, this parameter should be zero. This
;; parameter must be zero when drawing on a pixmap.
;;
;; ORIENT: orientation of the page. The number represents clockwise
;; rotation of the paper in degrees. Permitted values are 0, 90, 180,
;; 270.
;;
;; LLX, LLY, URX, URY: Bounding box of the drawable. The bounding box
;; is specified in PostScript points in default user coordinates.
;;
;; XDPI, YDPI: Resolution of window. (This can be derived from the
;; other parameters, but not without roundoff error. These values are
;; included to avoid this error.)
;;
;; LEFT, BOTTOM, TOP, RIGHT: (optional) Margins around the window.
;; The margins extend the imageable area beyond the boundaries of the
;; window. This is primarily used for popup zoom windows. I have
;; encountered several instances of PostScript programs that position
;; themselves with respect to the imageable area. The margins are
;; specified in PostScript points. If omitted, the margins are
;; assumed to be 0.
(defun gs-width-in-pt (frame pixel-width)
"Return, on FRAME, pixel width PIXEL-WIDTH tranlated to pt."
(let ((mm (* (float pixel-width)
(/ (float (x-display-mm-width frame))
(float (x-display-pixel-width frame))))))
(/ (* 25.4 mm) 72.0)))
(defun gs-height-in-pt (frame pixel-height)
"Return, on FRAME, pixel height PIXEL-HEIGHT tranlated to pt."
(let ((mm (* (float pixel-height)
(/ (float (x-display-mm-height frame))
(float (x-display-pixel-height frame))))))
(/ (* 25.4 mm) 72.0)))
(defun gs-set-ghostview-window-prop (frame spec img-width img-height)
"Set the `GHOSTVIEW' window property of FRAME.
SPEC is a GS image specification. IMG-WIDTH is the width of the
requested image, and IMG-HEIGHT is the height of the requested
image in pixels."
(let* ((box (plist-get (cdr spec) :bounding-box))
(llx (nth 0 box))
(lly (nth 1 box))
(urx (nth 2 box))
(ury (nth 3 box))
(rotation (or (plist-get (cdr spec) :rotate) 0))
;; The pixel width IMG-WIDTH of the pixmap gives the
;; dots, URX - LLX give the inch.
(in-width (/ (- urx llx) 72.0))
(in-height (/ (- ury lly) 72.0))
(xdpi (/ img-width in-width))
(ydpi (/ img-height in-height)))
(x-change-window-property "GHOSTVIEW"
(format "0 %d %d %d %d %d %g %g"
rotation llx lly urx ury xdpi ydpi)
frame)))
(defun gs-set-ghostview-colors-window-prop (frame pixel-colors)
"Set the `GHOSTVIEW_COLORS' environment variable depending on FRAME."
(let ((mode (cond ((x-display-color-p frame) "Color")
((x-display-grayscale-p frame) "Grayscale")
(t "Monochrome"))))
(x-change-window-property "GHOSTVIEW_COLORS"
(format "%s %s" mode pixel-colors))))
;
;;;###autoload
(defun gs-load-image (frame spec img-width img-height window-and-pixmap-id
pixel-colors)
"Load a PS image for display on FRAME.
SPEC is an image specification, IMG-HEIGHT and IMG-WIDTH are width
and height of the image in pixels. WINDOW-AND-PIXMAP-ID is a string of
the form \"WINDOW-ID PIXMAP-ID\". Value is non-nil if successful."
(unwind-protect
(let ((file (plist-get (cdr spec) :file))
gs)
(gs-set-ghostview-window-prop frame spec img-width img-height)
(gs-set-ghostview-colors-window-prop frame pixel-colors)
(setenv "GHOSTVIEW" window-and-pixmap-id)
(setq gs (apply 'start-process "gs" "*GS*" gs-program
(gs-options gs-device file)))
(process-kill-without-query gs)
gs)
nil))
;(defun gs-put-tiger ()
; (let* ((ps-file "/usr/local/share/ghostscript/5.10/examples/tiger.ps")
; (spec `(image :type ghostscript
; :pt-width 200 :pt-height 200
; :bounding-box (22 171 567 738)
; :file ,ps-file)))
; (put-text-property 1 2 'display spec)))
;
(provide 'gs)
;; gs.el ends here.
;;; image.el --- image API
;; Copyright (C) 1998 Free Software Foundation, Inc.
;; This file is part of GNU Emacs.
;; GNU Emacs 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.
;; 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
;; 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:
;;; Code:
(defconst image-type-regexps
'(("^/\\*.*XPM.\\*/" . xpm)
("^P[1-6]" . pbm)
("^GIF8" . gif)
("JFIF" . jpeg)
("^\211PNG\r\n" . png)
("^#define" . xbm)
("^\\(MM\0\\*\\)\\|\\(II\\*\0\\)" . tiff)
("^%!PS" . ghostscript))
"Alist of (REGEXP . IMAGE-TYPE) pairs used to auto-detect image types.
When the first bytes of an image file match REGEXP, it is assumed to
be of image type IMAGE-TYPE.")
;;;###autoload
(defun image-type-from-file-header (file)
"Determine the type of image file FILE from its first few bytes.
Value is a symbol specifying the image type, or nil if type cannot
be determined."
(unless (file-name-directory file)
(setq file (concat data-directory file)))
(setq file (expand-file-name file))
(let ((header (with-temp-buffer
(insert-file-contents-literally file nil 0 256)
(buffer-string)))
(types image-type-regexps)
type)
(while (and types (null type))
(let ((regexp (car (car types)))
(image-type (cdr (car types))))
(when (string-match regexp header)
(setq type image-type))
(setq types (cdr types))))
type))
;;;###autoload
(defun image-type-available-p (type)
"Value is non-nil if image type TYPE is available.
Image types are symbols like `xbm' or `jpeg'."
(not (null (memq type image-types))))
;;;###autoload
(defun create-image (file &optional type &rest props)
"Create an image which will be loaded from FILE.
Optional TYPE is a symbol describing the image type. If TYPE is omitted
or nil, try to determine the image file type from its first few bytes.
If that doesn't work, use FILE's extension.as image type.
Optional PROPS are additional image attributes to assign to the image,
like, e.g. `:heuristic-mask t'.
Value is the image created, or nil if images of type TYPE are not supported."
(unless (stringp file)
(error "Invalid image file name %s" file))
(unless (or type
(setq type (image-type-from-file-header file)))
(let ((extension (file-name-extension file)))
(unless extension
(error "Cannot determine image type"))
(setq type (intern extension))))
(unless (symbolp type)
(error "Invalid image type %s" type))
(when (image-type-available-p type)
(append (list 'image :type type :file file) props)))
;;;###autoload
(defun put-image (image pos &optional buffer area)
"Put image IMAGE in front of POS in BUFFER.
IMAGE must be an image created with `create-image' or `defimage'.
POS may be an integer or marker.
BUFFER nil or omitted means use the current buffer.
AREA is where to display the image. AREA nil or omitted means
display it in the text area, a value of `left-margin' means
display it in the left marginal area, a value of `right-margin'
means display it in the right marginal area.
IMAGE is displayed by putting an overlay into BUFFER with a
`before-string' that has a `display' property whose value is the
image."
(unless buffer
(setq buffer (current-buffer)))
(unless (eq (car image) 'image)
(error "Not an image: %s" image))
(unless (or (null area) (memq area '(left-margin right-margin)))
(error "Invalid area %s" area))
(let ((overlay (make-overlay pos pos buffer))
(string (make-string 1 ?x))
(prop (if (null area) image (cons area image))))
(put-text-property 0 1 'display prop string)
(overlay-put overlay 'put-image t)
(overlay-put overlay 'before-string string)))
;;;###autoload
(defun insert-image (image &optional area)
"Insert IMAGE into current buffer at point.
AREA is where to display the image. AREA nil or omitted means
display it in the text area, a value of `left-margin' means
display it in the left marginal area, a value of `right-margin'
means display it in the right marginal area.
IMAGE is displayed by inserting an \"x\" into the current buffer
having a `display' property whose value is the image."
(unless (eq (car image) 'image)
(error "Not an image: %s" image))
(unless (or (null area) (memq area '(left-margin right-margin)))
(error "Invalid area %s" area))
(insert "x")
(add-text-properties (1- (point)) (point)
(list 'display (if (null area) image (cons area image))
'rear-nonsticky (list 'display))))
;;;###autoload
(defun remove-images (start end &optional buffer)
"Remove images between START and END in BUFFER.
Remove only images that were put in BUFFER with calls to `put-image'.
BUFFER nil or omitted means use the current buffer."
(unless buffer
(setq buffer (current-buffer)))
(let ((overlays (overlays-in start end)))
(while overlays
(let ((overlay (car overlays)))
(when (overlay-get overlay 'put-image)
(delete-overlay overlay)
(setq overlays (cdr overlays)))))))
;;;###autoload
(defmacro defimage (symbol specs &optional doc)
"Define SYMBOL as an image.
SPECS is a list of image specifications. DOC is an optional
documentation string.
Each image specification in SPECS is a property list. The contents of
a specification are image type dependent. All specifications must at
least contain the properties `:type TYPE' and `:file FILE', where TYPE
is a symbol specifying the image type, e.g. `xbm', and FILE is the
file to load the image from. The first image specification whose TYPE
is supported, and FILE exists, is used to define SYMBOL.
Example:
(defimage test-image ((:type xpm :file \"~/test1.xpm\")
(:type xbm :file \"~/test1.xbm\")))"
(let (image)
(while (and specs (null image))
(let* ((spec (car specs))
(type (plist-get spec :type))
(file (plist-get spec :file)))
(when (and (image-type-available-p type) (stringp file))
(setq file (expand-file-name file))
(unless (file-name-absolute-p file)
(setq file (concat data-directory "/" file)))
(when (file-exists-p file)
(setq image (cons 'image spec))))
(setq specs (cdr specs))))
`(defvar ,symbol ',image ,doc)))
(provide 'image)
;; image.el ends here.
;;; jit-lock.el --- just-in-time fontification.
;; Copyright (C) 1998 Free Software Foundation, Inc.
;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
;; Version: 1.0
;; This file is part of GNU Emacs.
;; GNU Emacs 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.
;; 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
;; 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:
;; Just-in-time fontification, triggered by C redisplay code.
;;; Code:
(require 'font-lock)
(eval-when-compile
(defmacro with-buffer-prepared-for-font-lock (&rest body)
"Execute BODY in current buffer, overriding several variables.
Preserves the `buffer-modified-p' state of the current buffer."
`(let ((modified (buffer-modified-p))
(buffer-undo-list t)
(inhibit-read-only t)
(inhibit-point-motion-hooks t)
before-change-functions
after-change-functions
deactivate-mark
buffer-file-name
buffer-file-truename)
,@body
(set-buffer-modified-p modified))))
;;; Customization.
(defcustom jit-lock-chunk-size 500
"*Font-lock chunks of this many characters, or smaller."
:type 'integer
:group 'jit-lock)
(defcustom jit-lock-stealth-time 3
"*Time in seconds to wait before beginning stealth fontification.
Stealth fontification occurs if there is no input within this time.
If nil, means stealth fontification is never performed.
The value of this variable is used when JIT Lock mode is turned on."
:type '(choice (const :tag "never" nil)
(number :tag "seconds"))
:group 'jit-lock)
(defcustom jit-lock-stealth-nice 0.125
"*Time in seconds to pause between chunks of stealth fontification.
Each iteration of stealth fontification is separated by this amount of time,
thus reducing the demand that stealth fontification makes on the system.
If nil, means stealth fontification is never paused.
To reduce machine load during stealth fontification, at the cost of stealth
taking longer to fontify, you could increase the value of this variable.
See also `jit-lock-stealth-load'."
:type '(choice (const :tag "never" nil)
(number :tag "seconds"))
:group 'jit-lock)
(defcustom jit-lock-stealth-load
(if (condition-case nil (load-average) (error)) 200)
"*Load in percentage above which stealth fontification is suspended.
Stealth fontification pauses when the system short-term load average (as
returned by the function `load-average' if supported) goes above this level,
thus reducing the demand that stealth fontification makes on the system.
If nil, means stealth fontification is never suspended.
To reduce machine load during stealth fontification, at the cost of stealth
taking longer to fontify, you could reduce the value of this variable.
See also `jit-lock-stealth-nice'."
:type (if (condition-case nil (load-average) (error))
'(choice (const :tag "never" nil)
(integer :tag "load"))
'(const :format "%t: unsupported\n" nil))
:group 'jit-lock)
(defcustom jit-lock-stealth-verbose nil
"*If non-nil, means stealth fontification should show status messages."
:type 'boolean
:group 'jit-lock)
(defcustom jit-lock-defer-contextually 'syntax-driven
"*If non-nil, means deferred fontification should be syntactically true.
If nil, means deferred fontification occurs only on those lines modified. This
means where modification on a line causes syntactic change on subsequent lines,
those subsequent lines are not refontified to reflect their new context.
If t, means deferred fontification occurs on those lines modified and all
subsequent lines. This means those subsequent lines are refontified to reflect
their new syntactic context, either immediately or when scrolling into them.
If any other value, e.g., `syntax-driven', means deferred syntactically true
fontification occurs only if syntactic fontification is performed using the
buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.
The value of this variable is used when JIT Lock mode is turned on."
:type '(choice (const :tag "never" nil)
(const :tag "always" t)
(other :tag "syntax-driven" syntax-driven))
:group 'jit-lock)
;;; Variables that are not customizable.
(defvar jit-lock-mode nil
"Non-nil means Just-in-time Lock mode is active.")
(make-variable-buffer-local 'jit-lock-mode)
(defvar jit-lock-first-unfontify-pos nil
"Consider text after this position as unfontified.")
(make-variable-buffer-local 'jit-lock-first-unfontify-pos)
(defvar jit-lock-stealth-timer nil
"Timer for stealth fontification in Just-in-time Lock mode.")
;;; JIT lock mode
;;;###autoload
(defun jit-lock-mode (arg)
"Toggle Just-in-time Lock mode.
With arg, turn Just-in-time Lock mode on if and only if arg is positive.
Enable it automatically by customizing group `font-lock'.
When Just-in-time Lock mode is enabled, fontification is different in the
following ways:
- Demand-driven buffer fontification triggered by Emacs C code.
This means initial fontification of the whole buffer does not occur.
Instead, fontification occurs when necessary, such as when scrolling
through the buffer would otherwise reveal unfontified areas. This is
useful if buffer fontification is too slow for large buffers.
- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
This means remaining unfontified areas of buffers are fontified if Emacs has
been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
This is useful if any buffer has any deferred fontification.
- Deferred context fontification if `jit-lock-defer-contextually' is
non-nil. This means fontification updates the buffer corresponding to
true syntactic context, after `jit-lock-stealth-time' seconds of Emacs
idle time, while Emacs remains idle. Otherwise, fontification occurs
on modified lines only, and subsequent lines can remain fontified
corresponding to previous syntactic contexts. This is useful where
strings or comments span lines.
Stealth fontification only occurs while the system remains unloaded.
If the system load rises above `jit-lock-stealth-load' percent, stealth
fontification is suspended. Stealth fontification intensity is controlled via
the variable `jit-lock-stealth-nice' and `jit-lock-stealth-lines'."
(interactive "P")
(setq jit-lock-mode (if arg
(> (prefix-numeric-value arg) 0)
(not jit-lock-mode)))
(cond ((and jit-lock-mode
(or (not (boundp 'font-lock-mode))
(not font-lock-mode)))
;; If font-lock is not on, turn it on, with Just-in-time
;; Lock mode as support mode; font-lock will call us again.
(let ((font-lock-support-mode 'jit-lock-mode))
(font-lock-mode t)))
;; Turn Just-in-time Lock mode on.
(jit-lock-mode
;; Setting `font-lock-fontified' makes font-lock believe the
;; buffer is already fontified, so that it won't highlight
;; the whole buffer.
(make-local-variable 'font-lock-fontified)
(setq font-lock-fontified t)
(setq jit-lock-first-unfontify-pos nil)
;; Install an idle timer for stealth fontification.
(when (and jit-lock-stealth-time
(null jit-lock-stealth-timer))
(setq jit-lock-stealth-timer
(run-with-idle-timer jit-lock-stealth-time
jit-lock-stealth-time
'jit-lock-stealth-fontify)))
;; Add a hook for deferred contectual fontification.
(when (or (eq jit-lock-defer-contextually 'always)
(and (not (eq jit-lock-defer-contextually 'never))
(null font-lock-keywords-only)))
(add-hook 'after-change-functions 'jit-lock-after-change))
;; Install the fontification hook.
(add-hook 'fontification-functions 'jit-lock-function))
;; Turn Just-in-time Lock mode off.
(t
;; Cancel our idle timer.
(when jit-lock-stealth-timer
(cancel-timer jit-lock-stealth-timer)
(setq jit-lock-stealth-timer nil))
;; Remove hooks.
(remove-hook 'after-change-functions 'jit-lock-after-change)
(remove-hook 'fontification-functions 'jit-lock-function))))
;;;###autoload
(defun turn-on-jit-lock ()
"Unconditionally turn on Just-in-time Lock mode."
(jit-lock-mode 1))
;;; On demand fontification.
(defun jit-lock-function (start)
"Fontify current buffer starting at position START.
This function is added to `fontification-functions' when `jit-lock-mode'
is active."
(when jit-lock-mode
(with-buffer-prepared-for-font-lock
(let ((end (min (point-max) (+ start jit-lock-chunk-size)))
(parse-sexp-lookup-properties font-lock-syntactic-keywords)
(old-syntax-table (syntax-table))
(font-lock-beginning-of-syntax-function nil)
next)
(when font-lock-syntax-table
(set-syntax-table font-lock-syntax-table))
(save-excursion
(save-restriction
(widen)
(save-match-data
(condition-case error
;; Fontify chunks beginning at START. The end of a
;; chunk is either `end', or the start of a region
;; before `end' that has already been fontified.
(while start
;; Determine the end of this chunk.
(setq next (or (text-property-any start end 'fontified t)
end))
;; Goto to the start of the chunk. Make sure we
;; start fontifying at the beginning of the line
;; containing the chunk start because font-lock
;; functions seem to expects this, if I believe
;; lazy-lock.
(goto-char start)
(unless (bolp)
(beginning-of-line)
(setq start (point)))
;; Fontify the chunk, and mark it as fontified.
(unwind-protect
(font-lock-fontify-region start end nil))
;; Even if we got an error above, mark the region as
;; fontified. If we get an error now, we're
;; probably getting the same error the next time we
;; try, so it's moot to try again.
(add-text-properties start next '(fontified t))