\begindata{text,17784576}
\textdsversion{12}
\template{default}
\define{section
menu:[Title~3,Section~21]
attr:[Justification LeftJustified Point 0]
attr:[Flags KeepPriorNL Int Set]
attr:[Flags KeepNextNL Int Set]
attr:[FontFace Bold Int Set]}
\define{keyname

attr:[FontFace Bold Int Set]}
\define{userintext
}
\define{footnote

attr:[Flags OverBar Int Set]
attr:[FontSize PreviousFontSize Point -2]}
\define{commandname

attr:[FontFace Italic Int Set]}
\define{verbatim

attr:[FontFace FixedFace Int Set]
attr:[FontFamily AndyType Int 0]}
\define{symbola
}
\heading{Introduction

}
This document tells:


a. what the EZ text editor key bindings are, as compared to GNU Emacs key 
bindings.

b. any differences between them and the GNU Emacs key bindings.

c. what the changes were to eliminate particular differences.

d. a list of projects to remove most of the remaining differences.

e. a mini-spec of the work required to do each project.

e. the status of each project.


Share and enjoy,

Chad Brown

Bill Cattey


\heading{EZ Key Bindings (with Comparison to GNU Emacs)}


Many of the menu commands in EZ have keyboard equivalents.  There are also a 
number of commands in EZ that are only executable as key commands.  All of the 
commands that you can execute in EZ from the keyboard are listed here, with 
their corresponding GNU Emacs equivalents.  \keyname{M-} means \keyname{Meta-} 
and \keyname{C-} means \keyname{Control-}.  Note that at Athena, most (but not 
all) key commands are the same in EZ as in GNU Emacs.


The lines in this card are organized as follows:

\verbatim{
\smaller{  Emacs key       EZ key             Command Description}}


In some cases, useful descriptive text follows the key summaries.


If there is a command conflict, the other system's command name is in angle 
brackets.  If one system has no equivalent, the key string 
\smaller{\typewriter{<none>}} appears.


\subheading{Starting the Editor}

\verbatim{\smaller{
  emacs &       ez}}


Note:  You do not need to use \typewriter{&} when starting up EZ.  EZ 
automatically puts itself in background.  


\subheading{Exiting the Editor}

\verbatim{\smaller{
  C-x C-c       C-x C-c            exit 

  M-C-c,C-]     C-c,C-]            exit-recursive-edit 
\footnote{\
\begindata{fnote,17910016}
\textdsversion{12}
Added C-] frame-exit-recursive-edit to gnu.init.\
\enddata{fnote,17910016}
\view{fnotev,17910016,0,0,0}}

}}
\subheading{Getting Help}

\verbatim{\smaller{
  C-h           <see below>        help}}\verbatim{\smaller{

  C-h k         M-?                describe key binding

  C-h m         C-M-?              describe-bound-keys 
\footnote{\
\begindata{fnote,17910272}
\textdsversion{12}
New to gnu.init.\
\enddata{fnote,17910272}
\view{fnotev,17910272,1,0,0}}

}}
EZ considers \keyname{C-h} the same as a backspace deletion command.  You must 
choose the \commandname{Help} option from the \commandname{Front} menu card 
while in an EZ window or run \commandname{help} / \commandname{ezhelp} from 
the shell to get help in EZ.


\subheading{Recovering from Errors}

\verbatim{\smaller{
  C-g           C-g                abort

  C-x u         <none>             undo}}


EZ has no undo. 
\footnote{\
\begindata{fnote,17910528}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17911040}
\textdsversion{12}
undo\
\enddata{textref,17911040}
\view{textrefv,17911040,63,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17910528}
\view{fnotev,17910528,2,0,0}}


\subheading{Moving the Cursor}

\verbatim{\smaller{
  C-f           C-f                character forward

  C-b           C-b                character backward

  C-n           C-n                next line

  C-p           C-p                previous line

  M-f           M-f                word forward

  M-b           M-b                word backward


}}Note that the arrow keys also work in both GNU Emacs and 
EZ.\verbatim{\smaller{


  C-e           C-e                end of line

  C-a           C-a                beginning of line}}\verbatim{\smaller{

}}
Due to onscreen wordwrap, EZ moves to the end of onscreen line, not to the 
logical line as in GNU Emacs.

\verbatim{\smaller{
  M-]           M-]                forward paragraph

  M-[           M-[                backward paragraph


  C-x ]         C-x ]              forward page 
\footnote{\
\begindata{fnote,17910784}
\textdsversion{12}
New to gnu.init.\
\enddata{fnote,17910784}
\view{fnotev,17910784,4,0,0}}

  C-x [         C-x [              backward page 
\footnote{\
\begindata{fnote,17911296}
\textdsversion{12}
New to gnu.init.\
\enddata{fnote,17911296}
\view{fnotev,17911296,5,0,0}}}}


Note that the page motion commands move between page breaks in both EZ and GNU 
Emacs.  In EZ, page breaks can be inserted with the \bold{Insert Pagebreak} 
command on the \italic{Page} menu card.  In GNU emacs, a pagebreak is normally 
represented by a ^L (control-L) character at the beginning of a line.


With motion commands, when the cursor reaches the bottom or top of the screen, 
GNU Emacs scrolls the text to the middle of the screen/window; EZ currently 
scrolls one line to keep the caret in 
view.\footnote{\
\begindata{fnote,17911552}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17940480}
\textdsversion{12}
scroll-step\
\enddata{textref,17940480}
\view{textrefv,17940480,62,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17911552}
\view{fnotev,17911552,6,0,0}}


\subheading{Scrolling}\verbatim{\smaller{


}}\verbatim{\smaller{  C-v           C-v                next screenful

  M-v           M-v                previous screenful}}


The numerical arguments to \keyname{C-v} and \keyname{M-v} are interpreted 
differently.  GNU Emacs takes the argument as the number of \italic{lines} to 
scroll, whereas EZ interprets it as the number of \italic{screenfuls} to 
scroll.\footnote{\
\begindata{fnote,17940736}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17940992}
\textdsversion{12}
scrolling\
\enddata{textref,17940992}
\view{textrefv,17940992,61,0,0}} in  \italic{Future Changes}.\
\enddata{fnote,17940736}
\view{fnotev,17940736,8,0,0}}

\verbatim{\smaller{

  <suspend>     C-z                next line

  <zap-to-char> M-z                previous line}}


Screen motion in GNU Emacs may re-position the cursor if the cursor would have 
scrolled off screen.  EZ never repositions the caret for text 
scrolling.\footnote{\
\begindata{fnote,17941248}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17941504}
\textdsversion{12}
recenter\
\enddata{textref,17941504}
\view{textrefv,17941504,60,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17941248}
\view{fnotev,17941248,10,0,0}}


\subheading{Typing in the Message Line / Minibuffer}

\verbatim{\smaller{
  TAB           SPC, TAB           complete 
all\footnote{\
\begindata{fnote,17941760}
\textdsversion{12}
Added ^I frameview-complete to gnu.init.\
\enddata{fnote,17941760}
\view{fnotev,17941760,12,0,0}}

  SPC           <none>             complete token

  RET           RET                execute

  ?             ?                  show completions}}

\subheading{
Working with Regions

}
\verbatim{\verbatim{\smaller{ C-w           C-w                kill region

 M-w           M-w                copy region as kill

 M-=           <none>             count lines in region

 <none>        M-n                go to paragraph

 <none>        M-N                identify paragraph number

}}
}In EZ a paragraph is either a double newline in text mode, or a single 
newline in ctext, ltext, and other programming language modes.  The paragraph 
commands can therefore act as very nice `what line' and `goto line' commands 
when editing C, lisp and other language texts.

\verbatim{\smaller{
}}\subheading{ Marking Text}

\verbatim{\smaller{
  C-@,C-SPC     C-@,C-SPC          set mark

  C-x C-x       C-x C-x            cursor and mark exchange positions

  <none>        C-M-@,C-M-SPC      select region}}


EZ will only operate on the region between mark and point after the select 
region (\keyname{C-M-@}) command has been issued.  Normally, EZ operates on a 
region selected with the 
mouse.\footnote{\
\begindata{fnote,17942016}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17942272}
\textdsversion{12}
selection\
\enddata{textref,17942272}
\view{textrefv,17942272,59,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17942016}
\view{fnotev,17942016,13,0,0}}


\subheading{Killing and Deleting Text}

\verbatim{\smaller{
  C-d           C-d                delete char forward

  DEL           DEL                delete char backward

  <help>        C-h                delete char backward

  M-d           M-d                kill word forward 
\footnote{\
\begindata{fnote,17942528}
\textdsversion{12}
Added textview-kill-next-word to gnu.init.\
\enddata{fnote,17942528}
\view{fnotev,17942528,15,0,0}}

  M-DEL         M-DEL              kill word backward 
\footnote{\
\begindata{fnote,17942784}
\textdsversion{12}
Added textview-kill-previous-word to gnu.init.\
\enddata{fnote,17942784}
\view{fnotev,17942784,16,0,0}}

  C-k           C-k                kill to end of line 
\footnote{\
\begindata{fnote,17943040}
\textdsversion{12}
Added textview-MIT-kill-line to gnu.init. (MIT Version modifies current kill 
ring element rather than trashing new kill ring elements for every subsequent 
line kill.)\
\enddata{fnote,17943040}
\view{fnotev,17943040,17,0,0}}

  M-k           <kill whitespace>  kill sentence}}\verbatim{\smaller{

  C-y           C-y                yank back last kill

  M-y           M-y                replace last yank with previous}}


For a line with only whitespace, ending with a newline, \keyname{C-k} in GNU 
Emacs removes the whitespace and the newline,  whereas \keyname{C-k} in EZ 
erases only the whitespace, requiring another \keyname{C-k} to remove the 
newline.


EZ has an 8 element kill ring.  GNU Emacs has a 30 element kill ring.  When 
using commands to cycle through the kill ring, GNU Emacs will skip any kill 
ring element which is empty (if four elements are on the ring and you are at, 
say, element "A", four cycles in the same direction are necessary to return to 
element "A").  EZ always cycles through empty elements, however, so if there 
are four non-empty elements and you are at element "B", EZ will require eight 
cycles to return to element "B".




\subheading{Searching}

\verbatim{\smaller{
  C-s           C-s                forward incremental 
search\footnote{\
\begindata{fnote,17943296}
\textdsversion{12}
Added gsearch-forward to gnu.init.\
\enddata{fnote,17943296}
\view{fnotev,17943296,18,0,0}}

  C-r           C-r                reverse incremental 
search\footnote{\
\begindata{fnote,17943552}
\textdsversion{12}
Added gsearch-backward to gnu.init.\
\enddata{fnote,17943552}
\view{fnotev,17943552,19,0,0}}

                C-M-s              Dynamic search 
forward\footnote{\
\begindata{fnote,17943808}
\textdsversion{12}
Added dynsearch-search-forward to gnu.init New: delete this.\
\enddata{fnote,17943808}
\view{fnotev,17943808,20,0,0}}

                C-M-r              Dynamic search 
reverse\footnote{\
\begindata{fnote,17944064}
\textdsversion{12}
Added dynsearch-search-reverse to gnu.init New: delete this.\
\enddata{fnote,17944064}
\view{fnotev,17944064,21,0,0}}}}


When a search is in progress, the following key bindings are in effect:

\verbatim{\smaller{
  DEL           DEL                undo effect of last char

  ESC           ESC                exit search

  C-g           C-g                abort search

  C-y                              next line to search string

                C-y                cut buffer to search string

  C-w                              next word to search string

                C-w                selection to search string}}


EZ performs searching on regular expressions by default; the following 
characters are treated specially: \commandname{\\ . ] [} and \commandname{*}. 
If you need to use them, simply precede them with a backslash 
\commandname{\bold{/}}.  GNU Emacs does regular expression searching only when 
explicitly requested by the user.


With the C-y and C-w commands (used to append text to the end of the search 
string), EZ uses the cut buffer and the selection, whereas GNU Emacs uses the 
text appearing after point in the text buffer.


With both systems, typing any \keyname{Ctrl} or \keyname{Meta} character will 
also exit the search, as will using any of the mouse commands that affect the 
cursor location.


\subheading{Query Replace}

\verbatim{\smaller{
  M-%           M-%                query replace 
\footnote{\
\begindata{fnote,17944320}
\textdsversion{12}
Added textview-query-replace to gnu.init.\
\enddata{fnote,17944320}
\view{fnotev,17944320,22,0,0}}

}}
When a query-replace is in progress, the following key bindings are in 
effect:\verbatim{\smaller{


  SPC           SPC                replace current go to next

  y             y                  replace current go to 
next\footnote{\
\begindata{fnote,17944576}
\textdsversion{12}
New functionality added to txtvcsrch.c.\
\enddata{fnote,17944576}
\view{fnotev,17944576,23,0,0}}

  ,             <none>             replace current do not move

  n, DEL        n                  do not replace go to next

  !             !                  replace all remaining

  q, ESC        q                  exit query replace

  r}}


EZ treats all search strings as regular expressions.   See the section below 
 on regular expressions for more help.


\subheading{Changing Case}

\verbatim{\smaller{
  M-u           M-u                make word upper case 
\footnote{\
\begindata{fnote,17944832}
\textdsversion{12}
Added textview-uppercase-word to gnu.init.\
\enddata{fnote,17944832}
\view{fnotev,17944832,24,0,0}}

  M-l           M-l                make word lower case

  M-c           M-c                capitalize word 
\footnote{\
\begindata{fnote,17945088}
\textdsversion{12}
Added textview-capitalize-word to gnu.init.\
\enddata{fnote,17945088}
\view{fnotev,17945088,25,0,0}}

  C-x C-u       <see note>         upper case region

  C-x C-l       <see note>         lower case region

  <none>        C-^                toggle character case}}


When changing the case of words, GNU Emacs finds the first word on or after 
the cursor, looking past spaces, tabs, and newlines when necessary, operates 
on that word, and moves the cursor immediately past the word.  EZ operates on 
a word only if it is on it or immediately after it, and does not move the 
cursor.\footnote{\
\begindata{fnote,17945344}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17945600}
\textdsversion{12}
case-change\
\enddata{textref,17945600}
\view{textrefv,17945600,58,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17945344}
\view{fnotev,17945344,26,0,0}}  EZ will take the word case change commands to 
refer to a region if there is a region selected.


\subheading{Transposing Text}

\verbatim{\smaller{
  C-t           C-t                transpose chars}}\verbatim{\smaller{

  M-t           <none>             transpose words

  C-x t         <recursive edit>   transpose lines}}


GNU Emacs drags the character before the cursor past the character on the 
cursor and moves the cursor to the right.  EZ toggles the position of the 
character before the cursor and the character before that one.  The cursor 
does not 
move.\footnote{\
\begindata{fnote,17945856}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17946112}
\textdsversion{12}
transposition\
\enddata{textref,17946112}
\view{textrefv,17946112,57,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17945856}
\view{fnotev,17945856,28,0,0}}


\subheading{Checking Spelling}

\verbatim{\smaller{
  M-$           M-$                spell check 
\footnote{\
\begindata{fnote,17946368}
\textdsversion{12}
Added spell-check-document to gnu.init.\
\enddata{fnote,17946368}
\view{fnotev,17946368,30,0,0}}

}}
GNU Emacs spell checks the word.  EZ checks from the current position to the 
end of the file.  In EZ, the following key bindings are in effect during the 
spell check:

\verbatim{\smaller{
}}\verbatim{\smaller{                <number>           replace word with 
numbered choice

                SPC                replace once

                r                  replace to end of document

                a                  accept

                i                  insert in private dictionary

                q                  exit query replace}}\verbatim{

}
\subheading{Working with Files}

\verbatim{\smaller{
  C-x C-f       C-x C-f            find (visit) 
file\footnote{\
\begindata{fnote,17946880}
\textdsversion{12}
Added frame-visit-file to gnu.init.\
\enddata{fnote,17946880}
\view{fnotev,17946880,31,0,0}}

  C-x C-s       C-x C-s            save file

  C-x i         C-x i,C-x C-i      insert 
file\footnote{\
\begindata{fnote,17947136}
\textdsversion{12}
Added C-x i textview-insert-file to gnu.init.\
\enddata{fnote,17947136}
\view{fnotev,17947136,32,0,0}}

  C-x C-v       C-x C-v            switch file

  C-x C-w       C-x C-w            write to named file

  C-x s         C-x s              save all 
files\footnote{\
\begindata{fnote,17947392}
\textdsversion{12}
Added frame-save-all-files to gnu.init.\
\enddata{fnote,17947392}
\view{fnotev,17947392,33,0,0}}}}


\subheading{Working with Buffers}

\verbatim{\smaller{
  C-x b         C-x b              go to other buffer

  C-x C-b       C-x C-b            list buffers}}\verbatim{\smaller{

  C-x k         C-x k              kill a buffer

  M-~           M-~                mark buffer 
unmodified\footnote{\
\begindata{fnote,17947648}
\textdsversion{12}
Added frame-set-buffer-modified to gnu.init.\
\enddata{fnote,17947648}
\view{fnotev,17947648,34,0,0}}

  C-x C-q       C-x C-q            toggle 
read-only\footnote{\
\begindata{fnote,17947904}
\textdsversion{12}
Added textview-toggle-read-only to gnu.init.\
\enddata{fnote,17947904}
\view{fnotev,17947904,35,0,0}}}}


\subheading{Manipulating Multiple Windows}

\verbatim{\smaller{
  C-x 2         C-x 2              new window}}\verbatim{\smaller{

  C-x 0         C-x d, C-x 0       delete this window 
\footnote{\
\begindata{fnote,17948160}
\textdsversion{12}
Currently C-x 0 is frame-hide-window to gnu.init. New gnu.init: change to 
frame-delete-window.\
\enddata{fnote,17948160}
\view{fnotev,17948160,36,0,0}}

  C-x o         C-x o              go to next window 
\footnote{\
\begindata{fnote,17948416}
\textdsversion{12}
Added frame-next-window to gnu.init\
\enddata{fnote,17948416}
\view{fnotev,17948416,37,0,0}}}}

    

Both EZ and Emacs have what they call 'windows', but they are not the same 
thing.  Emacs makes new windows by dividing up its X window into sections, 
while EZ makes separate X windows.


\subheading{Using Tags}

\verbatim{\smaller{
  M-.           M-.                go to next tag 
\footnote{\
\begindata{fnote,17965056}
\textdsversion{12}
Added tags-goto-tag to gnu.init.\
\enddata{fnote,17965056}
\view{fnotev,17965056,38,0,0}}}}


\subheading{Executing Shell Commands}

\verbatim{\smaller{
  M-!           <none>             execute shell command}}


\subheading{Using Keyboard Macros}

\verbatim{\smaller{
  C-x (         C-x (              start keyboard macro

  C-x )         C-x )              end keyboard macro

  C-x e,C-x E   C-x e,C-x E        execute keyboard 
macro\footnote{\
\begindata{fnote,17965312}
\textdsversion{12}
Added C-x E play-keyboard-macro to gnu.init so that upper case E in command 
works too.\
\enddata{fnote,17965312}
\view{fnotev,17965312,39,0,0}}

  C-u C-x (     <none>             append to keyboard macro}}


\subheading{Regular Expressions}

\verbatim{\smaller{
  \\             \\                  quote regexp special

  .             .                  match any single character

  *             *                  match 0 or more of previous

  [...]         [...]              any char in set}}


The 'quote regexp special' character can be used in a regular expression to 
'hide' the special meaning of one of the other regexp characters \bold{.}, 
\bold{*}, \bold{[}, \bold{]}, and 
\bold{  }\bold{\\}.\footnote{\
\begindata{fnote,17965568}
\textdsversion{12}
\define{footnote
}
\define{italic
menu:[Font~1,Italic~11]
attr:[FontFace Italic Int Set]}
See item 
\footnote{\
\begindata{textref,17965824}
\textdsversion{12}
regexp\
\enddata{textref,17965824}
\view{textrefv,17965824,56,0,0}} in \italic{Future Changes}.\
\enddata{fnote,17965568}
\view{fnotev,17965568,40,0,0}}\bold{ }This means that you can use '\bold{\\*}' 
to refer to a literal '\bold{*}' character, instead of getting the special 
meaning 'match 0 or more of previous'.


\subheading{Formatting Text}

\verbatim{\smaller{
  TAB           TAB                insert tab character

  C-o           C-o                insert newline after point

  <mark-page>   C-x C-p            make selection 
plainest\footnote{\
\begindata{fnote,17966080}
\textdsversion{12}
Added textview-plainest to gnu.init.\
\enddata{fnote,17966080}
\view{fnotev,17966080,42,0,0}}

  C-j           C-j                newline and indent}} <see 
note>\verbatim{\smaller{

  <none>        M-s                show styles

  <none>        C-M-x              toggle expose styles 
\footnote{\
\begindata{fnote,17966336}
\textdsversion{12}
Added textview-toggle-expose-styles to gnu.init.\
\enddata{fnote,17966336}
\view{fnotev,17966336,43,0,0}}}}


GNU Emacs inserts a newline after the cursor; EZ currently inserts the newline 
at the end of the current line.


Showing styles in EZ will display many of the formatting commands in a 
Scribe-like  syntax.


Ez allows formatting with keystroke commands in addition to menu commands. 
 Each of these commands works as follows:  if there is no selection region, 
the command starts you typing in the designated style; if there is a selection 
region, the command makes the selected text the designated style.

\verbatim{\smaller{
  <See Note>    M-' M-i            italic

  <See Note>    M-' M-b            bold

  <See Note>    M-' M-^            superscript

  <See Note>    M-' M-!            subscript

  <See Note>    M-' M-_            underline

  <See Note>    M-' M-t            typewriter

  <See Note>    M-' M-+            bigger

  <See Note>    M-' M--            smaller

  <See Note>    M-' M-=            center

  <See Note>    M-' M-<            flushleft

  <See Note>    M-' M->            flushright

  <See Note>    M-' M-<tab>        leftindent

  <See Note>    M-' M-l            prompts for style to use

                                   (completion is available)

  <See Note>    M-' M-p            plainer

  <See Note>    M-' M-P            plainest}}


EZ has the notion of the "current" style which controls what style will be in 
effect with the next character you type.  Here are commands to manipulate the 
current style:

\verbatim{\smaller{
  <See Note>    M-'<up arrow>       moves you out of the innermost

             or M-' M-u            style


  <See Note>    M-'<down arrow>     moves you down into a style

             or M-' M-d            (typically used when you are at

                                   the beginning of a style and

                                   want to type inside that style)


  <See Note>    M-'<left arrow>     moves you to the next style in

                                   the left direction (used only

                                   when you are between two styles)


  <See Note>    M-'<right arrow>    moves you to the next style in

                                   the right direction (used only

                                   when you are between two styles)}}

Note: In GNU Emacs, M-' is bound to 'abbrev-prefix-mark', an command dealing 
with Emacs abbrevs; a rarely used dynamic macro package, whereas EZ uses it to 
delineate it's formatting commands.


\subheading{Special Commands

}
\verbatim{\smaller{  C-q           C-q                Insert literally quoted 
char\footnote{\
\begindata{fnote,17966592}
\textdsversion{12}
Added ^I textview-quote to gnu.init.

\enddata{fnote,17966592}
\view{fnotev,17966592,44,0,0}}

  M-q           M-q                Fill 
Paragraph\footnote{\
\begindata{fnote,17966848}
\textdsversion{12}
Added gnucompat-fill-para to gnu.init.\
\enddata{fnote,17966848}
\view{fnotev,17966848,45,0,0}}

}}\subheading{
Composing Foreign, Accented and Special Characters}

\verbatim{\smaller{
  <none>        C-x v              verbose compose

  <none>        C-x x              quick compose }}


\subheading{Language Modes}


Common to all language modes:

\verbatim{\smaller{\verbatim{\smaller{
}}\verbatim{  C-j           C-j                newline and indent

                M-r                redo styles

}}}
See the note in the \bold{Formatting Text} section for differences between 
newline-and-indent in EZ and Emacs.


Available in C language mode only:

\verbatim{\smaller{
                M-Q                rename identifier

                */                 complete comment}}


\begindata{bp,17958656}
\enddata{bp,17958656}
\view{bpv,17958656,46,0,0}
\heading{
Future Changes

}
This section will detail some of the changes necessary to EZ to make it more 
compatible with GNU Emacs.  These are listed in rough order of importance, and 
tagged to indicate the current status of each change here at MIT.  The tags 
are:


\leftindent{Coded -- The change is coded and slated for installation in the 
next release

Probably -- The change will probably be done in time for the next release

Later -- The change will probably be done for a later release

Never -- The change is not scheduled to be done at the present time.

}
\section{1	Undo} Later/Never 
 \footnote{\
\begindata{texttag,17967104}
\textdsversion{12}
undo\
\enddata{texttag,17967104}
\view{texttagv,17967104,47,0,0}}

This is probably the single largest remaining feature or GNU Emacs that EZ 
lacks.  However, it may also be the single most difficult to implement within 
the constraints of the IM.  Additionally, in many cases, EZ's functions are 
non-reversible, requiring  changes to a large body of code to support the undo 
feature itself.


\section{2	case-change commands} Probably 
\footnote{\
\begindata{texttag,17967360}
\textdsversion{12}
case-change\
\enddata{texttag,17967360}
\view{texttagv,17967360,48,0,0}} 

New versions of the commands bound to  M-u, M-l, and M-c should be written for 
txtvcmod.c and bound to these keys.  These versions would find the first word 
on or after the cursor, looking past spaces, tabs, and newlines when 
necessary, operate on that word, and move the cursor immediately past the 
word.  A preference would be added to enable or disable the EZ behavior of 
operating on regions, and new commands (bound to  C-x C-u, and C-x C-l, 
respectively) would be added (to text/txtvcmod.c), to implement this 
region-only behavior


\section{3	recenter vs. refresh}  Probably/Later 
\footnote{\
\begindata{texttag,17967616}
\textdsversion{12}
recenter\
\enddata{texttag,17967616}
\view{texttagv,17967616,49,0,0}}

Emacs has C-l bound to recenter; a function that redraws the display after 
having centered point in the current window.  It takes and optional argument 
that means put the point on line ARG, unless ARG is 4 (the default for C-u), 
in which case it will simply center in the current screen.  EZ has C-l bound 
to refresh; a function that simply refreshes the current display, without 
moving anything.   While it is arguable that this is the correct behavior, 
 there should be some way to accomplish the recenter-type behavior from the 
keyboard.  We should bind C-l to a function that recenters if and only if the 
cursor is visible; otherwise it merely refreshes the display.  Also, possibly 
add another function that brings the cursor to the currently visible area.


\section{4	compatible kill-line} Later

The current implementation of EZ's kill-line (MIT-kill-line) does not treat 
lines  like <whitespace><newline> as blank lines, requiring two invocations to 
completely delete the line; one for the whitespace, and one for the newline. 
 Emacs ignores the whitespace in this context, and kills the line in one 
invocation.  We should implement the Emacs-style behavior, and add a 
preference to enable it.


\section{5	fix newline-and-indent} Later

The current behavior of EZ's newline-and-indent code is more aptly described 
as end-of-line-newline-and-indent.  The GNU Emacs style behavior of inserting 
the newline at the current location should be optionally available.  Note that 
this might involve complications with opening new lines in the middle of 
styles, since the resulting scope of the current styles may not be what is 
most commonly wanted.


\section{6	transposition commands} Probably 
\footnote{\
\begindata{texttag,17967872}
\textdsversion{12}
transposition\
\enddata{texttag,17967872}
\view{texttagv,17967872,50,0,0}}

The current implementation of the transpose-characters command in EZ 
(textview-twiddle-chars) exchanges the character immediately before the point 
with the character immediately before that one; point is not moved.  The Emacs 
version (transpose-chars) exchanges the character immediately before point 
(where point is defined to be immediately \italic{before} the highlighted 
character) with the charcter immediately after the point; point is then moved 
forward one character.  We should implement the Emacs-style behavior and 
introduce a preference option to enable it.

 

\section{7	Scroll-step }Later 
\footnote{\
\begindata{texttag,17968128}
\textdsversion{12}
scroll-step\
\enddata{texttag,17968128}
\view{texttagv,17968128,51,0,0}}

For next-line and prev-line, emacs allows for a variable:\leftindent{

scroll-step (defaults to 0)

The number of lines to try scrolling a window by when point moves out.

If that fails to bring point back on screen, point is centered instead.

If this is zero, point is always centered after it moves off screen.}


EZ always just scrolls up one line.  We'd like to emulate Emacs as above, but 
the situation in EZ is more complicated, since difference insets handle 
scrolling differently.  Should the variable be in lines, pixels, or percentage 
of screen height?  How should it deal with insets and styles which may require 
special scrolling behavior?


\section{8	Numeric arg handling of scroll commands} Later 
\footnote{\
\begindata{texttag,17968384}
\textdsversion{12}
scrolling\
\enddata{texttag,17968384}
\view{texttagv,17968384,52,0,0}}

In Emacs, the screen-forward and -backward commands take a numeric arg as the 
number of lines to scroll.  In EZ, it's used as number of screens.  The GNU 
Emacs style behavior should be optionally available through a preference of 
some sort.  As is the case with scroll-step (described above), EZ is trickier, 
given the way some insets handle scrolling.

\section{
9	kill-ring behavior} Later/Never

Currently, Emacs has a variable-sized kill ring, which defaults to a much 
higher number (30) than EZ's hard coded 8.  (Eight is probably acceptable, 
since most users don't seem to use the extra elements.)  The important 
difference is that Emacs's kill-ring-motion commands ignore empty entries, 
while EZ's do not.  This means that if I have 3 elements on Emacs' kill ring, 
then I need to issue 3 motion commands to completely cycle back to the 
original entry.  EZ, however, will require 8;  I'll need to cycle past all of 
the empty entries by hand.  The Emacs behavior should be implemented and 
offered as an option, via a preference setting.

\section{
10	recover-file} Later

EZ should have a function (M-x foo-recover-file) that prompts for a path to a 
filename, then sees if it a corresponding checkpoint file exists.  If so, it 
should (after confirming), copy the current copy (if any) to a backup file, 
and copy the checkpoint file to the given path.  Emacs does this, and people 
regularly ask OLC, SIPB, and -i help about how to do this in EZ. (Alas, users 
must be protected from the horrors of learning "\typewriter{cp 
/usr/tmp/#<uid>#...#.CKP ~/<myfile>}". -wdc)


\section{11	Add 'y' key to textview-query-replace }Coded 

textview-query-replace should understand 'y' as 'Yes, replace', as Emacs does.

\section{
12	investigate non-regexp search} Probably/Later

The primary customers of EZ are bewildered by the superfluous complexity of 
regexp searching.  They need a simple string-search functionality.  The 
initial attempt at implementing this by cannibalizing from the existing 
regexp-search proved more difficult than expected.


\section{13	Finish dired mode} Probably/Later

The current implementation of dired mode needs some additional work.  Specific 
changes include:


o	Add command 'e' to edit in same window.

o	Add a "?" functionality, to list available commands?

o	Change title bar to say "Dired: " not "Buffer"

o	Possibly highlight/unhighlight key commands.

o	Consider adding in commands to copy/rename/delete a file.

o	The mouse behavior is to be changed according to the following table:

\begindata{table,17963392}
\rows 32 27 26 32
\cols 72 172 145
	-	-
 	| Selection unhighlighted	| Selection highlighted	| 
-	-	-
| Button 1	| Highlight selection	| Zoom selection	| 
=		=
| 	| and unhighlight all others	| 	| 
-	-	-
| Button 3	| Highlight selection	| Unhighlight selection	| 
-	-	-
\enddata{table,17963392}
\view{spread,17963392,53,0,0}


\section{14	Finish electric buffer mode} Later

The frame-list-buffers command currently has disabled code to allow for mouse 
selection from the buffer list, similar to Emacs' electric-buffer mode. 
 Basically,  the view connected to the text object with the list of filenames 
needs to be changed to have an appropriate hit method.  Also, possibly add in 
keyboard  commands as in the suggested dired mode changes, described above.


\section{15	Execute-extended-command} Never

Currently, metax allows EZ users to execute named functions, as in GNU Emacs, 
but requires that the user know the \{package,class\} of the function.  This 
requires the user to inappropriately know the insides of EZ -- to wit, the 
name of the object that implements a particular function.  It would be better 
if we could gather common functions (including recover-file?) under a generic 
package name.


\section{16	other-window commands} Never

For strict compatibility with GNU Emacs, one might want to implement the 
commands that affect other windows such as:


\leftindent{find-file-other-window

scroll-up-other-window

scroll-down-other-window

switch-to-buffer-other-window

delete-other-windows

}
Since users may have started multiple (and difficult to distinguish) instances 
of EZ from their command shell, or other runapp process started by EZ, these 
sorts of commands are nearly impossible to implement in a way that the user 
would perceive as coherent.  They also provide little value to the user.  EZ 
currently has a variation on find-file-other-window which pops up a new window 
on a file (for example in the use of the link inset) which is adequate.

\section{
17	Region and selection vs. selection and region} Later 
\footnote{\
\begindata{texttag,17968640}
\textdsversion{12}
selection\
\enddata{texttag,17968640}
\view{texttagv,17968640,54,0,0}}

While Emacs has the idea of region, and, to a smaller extent, of selection, EZ 
only acts on selections.  In general, this is fine, and removes some of the 
confusion associated with Emacs' (Athena-added) handling of selections, but it 
also causes some extra effort to be required for certain often-used commands, 
since EZ requires that defined areas be selected before acting one them.  Some 
suggestions:


\leftindent{It might be useful to have certain selection-commands 
automatically select the region if no other selection exists.  This will 
optimize certain common actions (such as C-w) but may lead to more confusion 
later.  The 'more confusion later' will affect mainly advanced users who will 
know how to deal appropriately.  The possible gain in ease of use (and strict 
compatibility) may be worth the risk, especially if we add in a preference to 
disable this behavior.

}\leftindent{\section{
}EZ might optionally place the selection into the cut buffer automatically. 
 This might cause some problems, but would be more compatible with the current 
Emacs behavior in a strict sense (although more restrictive, since Emacs uses 
the region as a separate entity to get around problems EZ would then have to 
face.)}\section{


18	access to options to ispell} Later

If there were some way that we could allow the user to access the arglist for 
the ispell process we spawn, then EZ could start supporting things like 
private dictionaries, the -t option for suppressing checking of 
L\smaller{\superscript{A}}T\subscript{E}X commands, etc.  This could be done 
by allowing a preference "IspellAdditionalArgs".


\section{19	Shell things} Later/Never

EZ seems to have the raw capability to spawn subshells, but not any real 
user-defined interface for it.  This would be very nice, and may be a 
requirement for getting serious programmers to use EZ.


\section{20	token completion} Later/Never

EZ's message line current supports full completion but does not support 
 single token-completion.


\section{21	add regexp operators } Never 
\footnote{\
\begindata{texttag,17968896}
\textdsversion{12}
regexp\
\enddata{texttag,17968896}
\view{texttagv,17968896,55,0,0}}

The addition of a few common regexp operators (namely, '^') would be helpful. 
 Supporting Emacs' full set of regexps is, probably, too difficult and would 
involve emulating  GNU Emacs functionality not universally accepted as good.


\section{22	named/stored macros} Later

This is apparently a project in progress at CMU.


\section{23	continuations }Later/Never

Conventions on continuations should change.  For example, in \keyname{^X^B}, 
the user is prompted to hit Enter to continue.  The following should be the 
behavior:

\leftindent{Hitting space should continue and not auto-insert the space.

Issuing a command should continue, and do the command on the restored buffer.

}
\enddata{text,17784576}
