@c Copyright (C) 1996,1997 Robert Hhne, see COPYING.RH for details 
@c This file is part of RHIDE. 
\input texinfo  @c -*-texinfo-*-

@comment %**start of header

@setfilename editor.info
@set version 0.2.14
@set update-date 17 November 1996
@set update-month November 1996

@iftex
@immediate@write17{-------------------------------------------------------------------}
@immediate@write17{---------IGNORE THE FOLLOWING ERROR ABOUT THE INVALID CHARACTER----}
@immediate@write17{-------------------------BY SIMPLY PRESSING ENTER------------------}
@immediate@write17{-------------------------------------------------------------------}
@end iftex
@set rh Robert Hhne
@iftex
@set rh Robert H@"ohne
@end iftex
@ifset html
@set rh Robert H&ouml;hne
@end ifset
@macro RH{}
@value{rh}
@end macro

@set sset Salvador Eduardo Tropea

@settitle SET's editor @value{version}
@footnotestyle separate
@paragraphindent asis
@iftex
@afourpaper
@end iftex

@comment %**end of header


@ifclear html
@ifinfo
@format
START-INFO-DIR-ENTRY
* SET's editor: (editor.inf).           Documentation about the editor.
END-INFO-DIR-ENTRY
@end format
@end ifinfo
@end ifclear

@ifset html
@include rhidemac.htm
@clear text
@end ifset

@ifset text
@include rhidemac.txt
@clear html
@end ifset

@ifclear html
@ifclear text
@include rhidemac.txi
@end ifclear
@end ifclear

@ifinfo
@html
@end ifinfo

@macro SSET{}
@mail{@value{sset},salvador@@inti.edu.ar}
@end macro

@macro ikey{KEY,DESC}
@key{\KEY\}
@kindex \DESC\ | @key{\KEY\} |
@end macro

@macro RHIDEHOME
@www{the RHIDE home page,www.tu-chemnitz.de/~rho/rhide.html}

@end macro

@macro EDCOM2{NOM,COM,KEY,ALT,_ALT}
@item \NOM\@*
@itemize @minus
  @item Editor command: @code{\COM\}@*
  @item Key: @key{\KEY\}@*
  @item Alternative: @key{\ALT\}, @key{\_ALT\}
@end itemize
@c @key{\KEY\}
@kindex \COM\ @key{\KEY\}
@kindex \NOM\ @key{\KEY\}
@end macro

@macro EDCOM1{NOM,COM,KEY,ALT}
@item \NOM\@*
@itemize @minus
  @item Editor command: @code{\COM\}@*
  @item Key: @key{\KEY\}@*
  @item Alternative: @key{\ALT\}
@end itemize
@c @key{\KEY\}
@kindex \COM\ @key{\KEY\}
@kindex \NOM\ @key{\KEY\}
@end macro

@macro EDCOM0{NOM,COM,KEY}
@item \NOM\@*
@itemize @minus
  @item Editor command: @code{\COM\}@*
  @item Key: @key{\KEY\}
@end itemize
@c @key{\KEY\}
@kindex \COM\ @key{\KEY\}
@kindex \NOM\ @key{\KEY\}
@end macro

@c Smaller amounts of whitespace between chapters
@c and sections.
@tex
\global\chapheadingskip = 15pt plus 4pt minus 2pt
\global\secheadingskip = 12pt plus 3pt minus 2pt
\global\subsecheadingskip = 9pt plus 2pt minus 2pt
@end tex

@c Smaller amounts of whitespace between paragraphs
@tex
\global\parskip 6pt plus 2pt minus 2pt
@end tex

@macro pre1
  This document describes the use of the SET's editor, this editor was
designed for programmers and to be used alone or inside of the RHIDE.
@end macro

@macro pre2
  Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.
@end macro

@macro pre3
  Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.
@end macro

@macro lista1
@itemize @bullet
  @item @sc{@value{rh}} <Robert.Hoehne@@Mathematik.TU-Chemnitz.DE>
    (with some base routines, a lot of patchs and reports)

  @item @sc{Molnar Laszlo} <molnarl@@postabank.hu>
    (with test and a lot of ideas)

  @item @sc{Marek Habersack} <grendel@@ananke.amu.edu.pl>
    (with test and a lot of ideas)

@end itemize
@end macro

@finalout

@setchapternewpage odd

@titlepage
@c use the new format for titles
@title SET's Editor @value{version}
@subtitle @sc{An editor for C/C++, Pascal and Clipper programmers}
@subtitle Version @value{version}
@subtitle @value{update-month}

@author by @value{sset}
@author @ii{last updated @value{update-date}}

@page

@pre1{}

@pre2{}

@pre3{}

@sp 3
  People, who helped me, to develop the editor:

@lista1{}

@tex
@vskip 0pt plus 1filll
@end tex
Copyright @copyright{} 1996 by @value{sset}

@end titlepage

@ifinfo
@htmltitle SET's Editor documentation for Version @value{version}
@htmlsubtitle @value{update-month}

@htmlauthor by @value{sset}
@paragraph{}
@*
@*
This is the documentation for the SET's Editor.
@paragraph{}

Copyright (C) 1996 @value{sset}
@paragraph{}

@paragraph{}

This documentation may be freely distributed with the editor or the RHIDE
package or any part thereof, provided this copyright notice is left intact
on all copies.
@end ifinfo

@ifset html
@include editor.ctx
@end ifset

@ifinfo
@node Top
@top EDITOR

@ifclear text
  The following master menu lists the major topics in this documentation,
including all the indices.
@end ifclear

@ifset text
   Table of Contents@*
   *****************@*
@sp 2
@format
@include contents.idx
@end format
@*
@end ifset
@end ifinfo

@ignore
@c Why this?? titlepage should be before any node and in TeX the
@c the titlepage is allowed ONLY in the preamble

@c @chapter Title Page
@c @TitlePage{}
@end ignore

@chapter Introduction

@pre1{}
@paragraph{}

@pre2{}
@paragraph{}

@pre3{}
@paragraph{}

  People, who helped me, to develop the editor:
@paragraph{}

@lista1{}

  The editor is freeware, but the souce-code of this editor is copyright by
@value{sset}.
  If you want to include the editor in your application, using the whole code
or only a part contact at first @mail{me,salvador@@inti.edu.ar}
@paragraph{}

  This editor is included in the @RH{}'s RHIDE as replace of the
original TVision's editor class.
@paragraph{}

@c when using something like What's, TeX is confused by the '
@section What is SETs Editor?

  SET's editor is an editor designed to be used by programmers, the main
target of the editor is C and C++ code but Pascal and Clipper are supported
too.
@paragraph{}

  The editor was designed to be very similar to the DOS standard editors for
C, specially to the Borland's IDE editor. The editor supports a lot of
WordStar style commands plus some CUA commands, so if you used any editor
that uses this kind of commands you'll find my editor very familiar. On the
other hand if you never used a DOS editor, specially if you use VI on UNIX
machines you'll feel loosed. You can configure the keyboard but this
feature is relative limited @xref{How to configure the keyboard}.
@paragraph{}

@section Requirements

  As by now I only plan to distribute my editor inside of RHIDE the
requirements are the requirements of RHIDE.
@paragraph{}

@section About the Author
@iftex
@immediate@write17{-------------------------------------------------------------------}
@immediate@write17{---------IGNORE THE FOLLOWING ERROR ABOUT THE INVALID CHARACTER----}
@immediate@write17{-------------------------BY SIMPLY PRESSING ENTER------------------}
@immediate@write17{-------------------------------------------------------------------}
@end iftex
@set cura Curapalige
@iftex
@set cura Curapalig@"ue
@end iftex
@ifset html
@set cura Curapalig&uuml;e
@end ifset

@ifclear info
@c ************************************************************************
@c @paragraph{}
@end ifclear
@c Don't put away that Robert!
@ifinfo
@*
0Bлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл@*
0Fлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл@*
0Bлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл
@end ifinfo

The editor was made by Salvador Eduardo Tropea (SET), with the help of
@RH{}.

@display
E-Mail: @SSET{}

Telephone: (+541) 759-0013
Postal Address:
Salvador E. Tropea
@value{cura} 2124
(1678) Caseros - 3 de Febrero
Prov: Buenos Aires
Argentina
@end display
@paragraph{}

@ifinfo
@*
0Bлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл@*
0Fлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл@*
0Bлллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллллл
@end ifinfo
@ifclear info
@c ************************************************************************
@c @paragraph{}
@end ifclear

@chapter Available commands

  In this section I will explain the features of the editor and how is
configured the keyboard by default. If you want to change some assigment
of a key consult @xref{How to configure the keyboard}.
@paragraph{}

  Read the conventions topic first to understand my way of indicate keystrokes.
@paragraph{}

  In the description of each command I'll include the internal name used by
the editor because this name is needed to configure the keyboard.
@paragraph{}

@section Conventions

  I'll use some conventions when talking about the keystrokes needed to
trigger some command. So here is what I use:
@paragraph{}

  The key named Ctrl or Control is represented as ^, this key don't have any
effect used alone inside of the editor so the ^ symbol will be used ever
in conjuntion with the name of some key indicating that you must press the
two keys at the same time, for example: ^A is Ctrl and A at the same time.
When I say "at the same time" that means: press Ctrl, hold it, and press
the other key, that's the reason to put Ctrl after A.
@paragraph{}

  To indicate a sequence of keystrokes I'll use a - to separate the keys, for
example ^K-B is Ctrl and K at the same time, and then press B, of course
release ^K before.
@paragraph{}

  To indicate keys pressed at the same time others than ^x I'll use the +,
for example: Shift+^Insert is the three keys at the same time!.
@paragraph{}

  I don't think that you are an stupid, the editor is writed for programmers,
but I'll want to put that clear to avoid problems ;-).
@paragraph{}

@section Cursor movement
@cindex Movement

@itemize @bullet
   @EDCOM1{Character left,cmbCharLeft,Left arrow,^S}
   @EDCOM1{Character right,cmbCharRight,Right arrow,^D}
   @EDCOM1{Word left,cmbWordLeft,^Left arrow,^A}
   @EDCOM1{Word right,cmbWordRight,^Right arrow,^F}
   @EDCOM1{Line up,cmbLineUp,Up arrow,^E}
   @EDCOM1{Line down,cmbLineDown,Down arrow,^X}
   @EDCOM0{Scroll the screen one line up,cmbScrollUp,^W}
   @EDCOM0{Scroll the screen one line down,cmbScrollDown,^Z}
   @EDCOM1{Page up,cmbPageUp,PgUp,^R}
   @EDCOM1{Page down,cmbPageDown,PgDn,^C}
   @EDCOM1{Beginning of line,cmbLineStart,Home,^Q-S}
   @EDCOM1{End of line,cmbLineEnd,End,^Q-D}
   @EDCOM1{Top of window,cmbFirstLineInScreen,^Q-E,^Home}
   @EDCOM1{Bottom of window,cmbLastLineInScreen,^Q-X,^End}
   @EDCOM1{Top of file,cmbTextStart,^Q-R,^PgUp}
   @EDCOM1{Bottom of file,cmbTextEnd,^Q-C,^PgDn}
@end itemize

@section Insert and Delete
@cindex Insert and Delete

@itemize @bullet
   @EDCOM1{Delete the character under cursor,cmbDelChar,Del,^G}
   @EDCOM1{Delete character to left,cmbBackSpace,Backspace,^H}
   @EDCOM0{Delete line,cmbDelLine,^Y}
   @EDCOM1{Delete to end of line,cmbDelEnd,^Q-Y,Shift+^Y}
   @EDCOM0{Delete to start of line,cmbDelStart,^Q-H}
   @EDCOM0{Delete word at left,cmbDelWord,^T}
   @EDCOM0{Delete word at right,cmbDelPrevWord,^Backspace}
   @EDCOM1{Insert line,cmbNewLine,Enter,^N}
   @EDCOM1{Insert mode on/off,cmbInsMode,Ins,^V}
@end itemize

  When you are in insert mode all the typed characters are inserted in the
text, but when the isert mode is off the typed characters replaces the
old text. The editor starts with insert mode on. You can quickly know the
mode by the cursor shapem when the insert mode is on the cursor is only a
line, but when is off the cursor is a block.
@paragraph{}

@section Blocks
@cindex Blocks

  A block is a selected portion of the text, you can copy, delete, etc blocks
of text. The asociated commands are:
@paragraph{}

@itemize @bullet
   @EDCOM0{Move to beginning of block,cmbGoBeginBlock,^Q-B}
   @EDCOM0{Move to end of block,cmbGoEndBlock,^Q-K}
   @EDCOM0{Set beginning of block,cmbStartSelect,^K-B}
   @EDCOM0{Set end of block,cmbEndSelect,^K-K}
   @EDCOM0{Hide/Show block,cmbHideSelect,^K-H}
   @EDCOM0{Mark line,cmbMarkLine,^K-L}
   @EDCOM0{Mark word,cmbMarkWord,^K-T}
   @EDCOM1{Delete block and copy it to the Clipboard,cmbCut,^K-Y,Shift+Del}
   @EDCOM0{Copy the selected block,cmbCopyBlock,^K-C}
   @EDCOM0{Move block,cmbMoveBlock,^K+V}
   @EDCOM0{Copy to Clipboard,cmbCopy,^Ins}
   @EDCOM0{Delete block,cmbClear,^Del}
   @EDCOM0{Paste from Clipboard,cmbPaste,Shift+Ins}
   @EDCOM1{Read block from disk,cmbReadBlock,^K-R,Shift+^R}
   @EDCOM1{Write block to disk,cmbWriteBlock,^K-W,Shift+^W}
   @EDCOM0{Replace the block by the Clipboard block,cmbReplaceSelect,Shift+^Ins}
   @EDCOM0{Convert to Uppercase,cmbToUpper,^K-M}
   @EDCOM0{Convert to Lowercase,cmbToLower,^K-O}
   @EDCOM0{Report the length of the block,cmbSelLength,^Q-L}
@end itemize

@subsection Block modes
@cindex Persistent Blocks

  There are two block modes, one is the mode that the old editor of RHIDE
used this mode is used in CUA programs, and the other is called Persistent
Blocks.
@paragraph{}

  In the normal mode each time you select a block and then insert any thing
on it (with @code{cmbPaste} or typing anything) the selected block is deleted
and is replaced by the new text.
@paragraph{}

  In persistent blocks the selection is not replaced and is not loosed when
you move the cursor, from here comes the name "Persistent", in this mode
you can use @code{cmbMoveBlock} and @code{cmbCopyBlock} without using the Clipboard, in
adition you can apply indentations to the block (@xref{Indentation}),
search only inside it, etc, that's makes this mode much more powerful than
the former. If you really like to replace the selected text by the selection
of the Clipboard, that's the default behaviour of the first mode, you can use
the @code{cmbReplaceSelect} command to achieve the same in the Persistent Blocks
mode.
@paragraph{}

@subsection Selecting with the mouse or Shift

  The described commands for select a block, @code{cmbStartSelect} and @code{cmbEndSelect},
are good but not so quick, there are another ways to make that.
@paragraph{}

@subsubsection Using the mouse

  Using the mouse you only need to point the start place, hold the left button
pressed and move the mouse to the end point of your block.
@paragraph{}

  To select a word with the mouse just double click on it.
@paragraph{}

@subsubsection Using the Shift key

  Using the shift key you only need to move the cursor to the start point,
hold Shift pressed and move the cursor to the end point with any of the
available @xref{Cursor movement} commands.
@paragraph{}

@subsection Indentation
@cindex Indentation

  You can indent or unindent a block of text using various commands, but you
must keep in mind that by now the editor is limited in the following: If
you are using @xref{Real Tabs} to indent your text don't mix the tabs with
spaces and if you are using spaces to indent don't mix it with real tabs.
@paragraph{}

@itemize @bullet
   @EDCOM1{Indent block one position adding an space,cmbIndentBlkOne,^K-I,Shift+^I}
   @EDCOM1{Unindent block one character - not an x position,cmbUnIndentBlkOne,^K-U,Shift+^U}
   @EDCOM0{Indent block,cmbIndentBlk,^K-Tab}
   @EDCOM0{Unindent block,cmbUnIndentBlk,^K-Shift+Tab}
   @EDCOM0{Smart Indent block,cmbSmartIndent,^Tab}
   @EDCOM0{Smart Unindent block,cmbSmartUnIndent,Shift+^Tab}
@end itemize

@code{cmbUnIndentBlkOne} unindents deleting one char at the start of the line so
if the line is indented with tabs the line will retroced one tab.
@paragraph{}

@code{cmbIndentBlk} acts according to the mode, if you are using @xref{Real Tabs},
the editor will put one tab in each line, if you aren't using tabs the
editor will operate the Tab command on the first line and then will use
this amount of indentation in the rest of the block.
@paragraph{}

@code{cmbUnIndentBlk} acts according to the mode too, in @xref{Real Tabs} mode is
just like @code{cmbUnIndentBlkOne} deleting one tab but if you don't use tabs the
editor uses Backspace on the first used column of the first line of the
block and unindents the resulting amount all the block.
@paragraph{}

@code{cmbSmartIndent} and @code{cmbSmartUnIndent} indents taking as reference the @{ @} pair
where the block is, for example:@*
@example
  @{
line1
     line2
   line3
  @}
@end example
After indenting a block that contains line1 to line3 is:@*
@example
  @{
   line1
   line2
   line3
  @}
@end example
The indentation is made with spaces.
@paragraph{}

@subsection Rectangular Blocks
@cindex Blocks - Rectangular

  The editor includes a mode where you can select a rectangular portion of
the text and copy, cut, clear, paste, move, etc this region.
  This tool is very useful for modifications on columns.
@paragraph{}

  Attention! the selected area is based on the X,Y coordinates, for this
reason if you insert lines before the bottom of the rectangle the area won't
be moved. I don't plan to move the area by now because that takes some CPU
and I think that this selection is made just before using it. So don't
report that like a bug is that the way that works.
@paragraph{}

@itemize @bullet
   @EDCOM0{Set beginning of block,cmbSelRectStart,^K-Shift+B}
   @EDCOM0{Set end of block,cmbSelRectEnd,^K-Shift+K}
   @EDCOM0{Hide/Show block,cmbSelRectHide,^K-Shift+H}
   @EDCOM0{Delete block and copy it to an special Clipboard,cmbSelRectCut,^K-ShiftT}
   @EDCOM0{Move block,cmbSelRectMove,^K+Shift+V}
   @EDCOM0{Copy to special Clipboard,cmbSelRectCopy,^K-Shift+C}
   @EDCOM0{Delete block,cmbSelRectDel,^K-Shift+L}
   @EDCOM0{Paste from special Clipboard,cmbSelRectPaste,^K-Shift+P}
@end itemize

@section Pseudo Macros
@cindex Pseudo Macros
@cindex pmacros.txt

  This feature is very useful to save some keystrokes, with this feature you
can create a lot of shortcuts to make your life easiest.
@paragraph{}

@subsection Please enlight me - what is that?

  So now, What's a Pseudo Macro?, It's like a macro but is triggered but two
things: one the text behine the cursor and two the Shift+Space convination.
@paragraph{}

  And What's the result?, the result is customizable, but by default there are
some predefined behaviours for example, type in a new window the following
two letter: #i and the press Shift+Space ...
@paragraph{}

  Surprised?, I bet, you got: #include <.h> and the cursor just in the right
place to write the name of the header.
@paragraph{}
Now write the famous stdio word, press End, then Enter twice and now write
the following two letters: ma and then Shift+Space ...
@paragraph{}

  I bet that this time you predicted better what will happend so you aren't so
surprised ;-), anyways Surprise!, now type pr and the magic keys and ....
printf(""); appears, to end the happy history now type Hello world!, that's
all you writed the hello world program at a very good speed.
@paragraph{}

  Now you know what I mean when I say pseudo-macros.
@paragraph{}

@subsection How can I customize that?

  Is very easy there is a file called @file{pmacros.txt} in the same directory
where you started the editor, this file contains the definitions for each
pseudo macro, you can define up to 32 pseudo macros (Please tell me if that
isn't enough I can sacrify some time to make it dinamically expandable).
@paragraph{}

  The pmacros.txt file is a very good example and is self-explained but I'll
include here one example.
@paragraph{}

@format
Trigger: "i("
Mode: 0,1,0,1,0
 "if (@@0)\n"
 "  @{@@1\n"
   "@}\n"
 "\belse\n"
 "  @{@@2\n"
   "@}"
@end format

  The Trigger keyword defines the two letter behine the cursor that will
trigger the pseudo macro.
@paragraph{}
  The Mode keyword indicates the mode that the editor will use when inserting
the text. The modes are:
@paragraph{}

@itemize @bullet
  @item Overwrite @xref{Overwrite}
  @item Autoindent @xref{Autoindent}
  @item Use Tabs @xref{Real Tabs}
  @item Persistent blocks @xref{Block modes}
  @item Inteligent C indent @xref{Inteligent C indent}
@end itemize

  Each mode can be 0 or 1. The editor will return to the original mode after
expanding the pseudo macro. In this case the macro is expanded in the No
overwrite, autoindent, don't use @xref{Real Tabs}, the blocks are persistent
and don't be smart when indenting mode.
@paragraph{}

  The rest is the code to insert surrounded by ". You can use \b to indicate
backspace, \n for newline and \\ to indicate a simple \. If you want to
insert a @@ you have to type it twice @@@@, because this character
has a special meaning (see below).
@paragraph{}

  After the insertion the cursor is positioned in the place marked with @@0,
don't forget to signal this point or the cursor will positioned at the
beggining of the file, the places marked with @@1, @@2 and @@3 are saved in
the markers 7, 8 and 9.
@paragraph{}

@section Miscellaneous

@itemize @bullet
   @EDCOM0{Autoindent mode on/off,cmbIndentMode,^O}
   @EDCOM0{Find place marker,cmbGotoMarkn,^Q n*}
   @EDCOM0{Set marker,cmbPutMarkn,^K n*}
@c I put it here explicit, because there is probably a bug in
@c makeinfo when calling a macro with @{ and/or @}
   @item Search the @{ where the cursor is@*
   @itemize @minus
     @item Editor command: cmbSearchStart@*
     @item Key: @key{^[}
   @end itemize
@kindex cmbSearchStart @key{^[}
@kindex Search the @{ where the cursor is @key{^[}
   @item Search the @} where the cursor is@*
   @itemize @minus
     @item Editor command: cmbSearchEnd@*
     @item Key: @key{^]}
   @end itemize
@kindex cmbSearchStart @key{^]}
@kindex Search the @{ where the cursor is @key{^]}
   @EDCOM0{Search the ( where the cursor is,cmbSearchOpPar,Shift+^9}
   @EDCOM0{Search the ) where the cursor is,cmbSearchClPar,Shift+^0}
   @EDCOM0{Search the [ where the cursor is,cmbSearchOpCor,Shift+^[}
   @EDCOM0{Search the ] where the cursor is,cmbSearchClCor,Shift+^]}
   @EDCOM0{Undo,cmbUndo,Alt+Backspace}
   @EDCOM0{PMacro's Trigger,cmbExpandCode,Shift+Space}
   @EDCOM0{Goto Line,cmbGotoEditorLine,^J}
   @EDCOM0{Set the options of the current window (Not in RHIDE),cmbSetLocalOptions,Alt+L}
   @EDCOM0{Set the default options (Not in RHIDE),cmbSetGlobalOptions,Alt+G}
   @EDCOM0{Convert all tabs in spaces,cmbExpandAllTabs,From menu}
   @EDCOM0{Compact the text using tabs,cmbCompactBuffer,From menu}
   @EDCOM0{Start recording a macro,cmbRecordMacro,Shift+F10}
   @EDCOM0{Stop recording a macro,cmbStopMacro,Alt+F10}
   @EDCOM0{Play a macro,cmbPlayMacro,^F10}
@end itemize

@chapter Keyboard

  The editor uses the scancodes of the keys to trigger the different commands,
you can reconfigure wich key triggers some command. In addition some non
US keyboards can mess the commands so you could need to configure the editor
for your keyboard.
@paragraph{}

@section How to configure the keyboard
@cindex keybind.cc
@cindex keybind.h
@cindex keybind.txt

  There are three associated files with the keyboard: @file{keybind.cc},
@file{keybind.h} and @file{keybind.txt}.
@paragraph{}

  The @file{keybind.h} file contains the scancode number for each key and the number
for each command, this file is included in @file{keybind.cc}. If your keyboard
have a different assigment you can modify the scancodes in this file, for
example: The german keyboards have the following sequence QWERTZ instead of
the more common QWERTY, so each time you press ^Z you won't get the
function of ^Z, but ^Y instead. Somebody can live with it, but is fixable.
To fix this problem you must correct the scancode of the Z key in keybind.h,
of course that this affects to ^Y too. That's only an example, the most
common problem is with the symbols like @{, @}, [, etc.
If you don't know how to find the scancode of a key take this link
@xref{A program to find the scancodes}.
@paragraph{}

  The @file{keybind.cc} file is a C++ file but you don't need to compile it and link
with the editor, you only need to preprocess it (I used this methode to
save the time needed to make a parser ;-).
@paragraph{}

  To convert this file into a @file{keybind.txt} file use:@*
@paragraph{}

  cpp keybind.cpp > keybind.txt@*
@paragraph{}

  Where cpp is the C++ preprocessor. You can use any of the comment systems
available in C++ inside the file.@*
I guess that you have cpp, but if not you can use another C++ preprocessor
or even Clipper using the /P switch.
@paragraph{}

  There are 7 sections in the file, each section is the keyboard translation
under certain situation.@*
  The sections are:
@paragraph{}

@itemize @bullet
   @item NORMAL
   The normal case.

   @item SHIFT
   Shift plus a key.

   @item CONTROL
   Control plus a key.

   @item SHIFT_CONTROL
   Shift plus control plus a key (all at the same time).

   @item QUICK
   A key after ^Q or wherever you defined as @code{cmbCtrlQ}.

   @item BLOCK
   A key after ^K or wherever you defined as @code{cmbCtrlK}.

   @item BLOCK_SHIFT
   A key plus shift after ^K or wherever you defined as @code{cmbCtrlK}.
@end itemize

   In each section you must put the keyboards and the command asociated to it.@*
   Use the following syntax:

   Scan_Code = Command

   Not all the scan codes are available, for example you can't put:

   RSHIFT = xxxxx

   Look the keybind.h to see the scan codes labels and the available commands.

Important Notes:@*
I)@*
  The new assignments are mixed with the original assignments, so if you
want to eliminate an old key combination you *must* assign a @code{cmbNoCommand}
to this key, for example is you wish eliminate the BACKSPACE key and use the
^O instead you must:@*
a) put @code{BACKSPACE = cmbNoCommand} in the NORMAL section.@*
b) put @code{O = cmbBackSpace} in the CONTROL section,@*
  If you only put the b) you'll not eliminate the BACKSPACE key.
@paragraph{}

II)@*
  If some thing is wrong in the @file{KEYBIND.TXT} file the program will inform the
error, the line number is for the @file{KEYBIND.TXT} and not for @file{KEYBIND.CPP} (sorry
some day I'll fix this).@*
  To continue the execution press any key and then enter.
@paragraph{}

III)@*
  You can repeat an assignment, the last win:
@paragraph{}

@smallexample
BACKSPACE = cmbNoCommand
BACKSPACE = cmbBackSpace
@end smallexample

  The first is ignored
@paragraph{}

@section A program to find the scancodes
@cindex scan codes

  The author of the following program is @RH{}:
@paragraph{}

@format
#include <stdio.h>
#include <dos.h>

#ifdef __GNUC__
#include <dpmi.h>
#define REGS __dpmi_regs
#define INTR(nr,r) __dpmi_int(nr,&r)
#else
#define REGS union REGS
#define INTR(nr,r) int86(nr,&r,&r)
#endif

unsigned short getshiftstate(void)
@{
  REGS r;
  r.h.ah = 0x12;
  INTR(0x16,r);
  return r.x.ax;
@}

unsigned short gkey(void)
@{
  REGS r;
  r.h.ah = 0x10;
  INTR(0x16,r);
  if (r.h.al == 0xE0 || r.h.al == 0) r.h.al = 0;
  return r.x.ax;
@}

main()
@{
  unsigned short key;
  do
  @{
    key = gkey();
    fprintf(stdout,"%04X, scan code: %d\n",key,key>>8);
  @} while (1);
@}
@end format

@chapter Edition Modes

  The editor have 9 settings that controls the edition and the aspect of
the editor. Not all can be controlled by RHIDE Beta 6 release 22/10, and
I don't know if all the settings will be supported in the 1.0 release so
if you don't find some setting in RHIDE and you feel that setting is
really needed contact me.
@paragraph{}

  The settings are:
@paragraph{}

@section Overwrite
@cindex Overwrite

  This setting controls if the typed characters are inserted in the buffer or
if the typed characters replaces the original ones, see @xref{Insert and Delete}
for a detailed explanation.

@section Autoindent
@cindex Autoindent

  This setting controls what happend when you press @key{ENTER}, if this setting
is off the cursor goes to the column 1 of a new inserted line. If the
mode is on the editor will try to keep the indentation of the code
inserting spaces.

@section Real Tabs
@cindex Real Tabs
@cindex Use Real Tabs
@cindex TABs

  This setting controls what happend when you press @key{TAB}, if this setting
is on the editor will insert an ASCII 9 in this place.
@paragraph{}

  An ASCII 9 is a TAB, that means that the width of this char is enough to
move the cursor to the next tabulator column. In the editor the tabulator
columns are equidistant and the positions are controled by the Tab Size value.
@paragraph{}

  If this setting is off the editor won't put any ASCII 9 in your text,
instead the editor will insert enough spaces to move the cursor to the
next tabulator, but if the cursor is positioned on the first character of
the line the editor will insert spaces to move this position to the next
hole in the line over the line where you are. Confused?, sorry for my
english, an example will clarify that:
@paragraph{}

This is a line over the line where you are
@paragraph{}

That's the line where the cursor is, at column one.
@paragraph{}

  After pressing TAB you'll get:
@paragraph{}

This is a line over the line where you are
@paragraph{}

     That's the line where the cursor is, at column one.
@paragraph{}

  Now can ask, why this? Is that useful?, the answer is that's very useful
to keep your code indented, experiment using that under a line with if, for,
etc.
@paragraph{}

  Another thing controlled by this setting is the behaviour of the
@key{Backspace} key, when the setting is on the key is just 'delete the
character at the left of the cursor' but when the setting is off this
key is the 'Unindent' key.
@paragraph{}

  The editor is much more coherent when you choose to use TABs or not use
tabs, if you mess the two things you'll get some unexpected things, specially
in the indentation of the blocks.
@paragraph{}

  Is better is you ever works in a file without tabs and with this setting
of, then you'll get much from the editor.
@paragraph{}

  Now you can say: But I really need tabs because I'm editing a make file! or
because I'll send the file using an ultra slow link and I want the compression
granted by the tabs. In these cases you can first expand all tabs, then
work without real tabs and at the final of your work compact all possible
spaces and generate a file with all the tabs that you need see the
@xref{Miscellaneous} section.
@paragraph{}

@section Persistent Blocks

  This setting controls the behaviour of the selected area.
@paragraph{}
  See the chapter @xref{Block modes} for a detailed explanation.
@paragraph{}

@section Inteligent C indent
@cindex Inteligent C indent

  This mode was designed to be used in joint with the Pseudo Macros
(@xref{Pseudo Macros}) and the Real Tabs mode in off to achieve an
easy way to indent the code making a better work than the Autoindent mode.
@paragraph{}

  In this mode the spaces inserted after pressing @key{ENTER} depends on
the first word in the last line, for example, if you have:
@paragraph{}

@smallexample
if (a==b)_
@end smallexample

  With the cursor in the '_' position and press @key{ENTER} you'll get:
@paragraph{}

@smallexample
if (a==b)
  _
@end smallexample

  Now you can do two things, 1) press space and write the code that will
be executed by the if, or 2) if this a multiline code press @{ and @key{ENTER},
in the last case you'll get:

@smallexample
if (a==b)
  @{
   _
@end smallexample

  Now type your first line of code, press @key{ENTER}, write your next line,
press @key{ENTER} again and then Backspace:

@smallexample
if (a==b)
  @{
   1st line;
   2nd line;
  _
@end smallexample

  Now type @} and press @key{ENTER} one more time:

@smallexample
if (a==b)
  @{
   1st line;
   2nd line;
  @}
_
@end smallexample

  As you can see the code is perfectly aligned without a significant work
from your part.
@paragraph{}

  I tried to make this mode as smart as possible, but needs more work, if
you have suggestions contact me.
@paragraph{}

  Another important thing is that this indentation have a personal style,
mine style ;-), so may be you don't like it. If that's your case you can
do the following things:
@paragraph{}

@itemize @bullet
  @item Use another way of indentation offered by the editor, for example,
turn on the Real Tabs mode and indent with tabs.
  @item Customize the pmacros.txt file (@xref{Pseudo Macros}), actually this
file is coherent with this mode.
  @item The editor isn't configurable like Emacs or Brief using a language,
but is writed in C++ and chances that you know C++ are over the
90% so contact me and I'll help you to write the routines that you
need to get an indentation in your own style :-).
@end itemize

@subsection Can you explain me more about the behaviour of this mode?

  I'll try to describe the behaviour of the mode:
@paragraph{}
  Each time you press @key{ENTER} the editor inserts a '\r\n' string in your
text, after that the editor searchs one line located above the new line that
have at least one character inside. This line is taked as reference, the
editor analizes this line searching for:
@paragraph{}

@itemize @bullet
   @item The first non blank character on this line.
   @item The first word on this line.
   @item The first parethesis.
   @item The balance of parenthesis on the line.
   @item The last non-blank and non-comment character in the line.
@end itemize

  Now, if the line contains @{ at the start the editor goes to the first
column after the @{.
@paragraph{}
  If the line contains @} at the start the editor will go to the same column
of the @} and then will perform a @key{Backspace}, is the @xref{Real Tabs}
mode is off that's an unindent.
@paragraph{}
  If the line starts with a C++ comment the effect is the same as in
@xref{Autoindent}.
@paragraph{}
  If the line starts with a C comment the editor will try to skip the
comment and analize the rest of the line, but if the comment doesn't end
on this line the editor will go to the column where the / is.
@paragraph{}
  If the line starts with / the editor goes to this column.
@paragraph{}
  If the line have more ( than ) the editor will go to the column of the
first non-blank after the first (.
@paragraph{}
  If the line have more ) than ( the editor will search the line where the
number of parenthesis is balanced, then will analize this line, if the whole
line still generating an unbalanced situation the editor will go to the
first used column in the line that was found at first time. But if this
line lets all balanced the editor will take the first word on the line and
will use it as reference.
@paragraph{}
  At last, and according to the word founded, the editor will use this
word as reference. The editor recognises the following keywords:
@paragraph{}

@itemize @bullet
  @item do: +2, no if ;
  @item if: +2, no if ;
  @item for: +3, no if ;
  @item else: +2
  @item case: +5
  @item while: +2, no if ;
  @item switch: +2
  @item break: unindent
  @item return: unindent
  @item default: +5
@end itemize

  The numbers are how much spaces are added with refernce to the first letter
of the word. When 'no if ;' is specified means that if the line ends with
a semicolon the editor will make the same as @xref{Autoindent}. The
unindent is performed with @key{Backspace}.
@paragraph{}

  Seasick? take a look at: @xref{Do you have more examples?}.
@paragraph{}

  Note: Some of these features was added in v0.2.14 of the editor based on a
suggestion of @email{Bradford L. Spencer,stud73@@nortel.ca} about of the
behaviour of the mode on line like this 'printf("Num: %d",' and the
rest of the parameters in the next line.
@paragraph{}

@subsection Do you have more examples?

  Well here are some examples, I used some strange convention, is like this:
if I say 'type a[ENTER]@{' is type the a letter, then press @key{ENTER} and
finally press the @{ key.
@paragraph{}

Example 1: (Is similar to the explained before but is to show the
convention)
@paragraph{}

@smallexample
Type:
if (a==1)[ENTER]@{[ENTER]a=2;[ENTER]b=3;[ENTER][BACKSPACE]@}[ENTER]

You'll get:

if (a==1)
  @{
   a=2;
   b=3;
  @}
[<--- cursor here]
@end smallexample


Example 2: A switch/case example
@paragraph{}

@smallexample
Type:
switch(a)[ENTER]@{[ENTER]case 1:[ENTER]a=2;[ENTER]b=3;[ENTER]break;
[ENTER]case 2:[ENTER]b=5;[ENTER]break;[ENTER][BACKSPACE]@}[ENTER]

You'll get:

switch(a)
  @{
   case 1:
        a=2;
        b=3;
        break;
   case 2:
        b=5;
        break;
  @}
[<--- cursor here]
@end smallexample


Example 3: A call to a function that takes a lot of parameters
@paragraph{}

@smallexample
Type:
printf([SPACE]"Num: %d",[ENTER]a[SPACE]);[ENTER]

You'll get:

printf( "Num: %d",
        a );
[<--- cursor here]
@end smallexample


Example 4: A lot of parethesis
@paragraph{}

@smallexample
Type:
if[SPACE]([SPACE](a==1)[SPACE]||[ENTER](b==2)[SPACE]||[ENTER]
c[SPACE])[ENTER]

You'll get:

if ( (a==1) ||
     (b==2) ||
     c )
  [<--- cursor here]
@end smallexample


Example 5: Comment trying to interfer part 1
@paragraph{}

@smallexample
Type:
/*-a-*/for[SPACE](x=1;x;--x)[ENTER]

You'll get:

/*-a-*/for (x=1;x;--x)
          [<--- cursor here]
@end smallexample


Example 6: Comment trying to interfer part 2
@paragraph{}

@smallexample
Type:
for[SPACE](x=1;x;--x);[SPACE]//-b[ENTER]

You'll get:

for (x=1;x;--x); //-b
[<--- cursor here]
@end smallexample


 Note: Of course you can full the editor but as you can see is relative
smart ;-).
@paragraph{}

@section Column cursor
@cindex Column cursor

  This setting enables an strange feature of the editor, when this mode is
on the column where the cursor is is highlithed. This feature is very good
to check if some part of your code is aligned.
@paragraph{}

  If you like this mode but is very uncomfortable to be used all the time
contact me and if I get enough feedback I'll put this thing in a key to be
turned on/off quickly.
@paragraph{}

@section Row cursor
@cindex Row cursor

  This setting is similar to the @xref{Column cursor} but acts on the row
where the cursor is. If you enable the two modes you'll get a cross on the
screen showing where the cursor is.
@paragraph{}

@section Match pair highligth
@cindex Match pair highligth

  This mode acts showing the pairs of (/), [/] and @{/@} on the fly. Each
time you type one of these symbols the editor will search the matching
pair, if the editor finds it and the match is on the screen both will be
highlithed, if the match is outside the screen the editor will inform the
position on the status line, and if there is no match the editor will
inform the situation in the status line too.
@paragraph{}

  That's very usefull when you are typing complex parenthesis expressions or
a very nested code. You can use it in joint with the @code{cmbSearchStart},
@code{cmbSearchEnd}, @code{cmbSearchOpPar}, @code{cmbSearchClPar}, @code{cmbSearchOpCor} and
@code{cmbSearchClCor} commands (@xref{Miscellaneous}).
@paragraph{}

@section Syntax Highlight

  The editor can make highlight the syntax of your code, the available modes
are:
@paragraph{}

@itemize @bullet
  @item No highlight, all the code is with the same color.
  @item C/C++ Highlight.
  @item Pascal Highlight.
  @item Clipper Highlight.
@end itemize

  The kind of highlight is choosed automatically in RHIDE using the extention
of the file.
@paragraph{}

  The C/C++ highlight was designed for the GNU C compiler.
@paragraph{}
  The Pascal highlight was designed for the GNU Pascal compiler.
@paragraph{}
  The Clipper highlight was designed for the CA-Clipper 5 compiler.
@paragraph{}

@chapter How to contact me
@cindex How to contact me

  If you have any suggestions or bug report contact me in the address showed
in the @xref{About the Author} section.
@paragraph{}

@section Bugs
@cindex Bugs

  If you find a bug please contact me, the Undo thing is the most complex
one and I know that needs some work on it.
@paragraph{}

  When reporting a bug please don't say me: Some times some strange thing
happend ..., try to find a pattern of the problem, what situation triggers
the problem, with wich file. Then send me the file and the description.
@paragraph{}

  When sending to me a file UUEncode it to avoid problems related with the
e-mail.
@paragraph{}

@chapter Index

@ifset html
<p>@*
<ul>@*
@include cindex.idx
@*
</ul>@*
@end ifset

@ifclear html
@printindex cp
@end ifclear

@chapter Index of key commands

@ifset html
<p>@*
<ul>@*
@include kindex.idx
@*
</ul>@*
@end ifset

@ifclear html
@printindex ky
@end ifclear

@contents

@bye

