3266 lines
135 KiB
EmacsLisp
3266 lines
135 KiB
EmacsLisp
;;; gnuplot.el --- Major-mode and interactive frontend for gnuplot
|
||
|
||
;; Copyright (C) 1998, 2011 Phil Type and Bruce Ravel, 1999-2012 Bruce Ravel
|
||
|
||
;; Author: Jon Oddie
|
||
;; Bruce Ravel
|
||
;; Phil Type
|
||
;; Maintainer: Bruce Ravel <bruceravel1@gmail.com>
|
||
;; Created: June 28 1998
|
||
;; Version: 0.7.0
|
||
;; Keywords: data gnuplot plotting
|
||
;; URL: https://github.com/emacsorphanage/gnuplot
|
||
;; Package-Requires: ((emacs "24.1"))
|
||
|
||
;; This file is not part of GNU Emacs.
|
||
|
||
;; 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 3 of the License, 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. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
;;; Commentary:
|
||
|
||
;; This is a major mode for composing gnuplot scripts and displaying
|
||
;; their results using gnuplot. It supports features of recent
|
||
;; Gnuplot versions (4.4 and up), but should also work fine with older
|
||
;; versions.
|
||
;;
|
||
;; This version of gnuplot-mode has been tested mostly on GNU Emacs 23
|
||
;; and 24, but should also work with older GNU Emacs versions back to
|
||
;; Emacs 21, and XEmacs 21.
|
||
;;
|
||
;; This mode offers several tools to help you compose your scripts,
|
||
;; including font-lock syntax colorization, a syntax table appropriate
|
||
;; to gnuplot, key bindings, pull-down menus, indentation, keyword
|
||
;; completions and variable customization using the Custom package.
|
||
;; Once the script is composed, there are several function for sending
|
||
;; some or all of the script to gnuplot. The interaction with the
|
||
;; gnuplot process is within a comint buffer. Plots can optionally be
|
||
;; displayed within Emacs.
|
||
;;
|
||
;; C-c C-l send current line to gnuplot
|
||
;; C-c C-v send current line to gnuplot and move forward 1 line
|
||
;; C-c C-r send current region to gnuplot
|
||
;; C-c C-b send entire buffer to gnuplot
|
||
;; C-c C-f send a file to gnuplot
|
||
;; C-c C-i insert filename at point
|
||
;; C-c C-n negate set option on current line
|
||
;; C-c C-c comment region
|
||
;; C-c C-o set arguments for command at point
|
||
;; S-mouse-2 set arguments for command under mouse cursor
|
||
;; C-c C-d read the gnuplot info file
|
||
;; C-c C-e show-gnuplot-buffer
|
||
;; C-c C-k kill gnuplot process
|
||
;; C-c C-u submit a bug report about gnuplot-mode
|
||
;; C-c C-z customize gnuplot-mode
|
||
;; M-tab or M-ret complete keyword before point
|
||
;; ret newline and indent
|
||
;; tab indent current line
|
||
;; C-c M-i toggle inline plot display in comint buffer
|
||
;;
|
||
;; With the exception of the commands for sending commands to Gnuplot,
|
||
;; most of the above commands also work in the Gnuplot comint buffer,
|
||
;; in addition to the following:
|
||
;; M-C-p plot the most recent script buffer line-by-line
|
||
;; M-C-f save the current script buffer and load that file
|
||
;; C-c C-e pop back to most recent script buffer
|
||
;;
|
||
;; These two functions are useful for starting up gnuplot-mode:
|
||
;;
|
||
;; M-x gnuplot-mode
|
||
;; start gnuplot-mode in the current buffer
|
||
;;
|
||
;; M-x gnuplot-make-buffer
|
||
;; open a new buffer (which is not visiting a file) and start
|
||
;; gnuplot-mode in that buffer
|
||
;;
|
||
;; Gnuplot-mode now includes context-sensitive support for keyword
|
||
;; completion and, optionally, eldoc-mode help text. See the
|
||
;; commentary in gnuplot-context.el for more information. If you
|
||
;; don't find it useful, it can be turned off by customizing
|
||
;; `gnuplot-context-sensitive-mode'.
|
||
;;
|
||
;;
|
||
;; ---------------------------------------------------------------------
|
||
;;
|
||
;; Other Lisp files used by gnuplot.el
|
||
;;
|
||
;; gnuplot-gui.el (written by Bruce):
|
||
;; Defines the GUI interface for setting setting arguments to
|
||
;; gnuplot options. This uses the widget package extensively.
|
||
;;
|
||
;; gnuplot-context.el (written by Jonathan, j.j.oddie@gmail.com)
|
||
;; Context-sensitive completion, help lookup and eldoc
|
||
;; strings for gnuplot buffers. Should be byte-compiled before
|
||
;; using.
|
||
;;
|
||
;; ---------------------------------------------------------------------
|
||
;;
|
||
;; This mode was inspired by the original gnu-plot-mode by Gershon
|
||
;; Elber, which is distributed with gnuplot itself and which dates
|
||
;; back to the early 90's. Although this mode encompasses the
|
||
;; functionality of the original, the two share no code and the
|
||
;; current implementation takes advantage of many features of modern
|
||
;; versions of Emacs and adheres (or so I intend) to the major mode
|
||
;; conventions described in the emacs-lisp reference for version 19
|
||
;; and later.
|
||
;;
|
||
;; ---------------------------------------------------------------------
|
||
;;
|
||
;; Installation
|
||
;; ============
|
||
;;
|
||
;; A recent version of this file can be found at
|
||
;; https://github.com/emacsorphanage/gnuplot/
|
||
;;
|
||
;; To autoload gnuplot-mode on any file with gp extension, put this in
|
||
;; your .emacs file
|
||
;; (autoload 'gnuplot-mode "gnuplot" "gnuplot major mode" t)
|
||
;; (autoload 'gnuplot-make-buffer "gnuplot" "open a buffer in gnuplot-mode" t)
|
||
;;
|
||
;; Something like
|
||
;; (setq auto-mode-alist (append '(("\\.gp$" . gnuplot-mode))
|
||
;; auto-mode-alist))
|
||
;; is useful for having files ending in .gp start up in gnuplot-mode.
|
||
;;
|
||
;; Something like
|
||
;; (global-set-key [(f9)] 'gnuplot-make-buffer)
|
||
;; may be useful. This binds f9 to the function that opens a scratch
|
||
;; buffer (i.e. one that is not visiting a file) in gnuplot-mode.
|
||
;; This is handy for your quick 'n' dirty plotting chores.
|
||
;;
|
||
;; To use the `gnuplot-info-lookup-symbol' function, the file
|
||
;; gnuplot.info MUST be installed somewhere that info can find it.
|
||
;; This means you must either:
|
||
;; 1. Copy gnuplot.info to the normal info directory or
|
||
;; 2. Make sure info can find gnuplot.info by putting this in your
|
||
;; .emacs file:
|
||
;; (setenv "INFOPATH"
|
||
;; (concat (getenv "INFOPATH") ":"
|
||
;; (expand-file-name "/path/to/file")))
|
||
;; where "/path/to/file" is the location of gnuplot.info
|
||
;;
|
||
;; This mode has been tested extensively with GNU Emacs 23 and 24, and
|
||
;; in a limited manner with GNU Emacs 22 and XEmacs 21.
|
||
;;
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
|
||
;;; History:
|
||
|
||
;;
|
||
;; 0.1 Jun 25 1998 Finished with initial release.
|
||
;; 0.2 Sep 4 1998 Added filename insertion, indentation, and
|
||
;; colorization/completion in comint buffer. <BR>
|
||
;; 0.2a Sep 11 1998 made `indent-line-function' buffer-local (whoops!)
|
||
;; and fixed some stuff in the installation script <BR>
|
||
;; 0.3 Sep 12 1998 include insertions menu <BR>
|
||
;; 0.3a Sep 14 1998 fixed bug finding info file if missing, fixed bug
|
||
;; starting font-lock, fixed bug re overwriting files in
|
||
;; installation script <BR>
|
||
;; 0.3b Sep 15 1998 Added (require 'info) to `(eval-and-compile'
|
||
;; clause, Added (kill-all-local-variables) to `gnuplot-mode',
|
||
;; altered order of:-
|
||
;; (provide 'gnuplot)
|
||
;; (run-hooks 'gnuplot-load-hook)
|
||
;; at the end of the file in case something in the load hook
|
||
;; requires gnuplot (oh not that old one again...), added
|
||
;; `gnuplot-comint-setup-hook', corrected `gnuplot-mark-active'
|
||
;; which caused an error to be raised by (mark) when the mark
|
||
;; was inactive <DB> Some changes to font-lock rules <LB>&<BR>
|
||
;; 0.4 Nov 14 1998 <BR> Use info-look for info interface. No
|
||
;; change to gnuplot-mode user interface, but cleaner code.
|
||
;; With info-look, the help funcion works regardless of the
|
||
;; version number of gnuplot. Also, `gnuplot-keywords' (used
|
||
;; for help, keyword-completion, and hilit19 highlighting) is
|
||
;; now generated automatically.
|
||
;; 0.4a Nov 18 1998 <BR> info-look leaves a couple of really useless
|
||
;; buffers lying around so I cleaned them up. Also fixed
|
||
;; font-lock rules so that things in quotes get highlighted
|
||
;; correctly and the surrounding text is unhighlighted. Fixed
|
||
;; up font-lock rules for plot and splot. Added
|
||
;; `gnuplot-send-line-and-forward' as suggested by <MD>.
|
||
;; 0.4b Nov 21 1998 <BR> added toolbar for xemacs -- see file
|
||
;; gnuplot-toolbar.el. fixed error message in plot line
|
||
;; function when line is empty. option added to display the
|
||
;; comint buffer showing the gnuplot process in a separate
|
||
;; frame
|
||
;; 0.4c Minor stuff: Nov 30 1998 <BR> fixed highlighting in comint
|
||
;; buffer. fixed frame behavior. added "[:]" to range
|
||
;; insertions. added :link to defgroup. Dec 1 1998 <BR> fixed
|
||
;; some mismatched defcustoms. added a few lines to suppress
|
||
;; some compile-time warnings. Dec 3 1998 <BR> Fixed behavior
|
||
;; of filename insertion function. Added more :links to
|
||
;; defgroup.
|
||
;; 0.4d Dec 6 1998 <BR> Added function gnuplot-setup-info-look and
|
||
;; variable gnuplot-info-hook to handle various versions of the
|
||
;; gnuplot info file.
|
||
;; 0.4e Dec 12 1998 <BR> Split up gnuplot-insertions-menu for ease of
|
||
;; custimization, put menubar initialization in a function.
|
||
;; 0.4f Dec 14 1998 <BR> defcustom the insertions submenus, add
|
||
;; gnuplot-insertion-menu-flag, intelligent Makefile knows
|
||
;; which info-look to compile
|
||
;; 0.5 Dec 27 1998 <BR> wrote initial draft of gnuplot-gui.el,
|
||
;; included it in insertions menu and in `gnuplot-insert'.
|
||
;; Negate option function, bound to C-c C-n. Dec 29 1998 <BR>
|
||
;; C-c C-h with no response goes to Commands menu. Transparent
|
||
;; toolbar icons. Replace kw-compl with a simple completion
|
||
;; function. Put gnuplot-toolbar code in gnuplot.el.
|
||
;; 0.5a Jan 23 1999 <BR> send file uses the load command. add
|
||
;; gnuplot-plot-from-comint and
|
||
;; gnuplot-save-and-plot-from-comint and keybindings in the
|
||
;; comint buffer. do (process-kill-without-query
|
||
;; gnuplot-process nil). `gnuplot-negate-option' checks if set
|
||
;; option has a negated form.
|
||
;; 0.5b `gnuplot-kill-gnuplot-buffer' made more robust. fixed a bug
|
||
;; in `gnuplot-plot-from-comint'. fixed description of
|
||
;; gnuplot-faces group.
|
||
;; 0.5c update copyright information, update gpelcard
|
||
;; 0.5d Mar 20 1999 <BR> adopt installation materials from <LH>. Add
|
||
;; some support for hidden3d. Use constants in types alists in
|
||
;; gui. Various other minor improvements to the types alists.
|
||
;; 0.5e Apr 6 1999 <BR> at the suggestion of <SE> I did away with the
|
||
;; gnuplot-which-highlight variable and revamped how
|
||
;; colorization gets turned on. This is a bit tricky since I
|
||
;; want it to work with font-lock under emacs and xemacs and
|
||
;; with hilit19. Apr 11 1999 <BR> insert space at end of
|
||
;; unique completion. add a few GUI types, rewrite some stuff
|
||
;; in the GUI interface. primitive support for plot, splot,
|
||
;; and fit. Fixed completion in file widget.
|
||
;; 0.5f May 15 1999 <BR> Add pgnuplot.c and Win9x install instructions
|
||
;; to the distribution. Fixed a defface bug. Added
|
||
;; `gnuplot-keywords-when' allowing deferral of parsing the
|
||
;; info file.
|
||
;; 0.5g May 27 1999 <BR> Fixed font-locking of strings and
|
||
;; comments. Figure out gnuplot-version number from startup
|
||
;; message and set `gnuplot-echo-command-line-flag'
|
||
;; accordingly. Added `gnuplot-program-version' variable.
|
||
;; Check that font-lock is actually a feature, as suggested by
|
||
;; <KL>
|
||
;; 0.5h Aug 15 1999 <BR> Added `gnuplot-determine-gnuplot-version' so
|
||
;; that the gnuplot version number and `comint-process-echos'
|
||
;; actually get set correctly. Actually, the first time
|
||
;; something is plotted, the echoing might not work, but the
|
||
;; second time it will.
|
||
;; 0.5i Sep 2 1999 <BR> Once again changed how
|
||
;; `comint-process-echos' gets set. Maybe I got it right this
|
||
;; time? Also fixed certain situations where the info file
|
||
;; did notget properly loaded (insertion with info toggle on
|
||
;; and info button in GUI).
|
||
;; 0.5j Sep 9 1999 <BR> Do a more robust check for the gnuplot
|
||
;; process before killing the gnuplot buffer, as suggested by
|
||
;; <SE>.
|
||
;; 0.5k Sep 22 1999 <BR> make `gnuplot-send-line-and-forward' skip
|
||
;; over blank and comment lines as suggested by <SE>. Jan 10
|
||
;; 2000 Bound C-c C-j to `gnuplot-forward-script-line'.
|
||
;; 0.5l Nov 16 2000 <BR> support for pm3d in gnuplot-gui and in plot
|
||
;; options insertions menu. mentioned pm3d in gpelcard. gui
|
||
;; support for x11 pm3d and vgagl terms.
|
||
;; `gnuplot-negate-option' works with new syntax.
|
||
;; 0.5m Nov 17 2000 <BR> add colorization and gui support for new
|
||
;; commands in 3.8. gui support for emf term. gui support for
|
||
;; new "set style" syntax. much better scheme for determining
|
||
;; gnuplot version number + make better use of it.
|
||
;; 0.5n Jan 4 2001 <BR> corrected a serious problem interacting with
|
||
;; speedbar
|
||
;; 0.5o skipped
|
||
;; 0.5p Mar 14 2001 <BR> fixed problem with toolbar creation and
|
||
;; speedbar clicking
|
||
;; 0.5q May 30 2001 <BR> added font-lock bindings for words associated
|
||
;; with plotting
|
||
;; 0.5r Oct 17 2001 <BR> Incorporate two suggestions by <RF>, bind
|
||
;; C-c C-c to comment-region and C-c C-o to the GUI, also make
|
||
;; C-c C-l respect continuation lines
|
||
;; April 12, 2002 <BR> added feature to trim length of gnuplot
|
||
;; process buffer
|
||
;; 0.5s Jun 7 2002 <BR> Yet again changed how `comint-process-echos'
|
||
;; gets set. It really needs to be nil on NTEmacs 21.1 or
|
||
;; comint gets stuck in an infinate loop.
|
||
;; 0.5t Sep 16 2002 <BR> Fixed a problem with C-c C-v jumping
|
||
;; forward 2 lines at a time
|
||
;; 0.6.0 Dec 13 2002 <BR> Changed numbering scheme to accommodate
|
||
;; gnuplot packaging requirements
|
||
;; 0.6.1 Sep 13 2011 <BR> Moved to github, updated contact info
|
||
;; 0.7.0 Oct 20 2012 <jjo> Contextual completion & help, inline plots,
|
||
;; some other stuff
|
||
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
;;; Acknowledgements:
|
||
;; David Batty <DB> (numerous corrections)
|
||
;; Laurent Bonnaud <LB> (suggestions regarding font-lock rules)
|
||
;; Markus Dickebohm <MD> (suggested `gnuplot-send-line-and-forward')
|
||
;; Stephen Eglan <SE> (suggested the use of info-look,
|
||
;; contributed a bug fix regarding shutting
|
||
;; down the gnuplot process, improvement to
|
||
;; `gnuplot-send-line-and-forward')
|
||
;; Robert Fenk <RF> (suggested respecting continuation lines)
|
||
;; Michael Karbach <MK> (suggested trimming the gnuplot process buffer)
|
||
;; Alex Chan Libchen <AL> (suggested font-lock for plotting words)
|
||
;; Kuang-Yu Liu <KL> (pointed out buggy dependence on font-lock)
|
||
;; Hrvoje Niksic <HN> (help with defcustom arguments for insertions)
|
||
;; Andreas Rechtsteiner <AR> (pointed out problem with C-c C-v)
|
||
;; Michael Sanders <MS> (help with the info-look interface)
|
||
;; Jinwei Shen <JS> (suggested functionality in comint buffer)
|
||
;; Michael M. Tung <MT> (prompted me to add pm3d support)
|
||
;; Holger Wenzel <HW> (suggested using `gnuplot-keywords-when')
|
||
;; Wolfgang Zocher <WZ> (pointed out problem with gnuplot-mode + speedbar)
|
||
;; Jon Oddie <jjo> (indentation, inline images, context mode)
|
||
;;
|
||
;; and especially to Lars Hecking <LH> for including gnuplot-mode
|
||
;; with the gnuplot 3.7-beta distribution and for providing me with
|
||
;; installation materials
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
;;; To Do:
|
||
;;
|
||
;; 1. Since `gnuplot-display-process' can be nil, it would be
|
||
;; handy to have a function to put on
|
||
;; `gnuplot-after-plot-buffer-hook' to check and see if the script
|
||
;; executed properly. Alas I am not sure how gnuplot signals its
|
||
;; errors.
|
||
;; 2. improve plot, splot, fit in GUI
|
||
;; 3. interface to setting bind command using `read-key-sequence'.
|
||
;; this is a pain because the nomenclature is really different in
|
||
;; gnuplot than in `read-key-sequence'
|
||
;;
|
||
;;
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
|
||
;;; Code:
|
||
|
||
(require 'comint)
|
||
(require 'easymenu)
|
||
(eval-when-compile (require 'cl))
|
||
|
||
(declare-function 'eldoc-add-command "eldoc")
|
||
|
||
|
||
;;; --- variable definitions + eval-and-compile clauses
|
||
|
||
;; We no longer hack around ancient versions of Customize with macros
|
||
(require 'custom)
|
||
|
||
(eval-and-compile ;; <DB>
|
||
(require 'info))
|
||
|
||
(eval-and-compile
|
||
(condition-case ()
|
||
(require 'info-look)
|
||
(error nil)))
|
||
|
||
;; Workaround missing `completion-at-point' in (X)Emacs < 22
|
||
(if (not (fboundp 'completion-at-point))
|
||
(defun gnuplot-xemacs-completion-at-point ()
|
||
"Perform completion on keyword preceding point.
|
||
|
||
This binds `comint-dynamic-complete-functions' to
|
||
`gnuplot-comint-complete' and uses `comint-dynamic-complete' to do the
|
||
real work."
|
||
(interactive)
|
||
(let ((comint-dynamic-complete-functions
|
||
'(gnuplot-comint-complete)))
|
||
(completion-at-point))))
|
||
|
||
;; Work around missing `window-full-height-p'
|
||
(if (fboundp 'window-full-height-p)
|
||
(defalias 'gnuplot-window-full-height-p 'window-full-height-p)
|
||
;; The below is taken from window.el in GNU Emacs
|
||
(defun gnuplot-window-full-height-p (&optional window)
|
||
(unless window
|
||
(setq window (selected-window)))
|
||
(= (window-height window)
|
||
(window-height (frame-root-window (window-frame window))))))
|
||
|
||
;; Workaround obsolete `process-kill-without-query'
|
||
(if (fboundp 'set-process-query-on-exit-flag)
|
||
(defalias 'gnuplot-set-process-query-on-exit-flag 'set-process-query-on-exit-flag)
|
||
(defalias 'gnuplot-set-process-query-on-exit-flag 'process-kill-without-query))
|
||
|
||
;; Workaround for missing syntax-ppss in XEmacs
|
||
(if (fboundp 'syntax-ppss)
|
||
(defalias 'gnuplot-syntax-ppss 'syntax-ppss)
|
||
(defun gnuplot-syntax-ppss (&optional pos)
|
||
(save-excursion
|
||
(unless pos (setq pos (point)))
|
||
(let ((begin
|
||
(save-excursion
|
||
(goto-char pos)
|
||
(gnuplot-point-at-beginning-of-continuation))))
|
||
(parse-partial-sexp begin pos)))))
|
||
|
||
|
||
;;;;
|
||
(defconst gnuplot-xemacs-p (string-match "XEmacs" (emacs-version)))
|
||
(defconst gnuplot-ntemacs-p (string-match "msvc" (emacs-version)))
|
||
(defvar gnuplot-three-eight-p "")
|
||
|
||
(defconst gnuplot-maintainer "Jon Oddie")
|
||
(defconst gnuplot-maintainer-url
|
||
"https://github.com/emacsorphanage/gnuplot/")
|
||
(defconst gnuplot-version "0.7-beta")
|
||
|
||
(defgroup gnuplot nil
|
||
"Gnuplot-mode for Emacs."
|
||
:prefix "gnuplot-"
|
||
:group 'processes
|
||
:group 'applications
|
||
:group 'local
|
||
:link '(emacs-library-link :tag "Lisp File" "gnuplot.el")
|
||
:link '(url-link :tag "Homepage"
|
||
"https://github.com/emacsorphanage/gnuplot/")
|
||
:link '(custom-manual "(gnuplot)Top")
|
||
:link '(emacs-commentary-link :tag "Commentary" "gnuplot.el"))
|
||
(defgroup gnuplot-insertions nil
|
||
"Insert commands into gnuplot-scripts from a pull-down menu."
|
||
:prefix "gnuplot-insertions-"
|
||
:group 'gnuplot)
|
||
(defgroup gnuplot-hooks nil
|
||
"Hook variables used by `gnuplot-mode'."
|
||
:prefix "gnuplot-"
|
||
:group 'gnuplot)
|
||
|
||
(defcustom gnuplot-mode-hook nil
|
||
"Hook run when `gnuplot-mode' is entered."
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
(defcustom gnuplot-load-hook nil
|
||
"Hook run when gnuplot.el is first loaded."
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
(defcustom gnuplot-after-plot-hook nil
|
||
"Hook run after gnuplot plots something.
|
||
This is the last thing done by the functions for plotting a line, a
|
||
region, a buffer, or a file."
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
|
||
|
||
(defcustom gnuplot-info-hook nil
|
||
"Hook run before setting up the info-look interface.
|
||
This hook is necessary to handle inconsistencies in versions of and
|
||
sources of the gnuplot info file. If Gnuplot-mode can find the info
|
||
file generated from the 3.6beta patchlevel 347 (or later) release of
|
||
Gnuplot, then this hook probably is not necessary. Some versions of
|
||
the info file may have a General Index session, which can be used by
|
||
info-look. In that case the following (or something similar with the
|
||
value of `info-lookup-symbol-alist' altered appropriately) should be
|
||
placed in the .emacs file.
|
||
|
||
Emacs version 20.2 ships with a different version of info-look that
|
||
does 20.3. If you use any version of Emacs 19, you must use the
|
||
version from 20.2. Any version of XEmacs 20 or 21 should use the
|
||
version from 20.3 but can use either. XEmacs 19 should use the
|
||
version 20.2.
|
||
|
||
For the newer version of info-look, do this:
|
||
|
||
(add-hook \'gnuplot-info-hook
|
||
\'(lambda ()
|
||
(let ((elem (assoc \'gnuplot-mode info-lookup-alist)))
|
||
(delete elem info-lookup-alist)
|
||
(info-lookup-maybe-add-help
|
||
:mode 'gnuplot-mode :topic 'symbol
|
||
:regexp \"[a-zA-Z][_a-zA-Z0-9]*\"
|
||
:doc-spec '((\"(gnuplot)General Index\" nil
|
||
\"[_a-zA-Z0-9]+\"))))))
|
||
|
||
For the older version of info-look, do this:
|
||
|
||
(add-hook \'gnuplot-info-hook
|
||
\'(lambda ()
|
||
(let ((elem (assoc \'gnuplot-mode info-lookup-alist)))
|
||
(delete elem info-lookup-alist)
|
||
(setq info-lookup-alist
|
||
(append info-lookup-alist
|
||
\'((gnuplot-mode
|
||
\"[a-zA-Z][_a-zA-Z0-9]*\" nil
|
||
((\"(gnuplot)General Index\" nil
|
||
\"[_a-zA-Z0-9]+\" )))))))))"
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
|
||
;; comint hook suggested by <DB>
|
||
(defcustom gnuplot-comint-setup-hook nil
|
||
"Hook run after setting up the gnuplot buffer in comint mode.
|
||
So the configuration can be customised by the user."
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
|
||
(defcustom gnuplot-comint-mode-hook nil
|
||
"Hook run after setting up the gnuplot buffer in gnuplot-comint-mode.
|
||
By default this runs the hook named `gnuplot-comint-setup-hook',
|
||
for backward compatibility."
|
||
:group 'gnuplot-hooks
|
||
:type 'hook)
|
||
|
||
(defvar gnuplot-recently-sent nil
|
||
"This is a record of the most recent kind of text sent to gnuplot.
|
||
It takes as its value nil, 'line, 'region, 'buffer, or 'file. It is
|
||
useful for functions included in `gnuplot-after-plot-hook'.")
|
||
(make-variable-buffer-local 'gnuplot-recently-sent)
|
||
|
||
(defcustom gnuplot-program "gnuplot"
|
||
"The name of the gnuplot executable."
|
||
:group 'gnuplot
|
||
:type 'string)
|
||
(defvar gnuplot-program-version nil
|
||
"Version number of gnuplot.
|
||
This is using `gnuplot-fetch-version-number'.")
|
||
(defvar gnuplot-program-major-version nil
|
||
"Major version number of gnuplot.
|
||
This is found using `gnuplot-fetch-version-number'.")
|
||
(defvar gnuplot-program-minor-version nil
|
||
"Minor version number of gnuplot.
|
||
This is found using `gnuplot-fetch-version-number'.")
|
||
|
||
(defcustom gnuplot-process-name "gnuplot"
|
||
"Name given to the gnuplot buffer and process."
|
||
:group 'gnuplot
|
||
:type 'string)
|
||
(defvar gnuplot-buffer nil
|
||
"The name of the buffer displaying the gnuplot process.")
|
||
(defvar gnuplot-process nil
|
||
"Variable holding the process handle.")
|
||
(defvar gnuplot-process-frame nil
|
||
"The frame for displaying the gnuplot process.
|
||
This is used when `gnuplot-display-process' is equal to 'frame.")
|
||
(defvar gnuplot-comint-recent-buffer nil
|
||
"The most recently plotted gnuplot script buffer.
|
||
This is used by the function that plot from the comint buffer. It is
|
||
reset every time something is plotted from a script buffer.")
|
||
|
||
(defcustom gnuplot-gnuplot-buffer "plot.gp"
|
||
"The name of the gnuplot scratch buffer opened by 'gnuplot-make-buffer'."
|
||
:group 'gnuplot
|
||
:type 'string)
|
||
|
||
(defcustom gnuplot-display-process 'window
|
||
"This controls how the gnuplot process buffer is displayed.
|
||
The values are
|
||
'frame display gnuplot process in a separate frame
|
||
'window display gnuplot process in this frame but in another window
|
||
nil `gnuplot-process' is in the current frame but not displayed"
|
||
:group 'gnuplot
|
||
:type '(radio (const :tag "Separate frame" frame)
|
||
(const :tag "Separate window" window)
|
||
(const :tag "Not displayed" nil)))
|
||
(defcustom gnuplot-info-display 'window
|
||
"Determines how `gnuplot-info-lookup-symbol' displays the info file.
|
||
The values are
|
||
'frame display info file in a separate frame
|
||
'window display info file in another window
|
||
nil display info file in the current window"
|
||
:group 'gnuplot
|
||
:type '(radio (const :tag "Separate frame" frame)
|
||
(const :tag "Separate window" window)
|
||
(const :tag "This window" nil)))
|
||
|
||
(defcustom gnuplot-echo-command-line-flag (not gnuplot-ntemacs-p)
|
||
"Non-nil means the gnuplot subprocess echoes any input.
|
||
This sets the fall-back value of `comint-process-echoes'.
|
||
If `gnuplot-mode' cannot figure out what version number of gnuplot
|
||
this is, then the value of this variable will be used for
|
||
`comint-process-echos'. It seems that gnuplot 3.5 wants this to be
|
||
nil and 3.7 wants it to be t. If lines that you send to gnuplot from
|
||
the `gnuplot-mode' buffer are not appearing at the gnuplot prompt in
|
||
the process buffer, try toggling it. Also see the document string for
|
||
`comint-process-echos'. If you change this, kill the gnuplot process
|
||
and start it again."
|
||
:group 'gnuplot
|
||
:type 'boolean)
|
||
(defcustom gnuplot-insertions-show-help-flag nil
|
||
"Non-nil means to display certain help messages automatically.
|
||
These messages are shown after menu insertion of gnuplot commands."
|
||
:group 'gnuplot-insertions
|
||
:type 'boolean)
|
||
|
||
(defcustom gnuplot-delay 0.01
|
||
"Amount of time to delay before sending a new line to gnuplot.
|
||
This is needed so that the the line is not written in the gnuplot
|
||
buffer in advance of its prompt. Increase this number if the
|
||
prompts and lines are displayed out of order."
|
||
:group 'gnuplot
|
||
:type 'number)
|
||
(defcustom gnuplot-buffer-max-size 1000
|
||
"The maximum size in lines of the gnuplot process buffer.
|
||
Each time text is written in the gnuplot process buffer, lines are
|
||
trimmed from the beginning of the buffer so that the buffer is this
|
||
many lines long. The lines are deleted after the most recent lines
|
||
were interpretted by gnuplot. Setting to 0 turns off this feature."
|
||
:group 'gnuplot
|
||
:type 'integer)
|
||
(defcustom gnuplot-quote-character "\'"
|
||
"Quotation character used for inserting quoted strings.
|
||
Gnuplot can use single or double quotes. If you prefer to have the
|
||
filename insertion function never insert quotes for you, set this
|
||
to the empty string."
|
||
:group 'gnuplot
|
||
:type '(radio (const :tag "double quote" "\"")
|
||
(const :tag "single quote" "\'")
|
||
(const :tag "none" "" )))
|
||
(defcustom gnuplot-basic-offset 4
|
||
"Number of columns to indent lines inside a do- or if-else-block.
|
||
|
||
This applies only to new-style do- and if-statements using
|
||
braces. Commands continued over a linebreak using a backslash
|
||
are always indented to line up with the second word on the line
|
||
beginning the continued command."
|
||
:group 'gnuplot
|
||
:type 'integer)
|
||
|
||
;; (defcustom gnuplot-gnuplot-version nil
|
||
;; "Force gnuplot-mode to behave for this version of gnuplot."
|
||
;; :group 'gnuplot
|
||
;; :type '(radio (const :tag "unspecified" nil)
|
||
;; (const :tag "3.8 or newer" "3.8")
|
||
;; (const :tag "3.7 or older" "3.7")))
|
||
|
||
(defvar gnuplot-info-frame nil)
|
||
(defvar gnuplot-info-nodes '())
|
||
|
||
(defvar gnuplot-first-call t)
|
||
|
||
;; with info-look, there is no need to carry this list around -- it
|
||
;; can be generated on the fly appropriate to the currently installed
|
||
;; version of gnuplot.info
|
||
(defvar gnuplot-keywords nil
|
||
"A list of keywords used in GNUPLOT.
|
||
These are set by `gnuplot-set-keywords-list' from the values in
|
||
`info-lookup-cache'.")
|
||
(defvar gnuplot-keywords-alist nil) ;; For all-completions
|
||
(defvar gnuplot-keywords-pending t ;; <HW>
|
||
"A boolean which gets toggled when the info file is probed.")
|
||
(defcustom gnuplot-keywords-when 'deferred ;; 'immediately
|
||
"This variable controls when the info file is parsed.
|
||
The choices are immediately upon starting gnuplot-mode or the first
|
||
time that data is needed."
|
||
:group 'gnuplot
|
||
:type
|
||
'(radio (const :tag "Parse info file when gnuplot-mode starts" immediately)
|
||
(const :tag "Parse info file the first time it is needed" deferred)))
|
||
|
||
(defcustom gnuplot-use-context-sensitive-completion t
|
||
"Non-nil if `gnuplot-context-sensitive-mode' should be enabled by default.
|
||
|
||
In context-sensitive mode, gnuplot-mode parses the current
|
||
command line to provide smarter completion and documentation
|
||
suggestions."
|
||
:group 'gnuplot
|
||
:type 'boolean
|
||
:initialize 'custom-set-default
|
||
:set (lambda (sym value)
|
||
(dolist (buffer (buffer-list))
|
||
(with-current-buffer buffer
|
||
(when (derived-mode-p 'gnuplot-mode 'gnuplot-comint-mode)
|
||
(gnuplot-context-sensitive-mode
|
||
(if value 1 0))))))
|
||
:link '(emacs-commentary-link "gnuplot-context"))
|
||
|
||
(defcustom gnuplot-eldoc-mode nil
|
||
"Non-nil if ElDoc mode should be enabled by default in Gnuplot buffers.
|
||
ElDoc support requires `gnuplot-context-sensitive-mode' to be
|
||
on."
|
||
:group 'gnuplot
|
||
:type 'boolean)
|
||
|
||
(defcustom gnuplot-tab-completion nil
|
||
"Non-nil if TAB should perform completion in gnuplot-mode buffers.
|
||
|
||
Setting this to non-nil sets the `tab-always-indent' variable to the
|
||
symbol `complete' in gnuplot-mode buffers."
|
||
:group 'gnuplot
|
||
:type 'boolean)
|
||
|
||
(defun gnuplot-set-display-mode (variable value &rest args)
|
||
"Customize :set function for `gnuplot-inline-image-mode'.
|
||
Set VARIABLE to VALUE. ARGS is optional args."
|
||
(if (and (eq variable 'gnuplot-inline-image-mode)
|
||
value
|
||
(not (gnuplot-display-images-p)))
|
||
(progn
|
||
(message "Displaying images is not supported.")
|
||
(set variable nil))
|
||
(set variable value))
|
||
(gnuplot-setup-comint-for-image-mode))
|
||
|
||
(defcustom gnuplot-inline-image-mode nil
|
||
"Whether to display Gnuplot output in Emacs.
|
||
|
||
Possible values are nil, `inline' and `dedicated'.
|
||
|
||
When this is nil, Gnuplot output is handled outside of Emacs in
|
||
the normal way. Otherwise, Emacs attempts to capture Gnuplot's
|
||
output and display it in a buffer. Output is inserted inline in
|
||
the Gnuplot interaction buffer it this is `inline', in a
|
||
separate dedicated buffer if it is `dedicated'.
|
||
|
||
Use Customize to set this variable, or the commands
|
||
`gnuplot-external-display-mode', `gnuplot-inline-display-mode',
|
||
and `gnuplot-dedicated-display-mode'."
|
||
:group 'gnuplot
|
||
:type '(radio
|
||
(const :tag "No" nil)
|
||
(const :tag "In Comint buffer" inline)
|
||
(const :tag "In dedicated buffer" dedicated))
|
||
:initialize 'custom-initialize-default
|
||
:set 'gnuplot-set-display-mode)
|
||
|
||
(defcustom gnuplot-image-format "png"
|
||
"Image format to use for displaying images within Emacs.
|
||
|
||
This will be sent directly to Gnuplot as a command of the form
|
||
\"set terminal <FORMAT>\". Common values are \"png\" and
|
||
\"svg\".
|
||
|
||
This only has an effect when `gnuplot-inline-image-mode' is
|
||
non-nil."
|
||
:group 'gnuplot
|
||
:type 'string
|
||
:initialize 'custom-initialize-default
|
||
:set 'gnuplot-set-display-mode)
|
||
|
||
(defgroup gnuplot-faces nil
|
||
"Text faces used by gnuplot-mode."
|
||
:prefix "gnuplot-"
|
||
:group 'gnuplot)
|
||
|
||
(defface gnuplot-prompt-face '((((class color))
|
||
(:foreground "firebrick"))
|
||
(t
|
||
(:bold t :underline t)))
|
||
"Face used for the prompt in the gnuplot process buffer."
|
||
:group 'gnuplot-faces)
|
||
|
||
|
||
;;; --- key bindings and menus
|
||
|
||
(defvar gnuplot-mode-map
|
||
(let ((map (make-sparse-keymap))
|
||
(completion-function
|
||
(if (fboundp 'completion-at-point)
|
||
'completion-at-point
|
||
'gnuplot-xemacs-completion-at-point)))
|
||
(define-key map "\C-c\C-b" 'gnuplot-send-buffer-to-gnuplot)
|
||
(define-key map "\C-c\C-c" 'comment-region) ; <RF>
|
||
(define-key map "\C-c\C-o" 'gnuplot-gui-set-options-and-insert)
|
||
(define-key map "\C-c\C-w" 'gnuplot-show-version)
|
||
(define-key map "\C-c\C-e" 'gnuplot-show-gnuplot-buffer)
|
||
(define-key map "\C-c\C-f" 'gnuplot-send-file-to-gnuplot)
|
||
(define-key map "\C-c\C-d" 'gnuplot-info-lookup-symbol)
|
||
(define-key map "\C-c\C-i" 'gnuplot-insert-filename)
|
||
(define-key map "\C-c\C-j" 'gnuplot-forward-script-line)
|
||
(define-key map "\C-c\C-k" 'gnuplot-kill-gnuplot-buffer)
|
||
(define-key map "\C-c\C-l" 'gnuplot-send-line-to-gnuplot)
|
||
(define-key map "\C-c\C-n" 'gnuplot-negate-option)
|
||
(define-key map "\C-c\C-p" 'gnuplot-show-gnuplot-version)
|
||
(define-key map "\C-c\C-r" 'gnuplot-send-region-to-gnuplot)
|
||
(define-key map (kbd "C-M-x") 'gnuplot-send-line-to-gnuplot)
|
||
(define-key map "\C-c\C-v" 'gnuplot-send-line-and-forward)
|
||
(define-key map "\C-c\C-z" 'gnuplot-customize)
|
||
(define-key map "\C-i" 'indent-for-tab-command)
|
||
(define-key map "\C-m" 'newline-and-indent)
|
||
(define-key map "\C-c\M-i" 'gnuplot-inline-image-mode)
|
||
(define-key map (kbd "}") 'gnuplot-electric-insert)
|
||
(define-key map "\M-\r" completion-function)
|
||
(define-key map "\M-\t" completion-function)
|
||
|
||
(if gnuplot-xemacs-p
|
||
(define-key map '(shift button2) 'gnuplot-gui-mouse-set)
|
||
(define-key map [S-mouse-2] 'gnuplot-gui-mouse-set))
|
||
|
||
map))
|
||
|
||
(defvar gnuplot-mode-menu nil)
|
||
|
||
(defvar gnuplot-display-options-menu
|
||
(flet ((make-image-setter (type)
|
||
`[,(concat (upcase type) " images")
|
||
(lambda () (interactive) (gnuplot-set-image-format ,type))
|
||
:style toggle
|
||
:selected (eq gnuplot-image-format ,type)]))
|
||
`("Display plot output"
|
||
["Externally" gnuplot-external-display-mode
|
||
:style toggle
|
||
:selected (null gnuplot-inline-image-mode)]
|
||
["In Comint buffer" gnuplot-inline-display-mode
|
||
:active (gnuplot-display-images-p)
|
||
:style toggle
|
||
:selected (eq gnuplot-inline-image-mode 'comint)]
|
||
["In dedicated buffer" gnuplot-dedicated-display-mode
|
||
:style toggle
|
||
:selected (eq gnuplot-inline-image-mode 'dedicated)]
|
||
"---"
|
||
,@(mapcar #'make-image-setter (list "png" "jpeg" "svg"))
|
||
["Other image type..." gnuplot-set-image-format])))
|
||
|
||
(defvar gnuplot-menu
|
||
`("Gnuplot"
|
||
["Send line to gnuplot" gnuplot-send-line-to-gnuplot t]
|
||
["Send line & move forward" gnuplot-send-line-and-forward (not (eobp))]
|
||
["Send region to gnuplot" gnuplot-send-region-to-gnuplot
|
||
(gnuplot-mark-active)]
|
||
["Send buffer to gnuplot" gnuplot-send-buffer-to-gnuplot t]
|
||
["Send file to gnuplot" gnuplot-send-file-to-gnuplot t]
|
||
"---"
|
||
,gnuplot-display-options-menu
|
||
["Contextual completion and help" gnuplot-context-sensitive-mode
|
||
:style toggle
|
||
:selected gnuplot-context-sensitive-mode]
|
||
["Echo area help (eldoc-mode)" eldoc-mode
|
||
:active gnuplot-context-sensitive-mode
|
||
:style toggle
|
||
:selected eldoc-mode]
|
||
"---"
|
||
["Insert filename at point" gnuplot-insert-filename t]
|
||
["Negate set option" gnuplot-negate-option t]
|
||
;;["Set key binding" gnuplot-set-binding gnuplot-three-eight-p]
|
||
["Keyword help" gnuplot-info-lookup-symbol
|
||
(or gnuplot-keywords gnuplot-keywords-pending)]
|
||
["Quick help for thing at point" gnuplot-help-function
|
||
gnuplot-context-sensitive-mode]
|
||
["Info documentation on thing at point"
|
||
gnuplot-info-at-point
|
||
gnuplot-context-sensitive-mode]
|
||
["Show gnuplot process buffer" gnuplot-show-gnuplot-buffer t]
|
||
["Set arguments at point" gnuplot-gui-set-options-and-insert
|
||
(fboundp 'gnuplot-gui-set-options-and-insert)]
|
||
["Swap plot/splot/fit lists in GUI" gnuplot-gui-swap-simple-complete
|
||
(fboundp 'gnuplot-gui-swap-simple-complete)]
|
||
"---"
|
||
["Customize gnuplot" gnuplot-customize t]
|
||
["Show gnuplot-mode version" gnuplot-show-version t]
|
||
["Show gnuplot version" gnuplot-show-gnuplot-version t]
|
||
"---"
|
||
["Kill gnuplot" gnuplot-kill-gnuplot-buffer t])
|
||
"Menu for `gnuplot-mode'.")
|
||
|
||
|
||
|
||
;;; --- insertions variables and menus
|
||
|
||
;;(load-library "gnuplot-insertions")
|
||
(defvar gnuplot-mode-insertions-menu nil)
|
||
(defvar gnuplot-insertions-menu nil
|
||
"Menu for insertions in `gnuplot-mode'.
|
||
|
||
The insertions menu is composed of several sub-menus. The variables
|
||
describing the sub-menus are:
|
||
`gnuplot-insertions-adornments'
|
||
`gnuplot-insertions-plot-options'
|
||
`gnuplot-insertions-terminal'
|
||
`gnuplot-insertions-x-axis'
|
||
`gnuplot-insertions-y-axis'
|
||
`gnuplot-insertions-z-axis'
|
||
`gnuplot-insertions-x2-axis'
|
||
`gnuplot-insertions-y2-axis'
|
||
`gnuplot-insertions-parametric-plots'
|
||
`gnuplot-insertions-polar-plots'
|
||
`gnuplot-insertions-surface-plots'
|
||
These variables can be customized by the user. For example, there are
|
||
many terminal types which are not in the terminal submenu but which
|
||
may be compiled into a user's copy of gnuplot.
|
||
|
||
Each of these variables is a list whose first element is a string and
|
||
all the rest are vectors as described in the document string for
|
||
`easy-menu-define'. The callback used throughout these menus is
|
||
`gnuplot-insert' which inserts the appropriate set expression and,
|
||
optionally, looks up that item in the gnuplot info file.
|
||
|
||
The easiest way to customize the submenus is to use the custom
|
||
package. Just type \\[gnuplot-customize] and follow your nose.
|
||
|
||
You can also add new items to any of these sub-menus by adding to the
|
||
`gnuplot-load-hook' in your .emacs file. Here is an example of adding
|
||
the \"regis\" terminal type to the terminal sub-menu:
|
||
|
||
(add-hook
|
||
'gnuplot-load-hook
|
||
'(lambda ()
|
||
(setq gnuplot-insertions-terminal
|
||
(append gnuplot-insertions-terminal
|
||
(list
|
||
[\"regis\"
|
||
(gnuplot-insert \"set terminal regis\")
|
||
t])))))")
|
||
|
||
(defvar gnuplot-insertions-top ()
|
||
"Top part of insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'")
|
||
|
||
(defcustom gnuplot-insertions-menu-flag t
|
||
"Non-nil means to place the insertion menu in the menubar.
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type 'boolean)
|
||
|
||
(defcustom gnuplot-insertions-adornments ; this is icky...
|
||
(if gnuplot-three-eight-p
|
||
'("adornments"
|
||
["arrow" (gnuplot-insert "set arrow ") t]
|
||
["bar" (gnuplot-insert "set bar") t]
|
||
["border" (gnuplot-insert "set border") t]
|
||
["boxwidth" (gnuplot-insert "set boxwidth ") t]
|
||
["format" (gnuplot-insert "set format ") t]
|
||
["grid" (gnuplot-insert "set grid") t]
|
||
["key" (gnuplot-insert "set key ") t]
|
||
["label" (gnuplot-insert "set label ") t]
|
||
["pointsize" (gnuplot-insert "set pointsize ") t]
|
||
["samples" (gnuplot-insert "set samples ") t]
|
||
["size" (gnuplot-insert "set size ") t]
|
||
["style" (gnuplot-insert "set style ") t]
|
||
["tics" (gnuplot-insert "set tics ") t]
|
||
["timefmt" (gnuplot-insert "set timefmt ") t]
|
||
["timestamp" (gnuplot-insert "set timestamp ") t]
|
||
["title" (gnuplot-insert "set title ") t]
|
||
["zeroaxis" (gnuplot-insert "set zeroaxis") t])
|
||
'("adornments"
|
||
["data style" (gnuplot-insert "set data style ") t]
|
||
["function style" (gnuplot-insert "set function style ") t]
|
||
["arrow" (gnuplot-insert "set arrow ") t]
|
||
["bar" (gnuplot-insert "set bar") t]
|
||
["border" (gnuplot-insert "set border") t]
|
||
["boxwidth" (gnuplot-insert "set boxwidth ") t]
|
||
["format" (gnuplot-insert "set format ") t]
|
||
["grid" (gnuplot-insert "set grid") t]
|
||
["key" (gnuplot-insert "set key ") t]
|
||
["label" (gnuplot-insert "set label ") t]
|
||
["pointsize" (gnuplot-insert "set pointsize ") t]
|
||
["samples" (gnuplot-insert "set samples ") t]
|
||
["size" (gnuplot-insert "set size ") t]
|
||
["tics" (gnuplot-insert "set tics ") t]
|
||
["timefmt" (gnuplot-insert "set timefmt ") t]
|
||
["timestamp" (gnuplot-insert "set timestamp ") t]
|
||
["title" (gnuplot-insert "set title ") t]
|
||
["zeroaxis" (gnuplot-insert "set zeroaxis") t]))
|
||
"Adornments submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
|
||
(defcustom gnuplot-insertions-plot-options
|
||
'("plot options"
|
||
["autoscale" (gnuplot-insert "set autoscale ") t]
|
||
["clip" (gnuplot-insert "set clip ") t]
|
||
["encoding" (gnuplot-insert "set encoding ") t]
|
||
["locale" (gnuplot-insert "set locale ") t]
|
||
["logscale" (gnuplot-insert "set logscale ") t]
|
||
["multiplot" (gnuplot-insert "set multiplot") t]
|
||
["missing" (gnuplot-insert "set missing \"\"") t]
|
||
["palette" (gnuplot-insert "set palette ") t] ; <MT>
|
||
["pm3d" (gnuplot-insert "set pm3d ") t]
|
||
["offsets" (gnuplot-insert "set offsets ") t]
|
||
["output" (gnuplot-insert "set output ") t]
|
||
["zero" (gnuplot-insert "set zero ") t])
|
||
"Plot options submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-terminal
|
||
'("terminal"
|
||
["eepic" (gnuplot-insert "set terminal eepic") t]
|
||
["fig" (gnuplot-insert "set terminal fig") t]
|
||
["gpic" (gnuplot-insert "set terminal gpic") t]
|
||
["latex" (gnuplot-insert "set terminal latex") t]
|
||
["linux" (gnuplot-insert "set terminal linux") t]
|
||
["pbm" (gnuplot-insert "set terminal pbm") t]
|
||
["png" (gnuplot-insert "set terminal png") t]
|
||
["postscript" (gnuplot-insert "set terminal postscript") t]
|
||
["pslatex" (gnuplot-insert "set terminal pslatex") t]
|
||
["table" (gnuplot-insert "set terminal table") t]
|
||
["tek40xx" (gnuplot-insert "set terminal tek40xx") t]
|
||
["tkcanvas" (gnuplot-insert "set terminal tkcanvas") t]
|
||
["tpic" (gnuplot-insert "set terminal tpic") t]
|
||
["vgagl" (gnuplot-insert "set terminal vgagl") t] ; for pm3d patch
|
||
["vttek" (gnuplot-insert "set terminal vttek") t]
|
||
["x11" (gnuplot-insert "set terminal x11") t])
|
||
"Terminal submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-x-axis
|
||
'("x-axis"
|
||
["xdata" (gnuplot-insert "set xdata ") t]
|
||
["xlabel" (gnuplot-insert "set xlabel ") t]
|
||
["xrange" (gnuplot-insert "set xrange [:]") t]
|
||
["xtics" (gnuplot-insert "set xtics ") t]
|
||
["mxtics" (gnuplot-insert "set mxtics ") t]
|
||
["xzeroaxis" (gnuplot-insert "set xzeroaxis ") t]
|
||
["xdtics" (gnuplot-insert "set xdtics ") t]
|
||
["xmtics" (gnuplot-insert "set xmtics ") t])
|
||
"X-axis submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-x2-axis
|
||
'("x2-axis"
|
||
["x2data" (gnuplot-insert "set xdata ") t]
|
||
["x2label" (gnuplot-insert "set xlabel ") t]
|
||
["x2range" (gnuplot-insert "set xrange [:]") t]
|
||
["x2tics" (gnuplot-insert "set xtics ") t]
|
||
["mx2tics" (gnuplot-insert "set mxtics ") t]
|
||
["x2zeroaxis" (gnuplot-insert "set xzeroaxis ") t]
|
||
["x2dtics" (gnuplot-insert "set xdtics ") t]
|
||
["x2mtics" (gnuplot-insert "set xmtics ") t])
|
||
"X2-axis submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-y-axis
|
||
'("y-axis"
|
||
["ydata" (gnuplot-insert "set ydata ") t]
|
||
["ylabel" (gnuplot-insert "set ylabel ") t]
|
||
["ymtics" (gnuplot-insert "set ymtics ") t]
|
||
["yrange" (gnuplot-insert "set yrange [:]") t]
|
||
["ytics" (gnuplot-insert "set ytics ") t]
|
||
["yzeroaxis" (gnuplot-insert "set yzeroaxis ") t]
|
||
["ydtics" (gnuplot-insert "set ydtics ") t]
|
||
["mytics" (gnuplot-insert "set mytics ") t])
|
||
"Y-axis submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
(defcustom gnuplot-insertions-y2-axis
|
||
'("y2-axis"
|
||
["y2data" (gnuplot-insert "set ydata ") t]
|
||
["y2label" (gnuplot-insert "set ylabel ") t]
|
||
["y2range" (gnuplot-insert "set yrange [:]") t]
|
||
["y2tics" (gnuplot-insert "set ytics ") t]
|
||
["my2tics" (gnuplot-insert "set mytics ") t]
|
||
["y2zeroaxis" (gnuplot-insert "set yzeroaxis ") t]
|
||
["y2mtics" (gnuplot-insert "set ymtics ") t]
|
||
["y2dtics" (gnuplot-insert "set ydtics ") t])
|
||
"Y2-axis submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
|
||
(defcustom gnuplot-insertions-z-axis
|
||
'("z-axis"
|
||
["zdata" (gnuplot-insert "set zdata ") t]
|
||
["zlabel" (gnuplot-insert "set zlabel ") t]
|
||
["zrange" (gnuplot-insert "set zrange [:]") t]
|
||
["ztics" (gnuplot-insert "set ztics ") t]
|
||
["mztics" (gnuplot-insert "set mztics ") t]
|
||
["zdtics" (gnuplot-insert "set zdtics ") t]
|
||
["zmtics" (gnuplot-insert "set zmtics ") t])
|
||
"Z-axis submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-parametric-plots
|
||
'("parametric plots"
|
||
["parametric" (gnuplot-insert "set parametric") t]
|
||
["isosamples" (gnuplot-insert "set isosamples ") t]
|
||
["dummy" (gnuplot-insert "set dummy ") t]
|
||
["trange" (gnuplot-insert "set trange [:]") t]
|
||
["urange" (gnuplot-insert "set urange [:]") t]
|
||
["vrange" (gnuplot-insert "set vrange [:]") t])
|
||
"Parametric plots submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-polar-plots
|
||
'("polar plots"
|
||
["polar" (gnuplot-insert "set polar") t]
|
||
["angles" (gnuplot-insert "set angles ") t]
|
||
["rrange" (gnuplot-insert "set rrange [:]") t])
|
||
"Polar plots submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defcustom gnuplot-insertions-surface-plots
|
||
'("surface plots"
|
||
["clabel" (gnuplot-insert "set clabel ") t]
|
||
["cntrparam" (gnuplot-insert "set cntrparam ") t]
|
||
["contour" (gnuplot-insert "set contour") t]
|
||
["dgrid3d" (gnuplot-insert "set dgrid3d ") t]
|
||
["hidden3d" (gnuplot-insert "set hidden3d ") t]
|
||
["mapping" (gnuplot-insert "set mapping ") t]
|
||
["surface" (gnuplot-insert "set surface ") t]
|
||
["view" (gnuplot-insert "set view ") t])
|
||
"Surface plots submenu in the insertions menu.
|
||
See the document string for `gnuplot-insertions-menu'
|
||
Changing this will not effect a change in any currently existing
|
||
`gnuplot-mode' buffer. You will see the change the next time you
|
||
create a `gnuplot-mode' buffer."
|
||
:group 'gnuplot-insertions
|
||
:type '(list (string :tag "Title")
|
||
(repeat :inline t
|
||
(vector (string :tag "Name")
|
||
(function :tag "Callback")
|
||
(boolean :tag "Enabled" t)))))
|
||
|
||
|
||
(defvar gnuplot-gui-popup-flag)
|
||
(defvar gnuplot-insertions-bottom ()
|
||
"Bottom part of the insertions menu.
|
||
This part contains the toggle buttons for displaying info or
|
||
opening an argument-setting popup.")
|
||
(setq gnuplot-insertions-bottom
|
||
'("---"
|
||
["Display of info with insertion" gnuplot-toggle-info-display
|
||
:style toggle :selected gnuplot-insertions-show-help-flag]
|
||
["Display GUI popup with insertion" gnuplot-gui-toggle-popup
|
||
:active (fboundp 'gnuplot-gui-toggle-popup)
|
||
:style toggle :selected (and (fboundp 'gnuplot-gui-toggle-popup)
|
||
gnuplot-gui-popup-flag)]))
|
||
|
||
|
||
;; Regarding a comment by <DB>:
|
||
;;
|
||
;; This is from the header in easymenu.el distributed with XEmacs:
|
||
;;
|
||
;; ;; - Function: easy-menu-add MENU [ MAP ]
|
||
;; ;; Add MENU to the current menubar in MAP.
|
||
;; ;;
|
||
;; ;; - Function: easy-menu-remove MENU
|
||
;; ;; Remove MENU from the current menubar.
|
||
;; ;;
|
||
;; ;; Emacs 19 never uses `easy-menu-add' or `easy-menu-remove', menus
|
||
;; ;; automatically appear and disappear when the keymaps specified by
|
||
;; ;; the MAPS argument to `easy-menu-define' are activated.
|
||
;; ;;
|
||
;; ;; XEmacs will bind the map to button3 in each MAPS, but you must
|
||
;; ;; explicitly call `easy-menu-add' and `easy-menu-remove' to add and
|
||
;; ;; remove menus from the menu bar.
|
||
;;
|
||
;; in Emacs, easy-menu-add is defined like this:
|
||
;; (defun easy-menu-add (menu &optional map))
|
||
|
||
(defun gnuplot-setup-menubar ()
|
||
"Initial setup of gnuplot and insertions menus."
|
||
(if gnuplot-insertions-menu-flag ; set up insertions menu
|
||
(progn
|
||
(if gnuplot-xemacs-p
|
||
(setq gnuplot-insertions-top
|
||
'("insert set expression" "--:doubleLine"))
|
||
(setq gnuplot-insertions-top
|
||
'("insert set expression" "---")))
|
||
(setq gnuplot-insertions-menu
|
||
(append (list "Insertions")
|
||
gnuplot-insertions-top
|
||
(list gnuplot-insertions-adornments)
|
||
(list gnuplot-insertions-plot-options)
|
||
(list gnuplot-insertions-terminal)
|
||
(list gnuplot-insertions-x-axis)
|
||
(list gnuplot-insertions-y-axis)
|
||
(list gnuplot-insertions-z-axis)
|
||
(list gnuplot-insertions-x2-axis)
|
||
(list gnuplot-insertions-y2-axis)
|
||
(list gnuplot-insertions-parametric-plots)
|
||
(list gnuplot-insertions-polar-plots)
|
||
(list gnuplot-insertions-surface-plots)
|
||
gnuplot-insertions-bottom))
|
||
(easy-menu-define gnuplot-mode-insertions-menu gnuplot-mode-map
|
||
"Insertions menu used in Gnuplot-mode"
|
||
gnuplot-insertions-menu)
|
||
(easy-menu-add gnuplot-mode-insertions-menu gnuplot-mode-map)))
|
||
(easy-menu-define ; set up gnuplot menu
|
||
gnuplot-mode-menu gnuplot-mode-map "Menu used in gnuplot-mode"
|
||
gnuplot-menu)
|
||
(easy-menu-add gnuplot-mode-menu gnuplot-mode-map))
|
||
|
||
;; There is no `mark-active' variable in XEmacs. Hassle! This is not
|
||
;; only replicates mark-active, but it only returns true if the region
|
||
;; is of non-zero width.
|
||
;; Error checking suggested by <DB>
|
||
(defun gnuplot-mark-active ()
|
||
"Return non-nil if the mark is active and it is not equal to point."
|
||
(condition-case nil
|
||
(and (mark) (/= (mark) (point)))
|
||
(error nil)))
|
||
|
||
|
||
;;; --- XEmacs toolbar
|
||
|
||
(defgroup gnuplot-toolbar nil
|
||
"Toolbar used by XEmacs."
|
||
:prefix "gnuplot-toolbar-"
|
||
:group 'gnuplot)
|
||
|
||
(defcustom gnuplot-toolbar-display-flag gnuplot-xemacs-p
|
||
"Non-nil means to display display a toolbar in XEmacs."
|
||
:group 'gnuplot-toolbar
|
||
:type 'boolean)
|
||
|
||
(defcustom gnuplot-toolbar-use-toolbar (if (featurep 'toolbar) 'left-toolbar nil)
|
||
"If nil, do not use a toolbar.
|
||
If it is non-nil, it must be a toolbar. The five legal values are
|
||
`default-toolbar', `top-toolbar', `bottom-toolbar', `right-toolbar',
|
||
and `left-toolbar', although choosing `default-toolbar' or
|
||
`top-toolbar' may be a bad idea since either will make the GNUPLOT
|
||
toolbar replace the standard toolbar. Changing this will not change
|
||
the toolbar in a currently existing buffer, but it will take effect
|
||
the next time you use `gnuplot-mode' and Emacs.
|
||
|
||
This is only used if a toolbar can be displayed, thus this is used in
|
||
XEmacs and ignored in FSF Emacs."
|
||
:type '(choice (const default-toolbar)
|
||
(const top-toolbar)
|
||
(const bottom-toolbar)
|
||
(const left-toolbar)
|
||
(const right-toolbar)
|
||
(const :tag "No toolbar" nil))
|
||
:group 'gnuplot-toolbar)
|
||
|
||
(defvar gnuplot-toolbar-location "")
|
||
|
||
(defun gnuplot-toolbar-setup-toolbar (toolbar)
|
||
"Setup function for the `gnuplot-mode' toolbar.
|
||
TOOLBAR contains the toolbar specification.
|
||
This is basically swiped from VM."
|
||
(let ((width 46) (height 46)
|
||
(buffer (current-buffer))
|
||
(frame (selected-frame))
|
||
(tag-set '(win)))
|
||
(cond
|
||
((eq (symbol-value gnuplot-toolbar-use-toolbar) right-toolbar)
|
||
(setq gnuplot-toolbar-location "right")
|
||
(set-specifier right-toolbar toolbar buffer)
|
||
(set-specifier right-toolbar-width width frame tag-set))
|
||
((eq (symbol-value gnuplot-toolbar-use-toolbar) left-toolbar)
|
||
(setq gnuplot-toolbar-location "left")
|
||
(set-specifier left-toolbar toolbar buffer)
|
||
(set-specifier left-toolbar-width width frame tag-set))
|
||
((eq (symbol-value gnuplot-toolbar-use-toolbar) bottom-toolbar)
|
||
(setq gnuplot-toolbar-location "bottom")
|
||
(set-specifier bottom-toolbar toolbar buffer)
|
||
(set-specifier bottom-toolbar-height height frame tag-set))
|
||
((eq (symbol-value gnuplot-toolbar-use-toolbar) top-toolbar)
|
||
(setq gnuplot-toolbar-location "top")
|
||
(set-specifier top-toolbar toolbar buffer)
|
||
(set-specifier top-toolbar-height height frame tag-set)))))
|
||
|
||
(defvar gnuplot-line-xpm
|
||
(if (and (featurep 'xpm) (fboundp 'toolbar-make-button-list))
|
||
(toolbar-make-button-list
|
||
"/* XPM */
|
||
static char *line[] = {
|
||
/* width height num_colors chars_per_pixel */
|
||
\" 40 40 5 1\",
|
||
/* colors */
|
||
\". c #000000\",
|
||
\"a c #bebebe s backgroundToolBarColor\",
|
||
\"b c #2f4f4f\",
|
||
\"c c #ff6347\",
|
||
\"d c #0000ff\",
|
||
/* pixels */
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaa..a..aaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaa..aaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaa..a..a....aaa...aaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaa..a..a..a..a..a..aaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaa..a..a.aa..a.....aaaaaaaaaaa\",
|
||
\"aaaaaaaaaaa..a..a..a..a..aaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaa..a..a..a..a..a..aaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaa..a..a..a..aa...aaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaadaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaadaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaadaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaadaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaacaaaadaadaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.caaadaaaccaccadaddaaaaaccaaaaaa\",
|
||
\"aaaaaaa..accdaddcaaaaaccaaaaaaccaaaaaaaa\",
|
||
\"aaaaaaaa.aadcaccdaaaadaaccaaccaaaaaaaaaa\",
|
||
\"aaaaaaaa.adaacaaaddadaaaaaccaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.daaaaaaaaadaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaa............................aaaaaa\",
|
||
\"aaaaaaaa.aaaa.aaaa.aaaa.aaaa.aaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};")
|
||
"XPM format image used for the \"plot line\" button"))
|
||
|
||
(defvar gnuplot-region-xpm
|
||
(if (and (featurep 'xpm) (fboundp 'toolbar-make-button-list))
|
||
(toolbar-make-button-list
|
||
"/* XPM */
|
||
static char *region[] = {
|
||
/* width height num_colors chars_per_pixel */
|
||
\" 40 40 5 1\",
|
||
/* colors */
|
||
\". c #000000\",
|
||
\"a c #bebebe s backgroundToolBarColor\",
|
||
\"b c #2f4f4f\",
|
||
\"c c #ff6347\",
|
||
\"d c #0000ff\",
|
||
/* pixels */
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaa..aaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaa.a..a...aaa....a..aa...aa....aaaaa\",
|
||
\"aaaaaa...a..a..a..a..a..a..a..a..a..aaaa\",
|
||
\"aaaaaa..aa.....a.aa..a....aa..a.aa..aaaa\",
|
||
\"aaaaa..a...aaaa..aa.a..a..aa....a..aaaaa\",
|
||
\"aaaaa..a...a..a..a..a..a..a..a..a..aaaaa\",
|
||
\"aaaa..aaaa...aaa....a..aa...aa..a..aaaaa\",
|
||
\"aaaaaaaaaaaaaaaaa..aaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaa...aaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaadaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaadaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaadaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaadaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaacaaaadaadaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.caaadaaaccaccadaddaaaaaccaaaaaa\",
|
||
\"aaaaaaa..accdaddcaaaaaccaaaaaaccaaaaaaaa\",
|
||
\"aaaaaaaa.aadcaccdaaaadaaccaaccaaaaaaaaaa\",
|
||
\"aaaaaaaa.adaacaaaddadaaaaaccaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.daaaaaaaaadaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaa............................aaaaaa\",
|
||
\"aaaaaaaa.aaaa.aaaa.aaaa.aaaa.aaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};")
|
||
"XPM format image used for the \"plot region\" button"))
|
||
|
||
(defvar gnuplot-buffer-xpm
|
||
(if (and (featurep 'xpm) (fboundp 'toolbar-make-button-list))
|
||
(toolbar-make-button-list
|
||
"/* XPM */
|
||
static char *buffer[] = {
|
||
/* width height num_colors chars_per_pixel */
|
||
\" 40 40 5 1\",
|
||
/* colors */
|
||
\". c #000000\",
|
||
\"a c #bebebe s backgroundToolBarColor\",
|
||
\"b c #2f4f4f\",
|
||
\"c c #ff6347\",
|
||
\"d c #0000ff\",
|
||
/* pixels */
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa..aaaaaaaaaa......aaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa..aaaaaaaaa..a..aaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaa....aa..a.........a...aa.a.aaaaaa\",
|
||
\"aaaaaaa..a..a..a..a..a..a..a..a...aaaaaa\",
|
||
\"aaaaaaa.aa....aa..a..a..a.....a..aaaaaaa\",
|
||
\"aaaaaa...a.a..a..a..a..a..aaaa..aaaaaaaa\",
|
||
\"aaaaaa.....a..a..a..a..a..a..a..aaaaaaaa\",
|
||
\"aaaaaa....aaa..a.a..a..aa...aa..aaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaadaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaadaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaadaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaadaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaacaaaadaadaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.caaadaaaccaccadaddaaaaaccaaaaaa\",
|
||
\"aaaaaaa..accdaddcaaaaaccaaaaaaccaaaaaaaa\",
|
||
\"aaaaaaaa.aadcaccdaaaadaaccaaccaaaaaaaaaa\",
|
||
\"aaaaaaaa.adaacaaaddadaaaaaccaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.daaaaaaaaadaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaa..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaa............................aaaaaa\",
|
||
\"aaaaaaaa.aaaa.aaaa.aaaa.aaaa.aaaaaaaaaaa\",
|
||
\"aaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};")
|
||
"XPM format image used for the \"plot buffer\" button"))
|
||
|
||
(defvar gnuplot-doc-xpm
|
||
(if (and (featurep 'xpm) (fboundp 'toolbar-make-button-list))
|
||
(toolbar-make-button-list
|
||
"/* XPM */
|
||
static char *book_index[] = {
|
||
/* width height num_colors chars_per_pixel */
|
||
\" 40 40 6 1\",
|
||
/* colors */
|
||
\". c #000000\",
|
||
\"a c #bebebe s backgroundToolBarColor\",
|
||
\"b c #2f4f4f\",
|
||
\"c c #ff0000\",
|
||
\"d c #ffffff\",
|
||
\"e c #708090\",
|
||
/* pixels */
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaa.........bbeaaaebb..........aaaaaa\",
|
||
\"aaaaaa.ddddddddaaebebeaaddddddddd.aaaaaa\",
|
||
\"aaaa...dab.bddeebadbdaeebedeeeeed...aaaa\",
|
||
\"aaaa.c.dbaddddebeedbdeebeedebebed.c.aaaa\",
|
||
\"aaaa.c.d.de.edeebeabdbbeeddebbbed.c.aaaa\",
|
||
\"aaaa.c.dbad.ddebeadbdeeebeddeeeed.c.aaaa\",
|
||
\"aaaa.c.dab..ddeeeedbdebeeedebebed.c.aaaa\",
|
||
\"aaaa.c.dddddddeebeabdebebedeebedd.c.aaaa\",
|
||
\"aaaa.c.debebedebeedbdbebeedbeeeeb.c.aaaa\",
|
||
\"aaaa.c.debeeedeeeaabdaaddddebedbb.c.aaaa\",
|
||
\"aaaa.c.deebeddbebedbdbaa.adeeedeb.c.aaaa\",
|
||
\"aaaa.c.ddeebedeeebaba.dd.dddeeedd.c.aaaa\",
|
||
\"aaaa.c.debeebdbeeedbd....ddeebeed.c.aaaa\",
|
||
\"aaaa.c.deebeedeebadbd.dd.ddeeeedd.c.aaaa\",
|
||
\"aaaa.c.dbbebddeeeeabd.aa.adebebbd.c.aaaa\",
|
||
\"aaaa.c.deeeeedeebeabaedddddeeeedd.c.aaaa\",
|
||
\"aaaa.c.dbebbbdebeadbdaeeeedebeeed.c.aaaa\",
|
||
\"aaaa.c.deeebddeeebdbdeebeedeebeed.c.aaaa\",
|
||
\"aaaa.c.debeeedebeeabdebebedebeebd.c.aaaa\",
|
||
\"aaaa.c.deebbedeeeedbdeeeeddeeeeed.c.aaaa\",
|
||
\"aaaa.c.dddddddddaadbdaddddddddddd.c.aaaa\",
|
||
\"aaaa.c..........beabaeb...........c.aaaa\",
|
||
\"aaaa.c.bbbbbbbbbb.bbbbbbbbbbbbbbb.c.aaaa\",
|
||
\"aaaa.c.bbbbbbbbbb..e.bbbbbbbbbbbb.c.aaaa\",
|
||
\"aaaa.c.bbbbbbbbbb.b.bbbbbbbbbbbbb.c.aaaa\",
|
||
\"aaaa.c............e.e.............c.aaaa\",
|
||
\"aaaa.cccccccccccc.a.a.ccccccccccccc.aaaa\",
|
||
\"aaaa................................aaaa\",
|
||
\"aaaaaaaaaaaaaaaaaa...aaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};")
|
||
"XPM format image used for the \"document\" button"))
|
||
|
||
(defvar gnuplot-help-xpm
|
||
(if (and (featurep 'xpm) (fboundp 'toolbar-make-button-list))
|
||
(toolbar-make-button-list
|
||
"/* XPM */
|
||
static char *help_btn[] = {
|
||
/* width height num_colors chars_per_pixel */
|
||
\" 40 40 3 1\",
|
||
/* colors */
|
||
\"a c #bebebe s backgroundToolBarColor\",
|
||
\"b c #000000\",
|
||
\"c c #ff0000\",
|
||
/* pixels */
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabbbbbbbbaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaabbbccccccccbbbaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaabbccccccccccccccbbaaaaaaaaaaa\",
|
||
\"aaaaaaaaaabccccccccccccccccccbaaaaaaaaaa\",
|
||
\"aaaaaaaaabccccccccccccccccccccbaaaaaaaaa\",
|
||
\"aaaaaaaabcccccccbbbbbbbbcccccccbaaaaaaaa\",
|
||
\"aaaaaaaabccccbbbaaaaaaaabbbccccbaaaaaaaa\",
|
||
\"aaaaaaabccccbaaaaaaaaaaaaaabccccbaaaaaaa\",
|
||
\"aaaaaaabcccbaaaaaaaaaaaaaaaabcccbaaaaaaa\",
|
||
\"aaaaaaabcccbaaaaaaaaaaaaaaaabcccbaaaaaaa\",
|
||
\"aaaaaaabcccbaaaaaaaaaaaaaaaabcccbaaaaaaa\",
|
||
\"aaaaaaabbbbbaaaaaaaaaaaaaaabccccbaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaabbbccccbaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabbbbbbbbcccccccbaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabcccccccccccccbaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccccccccccbaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccccccccbbaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbbbbbbaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabbbbbbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabbbbbbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabccccbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaabbbbbbaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
|
||
\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};")
|
||
"XPM format image used for the \"help\" button"))
|
||
|
||
(defvar gnuplot-toolbar
|
||
'([gnuplot-line-xpm
|
||
gnuplot-line-fn t "Plot the line under point"]
|
||
[gnuplot-region-xpm
|
||
gnuplot-region-fn t "Plot the selected region"]
|
||
[gnuplot-buffer-xpm
|
||
gnuplot-buffer-fn t "Plot the entire buffer"]
|
||
[:style 3d :size 8]
|
||
[gnuplot-help-xpm
|
||
gnuplot-help-fn t "Look at the gnuplot process buffer"]
|
||
[gnuplot-doc-xpm
|
||
gnuplot-doc-fn t "Look at the gnuplot document"])
|
||
"The gnuplot toolbar.")
|
||
|
||
(fset 'gnuplot-line-fn 'gnuplot-send-line-and-forward)
|
||
(fset 'gnuplot-region-fn 'gnuplot-send-region-to-gnuplot)
|
||
(fset 'gnuplot-buffer-fn 'gnuplot-send-buffer-to-gnuplot)
|
||
(fset 'gnuplot-help-fn 'gnuplot-show-gnuplot-buffer)
|
||
(fset 'gnuplot-doc-fn 'gnuplot-info-lookup-symbol)
|
||
|
||
(defvar gnuplot-all-buttons-defined
|
||
(and (listp gnuplot-line-xpm) (listp gnuplot-region-xpm)
|
||
(listp gnuplot-buffer-xpm) (listp gnuplot-doc-xpm)
|
||
(listp gnuplot-help-xpm)))
|
||
|
||
|
||
(defun gnuplot-make-toolbar-function ()
|
||
"Make toolbar."
|
||
(if (and gnuplot-xemacs-p gnuplot-all-buttons-defined)
|
||
(progn
|
||
;;(remove-specifier gnuplot-toolbar-use-toolbar (current-buffer))
|
||
(gnuplot-toolbar-setup-toolbar gnuplot-toolbar)
|
||
(add-spec-to-specifier (symbol-value gnuplot-toolbar-use-toolbar)
|
||
gnuplot-toolbar
|
||
(current-buffer)))))
|
||
|
||
;;(defalias 'gnuplot-make-toolbar 'gnuplot-make-toolbar-function)
|
||
|
||
|
||
|
||
;;; --- syntax colorization, syntax table
|
||
|
||
(defvar gnuplot-mode-syntax-table
|
||
(let ((table (make-syntax-table)))
|
||
(modify-syntax-entry ?* "." table)
|
||
(modify-syntax-entry ?+ "." table)
|
||
(modify-syntax-entry ?- "." table)
|
||
(modify-syntax-entry ?/ "." table)
|
||
(modify-syntax-entry ?% "." table)
|
||
(modify-syntax-entry ?= "." table)
|
||
(modify-syntax-entry ?: "." table)
|
||
(modify-syntax-entry ?& "." table ) ; rarely used
|
||
(modify-syntax-entry ?^ "." table ) ; operators
|
||
(modify-syntax-entry ?| "." table ) ; in gnuplot,
|
||
(modify-syntax-entry ?& "." table ) ; (by me,
|
||
(modify-syntax-entry ?? "." table ) ; anyway...)
|
||
(modify-syntax-entry ?~ "." table ) ;
|
||
|
||
(modify-syntax-entry ?_ "w" table )
|
||
|
||
;; In GNU Emacs >=24 we can use `syntax-propertize-function' to
|
||
;; accurately scan for strings and comments (see
|
||
;; `gnuplot-syntax-propertize'). If there's no
|
||
;; `syntax-propertize', fall back to using the built-in parser and
|
||
;; making ", ', and # string or comment delimiters as normal.
|
||
(if (not (boundp 'syntax-propertize-function))
|
||
(progn
|
||
(modify-syntax-entry ?\' "\"" table)
|
||
(modify-syntax-entry ?# "<" table)
|
||
(modify-syntax-entry ?\n ">" table)
|
||
(modify-syntax-entry ?\\ "\\" table))
|
||
|
||
;; When syntax-propertize is available, ", ', and # should be
|
||
;; punctuation so that the built-in parser doesn't interfere
|
||
;; with the syntax-propertize search.
|
||
(modify-syntax-entry ?\" "." table)
|
||
(modify-syntax-entry ?\' "." table)
|
||
(modify-syntax-entry ?` "." table)
|
||
(modify-syntax-entry ?\\ "." table))
|
||
|
||
table)
|
||
|
||
"Syntax table in use in `gnuplot-mode' buffers.
|
||
This is the same as the standard syntax table except that ` and _
|
||
are word characters, and math operators are punctuation
|
||
characters.")
|
||
|
||
;; Macro to generate efficient regexps for keyword matching
|
||
;;
|
||
;; These regular expressions treat the gnuplot vocabulary as complete
|
||
;; words. Although gnuplot will recognise unique abbreviations, these
|
||
;; regular expressions will not.
|
||
(defmacro gnuplot-make-regexp (list)
|
||
"Macro to generate efficient regexps for keyword matching from LIST."
|
||
`(regexp-opt ,list 'words))
|
||
|
||
;; Lists of gnuplot keywords for syntax coloring etc.
|
||
(defvar gnuplot-keywords-builtin-functions
|
||
'("abs" "acosh" "acos" "arg" "asinh" "asin" "atan" "atanh" "atan2" "besj1"
|
||
"besj0" "besy1" "besy0" "ceil" "column" "cosh" "cos" "erfc" "erf" "exp"
|
||
"floor" "gamma" "ibeta" "igamma" "imag" "int" "inverf" "invnorm" "lgamma"
|
||
"log" "log10" "norm" "rand" "real" "sgn" "sinh" "sin" "sqrt" "tanh" "tan"
|
||
"tm_hour" "tm_mday" "tm_min" "tm_mon" "tm_sec" "tm_wday" "tm_yday" "tm_year"
|
||
"valid" "EllipticPi" "EllipticE" "EllipticK" "words" "word" "value"
|
||
"timecolumn" "substr" "strstrt" "strptime" "strlen" "stringcolumn"
|
||
"strftime" "sprintf" "lambertw" "gprintf" "exists" "defined" "columnhead")
|
||
|
||
"List of GNUPLOT built-in functions, as strings.
|
||
|
||
These are highlighted using `font-lock-function-name-face'.")
|
||
|
||
(defvar gnuplot-keywords-plotting
|
||
'("axes" "every" "index" "lw" "lt" "ls" "linestyle" "linetype" "linewidth"
|
||
"notitle" "pt" "ps" "pointsize" "pointtype" "smooth" "thru" "title" "using"
|
||
"with" "noautoscale" "volatile" "matrix" "nonuniform" "binary" "fillstyle"
|
||
"linecolor" "pointinterval" "nosurface" "nocontours" "nohidden3d")
|
||
"List of GNUPLOT keywords associated with plotting, as strings.
|
||
|
||
These are highlighted using `font-lock-type-face'.
|
||
This list does not include plotting styles -- for that, see
|
||
`gnuplot-keywords-plotting-styles'")
|
||
|
||
(defvar gnuplot-keywords-plotting-styles
|
||
'("boxerrorbars" "boxes" "boxxyerrorbars" "candlesticks" "dots" "errorbars"
|
||
"financebars" "fsteps" "histeps" "impulses" "lines" "linespoints" "points"
|
||
"steps" "vector" "xerrorbars" "xyerrorbars" "yerrorbars" "vectors"
|
||
"filledcurves" "labels" "rgbalpha" "rgbimage" "image" "circles" "pm3d"
|
||
"histograms" "xyerrorlines" "xerrorlines" "errorlines" "yerrorlines")
|
||
|
||
"List of GNUPLOT plotting styles, as strings.
|
||
|
||
These are highlighted using `font-lock-function-name-face'.")
|
||
|
||
(defvar gnuplot-keywords-misc
|
||
'("bind" "cd" "clear" "exit" "fit" "help" "history" "load" "pause" "print"
|
||
"pwd" "quit" "replot" "save" "set" "show" "unset" "if" "else" "do" "update"
|
||
"undefine" "test" "system" "raise" "lower" "eval" "shell" "reset" "reread"
|
||
"refresh" "call")
|
||
"List of GNUPLOT miscellaneous commands, as strings.
|
||
|
||
These are highlighted using `font-lock-constant-face'.")
|
||
|
||
(defvar gnuplot-keywords-negatable-options
|
||
'("arrow" "autoscale" "border" "clabel" "clip" "contour" "dgrid3d" "grid"
|
||
"hidden3d" "historysize" "key" "label" "linestyle" "logscale" "mouse"
|
||
"multiplot" "mx2tics" "mxtics" "my2tics" "mytics" "mztics" "offsets" "polar"
|
||
"surface" "timestamp" "title" "x2dtics" "x2mtics" "x2tics" "x2zeroaxis"
|
||
"xdtics" "xmtics" "xtics" "xzeroaxis" "y2dtics" "y2mtics" "y2tics"
|
||
"y2zeroaxis" "ydtics" "ymtics" "ytics" "yzeroaxis" "zdtics" "zmtics" "ztics"
|
||
"zzeroaxis")
|
||
|
||
"List of gnuplot options which can be negated using `gnuplot-negate-option'.")
|
||
|
||
(defvar gnuplot-negatable-options-regexp
|
||
(gnuplot-make-regexp gnuplot-keywords-negatable-options))
|
||
|
||
;; Set up colorization for gnuplot.
|
||
;; This handles font-lock for emacs and xemacs.
|
||
(defvar gnuplot-font-lock-keywords nil)
|
||
(defvar gnuplot-font-lock-syntactic-keywords nil)
|
||
(defvar gnuplot-font-lock-defaults nil)
|
||
|
||
(when (featurep 'font-lock) ; <KL>
|
||
(setq gnuplot-font-lock-keywords
|
||
(list
|
||
;; stuff in brackets, sugg. by <LB>
|
||
'("\\[\\([^]]+\\)\\]" 1 font-lock-constant-face)
|
||
|
||
;; variable/function definitions
|
||
'("\\(\\(\\sw\\|\\s_\\)+\\s-*\\((\\s-*\\(\\sw\\|\\s_\\)*\\s-*\\(,\\s-*\\sw*\\)*\\s-*)\\)?\\s-*=\\)[^=]"
|
||
1 font-lock-variable-name-face)
|
||
|
||
;; built-in function names
|
||
(cons (gnuplot-make-regexp gnuplot-keywords-builtin-functions)
|
||
font-lock-function-name-face)
|
||
|
||
;; reserved words associated with plotting <AL>
|
||
(cons (gnuplot-make-regexp gnuplot-keywords-plotting)
|
||
font-lock-type-face)
|
||
(cons (gnuplot-make-regexp gnuplot-keywords-plotting-styles)
|
||
font-lock-function-name-face)
|
||
|
||
;; (s)plot -- also thing (s)plotted
|
||
'("\\<s?plot\\>" . font-lock-keyword-face)
|
||
;; '("\\<s?plot\\s-+\\([^'\" ]+\\)[) \n,\\\\]"
|
||
;; 1 font-lock-variable-name-face)
|
||
|
||
;; other common commands
|
||
(cons (gnuplot-make-regexp gnuplot-keywords-misc)
|
||
font-lock-constant-face)
|
||
(cons "!.*$" font-lock-constant-face))) ; what is this for? jjo
|
||
|
||
(setq gnuplot-font-lock-defaults
|
||
'(gnuplot-font-lock-keywords
|
||
nil ; Use syntactic fontification
|
||
t ; Use case folding
|
||
nil ; No extra syntax
|
||
;; calls `gnuplot-beginning-of-continuation'
|
||
;; to find a safe place to begin syntactic highlighting
|
||
beginning-of-defun))
|
||
|
||
;; Set up font-lock for Xemacs
|
||
;; For GNU Emacs, this is done in `gnuplot-mode'
|
||
(if gnuplot-xemacs-p
|
||
(put 'gnuplot-mode 'font-lock-defaults
|
||
gnuplot-font-lock-defaults)))
|
||
|
||
;; Some corner cases in Gnuplot's comment and string syntax are
|
||
;; difficult to handle accurately using Emacs's built-in syntax tables
|
||
;; and parser:
|
||
;;
|
||
;; - strings can continue over several lines, but only by using a
|
||
;; backslash to escape the newline
|
||
;;
|
||
;; - double-quoted strings can contain escaped quotes, \", and escaped
|
||
;; backslashes, \\; but in single-quoted strings the quote is
|
||
;; escaped by doubling it, '', and backslash is only special at
|
||
;; end-of-line
|
||
;;
|
||
;; - either type of string can end at newline without needing a
|
||
;; - closing delimiter
|
||
;;
|
||
;; - comments continue over continuation lines
|
||
;;
|
||
;; The following syntax-propertize rules should accurately mark string
|
||
;; and comment boundaries using the "generic string fence" and
|
||
;; "generic comment fence" syntax properties. When syntax-propertize
|
||
;; is unavailable (on Emacs versions <24), we fall back to using the
|
||
;; normal syntax-table parser, which is accurate enough for most
|
||
;; normal cases. (See the definition of `gnuplot-mode-syntax-table'.)
|
||
(defalias 'gnuplot-syntax-propertize
|
||
(when (fboundp 'syntax-propertize-rules)
|
||
(syntax-propertize-rules
|
||
;; Double quoted strings
|
||
((rx
|
||
(group "\"")
|
||
(* (or (seq "\\" anything)
|
||
(not (any "\"" "\n"))))
|
||
(group (or "\"" "\n" buffer-end)))
|
||
(1 "|") (2 "|"))
|
||
|
||
;; Single quoted strings
|
||
((rx
|
||
(group "'")
|
||
(* (or (seq "\\" "\n")
|
||
"''"
|
||
(not (any "'" "\n"))))
|
||
(group (or "'" "\n" buffer-end)))
|
||
(1 "|") (2 "|"))
|
||
|
||
;; Comments
|
||
((rx
|
||
(group "#")
|
||
(* (or (seq "\\" "\n")
|
||
any))
|
||
(or (group "\n") buffer-end))
|
||
(1 "!") (2 "!")))))
|
||
|
||
(defun gnuplot-syntax-propertize-extend-region (start end)
|
||
"Expand the region to `syntax-propertize' for strings and comments.
|
||
|
||
Region range is START to END.
|
||
Ensures that the region being searched begins and ends outside of
|
||
any lines continued with a backslash.
|
||
|
||
This function is added to `syntax-propertize-extend-region-functions'
|
||
in gnuplot-mode buffers."
|
||
(let ((continuation-start
|
||
(min start
|
||
(gnuplot-point-at-beginning-of-continuation start)))
|
||
(continuation-end
|
||
(max end
|
||
(gnuplot-point-at-end-of-continuation end))))
|
||
(if (and (= continuation-start start)
|
||
(= continuation-end end))
|
||
nil
|
||
(cons continuation-start continuation-end))))
|
||
|
||
;; Parsing utilities to tell if we are inside a string or comment
|
||
(defun gnuplot-in-string (&optional where)
|
||
"Return non-nil if the text at WHERE is within a string.
|
||
|
||
If WHERE is omitted, defaults to text at point.
|
||
This is a simple wrapper for `syntax-ppss'."
|
||
(save-excursion
|
||
(let ((parse-state (gnuplot-syntax-ppss where)))
|
||
(nth 3 parse-state))))
|
||
|
||
(defun gnuplot-in-comment (&optional where)
|
||
"Return non-nil if the text at WHERE is within a comment.
|
||
|
||
If WHERE is omitted, defaults to text at point.
|
||
This is a simple wrapper for `syntax-ppss'."
|
||
(save-excursion
|
||
(let ((parse-state (gnuplot-syntax-ppss where)))
|
||
(nth 4 parse-state))))
|
||
|
||
(defun gnuplot-in-string-or-comment (&optional where)
|
||
"Return non-nil if the text at WHERE is within a string or comment.
|
||
|
||
If WHERE is omitted, defaults to text at point.
|
||
This is a simple wrapper for `syntax-ppss'."
|
||
|
||
(save-excursion
|
||
(let ((parse-state (gnuplot-syntax-ppss where)))
|
||
(or (nth 3 parse-state)
|
||
(nth 4 parse-state)))))
|
||
|
||
;; these two lines get rid of an annoying compile time error
|
||
;; message. that function gets non-trivially defalias-ed in
|
||
;; gnuplot-toolbar.el
|
||
;; (defun gnuplot-make-toolbar-dummy ())
|
||
;; (defalias 'gnuplot-make-toolbar 'gnuplot-make-toolbar-dummy)
|
||
|
||
|
||
;;; --- functions for sending commands to gnuplot
|
||
|
||
(defun gnuplot-split-string (string)
|
||
"Break STRING at each carriage return, returning a list of lines."
|
||
(let ((list ()) (line "") (index 0))
|
||
(while (< index (length string))
|
||
(if (char-equal (elt string index) ?\n)
|
||
(setq list (append list (list line))
|
||
line "")
|
||
(setq line (concat line (char-to-string (elt string index)))))
|
||
(setq index (1+ index)))
|
||
list))
|
||
|
||
;; -- the calls to `sleep-for' are to allow enough time for gnuplot
|
||
;; to write to the buffer before the next line is inserted
|
||
;; -- note that the input string is split into lines and each line is
|
||
;; sent to gnuplot individually. this is a bit slow, but it puts
|
||
;; each line on the comint history.
|
||
(defun gnuplot-send-string-to-gnuplot (string text)
|
||
"Sends STRING to the gnuplot program.
|
||
If no gnuplot process exists, a new one is created. TEXT indicates
|
||
the type of text being sent to gnuplot and is typically one of
|
||
nil, 'line, 'region, 'buffer, or 'file. TEXT may be useful for
|
||
functions in `gnuplot-after-plot-hook'. `gnuplot-after-plot-hook' is
|
||
called by this function after all of STRING is sent to gnuplot."
|
||
(gnuplot-make-gnuplot-buffer) ; make sure a gnuplot buffer exists
|
||
(gnuplot-fetch-version-number)
|
||
(setq gnuplot-comint-recent-buffer (current-buffer))
|
||
|
||
;; Create a gnuplot frame if needed
|
||
(if (equal gnuplot-display-process 'frame)
|
||
(or (and gnuplot-process-frame
|
||
(frame-live-p gnuplot-process-frame))
|
||
(let ((frame (selected-frame)))
|
||
(setq gnuplot-process-frame (make-frame))
|
||
(select-frame gnuplot-process-frame)
|
||
(switch-to-buffer gnuplot-buffer)
|
||
(delete-other-windows)
|
||
(select-frame frame))))
|
||
|
||
(let ((list (gnuplot-split-string string)))
|
||
(with-current-buffer (get-buffer gnuplot-buffer)
|
||
(goto-char (point-max))
|
||
;; bruce asks: what is this next line for?
|
||
(set-marker (process-mark gnuplot-process) (point-marker))
|
||
(sleep-for (* 20 gnuplot-delay))
|
||
(while list
|
||
(insert (car list))
|
||
(comint-send-input)
|
||
(sleep-for gnuplot-delay)
|
||
(setq list (cdr list))
|
||
(goto-char (point-max))))
|
||
|
||
(cond ((equal gnuplot-display-process 'window)
|
||
(gnuplot-display-and-recenter-gnuplot-buffer))
|
||
((equal gnuplot-display-process 'frame)
|
||
;;(raise-frame gnuplot-process-frame)
|
||
(with-selected-frame gnuplot-process-frame
|
||
(gnuplot-display-and-recenter-gnuplot-buffer))))
|
||
|
||
(setq gnuplot-recently-sent text)
|
||
(run-hooks 'gnuplot-after-plot-hook)))
|
||
|
||
(defun gnuplot-display-and-recenter-gnuplot-buffer ()
|
||
"Make sure the gnuplot comint buffer is displayed.
|
||
Move point to the end if necessary."
|
||
(save-selected-window
|
||
(select-window (display-buffer (get-buffer gnuplot-buffer)))
|
||
(goto-char (point-max))
|
||
(unless (pos-visible-in-window-p (point) (selected-window)) (recenter 5))))
|
||
|
||
(defun gnuplot-send-region-to-gnuplot (&optional begin end text)
|
||
"Sends a selected region to the gnuplot program.
|
||
If BEGIN and END are not specified, point and mark are used. TEXT
|
||
indicates the type of text being sent to gnuplot. This will be
|
||
'region unless explicitly set by a function calling this one. Other
|
||
typical values are of nil, 'line, 'buffer, or 'file. TEXT may be
|
||
useful for function in `gnuplot-after-plot-hook'."
|
||
(interactive "r")
|
||
(let (string (txt (or text 'region)))
|
||
(cond ((equal major-mode 'gnuplot-mode)
|
||
(setq string (buffer-substring-no-properties begin end))
|
||
(if (string= (substring string -1) "\n") ()
|
||
(setq string (concat string "\n")))
|
||
(gnuplot-send-string-to-gnuplot string txt))
|
||
(t
|
||
(message (concat "You can only send regions from "
|
||
"gnuplot-mode buffers to gnuplot."))))))
|
||
|
||
(defun gnuplot-send-line-to-gnuplot ()
|
||
"Sends the current line to the gnuplot program.
|
||
Respects continuation lines.
|
||
This sets `gnuplot-recently-sent' to 'line."
|
||
(interactive)
|
||
(cond ((equal major-mode 'gnuplot-mode)
|
||
(let (start end)
|
||
(save-excursion
|
||
;; go to start of continued command, or beginning of line
|
||
;; if this is not a continuation of a previous line <JJO>
|
||
(gnuplot-beginning-of-continuation)
|
||
(setq start (point))
|
||
(end-of-line)
|
||
(while (save-excursion
|
||
(backward-char)
|
||
(looking-at "\\\\")) ; go to end of last continuation line
|
||
(end-of-line 2))
|
||
(beginning-of-line 2)
|
||
(setq end (point)))
|
||
(if (not (string-match "\\`\\s-*\\'"
|
||
(buffer-substring-no-properties start end)))
|
||
(gnuplot-send-region-to-gnuplot start end 'line))
|
||
end))
|
||
(t
|
||
(message "You can only send lines in gnuplot-mode buffers to gnuplot.")
|
||
nil)))
|
||
|
||
;; I chose a very easy to type but slightly non-mnemonic key-binding
|
||
;; for this (C-c C-v). It seems like the kind of thing one would want
|
||
;; to do repeatedly without incurring RSI. 8^)
|
||
(defun gnuplot-send-line-and-forward (&optional num)
|
||
"Call `gnuplot-send-line-to-gnuplot' and move forward 1 line.
|
||
You can use a numeric prefix to send more than one line. Blank lines and
|
||
lines with only comments are skipped when moving forward.
|
||
NUM is optional arg."
|
||
(interactive "p")
|
||
(let (end)
|
||
(while (> num 0)
|
||
(setq end (gnuplot-send-line-to-gnuplot))
|
||
(goto-char end)
|
||
(backward-char 1) ; <AR>
|
||
(gnuplot-forward-script-line 1)
|
||
(setq num (1- num)))))
|
||
|
||
(defun gnuplot-send-line-and-newline ()
|
||
"Call `gnuplot-send-line-to-gnuplot' and insert a new line."
|
||
(interactive)
|
||
(end-of-line)
|
||
(gnuplot-send-line-to-gnuplot)
|
||
(insert "\n"))
|
||
|
||
(defun gnuplot-forward-script-line (&optional num) ; <SE>
|
||
"Move forward my NUM script lines.
|
||
Blank lines and commented lines are not included in the NUM count."
|
||
(interactive "p")
|
||
(while (> num 0)
|
||
(and (not (eobp)) (forward-line 1))
|
||
(while (and (not (eobp))
|
||
(or (looking-at "^\\s-*$")
|
||
(looking-at "^\\s-*#")))
|
||
(forward-line 1))
|
||
(setq num (1- num))))
|
||
|
||
(defun gnuplot-send-buffer-to-gnuplot ()
|
||
"Sends the entire buffer to the gnuplot program.
|
||
This sets `gnuplot-recently-sent' to 'buffer."
|
||
(interactive)
|
||
(if (equal major-mode 'gnuplot-mode)
|
||
(gnuplot-send-region-to-gnuplot (point-min) (point-max) 'buffer)
|
||
(message "You can only send gnuplot-mode buffers to gnuplot.")))
|
||
|
||
(defun gnuplot-send-file-to-gnuplot ()
|
||
"Sends a selected file to the gnuplot program using the \"load\" command.
|
||
This sets `gnuplot-recently-sent' to 'file."
|
||
(interactive)
|
||
(let ((string (read-file-name "Name of file to send to gnuplot > " nil nil t)))
|
||
(setq string (concat "load '" (expand-file-name string) "'\n"))
|
||
(message "%S" string)
|
||
(gnuplot-make-gnuplot-buffer) ; make sure a gnuplot buffer exists
|
||
(gnuplot-send-string-to-gnuplot string 'file)))
|
||
|
||
;; suggested by <JS>
|
||
(defun gnuplot-plot-from-comint ()
|
||
"Send the contents of a script to gnuplot from the process buffer.
|
||
This inserts the contents of the most recently used gnuplot script
|
||
into the process buffer and sends those lines to gnuplot. It does
|
||
this by copying the script line by line."
|
||
(interactive)
|
||
(if (not (buffer-live-p gnuplot-comint-recent-buffer))
|
||
(message "Script buffer has been deleted.")
|
||
(let (string list (buffer (current-buffer)))
|
||
(set-buffer gnuplot-comint-recent-buffer)
|
||
(setq string (buffer-substring-no-properties (point-min) (point-max))
|
||
string (concat string "\n")
|
||
list (gnuplot-split-string string))
|
||
(set-buffer buffer)
|
||
(while list
|
||
(insert (car list))
|
||
(comint-send-input)
|
||
(sleep-for gnuplot-delay)
|
||
(setq list (cdr list)))
|
||
(comint-send-input))))
|
||
|
||
(defun gnuplot-save-and-plot-from-comint ()
|
||
"Send a current script to gnuplot from the process buffer.
|
||
This sends the most recently used gnuplot script to gnuplot using the
|
||
\"load\" command. This function first saves the script buffer to a
|
||
file, prompting for a filename if one is not associated with the script
|
||
buffer. Then it sends a load command to gnuplot using the name of the
|
||
file visited by the script buffer."
|
||
(interactive)
|
||
(if (not (buffer-live-p gnuplot-comint-recent-buffer))
|
||
(message "Script buffer has been deleted.")
|
||
(let (fname)
|
||
(with-current-buffer gnuplot-comint-recent-buffer
|
||
(save-buffer)
|
||
(setq fname (buffer-file-name)))
|
||
(goto-char (point-max))
|
||
(insert (format "load '%s'" fname))
|
||
(comint-send-input))))
|
||
|
||
(defun gnuplot-pop-to-recent-buffer ()
|
||
"Switch to the most recently-plotted gnuplot script buffer."
|
||
(interactive)
|
||
(when (buffer-live-p gnuplot-comint-recent-buffer)
|
||
(pop-to-buffer gnuplot-comint-recent-buffer)))
|
||
|
||
(defun gnuplot-trim-gnuplot-buffer ()
|
||
"Trim lines from the beginning of the *gnuplot* buffer.
|
||
This keeps that buffer from growing excessively in size. Normally,
|
||
this function is attached to `gnuplot-after-plot-hook'"
|
||
(if (> gnuplot-buffer-max-size 0)
|
||
(with-current-buffer gnuplot-buffer
|
||
(let ((nlines (count-lines (point-min) (point-max)))
|
||
(kill-whole-line t))
|
||
(while (> nlines gnuplot-buffer-max-size)
|
||
(goto-char (point-min))
|
||
(kill-line)
|
||
(setq nlines (1- nlines)))
|
||
(goto-char (point-max))))))
|
||
(add-hook 'gnuplot-after-plot-hook 'gnuplot-trim-gnuplot-buffer nil nil)
|
||
|
||
|
||
;;; --- functions controlling the gnuplot process
|
||
|
||
;; Menu for the comint-mode buffer
|
||
(defvar gnuplot-comint-menu
|
||
`("Gnuplot"
|
||
["Plot most recent gnuplot buffer" gnuplot-plot-from-comint
|
||
(buffer-live-p gnuplot-comint-recent-buffer)]
|
||
["Save and plot most recent gnuplot buffer" gnuplot-save-and-plot-from-comint
|
||
(buffer-live-p gnuplot-comint-recent-buffer)]
|
||
"---"
|
||
,gnuplot-display-options-menu
|
||
["Contextual completion and help" gnuplot-context-sensitive-mode
|
||
:style toggle
|
||
:selected gnuplot-context-sensitive-mode]
|
||
["Echo area help (eldoc-mode)" eldoc-mode
|
||
:active gnuplot-context-sensitive-mode
|
||
:style toggle
|
||
:selected eldoc-mode]
|
||
"---"
|
||
["Insert filename at point" gnuplot-insert-filename t]
|
||
["Negate set option" gnuplot-negate-option t]
|
||
["Keyword help" gnuplot-info-lookup-symbol
|
||
(or gnuplot-keywords gnuplot-keywords-pending)]
|
||
["Quick help for thing at point" gnuplot-help-function
|
||
gnuplot-context-sensitive-mode]
|
||
["Info documentation on thing at point"
|
||
gnuplot-info-at-point
|
||
gnuplot-context-sensitive-mode]
|
||
["Switch to recent gnuplot script buffer" gnuplot-pop-to-recent-buffer
|
||
(buffer-live-p gnuplot-comint-recent-buffer)]
|
||
"---"
|
||
["Customize gnuplot" gnuplot-customize t]
|
||
["Show gnuplot-mode version" gnuplot-show-version t]
|
||
["Show gnuplot version" gnuplot-show-gnuplot-version t]
|
||
"---"
|
||
["Kill gnuplot" gnuplot-kill-gnuplot-buffer t]))
|
||
|
||
;; Major mode `gnuplot-comint-mode' for the interaction buffer
|
||
(define-derived-mode gnuplot-comint-mode comint-mode "Gnuplot interaction"
|
||
"Major mode for interacting with a gnuplot process in a buffer.
|
||
|
||
This sets font-lock and keyword completion in the comint/gnuplot
|
||
buffer."
|
||
|
||
(set-syntax-table gnuplot-mode-syntax-table)
|
||
|
||
(if gnuplot-xemacs-p ; deal with font-lock
|
||
(if (fboundp 'turn-on-font-lock) (turn-on-font-lock))
|
||
(progn
|
||
(setq font-lock-defaults gnuplot-font-lock-defaults)
|
||
(set (make-local-variable 'parse-sexp-lookup-properties) t)
|
||
(set (make-local-variable 'syntax-propertize-function)
|
||
#'gnuplot-syntax-propertize)))
|
||
|
||
;; XEmacs needs the call to make-local-hook
|
||
(when (and (featurep 'xemacs)
|
||
(fboundp 'make-local-hook))
|
||
(make-local-hook 'kill-buffer-hook))
|
||
(add-hook 'kill-buffer-hook 'gnuplot-close-down nil t)
|
||
|
||
(add-hook 'comint-output-filter-functions
|
||
'comint-postoutput-scroll-to-bottom
|
||
nil t)
|
||
(add-hook 'comint-output-filter-functions
|
||
'gnuplot-protect-prompt-fn
|
||
nil t)
|
||
|
||
;; Set up completion, using completion-at-point in recent Emacs,
|
||
;; comint-dynamic-complete in older Emacs
|
||
(if (and (>= emacs-major-version 24)
|
||
(>= emacs-minor-version 1))
|
||
(add-hook 'completion-at-point-functions #'gnuplot-completion-at-point nil t)
|
||
(add-hook 'comint-dynamic-complete-functions 'gnuplot-comint-complete nil t))
|
||
|
||
;; Set up menu (see below)
|
||
(easy-menu-define
|
||
gnuplot-comint-mode-menu gnuplot-comint-mode-map "Menu used in gnuplot-comint-mode"
|
||
gnuplot-comint-menu)
|
||
(easy-menu-add gnuplot-comint-mode-menu gnuplot-comint-mode-map))
|
||
|
||
;; Key bindings for gnuplot-comint-mode
|
||
(define-key gnuplot-comint-mode-map "\M-\C-p" 'gnuplot-plot-from-comint)
|
||
(define-key gnuplot-comint-mode-map "\M-\C-f" 'gnuplot-save-and-plot-from-comint)
|
||
(define-key gnuplot-comint-mode-map "\C-d" 'gnuplot-delchar-or-maybe-eof)
|
||
(let ((completion-function
|
||
(if (and (>= emacs-major-version 24)
|
||
(>= emacs-minor-version 1))
|
||
'completion-at-point
|
||
'comint-dynamic-complete)))
|
||
(define-key gnuplot-comint-mode-map "\M-\r" completion-function)
|
||
(define-key gnuplot-comint-mode-map "\M-\t" completion-function))
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-d" 'gnuplot-info-lookup-symbol)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-w" 'gnuplot-show-version)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-i" 'gnuplot-insert-filename)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-n" 'gnuplot-negate-option)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-p" 'gnuplot-show-gnuplot-version)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-z" 'gnuplot-customize)
|
||
(define-key gnuplot-comint-mode-map "\C-c\C-e" 'gnuplot-pop-to-recent-buffer)
|
||
(define-key gnuplot-comint-mode-map "\C-c\M-i" 'gnuplot-inline-image-mode)
|
||
|
||
;; Menu for gnuplot-comint-mode
|
||
(defvar gnuplot-comint-mode-menu nil
|
||
"Menu for `gnuplot-comint-mode'.")
|
||
|
||
;; Switch to the gnuplot program buffer
|
||
(defun gnuplot-make-gnuplot-buffer ()
|
||
"Switch to the gnuplot program buffer or create one if none exists."
|
||
(unless (and gnuplot-process (eq (process-status gnuplot-process) 'run)
|
||
gnuplot-buffer (buffer-live-p gnuplot-buffer))
|
||
(message "Starting gnuplot plotting program...")
|
||
(setq gnuplot-buffer (make-comint gnuplot-process-name gnuplot-program)
|
||
gnuplot-process (get-buffer-process gnuplot-buffer))
|
||
(gnuplot-set-process-query-on-exit-flag gnuplot-process nil)
|
||
(with-current-buffer gnuplot-buffer
|
||
(gnuplot-comint-mode)
|
||
(when gnuplot-inline-image-mode
|
||
(sleep-for gnuplot-delay)
|
||
(gnuplot-setup-comint-for-image-mode)))
|
||
(message "Starting gnuplot plotting program...Done")))
|
||
|
||
|
||
(defun gnuplot-fetch-version-number ()
|
||
"Determine the installed version of the gnuplot program.
|
||
|
||
If `gnuplot-program-version' is already set, does nothing.
|
||
Otherwise, runs `gnuplot-program' and searches the text printed
|
||
at startup for a string like \"Version N.N\".
|
||
|
||
Sets the variables `gnuplot-program-version',
|
||
`gnuplot-program-major-version', `gnuplot-program-minor-version',
|
||
and `gnuplot-three-eight-p'.
|
||
|
||
If the version number cannot be determined by this method, it
|
||
defaults to 3.7."
|
||
(unless gnuplot-program-version
|
||
(message "gnuplot-mode %s -- determining gnuplot version ......"
|
||
gnuplot-version)
|
||
(with-temp-buffer
|
||
(insert "show version")
|
||
(call-process-region (point-min) (point-max)
|
||
gnuplot-program t (current-buffer))
|
||
(goto-char (point-min))
|
||
(if (and (re-search-forward "[Vv]ersion\\s-+" (point-max) t)
|
||
(looking-at "\\([0-9]\\)\\.\\([0-9]+\\)"))
|
||
(progn
|
||
(setq gnuplot-program-version (match-string 0)
|
||
gnuplot-program-major-version (string-to-number
|
||
(match-string 1))
|
||
gnuplot-program-minor-version (string-to-number
|
||
(match-string 2))
|
||
gnuplot-three-eight-p
|
||
(>= (string-to-number gnuplot-program-version) 3.8)))
|
||
|
||
;; Guess v3.7 if something went wrong
|
||
(message "Warning: could not determine gnuplot version, guessing 3.7")
|
||
(setq gnuplot-program-version "3.7"
|
||
gnuplot-program-major-version 3
|
||
gnuplot-program-minor-version 7
|
||
gnuplot-three-eight-p nil)))
|
||
|
||
;; Setup stuff that depends on version number
|
||
(gnuplot-setup-menu-and-toolbar)))
|
||
|
||
(defun gnuplot-setup-menu-and-toolbar ()
|
||
"Setup stuff that depends on version number."
|
||
;; set up the menubar (possibly dependent on version number)
|
||
(gnuplot-setup-menubar)
|
||
;; set up the toolbar (possibly dependent on version number)
|
||
(if (and gnuplot-xemacs-p gnuplot-toolbar-display-flag)
|
||
(condition-case () ; deal with the toolbar
|
||
(and (require 'toolbar)
|
||
(require 'xpm)
|
||
(gnuplot-make-toolbar-function))
|
||
(error nil)))
|
||
(message "gnuplot-mode %s (gnuplot %s) -- report bugs as issues at %s"
|
||
gnuplot-version gnuplot-program-version
|
||
gnuplot-maintainer-url))
|
||
|
||
(defvar gnuplot-prompt-regexp
|
||
(regexp-opt '("gnuplot> " "multiplot> "))
|
||
"Regexp for recognizing the GNUPLOT prompt.")
|
||
|
||
(defun gnuplot-protect-prompt-fn (string)
|
||
"Prevent the Gnuplot prompt from being deleted or overwritten.
|
||
STRING is the text as originally inserted in the comint buffer."
|
||
(save-excursion
|
||
(let ((b (progn
|
||
(goto-char (point-max))
|
||
(beginning-of-line)
|
||
(point)))
|
||
e)
|
||
(if (re-search-forward gnuplot-prompt-regexp (point-max) t)
|
||
(progn
|
||
(setq e (point))
|
||
(put-text-property b e 'rear-nonsticky '(read-only intangible face))
|
||
(put-text-property b e 'intangible t)
|
||
(put-text-property b e 'face 'gnuplot-prompt-face)
|
||
;;(put-text-property b e 'read-only t)
|
||
)))))
|
||
|
||
(defun gnuplot-close-down ()
|
||
"Tidy up when deleting the gnuplot buffer."
|
||
(if (and gnuplot-process
|
||
(eq (process-status gnuplot-process) 'run)) ; <SE>
|
||
(kill-process gnuplot-process))
|
||
(setq gnuplot-process nil
|
||
gnuplot-buffer nil))
|
||
|
||
(defun gnuplot-delchar-or-maybe-eof (arg)
|
||
"Delete ARG characters forward, or (if at eob) send an EOF to subprocess.
|
||
This is very similar to `comint-delchar-or-maybe-eof'."
|
||
(interactive "p")
|
||
(if (eobp)
|
||
(gnuplot-kill-gnuplot-buffer)
|
||
(delete-char arg)))
|
||
|
||
(defun gnuplot-kill-gnuplot-buffer ()
|
||
"Kill the gnuplot process and its display buffers."
|
||
(interactive)
|
||
(if (and gnuplot-process
|
||
(eq (process-status gnuplot-process) 'run)) ;; <SE>
|
||
(kill-process gnuplot-process))
|
||
(if (and gnuplot-buffer (get-buffer gnuplot-buffer))
|
||
(progn
|
||
(if (one-window-p) ()
|
||
(delete-window (get-buffer-window gnuplot-buffer)))
|
||
(kill-buffer gnuplot-buffer)))
|
||
(setq gnuplot-process nil
|
||
gnuplot-buffer nil))
|
||
|
||
|
||
(defun gnuplot-show-gnuplot-buffer ()
|
||
"Switch to the buffer containing the gnuplot process.
|
||
When `gnuplot-display-process' is nil this will switch to
|
||
the gnuplot process buffer. When that variable is non-nil, the
|
||
gnuplot process buffer will be displayed in a window."
|
||
(interactive)
|
||
(unless (and gnuplot-buffer (get-buffer gnuplot-buffer))
|
||
(gnuplot-make-gnuplot-buffer))
|
||
(cond ((equal gnuplot-display-process 'window)
|
||
(switch-to-buffer-other-window gnuplot-buffer))
|
||
((equal gnuplot-display-process 'frame)
|
||
(or (and gnuplot-process-frame
|
||
(frame-live-p gnuplot-process-frame))
|
||
(setq gnuplot-process-frame (make-frame)))
|
||
(raise-frame gnuplot-process-frame)
|
||
(select-frame gnuplot-process-frame)
|
||
(switch-to-buffer gnuplot-buffer))
|
||
(t
|
||
(switch-to-buffer gnuplot-buffer))))
|
||
|
||
|
||
;;; Support for displaying plotted images within Emacs
|
||
|
||
(defvar gnuplot-inline-image-filename nil
|
||
"Name of the current Gnuplot output file.")
|
||
|
||
(defvar gnuplot-image-buffer-name "*gnuplot output*")
|
||
|
||
(defun gnuplot-display-images-p ()
|
||
"Inline images require GNU Emacs."
|
||
(and (not (featurep 'xemacs))
|
||
(fboundp 'display-images-p)
|
||
(display-images-p)))
|
||
|
||
(defun gnuplot-external-display-mode ()
|
||
"Display image in external."
|
||
(interactive)
|
||
(gnuplot-set-display-mode 'gnuplot-inline-image-mode nil))
|
||
|
||
(defun gnuplot-inline-display-mode ()
|
||
"Display image in inline."
|
||
(interactive)
|
||
(gnuplot-set-display-mode 'gnuplot-inline-image-mode 'inline))
|
||
|
||
(defun gnuplot-dedicated-display-mode ()
|
||
"Display image in dedicated."
|
||
(interactive)
|
||
(gnuplot-set-display-mode 'gnuplot-inline-image-mode 'dedicated))
|
||
|
||
(defun gnuplot-set-image-format (format)
|
||
"Display image in FORMAT."
|
||
(interactive "sGnuplot image format: ")
|
||
(gnuplot-set-display-mode 'gnuplot-image-format format)
|
||
(unless gnuplot-inline-image-mode
|
||
(message "Setting will take effect when plots are displayed in Emacs")))
|
||
|
||
(defun gnuplot-setup-comint-for-image-mode ()
|
||
"Setup comint for image."
|
||
(when (and gnuplot-buffer (buffer-live-p gnuplot-buffer)
|
||
(get-buffer-process gnuplot-buffer))
|
||
(with-current-buffer gnuplot-buffer
|
||
(if gnuplot-inline-image-mode
|
||
(progn
|
||
(gnuplot-send-hiding-output
|
||
(format "set terminal %s\n" gnuplot-image-format))
|
||
(gnuplot-inline-image-set-output)
|
||
(add-hook 'comint-output-filter-functions
|
||
'gnuplot-insert-inline-image-output nil t))
|
||
(gnuplot-send-hiding-output "set terminal pop\n")
|
||
(remove-hook 'comint-output-filter-functions
|
||
'gnuplot-insert-inline-image-output t)))))
|
||
|
||
(defun gnuplot-inline-image-set-output ()
|
||
"Set Gnuplot's output file to `gnuplot-inline-image-filename'."
|
||
(let ((tmp (make-temp-file "gnuplot")))
|
||
(setq gnuplot-inline-image-filename tmp)
|
||
(gnuplot-send-hiding-output (format "set output '%s'\n" tmp))))
|
||
|
||
(defvar gnuplot-inhibit-filter nil)
|
||
|
||
(defun gnuplot-insert-inline-image-output (string)
|
||
"Insert Gnuplot graphical output STRING in the gnuplot-comint buffer.
|
||
|
||
Called via `comint-preoutput-filter-functions' hook when
|
||
`gnuplot-inline-image-mode' is enabled. Checks the status of the
|
||
file `gnuplot-inline-image-filename'; if it exists and has
|
||
nonzero size, inserts it as an inline image, stores a new
|
||
temporary filename in `gnuplot-inline-image-filename', and
|
||
updates Gnuplot with the appropriate 'set output' command."
|
||
(unless gnuplot-inhibit-filter ; Prevent recursively entering this filter
|
||
(let ((gnuplot-inhibit-filter t)) ; (causing an infinite loop)
|
||
(save-excursion
|
||
(goto-char (point-max))
|
||
(beginning-of-line)
|
||
(when (looking-at gnuplot-prompt-regexp)
|
||
(let* ((filename gnuplot-inline-image-filename)
|
||
(size (nth 7 (file-attributes filename))))
|
||
(when (and size (> size 0))
|
||
(gnuplot-send-hiding-output "set output\n") ; Flush output file
|
||
(sit-for 0.1) ; Hack: wait for Gnuplot IO to finish
|
||
(ecase gnuplot-inline-image-mode
|
||
(nil nil)
|
||
(inline
|
||
(ignore-errors
|
||
(let ((image (create-image filename)))
|
||
(beginning-of-line)
|
||
(insert-image image)
|
||
(insert "\n")
|
||
(gnuplot-inline-image-set-output))))
|
||
(dedicated
|
||
(with-current-buffer
|
||
(get-buffer-create gnuplot-image-buffer-name)
|
||
(let ((inhibit-read-only t))
|
||
(erase-buffer)
|
||
(insert-file-contents filename)
|
||
(ignore-errors (normal-mode))
|
||
(display-buffer (current-buffer))
|
||
(gnuplot-inline-image-set-output))))))))))))
|
||
|
||
;;; Send commands to GNUPLOT silently & without generating an extra prompt
|
||
(defvar gnuplot-hidden-output-buffer " *gnuplot output*")
|
||
|
||
(defun gnuplot-send-hiding-output (string)
|
||
"Send STRING to the running Gnuplot process invisibly."
|
||
(with-current-buffer gnuplot-buffer
|
||
(add-hook 'comint-preoutput-filter-functions
|
||
'gnuplot-discard-output nil t))
|
||
(with-current-buffer (get-buffer-create gnuplot-hidden-output-buffer)
|
||
(erase-buffer))
|
||
(comint-send-string (get-buffer-process gnuplot-buffer) string))
|
||
|
||
(defun gnuplot-discard-output (string)
|
||
"Temporary preoutput filter for hiding Gnuplot output & prompt.
|
||
Accumulates output STRING in a buffer until it finds the next prompt,
|
||
then removes itself from `comint-preoutput-filter-functions'."
|
||
(with-current-buffer
|
||
(get-buffer-create gnuplot-hidden-output-buffer)
|
||
(insert string)
|
||
(when (looking-back gnuplot-prompt-regexp (point-min))
|
||
(with-current-buffer gnuplot-buffer
|
||
(remove-hook 'comint-preoutput-filter-functions
|
||
'gnuplot-discard-output t))))
|
||
"")
|
||
|
||
|
||
|
||
;;; --- miscellaneous functions: insert file name, indentation, negation
|
||
|
||
(defun gnuplot-insert-filename ()
|
||
"Insert a filename at point, prompting for name in the minibuffer.
|
||
This inserts a filename relative to the buffer's default directory.
|
||
Uses completion and the value of `gnuplot-quote-character'.
|
||
Bound to \\[gnuplot-insert-filename]"
|
||
(interactive)
|
||
(insert gnuplot-quote-character
|
||
(file-relative-name (read-file-name "Filename > " "")
|
||
default-directory)
|
||
gnuplot-quote-character))
|
||
|
||
|
||
;; Adjust indentation for the line containing point
|
||
(defun gnuplot-indent-line ()
|
||
"Set indentation in gnuplot buffer.
|
||
For most lines, set indentation to previous level of indentation.
|
||
Add additional indentation for continuation lines."
|
||
(interactive)
|
||
(let (indent)
|
||
(if (gnuplot-in-string (point-at-bol))
|
||
;; Continued strings begin at left margin
|
||
(setq indent 0)
|
||
(save-excursion
|
||
(if (gnuplot-continuation-line-p)
|
||
;; This is a continuation line. Indent to the same level as
|
||
;; the second word on the line beginning this command (i.e.,
|
||
;; the first non-whitespace character after whitespace)
|
||
(progn
|
||
(gnuplot-beginning-of-continuation)
|
||
(back-to-indentation)
|
||
(re-search-forward "\\S-+\\s-+" (point-at-eol) 'end-at-limit)
|
||
(setq indent (current-column)))
|
||
|
||
;; Not a continuation line; indent according to block
|
||
;; nesting depth
|
||
(save-excursion
|
||
(condition-case nil
|
||
(progn
|
||
(beginning-of-line)
|
||
(skip-syntax-forward "-" (point-at-eol))
|
||
(if (looking-at "\\s)") (forward-char))
|
||
(backward-up-list)
|
||
(gnuplot-beginning-of-continuation)
|
||
(setq indent (+ gnuplot-basic-offset (current-indentation))))
|
||
(error
|
||
(setq indent 0)))))))
|
||
|
||
;; Set indentation
|
||
(save-excursion
|
||
(indent-line-to indent))
|
||
|
||
;; Move point after indentation when at beginning of line
|
||
(when (< (current-column) indent)
|
||
(move-to-column indent))))
|
||
|
||
(defun gnuplot-electric-insert (BRACE)
|
||
"Adjust indentation on inserting a close BRACE.
|
||
The blink-paren fix is stolen from cc-mode"
|
||
(interactive "*p")
|
||
(let ((old-blink-paren blink-paren-function)
|
||
(blink-paren-function nil))
|
||
(self-insert-command BRACE)
|
||
(gnuplot-indent-line)
|
||
(when old-blink-paren (funcall old-blink-paren))))
|
||
|
||
;;
|
||
;; Functions for finding the start and end of continuation blocks
|
||
;;
|
||
|
||
;; Check if line containing point is a continuation
|
||
(defun gnuplot-continuation-line-p ()
|
||
"Return t if the line containing point is a continuation of the previous line."
|
||
(save-excursion
|
||
(condition-case ()
|
||
(progn
|
||
(end-of-line 0)
|
||
(backward-char)
|
||
(looking-at "\\\\"))
|
||
(error nil))))
|
||
|
||
;; Move point to start of continuation block
|
||
(defun gnuplot-beginning-of-continuation ()
|
||
"Move point to the beginning of the continuation lines containing point.
|
||
|
||
If not in a continuation line, move point to beginning of line."
|
||
(beginning-of-line)
|
||
(while (gnuplot-continuation-line-p)
|
||
(beginning-of-line 0)))
|
||
|
||
;; Move point to end of continuation block
|
||
(defun gnuplot-end-of-continuation ()
|
||
"Move point to the end of the continuation lines containing point.
|
||
|
||
If there are no continuation lines, move point to `end-of-line'."
|
||
(end-of-line)
|
||
(unless (bobp)
|
||
(catch 'eob
|
||
(while (save-excursion (backward-char)
|
||
(looking-at "\\\\"))
|
||
(end-of-line 2)
|
||
(if (eobp) (throw 'eob nil))))))
|
||
|
||
;; Save-excursion wrappers for the above to return point at beginning
|
||
;; or end of continuation
|
||
(defun gnuplot-point-at-beginning-of-continuation (&optional pos)
|
||
"Return value of point at beginning of the continued block containing point.
|
||
|
||
If there are no continuation lines, returns `point-at-bol'.
|
||
If specify POS, move POS befere execution."
|
||
(save-excursion
|
||
(when pos (goto-char pos))
|
||
(gnuplot-beginning-of-continuation)
|
||
(point)))
|
||
|
||
(defun gnuplot-point-at-end-of-continuation (&optional pos)
|
||
"Return value of point at the end of the continued block containing point.
|
||
|
||
If there are no continuation lines, returns `point-at-eol'.
|
||
If specify POS, move POS before execution."
|
||
(save-excursion
|
||
(when pos (goto-char pos))
|
||
(gnuplot-end-of-continuation)
|
||
(point)))
|
||
|
||
(defun gnuplot-beginning-of-defun (&optional arg)
|
||
"We also treat a block of continuation lines as a `defun'.
|
||
ARG is optional arg."
|
||
(if (not arg) (setq arg 1))
|
||
(if (> arg 0)
|
||
(catch 'bob ; go to beginning of ARGth prev. defun
|
||
(dotimes (n arg)
|
||
(when (= (point)
|
||
(gnuplot-point-at-beginning-of-continuation))
|
||
(forward-line -1)
|
||
(if (bobp) (throw 'bob t))
|
||
(while (looking-at "^\\s-*$")
|
||
(forward-line -1)
|
||
(if (bobp) (throw 'bob t))))
|
||
(gnuplot-beginning-of-continuation))
|
||
t)
|
||
|
||
(catch 'eob ; find beginning of (-ARG)th following defun
|
||
(dotimes (n (- arg))
|
||
(gnuplot-end-of-continuation)
|
||
(forward-line)
|
||
(if (eobp) (throw 'eob t))
|
||
(while (looking-at "^\\s-*$")
|
||
(forward-line)
|
||
(if (eobp) (throw 'eob t)))))))
|
||
|
||
;; Movement to start or end of command, including multiple commands
|
||
;; separated by semicolons
|
||
(defun gnuplot-beginning-of-command ()
|
||
"Move point to beginning of command containing point."
|
||
(let ((limit (gnuplot-point-at-beginning-of-continuation)))
|
||
(while
|
||
(and
|
||
(search-backward ";" limit 'lim)
|
||
(gnuplot-in-string-or-comment)))
|
||
(skip-chars-forward ";")
|
||
(skip-syntax-forward "-")))
|
||
|
||
(defun gnuplot-end-of-command ()
|
||
"Move point to end of command containing point."
|
||
(let ((limit (gnuplot-point-at-end-of-continuation)))
|
||
(while
|
||
(and
|
||
(search-forward ";" limit 'lim)
|
||
(gnuplot-in-string-or-comment)))
|
||
(skip-chars-backward ";")
|
||
(skip-syntax-backward "-")))
|
||
|
||
(defun gnuplot-point-at-beginning-of-command ()
|
||
"Return position at the beginning of command containing point."
|
||
(save-excursion (gnuplot-beginning-of-command) (point)))
|
||
|
||
(defun gnuplot-point-at-end-of-command ()
|
||
"Return position at the end of command containing point."
|
||
(save-excursion (gnuplot-end-of-command) (point)))
|
||
|
||
(defun gnuplot-negate-option ()
|
||
"Append \"no\" to or remove \"no\" from the set option on the current line.
|
||
This checks if the set option is one which has a negated form.
|
||
|
||
Negatable options are defined in `gnuplot-keywords-negatable-options'."
|
||
(interactive)
|
||
(gnuplot-fetch-version-number)
|
||
(let ((begin (gnuplot-point-at-beginning-of-command))
|
||
(end (gnuplot-point-at-end-of-command))
|
||
(regex gnuplot-negatable-options-regexp))
|
||
(save-excursion
|
||
(goto-char begin)
|
||
(skip-syntax-forward "-" end)
|
||
(if (looking-at "\\(un\\)?set\\s-+")
|
||
(cond ((> (string-to-number gnuplot-program-version) 3.7)
|
||
(cond ((looking-at "unset")
|
||
(delete-char 2))
|
||
((looking-at (concat "set\\s-+\\(" regex "\\)"))
|
||
(insert "un"))
|
||
(t
|
||
(message "There is not a negatable set option on this line"))))
|
||
(t
|
||
(goto-char (match-end 0))
|
||
(if (> (point) end) (goto-char end))
|
||
(cond ((looking-at "no")
|
||
(delete-char 2))
|
||
((looking-at regex)
|
||
(insert "no"))
|
||
(t
|
||
(message "There is not a negatable set option on this line")))))
|
||
(message "There is not a set option on this line")))))
|
||
|
||
;; (defun gnuplot-set-binding ()
|
||
;; "Interactively select a key sequence for binding to a plot function.
|
||
;; This is only useful in gnuplot 3.8 and for plot terminals which support
|
||
;; key bindings (i.e. those covered by pm3d)."
|
||
;; (interactive)
|
||
;; (let ((keyseq (read-key-sequence "Choose a key sequence now"))
|
||
;; (command (read-string "Bind to this command > ")))
|
||
;; (setq keyseq (format "%S" keyseq))
|
||
;; (string-match "keypress-event\\s-+" keyseq)
|
||
;; (setq keyseq (substring keyseq (match-end 0) -2))
|
||
;; ;; need to convert from emacs nomenclature to gnuplot. what a pain.
|
||
;; (let* ((alist '(("backspace" . "Backspace") ("tab" . "Tab") ("linefeed" . "Linefeed")
|
||
;; ("clear" . "Clear") ("return" . "Return") ("pause" . "Pause")
|
||
;; ("scroll-lock" . "Scroll_Lock") ("SysReq" . "sys-req")
|
||
;; ("escape" . "Escape") ("delete" . "Delete") ("home" . "Home")
|
||
;; ("left" . "Left") ("right" . "Right") ("up" . "Up") ("down" . "Down")
|
||
;; ("prior" . "PageUp") ("next" . "PageDown") ("end" . "End")
|
||
;; ("begin". "Begin")))
|
||
;; (match (assoc keyseq alist)))
|
||
;; (if match (setq keyseq (cdr match)))
|
||
;;
|
||
;; (insert (format "bind \"%s\" \"%s\"" keyseq command)))))
|
||
|
||
|
||
(defun gnuplot-customize ()
|
||
"Customize `gnuplot-mode'."
|
||
(interactive)
|
||
(if (fboundp 'customize-group)
|
||
(customize-group "gnuplot")
|
||
(message "The Custom library is not installed.")))
|
||
|
||
|
||
|
||
;;; --- help from the info file, keyword list + completion, insert function
|
||
|
||
|
||
;; set up stuff for info-look (as suggested by <SE>)
|
||
;; modified with suggestion from <MS>
|
||
(defun gnuplot-setup-info-look ()
|
||
"Setup info-look in the gnuplot buffer.
|
||
|
||
Also set the variable `gnuplot-keywords' and do something sensible if
|
||
info-look was not available.
|
||
See the comments in `gnuplot-info-hook'."
|
||
(interactive)
|
||
(setq gnuplot-keywords-pending nil)
|
||
(if (featurep 'info-look)
|
||
(progn
|
||
(gnuplot-fetch-version-number)
|
||
|
||
;; In the absence of evidence to the contrary, I'm guessing
|
||
;; the info file layout changed with gnuplot version 4 <jjo>
|
||
(let ((doc-spec
|
||
(if (>= (string-to-number gnuplot-program-version) 4.0)
|
||
;; New info-file layout - works with gnuplot 4.4
|
||
'(("(gnuplot)Command_Index" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)Options_Index" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)Function_Index" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)Terminal_Index" nil "[_a-zA-Z0-9]+"))
|
||
|
||
;; Old info-file layout
|
||
'(("(gnuplot)Top" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)Commands" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)Functions" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)plot" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)set-show" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)data-file" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)smooth" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)style" nil "[_a-zA-Z0-9]+")
|
||
("(gnuplot)terminal" nil "[_a-zA-Z0-9]+")))))
|
||
(cond ((boundp 'info-lookup-symbol-alist) ; older info-lookup version
|
||
(setq info-lookup-symbol-alist
|
||
(append
|
||
info-lookup-symbol-alist
|
||
`((gnuplot-mode
|
||
"[a-zA-Z][_a-zA-Z0-9]*" nil
|
||
,doc-spec "[_a-zA-Z0-9]+" )))))
|
||
(t ; newer version
|
||
(info-lookup-add-help
|
||
:mode 'gnuplot-mode :topic 'symbol
|
||
:regexp "[a-zA-Z][_a-zA-Z0-9]*"
|
||
:doc-spec doc-spec)
|
||
;; allow help lookup from the comint buffer as well <jjo>
|
||
(info-lookup-add-help
|
||
:mode 'gnuplot-comint-mode :topic 'symbol
|
||
:regexp "[a-zA-Z][_a-zA-Z0-9]*"
|
||
:doc-spec doc-spec))))
|
||
|
||
;; this hook is my best way of working with info-look and
|
||
;; allowing multiple versions of the gnuplot-info file.
|
||
;; yes, this is a hassle.
|
||
(run-hooks 'gnuplot-info-hook)
|
||
(let ((there (bufferp (get-buffer "*info*"))))
|
||
(info-lookup-setup-mode 'symbol 'gnuplot-mode)
|
||
(or there (and (get-buffer "*info*") (kill-buffer "*info*")))
|
||
;; why are these buffers here? I think that the general
|
||
;; user will not want them lying around
|
||
(and (get-buffer "info dir") (kill-buffer "info dir"))
|
||
(and (get-buffer "info dir<2>") (kill-buffer "info dir<2>")))
|
||
(setq gnuplot-keywords (gnuplot-set-keywords-list))
|
||
(setq gnuplot-keywords-alist ; needed for all-completions
|
||
(mapcar 'list gnuplot-keywords)))
|
||
|
||
;; or do something sensible if info-look is not installed
|
||
(defun info-lookup-interactive-arguments (symbol)
|
||
(message
|
||
"Help is not available. info-look.el is not installed.")
|
||
(list nil nil))))
|
||
|
||
|
||
(defun gnuplot-set-keywords-list ()
|
||
"Set `gnuplot-keywords' from `info-lookup-cache'.
|
||
Return a list of keywords."
|
||
(let* ((list (cdr (assoc 'symbol info-lookup-cache)))
|
||
(list (cdr (cdr (assoc 'gnuplot-mode list))))
|
||
(list (car list))
|
||
(store ()) item)
|
||
(while list
|
||
(setq item (car (car list))
|
||
item (format "%s" item) ; keep this line for the sake of
|
||
store (append (list item) store) ; info-look.el w/o my patch
|
||
list (cdr list)))
|
||
(delete "nil" store)
|
||
store ))
|
||
|
||
|
||
;;;; Completion at point and Eldoc.
|
||
|
||
;; There are two alternative completion-at-point mechanisms: the old
|
||
;; one using info-look and the new one (enabled by default) which
|
||
;; parses the command line to provide smarter completions.
|
||
|
||
;; `gnuplot-completion-at-point-function' defines which one is
|
||
;; used. `gnuplot-context-sensitive-mode' toggles between the two.
|
||
|
||
(defvar gnuplot-completion-at-point-function #'gnuplot-completion-at-point-info-look
|
||
"Function to call to perform completion in Gnuplot buffers.")
|
||
|
||
(defun gnuplot-completion-at-point ()
|
||
"Perform completion in Gnuplot buffers."
|
||
(funcall gnuplot-completion-at-point-function))
|
||
|
||
(defvar gnuplot-eldoc-hash nil
|
||
"ElDoc strings for gnuplot-mode.
|
||
|
||
These have to be compiled from the Gnuplot source tree using
|
||
`doc2texi.el'.")
|
||
|
||
;; Enable and disable context-sensitive completion
|
||
(define-minor-mode gnuplot-context-sensitive-mode
|
||
"Use context-sensitive completion and help in gnuplot-mode.
|
||
|
||
When context-sensitive mode is enabled, gnuplot-mode tries to
|
||
provide more useful completions and help suggestions for built-in
|
||
keywords and functions by parsing each command as you type. It
|
||
attempts to take into account Gnuplot's many abbreviated
|
||
keywords. For example, with point at the end of a line reading
|
||
\"plot 'datafile' w \", typing \\[completion-at-point] will pop
|
||
up a list of plotting styles.
|
||
|
||
Key bindings:
|
||
|
||
\\[completion-at-point] will complete the keyword at point based
|
||
on its context in the command. To make keyword completion work on
|
||
pressing TAB, set `tab-always-indent' to `complete', or customize
|
||
`gnuplot-tab-completion' to make this automatic in gnuplot-mode
|
||
buffers.
|
||
|
||
\\[gnuplot-info-at-point] will try to find the most relevant
|
||
Gnuplot info node for the construction at point, prompting for a
|
||
node name if nothing is found.
|
||
|
||
\\[gnuplot-help-function] will pop up a brief summary of the
|
||
syntax at point in the minibuffer. To have one-line syntax
|
||
summaries appear in the echo area as you type, toggle
|
||
`eldoc-mode' or customize `gnuplot-eldoc-mode'.
|
||
|
||
To choose whether to use this mode by default in Gnuplot buffers,
|
||
customize the variable
|
||
`gnuplot-use-context-sensitive-completion'.
|
||
|
||
Note: help strings for eldoc-mode and \\[gnuplot-help-function]
|
||
need to be provided in an Emacs-readable form by the Gnuplot
|
||
distribution. See gnuplot-context.el for details."
|
||
:keymap
|
||
`((,(kbd "C-c C-/") . gnuplot-help-function)
|
||
(,(kbd "C-c C-d") . gnuplot-info-at-point))
|
||
(unless (derived-mode-p 'gnuplot-mode 'gnuplot-comint-mode)
|
||
(message "Gnuplot context-sensitive mode works only in Gnuplot-mode buffers")
|
||
(setq gnuplot-context-sensitive-mode nil))
|
||
(if gnuplot-context-sensitive-mode
|
||
;; Turn on
|
||
(progn
|
||
(load-library "gnuplot-context")
|
||
(load-library "eldoc")
|
||
(setq gnuplot-completion-at-point-function #'gnuplot-context-completion-at-point)
|
||
|
||
;; Setup Eldoc
|
||
(set (make-local-variable 'eldoc-documentation-function)
|
||
'gnuplot-eldoc-function)
|
||
(eldoc-add-command 'completion-at-point) ; Check for eldoc after completion
|
||
(when (fboundp 'comint-dynamic-complete)
|
||
(eldoc-add-command 'comint-dynamic-complete))
|
||
|
||
;; Try to load Eldoc strings
|
||
(when gnuplot-eldoc-mode
|
||
(unless gnuplot-eldoc-hash
|
||
(condition-case nil
|
||
(load-library "gnuplot-eldoc")
|
||
(error
|
||
(message "gnuplot-eldoc.el not found. Install it from the Gnuplot distribution.")
|
||
(setq gnuplot-eldoc-hash nil
|
||
gnuplot-eldoc-mode nil))))
|
||
|
||
(if gnuplot-eldoc-hash
|
||
(eldoc-mode 1)
|
||
(eldoc-mode 0)))
|
||
|
||
;; Set up tab-to-complete
|
||
(when gnuplot-tab-completion
|
||
(set (make-local-variable 'tab-always-indent) 'complete))
|
||
|
||
(message "Gnuplot context-sensitive help & completion enabled."))
|
||
|
||
;; Turn off
|
||
(setq gnuplot-completion-at-point-function #'gnuplot-completion-at-point-info-look)
|
||
(setq eldoc-documentation-function nil)
|
||
(eldoc-mode 0)
|
||
(message "Gnuplot context-sensitive help & completion disabled.")))
|
||
|
||
;; Older completion method using info-look
|
||
(defun gnuplot-completion-at-point-info-look ()
|
||
"Return completions of keyword preceding point.
|
||
|
||
Uses the cache of keywords generated by info-lookup. See
|
||
`gnuplot-setup-info-look'. If non-nil, the return value is in the form
|
||
\(BEGIN END COMPLETIONS) where BEGIN and END are buffer
|
||
positions and COMPLETIONS is a list."
|
||
|
||
(if gnuplot-keywords-pending ; <HW>
|
||
(gnuplot-setup-info-look))
|
||
(let* ((end (point))
|
||
(beg (condition-case _err
|
||
(save-excursion (backward-sexp 1) (point))
|
||
(error (point))))
|
||
(patt (buffer-substring beg end))
|
||
(pattern (if (string-match "\\([^ \t]*\\)\\s-+$" patt)
|
||
(match-string 1 patt) patt))
|
||
(completions (all-completions pattern gnuplot-keywords-alist)))
|
||
(if completions
|
||
(list beg end completions)
|
||
(message "No gnuplot keywords complete '%s'" pattern)
|
||
nil)))
|
||
|
||
(defun gnuplot-comint-complete ()
|
||
"Complete the keyword preceding point in the gnuplot comint buffer.
|
||
|
||
This is only used in Emacs versions before 24.1."
|
||
(let ((completions (gnuplot-completion-at-point)))
|
||
(if completions
|
||
(let* ((beg (nth 0 completions))
|
||
(end (nth 1 completions))
|
||
(candidates (nth 2 completions))
|
||
(completion-base-position (list beg end)))
|
||
(comint-dynamic-simple-complete
|
||
(buffer-substring-no-properties beg end)
|
||
candidates))
|
||
nil)))
|
||
|
||
|
||
(defun gnuplot-info-lookup-symbol (symbol &optional mode)
|
||
"Wrapper for `info-lookup-symbol'.
|
||
Takes SYMBOL and MODE as arguments exactly as
|
||
`info-lookup-symbol'. After doing the info lookup, calls
|
||
`gnuplot--adjust-info-display' to display the info buffer
|
||
according to the value of `gnuplot-info-display'."
|
||
(interactive
|
||
(cond (gnuplot-keywords
|
||
(info-lookup-interactive-arguments 'symbol))
|
||
(gnuplot-keywords-pending ; <HW>
|
||
(gnuplot-setup-info-look)
|
||
(info-lookup-interactive-arguments 'symbol))
|
||
(t
|
||
(list nil (message
|
||
"Help is not available. The gnuplot info file could not be found.")))))
|
||
|
||
(when (and (featurep 'info-look) gnuplot-keywords)
|
||
(unless symbol (setq symbol "Commands"))
|
||
(save-window-excursion
|
||
(info-lookup-symbol symbol mode))
|
||
(gnuplot--adjust-info-display)))
|
||
|
||
(defun gnuplot--adjust-info-display ()
|
||
"Displays the *info* buffer in a window or frame.
|
||
Specified by the value of `gnuplot-info-display'.
|
||
If `gnuplot-info-display' is 'window, then the window will be
|
||
shrunk to the size of the info entry if it is smaller than half
|
||
the height of the frame.
|
||
|
||
The *info* buffer should already exist when this function is
|
||
called."
|
||
(case gnuplot-info-display
|
||
(window
|
||
(switch-to-buffer-other-window "*info*")
|
||
;; Adjust window height only if the frame is split
|
||
;; horizontally, so as not to mess up the minibuffer <jjo>
|
||
;; we can't use shrink-window-if-larger-than-buffer here
|
||
;; because it doesn't work with Info mode's narrowing
|
||
(with-selected-window (get-buffer-window "*info*")
|
||
(unless (gnuplot-window-full-height-p)
|
||
(enlarge-window
|
||
(min (- (count-lines (point-min) (point-max)) (window-height) -1)
|
||
(- (/ (frame-height) 2) (window-height)))))))
|
||
|
||
(frame
|
||
(unless (and gnuplot-info-frame
|
||
(frame-live-p gnuplot-info-frame))
|
||
(setq gnuplot-info-frame (make-frame)))
|
||
(select-frame gnuplot-info-frame)
|
||
(raise-frame gnuplot-info-frame)
|
||
(if gnuplot-xemacs-p (setq toolbar-info-frame gnuplot-info-frame))
|
||
(switch-to-buffer "*info*"))
|
||
|
||
(t
|
||
(switch-to-buffer "*info*"))))
|
||
|
||
(defun gnuplot-insert (string)
|
||
"Insert STRING at point and display help for for STRING.
|
||
Help is not shown if `gnuplot-insertions-show-help-flag' is nil. The
|
||
help shown is for STRING unless STRING begins with the word \"set\" or
|
||
\"show\", in which case help is shown for the thing being set or
|
||
shown."
|
||
(interactive)
|
||
(cond ((and (not gnuplot-three-eight-p)
|
||
(string-match "\\(emf\\|p\\(alette\\|m3d\\)\\|vgagl\\)" string))
|
||
(message "%S is an option introduced in gnuplot 3.8 (You are using %s)"
|
||
string gnuplot-program-version))
|
||
(t
|
||
(insert string)
|
||
(let ((topic string) term)
|
||
(if (string-match
|
||
"\\(set\\|show\\)[ \t]+\\([^ \t]+\\)\\(\\s-+\\([^ \t]+\\)\\)?"
|
||
string)
|
||
(progn
|
||
(setq topic (downcase (match-string 2 string))
|
||
term (match-string 4 string))
|
||
(if (string= topic "terminal") (setq topic (downcase term)))))
|
||
(cond ((and (fboundp 'gnuplot-gui-set-options-and-insert)
|
||
gnuplot-gui-popup-flag)
|
||
(gnuplot-gui-set-options-and-insert))
|
||
(gnuplot-insertions-show-help-flag
|
||
(if gnuplot-keywords-pending ; <HW>
|
||
(gnuplot-setup-info-look))
|
||
(gnuplot-info-lookup-symbol topic)))))))
|
||
|
||
(defun gnuplot-toggle-info-display ()
|
||
"Toggle info display."
|
||
(interactive)
|
||
(setq gnuplot-insertions-show-help-flag (not gnuplot-insertions-show-help-flag))
|
||
(message (if gnuplot-insertions-show-help-flag
|
||
"Help will be displayed after insertions."
|
||
"Help no longer displayed after insertions.")))
|
||
|
||
|
||
;;; --- autoloaded functions: gnuplot-mode and gnuplot-make-buffer
|
||
|
||
;;;###autoload
|
||
(defun gnuplot-mode ()
|
||
"Major mode for editing and executing GNUPLOT scripts.
|
||
This was written with version 4.6 of gnuplot in mind, but should
|
||
work with newer and older versions.
|
||
|
||
Report bugs at https://github.com/emacsorphanage/gnuplot/issues
|
||
|
||
------O------
|
||
|
||
Gnuplot-mode includes two different systems for keyword
|
||
completion and documentation lookup: a newer one,
|
||
`gnuplot-context-sensitive-mode' (enabled by default), and a
|
||
older one which extracts keywords from gnuplot's Info file. Both
|
||
systems allow looking up documentation in the Info file. The
|
||
older system also depends having the info file properly installed
|
||
to make a list of keywords.
|
||
|
||
The info file should be installed by default with the Gnuplot
|
||
distribution, or is available at the `gnuplot-mode' web page:
|
||
https://github.com/emacsorphanage/gnuplot/
|
||
|
||
With the new context-sensitive mode active, gnuplot-mode can also
|
||
provide function/`eldoc-mode' syntax hints as you type. This requires a
|
||
separate file of strings, `gnuplot-eldoc.el', which is also
|
||
provided by recent Gnuplot distributions.
|
||
|
||
------O------
|
||
|
||
There are several known shortcomings of `gnuplot-mode', version 0.5g
|
||
and up. Many of the shortcomings involve the graphical interface
|
||
\(refered to as the GUI) to setting arguments to plot options. Here is
|
||
a list:
|
||
|
||
1. Currently there is no way for `gnuplot-mode' to know if information
|
||
sent to gnuplot was correctly plotted.
|
||
2. \"plot\", \"splot\", and \"fit\" are handled in the GUI, but are
|
||
a bit flaky. Their arguments may not be read correctly from
|
||
existing text, and continuation lines (common for plot and splot)
|
||
are not supported.
|
||
3. The GUI does not know how to read from continuation lines.
|
||
4. Comma separated position arguments to plot options are
|
||
unsupported in the GUI. Colon separated datafile modifiers (used
|
||
for plot, splot, and fit) are not supported either. Arguments
|
||
not yet supported by the GUI generate messages printed in grey
|
||
text.
|
||
5. The GUI handling of \"hidden3d\" is flaky and \"cntrparam\" is
|
||
unsupported.
|
||
|
||
------O------
|
||
|
||
Key bindings:
|
||
\\{gnuplot-mode-map}"
|
||
(interactive)
|
||
(kill-all-local-variables)
|
||
(use-local-map gnuplot-mode-map)
|
||
(setq major-mode 'gnuplot-mode
|
||
mode-name "Gnuplot")
|
||
(set (make-local-variable 'comment-start) "# ")
|
||
(set (make-local-variable 'comment-end) "")
|
||
(set (make-local-variable 'comment-column) 32)
|
||
(set (make-local-variable 'comment-start-skip) "#[ \t]*")
|
||
(set (make-local-variable 'indent-line-function) 'gnuplot-indent-line)
|
||
|
||
(set (make-local-variable 'beginning-of-defun-function) 'gnuplot-beginning-of-defun)
|
||
(set (make-local-variable 'end-of-defun-function) 'gnuplot-end-of-continuation)
|
||
|
||
(unless (featurep 'xemacs)
|
||
(add-hook 'completion-at-point-functions 'gnuplot-completion-at-point nil t))
|
||
|
||
(set-syntax-table gnuplot-mode-syntax-table)
|
||
|
||
(when (eq gnuplot-keywords-when 'immediately) ; <HW>
|
||
(gnuplot-setup-info-look)) ;; <SE>
|
||
|
||
(if gnuplot-xemacs-p ; deal with font-lock
|
||
(when (fboundp 'turn-on-font-lock)
|
||
(turn-on-font-lock))
|
||
(progn
|
||
;; Add syntax-propertizing functions to search for strings and comments
|
||
(set (make-local-variable 'syntax-propertize-function)
|
||
#'gnuplot-syntax-propertize)
|
||
(add-hook 'syntax-propertize-extend-region-functions
|
||
#'gnuplot-syntax-propertize-extend-region nil t)
|
||
|
||
;; Set up font-lock
|
||
(setq font-lock-defaults gnuplot-font-lock-defaults)
|
||
(set (make-local-variable 'font-lock-multiline) t)
|
||
(set (make-local-variable 'parse-sexp-lookup-properties) t)))
|
||
|
||
(if (fboundp 'widget-create) ; gnuplot-gui
|
||
(condition-case ()
|
||
(require 'gnuplot-gui)
|
||
(error nil)))
|
||
(setq gnuplot-first-call nil ; a few more details ...
|
||
gnuplot-comint-recent-buffer (current-buffer)
|
||
comint-process-echoes gnuplot-echo-command-line-flag)
|
||
(run-hooks 'gnuplot-mode-hook)
|
||
;; the first time we need to figure out which gnuplot we are running
|
||
(if gnuplot-program-version
|
||
(gnuplot-setup-menu-and-toolbar)
|
||
(gnuplot-fetch-version-number)))
|
||
|
||
;;;###autoload
|
||
(defun gnuplot-make-buffer ()
|
||
"Open a new buffer in `gnuplot-mode'.
|
||
When invoked, it switches to a new, empty buffer visiting no file
|
||
and then starts `gnuplot-mode'.
|
||
|
||
It is convenient to bind this function to a global key sequence. For
|
||
example, to make the F10 key open a gnuplot script buffer, put the
|
||
following in your .emacs file:
|
||
(autoload 'gnuplot-make-buffer \"gnuplot\"
|
||
\"open a buffer in gnuplot mode\" t)
|
||
(global-set-key [(f10)] 'gnuplot-make-buffer)"
|
||
(interactive)
|
||
(switch-to-buffer gnuplot-gnuplot-buffer)
|
||
(gnuplot-mode))
|
||
|
||
;;;###autoload
|
||
(defun run-gnuplot ()
|
||
"Run an inferior Gnuplot process."
|
||
(interactive)
|
||
(gnuplot-make-gnuplot-buffer)
|
||
(pop-to-buffer gnuplot-buffer))
|
||
|
||
(defun gnuplot-show-version ()
|
||
"Show version number in echo area."
|
||
(interactive)
|
||
(message "gnuplot-mode %s -- URL: %s" gnuplot-version gnuplot-maintainer-url))
|
||
|
||
(defun gnuplot-show-gnuplot-version ()
|
||
"Show gnuplot program and version number in echo area."
|
||
(interactive)
|
||
(gnuplot-fetch-version-number)
|
||
(message "You are calling gnuplot %s as %s" gnuplot-program-version gnuplot-program))
|
||
|
||
|
||
;;; That's it! ----------------------------------------------------------------
|
||
|
||
|
||
;;; --- final chores: provide 'gnuplot and run load-hook
|
||
;; provide before run-hooks suggested by <DB>
|
||
(provide 'gnuplot)
|
||
(run-hooks 'gnuplot-load-hook)
|
||
|
||
;; Local Variables:
|
||
;; indent-tabs-mode: nil
|
||
;; End:
|
||
|
||
;;; gnuplot.el ends here
|