cooledit.1

具有IDE功能的编辑器

\fBHINTS\fP file in the distribution, or look under the
\fBdoc/cooledit-3.17.5\fP directory in your file-system.
.PP
.SH DEFAULT KEY DEFINITIONS

Keys may be redefined using an easy to use key learner.
See the next section on how to get this to work.

The following is a partial list of all default key bindings
and their actions, for reference. You will probably never need
to refer to it because most of the editor actions can be found
in the menus. Note that F14 is analogous to Shift-F4 etc. Also
be aware that on some machines, what X percieves as an Alt/Meta
is actually some other modifier key (our Sun-Sparc uses the
diamond key).

.nf
.B Movement keys:
   Left                    left one char
   Right                   right one char
   Up                      up one line
   Down                    down one line
   Home                    beginning of line
   End                     end of line
   PgUp                    up one screen full
   PgDn                    down one screen full
   Ctrl-PgUp               beginning of file
   Ctrl-PgDn               end file
   Ctrl-Home               beginning of page
   Ctrl-End                end of page
   Ctrl-Left               left one word
   Ctrl-Right              right one word
   Ctrl-Up                 up one paragraph
   Ctrl-Down               down one paragraph
   Meta/Alt-Up             scroll up one line
   Meta/Alt-Down           scroll down one line

.B Highlight keys:
   Shift with any of the above keys will highlight
   at the same time.

.B Column highlighting:
   Holding down the Control key while using the mouse to highlight text,
   will cause the highlighted text to be displayed in inverse colour. You
   will be able to select columns (arbitrary rectangles) of text and
   drag and drop them as usual.

.I Input History:
   When editing an input line, Shift-Up or Shift-Down 
   will bring up a history of previous inputs.

.B Editing keys:
   Delete                  delete char to the right
   Backspace               delete char to the left
   Meta/Alt-Del            delete to line end
   Meta/Alt-Backspace      delete to line begin
   Meta/Alt-Right          delete word to the right
   Meta/Alt-Left           delete word to the left
   F5                      copy highlighted text to cursor
   F6                      move highlighted text to cursor
   F8                      delete highlighted text
   Ctrl-y                  delete line
   Shift-Enter             insert a newline
   Enter                   insert a newline with auto indent (default)
   Tab                     insert a tab (see options menu)
   Insert                  toggle insert/overwrite
   Ctrl-q                  quote - the next key pressed will be
                           interpreted as a literal
.B Undo:
   Ctrl-u
   Ctrl-Backspace

.B File
   Ctrl-F1                 man page
   F2                      save
   F12 or
   Shift-F2                save as
   Ctrl-o                  load
   Ctrl-n                  new
   Ctrl-f                  save highlighted text as
   Shift-F5 or
   F15                     insert file at cursor

.B Mark:
   F3                      toggle highlight
   Ctrl-b                  toggle highlight columns

.B Search and replace:
   F7                      search
   F17 or
   Shift-F7                search again
   F4                      replace
   F14 or
   Shift-F4                replace again

.B X Clipboard:
   Ctrl-Ins                copy to clipboard
   Shift-Ins               paste to clipboard
   Shift-Delete            cut to clipboard
   Ctrl-Delete             delete highlighted text
   Meta/Alt-Ins            insert from selection history

.B General:
   F10                     exit (current editor)
   Ctrl-F3                 new edit window
   Shift-F3                new main window
   Alt-F6                  maximise the window
   Ctrl-F6                 window cycle
   Ctrl-F10                exit application
   Meta/Alt-x              save all and exit
   Ctrl-F2                 save state of desktop
   Ctrl-d                  insert date and time
   Meta/Alt-l              goto line number
   Meta/Alt-F7             run make
   Meta/Alt-t              sort
   Ctrl-r                  start/end record macro
   Ctrl-a                  execute macro
   Ctrl-p                  spell check highlighted text
   Shift-F9                C formatter
   Ctrl-Tab                complete word
   Meta/Alt-i              insert unicode character
   Shift/F1                rxvt terminal

.B Debug:
   Alt-F2                  toggle breakpoint
   Alt-F3                  continue until cursor
   Alt-F4                  continue
   Alt-F5                  run from beginning
   Alt-F8                  single step, dive into functions
   Alt-F9                  single step, skip over functions
   Ctrl-c                  interrupt program
.fi
New shell scripts will be added from time to time. Consult
the \fBScripts\fP menu for the hotkeys that envoke these.
.PP
.SH EMERGENCIES
keywords: hang, crash, halt, pause, stop, infinite loop, SIGHUP,
SIGUSR1.
.PP
There are some circumstances when \fBCooledit\fP may
go into an infinite loop, like if there is a bug in the editor
movement commands, or if you create a recursive macro. In this
case, you can  restore \fBCooledit\fP by using the \fBkill\fP
shell function. Try \fBkill -SIGUSR1\fP \fIpid\fP  where
\fIpid\fP is the process ID of cooledit from: \fBps | grep
cooledit\fP, for example. This will send SIGUSR1, a user signal,
which, for \fBCooledit\fP, will force a jump into its main loop,
and restore operation. It is a good idea to then save what you
have done and exit immediately in case there has been memory
corruption.
.PP
.SH KEY REDEFINING
The Options menu has a key binding learner which is easy to use.
The key learning dialog contains a list
of every re-definable action that the editor can perform.
Simply click on the action you want to associate a key to,
and press that key. An 'X' will appear next to the action to
indicate the recording of a binding. To clear that binding
click on the Clear Line button (or the Clear All button to
clear all the bindings). You can even bind the same action
to two separate keys: for instance using either the key pad
arrows, or the normal arrows for cursor movement --- just
click on that action again, and hit another key --- where
two X's will appear. Up to three keys can be associated with
an action. The binding is also sensitive to the keyboard 'state'
(i.e. whether Control, Shift, Alt, Meta, or Hyper is
pressed, and any combination of these) so binding Shift-Left
to an action will work, and will be considered a different key
stroke to Shift-Control-Left, and will also be considered a
different key stroke to Shift-Left with NumLock on. Note that
the difference between 'Enter' and 'Return' is that the one
does an auto-indent.

The key binding records X11 key-codes. These are the actual hardware
codes that come from the keyboard, so the key binding works on the
lowest possible level of interpretation. The editor checks for
these user defined keys before any hard-coded key bindings, so
user binded keys will override the default key bindings. This means
user defining keys will always work, but may be specific to the
hardware you are using.

To redefine hardcoded keys (i.e. the default keys), modify the file
edit_key_translator.c and then recompile. It contains simple C code
which gets incorporated directly into the program during compilation.
Note that the first function it calls is to get the user defined
action for the key if there is one. To recompile, remove the file
edit.o and run make in the top directory. This will allow you to
change any key-binding. The editor menu however will have to be
modified separately to reflect the changes you've made (see
editmenu.c). A detailed explanation is given in the commentary of
edit_key_translator.c.

(I added key redefinition mainly because different X Servers
seem to interpret the same keys differently. It seems ridiculous that
this should happen in the face X11's thorough key definition
standard. The new X11R6.3 for Linux does seem to interpret keys
properly and all the keys should work as expected on the PC;
so there should be no need to redefine keys under Linux. You
can however easily emulate another editor as you like.)
.PP
.SH SPELL CHECK AS YOU TYPE
As of version 3.10.0, \fBCooledit\fP spell checks typed words on
the fly, placing the traditional wavy red line under miss-spelled
words. This works by feeding typed words through \fBispell\fP and
placing them amidst the syntax highlighting rules if \fBispell\fP
returns a non-match. These rules \fIexpire\fP after 60 seconds -
which mean they won't stay underlined indefinitely. Word feeding is
initiated by most key presses and applies only to the word under
the cursor. To look up a word, merely move the cursor over it.
.PP
.SH UNICODE, UCS AND UTF-8 SUPPORT
As of version 3.15.0, \fBCooledit\fP has Unicode support. What kind of
unicode support it has, and what unicode, UCS and UTF-8 are is
explained as follows:

\fBUCS\fP stands for \fIUniversal Character Set\fP. UCS is like ASCII
(see \fBascii\fP(1)) but instead of storing only 128 english
specific characters, UCS goes up to 65535 characters and covers every
known non-fictional language as well as scientific and mathematical
symbols etc.

UCS theoretically goes beyond 65535 (for example defining the very
useful Klingon character set). However, it is likely that most
implementations will keep to a 2 byte size requirement. Cooledit
supports up to 131072 (1FFFFh) characters. UCS is also called
\fBUnicode\fP and is officially ISO standard 10646. So wherever you see
ISO-10646 it means Unicode. (Actually, Unicode is a standard to
define further things like typographical layout, but for here,
they are taken to mean the same thing.)

2 bytes (for UCS) instead of 1 byte for ASCII posses a problem for most
programs. For example, the average C program uses a string function
every few lines (that assumes a 1 character per byte format). To solve
this we have \fBUTF-8\fP. UTF-8 stands for UCS Transformation Format.
It is an encoding scheme that says that any byte encountered by an
application that has a value below 128 is to be treated as ordinary ascii
characters, \fBbut\fP a byte with a value above 128 means that a
sequence of bytes is forthcoming that represents some character in the
range 128 to 65536 (or above). This enables a stream of single bytes to
represent the UCS character set, albeit with some inefficiency. More
information can be had from \fBhttp://www.unicode.org\fP.

Hence pure ASCII text is already in UTF-8 format.

At the time of this writing, I am not quite sure precisely what an
application has to be able to do to be classified as "Supporting Unicode".
For instance: what about inserting characters? Don't input methods
produce tradition charset encodings? And why are characters displayed
by X's Xmb* and Xwc* functions?

At the moment \fBCooledit\fP can display Unicode characters if: (1) the
"UTF8 Interpretation" is on, (2) the "Display Characters outside locale" is
on, (3) you are using a non-"fontset" type font - when loading you get an
error message "Font set not loaded", and (4) if the font is a Unicode
font - i.e. ending in the font name \fBiso10646-1\fP.

This may involve you having to install Unicode fonts. See
\fBhttp://www.cl.cam.ac.uk/~mgk25/unicode.html\fP and
\fBhttp://czyborra.com/unifont/\fP.

For instance
.nf
    cooledit --utf8-interpretation --all-characters --no-fontset \
      -font -gnu-unifont-*-*-*--*-*-*-*-*-*-iso10646-1
.fi
works. The GNU Unicode font is an attempt at supporting the entire
Unicode character set in one font. Most other fonts will support a limited
range (such as omitting the 20000 Chinese ideographs).

What \fBCooledit\fP is supposed to do under a non-US locale I have no
idea, so please give me a hint sometime. (Looking at the \fByudit\fP
documentation, it seems Gaspar also has my problems.

Note that \fBCooledit\fP does no character set translations whatsoever -
maybe later versions will.
.PP
.SH THE INTERACTIVE GRAPHICAL DEBUGGER
As of version 3.9.0, \fBCooledit\fP features an interface to
\fBgdb\fP(1) under the new \fBDebug\fP menu. This means that you can
seamlessly debug C/C++ programs from within \fBCooledit\fP just like you
used to with your DOS Turbo Debugger. This is extremely \fIc\fPool. You can
set and clear breakpoints (the line is bookmarked in red) and follow the
program flow with the green cursor line. Please remember that this an
\fIinterface\fP to gdb: \fBCooledit\fP has no debugging features of its
own. If you do not have the correct version of gdb, then a warning will
be displayed on startup.

Interfaces are given to the common gdb commands. Any other commands can
be executed with the \fBEnter Command\fP menu item. Automatic variable
displays will soon be available though.

When a program stops for some reason (either a breakpoint or a signal),
\fBCooledit\fP tries to determine the file and line number. If this
cannot be done, a backtrace is displayed. Backtraces do not contain full
paths, hence files cannot be located if they are not already loaded. If
the file \fIis\fP already loaded, then hitting enter on a
\fIfile\fP:\fIline\fP backtrace line will jump to the currect line
number.

Programs must of course be compiled with the \fB-g\fP option and
preferably the \fB-O0\fP option (without -O0 gcc's optimizations may
make the program flow appear a little strange and some variables will
not be accessible).

Break-points are set and cleared from the menu or with Meta-F2. If you
set a break point manually (with Meta-F1) it will not display in the
edit window. Similarly if you clear a break point manually or close a
window (thus clearing the breakpoints) there will be discrepancy between
the book marks and the actual breakpoints. The same goes if you modify
a file without restarting gdb.

Variables can be displayed by selecting \fBDisplay variable...\fP. A
listbox will show all the variables you have selected. Click on the
listbox and press \fBDel\fP to delete from this list. Use \fBIns\fP to
highlight a variable - this will cause a watchpoint to be inserted for
this variable (i.e. the program will thereafter stop whenever the value
of that variable changes). The listbox will also show an \fBX\fP in the
second column if the variable has been altered since the last time the
listbox was refreshed - this enables you to easily see which variable
changes as you step through the lines of your program.