cooledit.1

具有IDE功能的编辑器

As an example, the find file dialog can be reproduced as follows:
.RE
.PP
.nf
x = generic_dialog ("Find file",                                \\
    (".", "*.[ch]", ""),                                        \\
    (   "Starting directory",                                   \\
        "Filenames matching glob expression",                   \\
        "Containing" ),                                         \\
    (   "find-start_dir",                                       \\
        "find-glob_express",                                    \\
        "find-containing" ),                                    \\
    (   "Starting directory for the recursive search",          \\
        "Glob expressions such as *.[ch] or *.doc",             \\
        "Check if file contains this sequence" ),               \\
    (0, 0, 0, 0),                                               \\
    (   "Containing reg. exp.",                                 \\
        "Containing case insens.",                              \\
        "Search follows symlinks",                              \\
        "Search is case insens." ),                             \\
    (   "Enter regular expression pattern to find within file", \\
        "Match case insensitively when searching within files", \\
        "Dive into symlinks to directories",                    \\
        "Filenames are matched case insensitively" ),           \\
    60, INPUTS_WITH_OPTIONS_BROWSE_DIR_1                        \\
)
if x:
    inputs = x[1]
    checks = x[2]
.fi
.PP
The following are more simplistic utility dialogs:
.TP
\fIstring\fP \fBinput_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
Brings up an input dialog. Takes a title, prompt string and default
value as input. Returns the entered string or \fBNone\fP if cancelled.
.TP
\fIstring\fP \fBsave_file_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
Brings up a file browser dialog. Takes a title, a starting directory
and a default value as input. Returns the entered string or \fBNone\fP
if cancelled.
.TP
\fIstring\fP \fBload_file_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
This has a slightly different behaviour to \fBsave_file_dialog\fP - if a
non existing file is entered, it reports an error.
.TP
\fBmessage_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
Brings up a message dialog with the given title and message.
.TP
\fBerror_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
Brings up an error dialog with the given title and message.
.TP
\fIint\fP \fBquery_dialog(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fI...\fP\fB)\fP
Brings up a query dialog. Takes a header, a prompt and a number of
alternative buttons. Returns the button number or -1 on cancel.
.TP
\fBstatus(\fP\fIstring\fP\fB)\fP
Sets the status line of the current editor. The status line will return
to its usual when a key is pressed. This can be used with \fBgetkey()\fP
to inform the user of possible key presses.
.TP
\fIstring\fP \fBstatus_input(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
Sets the status line to an entry widget with the first argument as the
prompt string, and the second argument as the default text. Returns
the entered text or \fBNone\fP if Esc is pressed.
.TP
\fB(\fP\fIstring\fP\fB,\fP \fIint\fP\fB)\fP \fBget_key()\fP
This blocks waiting for a key press, and grabs the application. It
returns the string equivalent of the key press as in the X Window header
file \fBkeysymdef.h\fP without the \fBXK_\fP prefix. It also returns
the current state of the keyboard modifiers, being the inclusive or
of \fBShiftMask ... \fP etc. as listed above.
.PP
The following function allows display of shell output as those in
the \fBScripts\fP menu.
.TP
\fIint\fP \fBshell_output(\fP\fIstring\fP\fB,\fP \fIstring\fP\fB,\fP \fIstring\fP\fB)\fP
.RS
This displays the output of a shell command continuously in its own
window in the background. As always, clicking on \fIfile\fP:\fIline\fP
type messages will cause the editor to jump to that file and line
number.
.PP
The arguments are: the title of the output dialog, the shell program
(which should begin with \fB#!/bin/sh\fP or similar), and a unique
descriptive magic string that identifies the dialog. An example of a
magic string is \fBFindfIlEmAgiC\fP used by the find file dialog - if
you use the same magic string, then a new window will not be created if
the find file display window exists.
.RE
.PP
The following functions manipulate editor windows:
.TP
\fB(\fP\fIstring\fP\fB,\fP \fI...\fP\fB)\fP \fBget_editors()\fP
Returns a tuple with an entry for each editor window. These are the
full path names of the open files.
.TP
\fBset_editor(\fP\fIstring\fP\fB)\fP
Sets the current editor with the full path name. This allows
manipulation of a different edit buffer, but does not set input to that
buffer.
.TP
\fBfocus()\fP
Raises and the current editor window and sets the input focus to the
current editor.
.TP
\fBclose_window(\fP\fIint\fP\fB)\fP
Close the current edit window. If a non-zero value is passed, then this
forces a close, regardless of whether the buffer is modified or not.
.TP
\fBnew_window()\fP
Create a new editor window with no text in it.
.TP
\fBload(\fP\fIstring\fP\fB)\fP
Load a file into the current window. This will replace any text in the
current edit window.
.PP
The following are further miscellaneous commands:
.TP
\fBcommand(\fP\fIstring\fP\fB)\fP
Executes an arbitrary editor command. These are listed in the \fBDefine
Keys\fP dialog.
.TP
\fBredraw_page()\fP
After the edit buffer has been modified, the window must refresh.
Usually just the current line is redrawn. If you have made changes which
may reflect a different display on other lines, then call
\fBredraw_page()\fP before returning to ensure that the entire screen
displays correctly.
.TP
\fIstring\fP \fBfile_type(\fP\fI[string]\fP\fB)\fP
.RS
Forces the current file type as though you had selected it from
the \fBOptions\fP, \fBSyntax highlighting...\fP menu item.
Forcing the type disables automatic file type selection for this
window thereafter. The old file type is returned.

If no arguments are passed, \fBfile_type\fP just returns the
current file type. This is useful for creating actions specific
to the type of text being edited.

New syntax rule sets are being added all the
time, but the passed and returns string is least one of:
.PP
\fB
.nf
None
Unified Diff Output
Context Diff Output
LSM File
Shell Script
Perl Program
Python Program
NROFF Source
HTML File
Pascal Program
Ada Program
LaTeX 2.09 Document
Texinfo Document
C/C++ Program
SWIG Source
Java Program
SmallTalk Program
ML Program
GNU Distribution ChangeLog File
Makefile
Mail folder
Syntax Highlighting definitions
.fi
\fP
.RE
.PP
.SH SYNTAX HIGHLIGHTING
As of version 3.6.0, \fBcooledit\fP has syntax highlighting. This means
that keywords and contexts (like C comments, string constants, etc) are
highlighted in different colours. The following section explains the
format of the file \fB~/.cedit/syntax\fP.

The file \fB~/.cedit/Syntax\fP is rescanned on opening of any new editor
file. It contains a list of file types and how to identify what rule set
the text you are editing belongs to. The \fBfile\fP token dictates how
to match up your text. On the same line as a \fBfile\fP token must
appear a regular expression to match the filename, a string to be
displayed on the left of the editor window for description purposes, and
a regular expression to match the first line of the file. If either of
the regular expressions match, the file is deemed to have the particular
type. For example
.PP
.nf
file ..\\*\\\\.(py|PY])$ Python\\sProgram ^#!\\s\\*/.\\*/python
.fi
.PP
Will cause a file to be labelled as \fBPython Program\fP if it contains
say, \fB#!/usr/bin/python\fP, on the first line OR of it ends in say
\fB.py\fP.

Note that \fB*\fP, \fB+\fP and \fB\\\fP have to be escaped with
a \fB\\\fP, and space must be presented with a \fB\\s\fP.

After the \fBfile\fP keyword may come the \fBinclude\fP keyword. The
\fBinclude\fP keyword says to load a rule set from a separate file, and
is the preferred way of adding new rule sets. The path from where it
loads defaults to \fBcooledit/syntax/\fP under the \fBlib/\fP directory
where you installed \fBCooledit\fP. See the examples in your own
\fBSyntax\fP file and in this directory.

Each rule set is divided into contexts, and each context contains
keyword definitions. A context is a scope within the text that a
particular set of keywords applies to. For instance, the region within a
C style quote (i.e. between \fB"\fP quotations) has its own separate
colour and hence its own separate context. Within it, the normal C
tokens, like \fBif\fP and \fBwhile\fP, will not apply, but \fB%d\fP
should be highlighted in a different colour. Contexts are usually for
when you have something that must be coloured across multiple lines. The
\fBdefault\fP context contains the list of keywords to fall back on
should there be no other applicable context. This is usually normal
programming code.

A trivial C programming rule set might look like this:
.PP
.nf
file .\\*\\\\.c C\\sProgram\\sFile (#include|/\\\\\\*)

wholechars abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_

# default colors
context default
  keyword  whole  if       yellow/24
  keyword  whole  else     yellow/24
  keyword  whole  for      yellow/24
  keyword  whole  while    yellow/24
  keyword  whole  do       yellow/24
  keyword  whole  switch   yellow/24
  keyword  whole  case     yellow/24
  keyword  whole  static   yellow/24
  keyword  whole  extern   yellow/24
  keyword         {        brightcyan/14
  keyword         }        brightcyan/14
  keyword         '*'      green/6 

# C comments
context /\\* \\*/ brown/22

# C preprocessor directives
context linestart # \\n brightred/18
  keyword  \\\\\\n  yellow/24

# C string constants
context " " green/6
  keyword  %d    yellow/24
  keyword  %s    yellow/24
  keyword  %c    yellow/24
  keyword  \\\\"   yellow/24
.fi
.PP
Each context starts with a line of the form:
.br
\fBcontext\fP [\fBexclusive\fP] [\fBwhole\fP|\fBwholeright\fP|\fBwholeleft\fP] 
[\fBlinestart\fP] \fIdelim\fP [\fBlinestart\fP] \fIdelim\fP [\fIforeground\fP] [\fIbackground\fP]
.br

One exception is the first context. It must start with the command
.br
\fBcontext\fP \fBdefault\fP [\fIforeground\fP] [\fIbackground\fP]
.br
or else \fBcooledit\fP will return an error.

The \fBlinestart\fP option dictates that \fIdelim\fP must start at
the beginning of a line.

The \fBwhole\fP option tells that delim must be a whole word. What
constitutes a whole word are a set of characters that can be
changed at any point in the file with the \fBwholechars\fP
command. The \fBwholechars\fP command at the top just sets the
set exactly to its default and could therefore have been omitted. To
specify that a word must be whole on the left only, you can use
the \fBwholeleft\fP option, and similarly on the right. The left and
right set of characters can be set separately with,
.br
\fBwholechars\fP [\fBleft\fP|\fBright\fP] \fIcharacters\fP

The \fBexclusive\fP option causes the text between the delimiters to be
colourised, but not the delimiters themselves.

Each rule is a line of the form:
.br
\fBkeyword\fP [\fBwhole\fP|\fBwholeright\fP|\fBwholeleft\fP] [\fBlinestart\fP] 
\fIstring\fP \fIforeground\fP [\fIbackground\fP]
.br

Important to note is the line
.nf
\fB  keyword  \\\\\\n  yellow/24\fP
.fi
This line defines a keyword containing the \\ and newline characters.
Because keywords have a higher precedence than context delimiters, this
keyword prevents the context from ending at the end of a line if the
line ends in a \\ thus allowing C preprocessor directive to continue
across multiple lines.

The colours themselves need to apply to the Midnight Commander internal
editor as well as to \fBCooledit\fP. Therefore the form
.br
    \fImidnight-commander-color\fP\fB/\fP\fIcooledit-color\fP
.br
is used. See some of the many rule sets given, for examples on using
this. Usually the background colour is omitted, thus defaulting to the
usual background colour.

Context or keyword strings are interpreted so that you can include tabs
and spaces with the sequences \\t and \\s. Newlines and the \\ are
specified with \\n and \\\\ respectively. Since whitespace is used as a
seperator, it may not be used explicitedly. Also, \\* must be used to
specify a *, and a \\+ to specify a +. The * itself is a wildcard that
matches any length of characters. The + is like the * but matches a
length of non-whitespace characters only. For example,
.nf
\fB  keyword         '+'      green/6\fP
\fB  keyword         '\\s'      green/6\fP
.fi