{{{  Notes about this keybinding
; These bindings are written for the amiga version of origami (1.6.21)
; They use the emacs.keys bindings and define some addition keybinds for
; usage of menus, mouse, cursor keys and numberpad
; Some functions defined in emacs.keys are not implemented like spell-it or
; translate-word.
;
; Thomas Hadig
;
; Version 1.1
}}}

{{{F ami.termalias
:::F ami.termalias
}}}
{{{  uses
@if-using not (c-mode)
{{{F fun/error
:::F fun/error
}}}
{{{F fun/next-char
:::F fun/next-char
}}}
{{{F fun/pre-char
:::F fun/pre-char
}}}
{{{F fun/skippara
:::F fun/skippara
}}}
{{{F fun/fillpara
:::F fun/fillpara
}}}
@fi

@if-using (c-mode)
{{{F fun/go-match
:::F fun/go-match
}}}
@fi
{{{F fun/oripager
:::F fun/oripager
}}}
}}}
{{{  these bindings are named Emacs
@if-using not (c-mode)
{{{  reference title
@reference-begin
                        EMACS Emulation reference card
@reference-end
}}}
(defbinding Emacs)
@fi

@if-using (c-mode)
{{{  reference title
@reference-begin
                       C-EMACS Emulation reference card
@reference-end
}}}
(defbinding C-Emacs)
@fi

{{{  reference
@reference-begin

@reference-end
}}}
}}}
{{{  character-classes
@if-using not (c-mode)
  (defset word-char (alpha digit))
@fi

@if-using (c-mode)
  (defset word-char (alpha digit "_))
@fi
}}}

{{{  motion
{{{  begin reference
@reference-begin
---- MOTION

@reference-end
}}}

{{{  backward-character
{{{  reference
@reference-begin
C-B       backward-character, move back one character.
left
@reference-end
}}}
(keybind backward-character (C-B))
(keybind backward-character ($left))
}}}
{{{  forward-character
{{{  reference
@reference-begin
C-F       forward-character, move back one character.
right
@reference-end
}}}
(keybind forward-character (C-F))
(keybind forward-character ($right))
}}}

{{{  previous-line
{{{  reference
@reference-begin
C-P       previous-line, move up one line.
up
@reference-end
}}}
(keybind previous-line (C-P))
(keybind previous-line ($up))
}}}
{{{  next-line
{{{  reference
@reference-begin
C-N       next-line, move down one line.
down
@reference-end
}}}
(keybind next-line (C-N))
(keybind next-line ($down))
}}}

{{{  beginning-of-line
{{{  reference
@reference-begin
C-A       beginning-of-line, move to the beginning of line.
@reference-end
}}}
(keybind beginning-of-line (C-A))
}}}
{{{  end-of-line
{{{  reference
@reference-begin
C-E       end-of-line, move to the end of line.
@reference-end
}}}
(keybind end-of-line (C-E))
}}}

{{{  beginning-of-fold
{{{  reference
@reference-begin
M-"<      beginning-of-fold, move to the beginning of the entered fold.
@reference-end
}}}
(keybind beginning-of-fold (M-"<))
}}}
{{{  end-of-fold
{{{  reference
@reference-begin
M-">      end-of-fold, move to the end of the entered fold.
@reference-end
}}}
(keybind end-of-fold (M-">))
}}}

{{{  backward-word
{{{  backward-word
(deffun backward-word
(
  {{{  go back one character in text
  if and(test-begin-line, not(test-top))
  (
    previous-line
    end-of-line
  )
  else
  (
    backward-character
  ) fi
  }}}
  {{{  skip white space
  while not(test-char-set word-char)
  (
    if counter-0 +(store-pos -1)
    (
      previous-line end-of-line
    )
    else
    (
      backward-character
    ) fi
  )
  }}}
  {{{  skip word
  while test-char-set word-char
  (
    if test-begin-line
    (
      return-from-macro
    )
    else
    (
      backward-character
    ) fi
  )
  }}}
  {{{  move forward to beginning of word
  forward-character
  }}}
))
}}}
{{{  reference
@reference-begin
M-"b      backward-word, moves the cursor back one word.
@reference-end
}}}
(keybind backward-word (M-"b))
}}}
{{{  forward-word
{{{  forward-word
(deffun forward-word
(
  {{{  skip this word
  if test-end-line
  {{{  go to next line
  (
    next-line
    beginning-of-line
  )
  }}}
  else
  {{{  go behind the end of this word
  (
    if not(test-bottom)
    (
      while test-char-set word-char (forward-character)
    ) fi
  ) fi
  }}}
  }}}
  {{{  skip white space
  while not(test-char-set word-char)
  (
    if test-end-line
    (
      next-line
      beginning-of-line
    )
    else
    (
      forward-character
    ) fi
  )
  }}}
))
}}}
{{{  reference
@reference-begin
M-"f      backward-word, moves the cursor forward one word.
@reference-end
}}}
(keybind forward-word (M-"f))
}}}

{{{  previous-page
{{{  reference
@reference-begin
M-"v      previous-page, move one page back.
pgup      previous-page
@reference-end
}}}
(keybind previous-page (M-"v))
(keybind previous-page ($prev_page))
}}}
{{{  next-page
{{{  reference
@reference-begin
C-V       next-page, move one page forward.
pgdown    next-page
@reference-end
}}}
(keybind next-page (C-V))
(keybind next-page ($next_page))
}}}

{{{  go-to-line
{{{  go-to-line
(defvar (ln))

(deffun go-to-line
(
  set-counter ln read-repeat
  if counter>0 ln (goto-line-counter ln)
  else (goto-line) fi
))
}}}
{{{  reference
@reference-begin
M-"g      go-to-line, moves the cursor to the specified line in an entered
          fold.  A numeric argument specifies the line or a prompt will be
          issued if none is given.
@reference-end
}}}
(keybind go-to-line (M-"g))
}}}

@if-using (c-mode)
{{{  forward-s-expression
{{{  forward-s-expression
(deffun forward-s-expression
(
  case
    {{{  opening paren, bracket or brace
    (or(test-char "( , test-char "[ , test-char "{ )
    (
      if test-text (goto-matching-fence forward-character)
      else (forward-word)
      fi
    ))
    }}}
    {{{  double quote
    (test-char ""
    (
      forward-character
      while not(or(test-end-line,test-char "" )) (forward-character)
      forward-character
    ))
    }}}
    {{{  single quote
    (test-char "'
    (
      forward-character
      while not(or(test-end-line,test-char "' )) (forward-character)
      forward-character
    ))
    }}}
    {{{  in word
    (test-char-set word-char
    (
      while test-char-set word-char (forward-character)
    ))
    }}}
    {{{  default
    default
    (
      while not(or(test-char-set word-char, test-char "(, test-char "[, test-char "{, test-char "", test-char "',test-end-line))
      (
        forward-character
      )
    )
    }}}
  esac
  if test-end-line
  (
    next-line
    beginning-of-line
  ) fi
))
}}}
{{{  reference
@reference-begin
M-C-F     forward-s-expression, moves the cursor forward in a syntax
          oriented way.  I am still experimenting with this function.
@reference-end
}}}
(keybind forward-s-expression (M-C-F))
}}}
{{{  backward-s-expression
{{{  backward-s-expression
(deffun backward-s-expression
(
  case
    {{{  closing paren, bracket or brace
    (or(test-char ") , test-char "] , test-char "} )
    (
      if test-text (goto-matching-fence backward-character)
      else (backward-word)
      fi
    ))
    }}}
    {{{  double quote
    (test-char ""
    (
      backward-character
      while not(or(test-begin-line,test-char "" )) (backward-character)
      backward-character
    ))
    }}}
    {{{  single quote
    (test-char "'
    (
      backward-character
      while not(or(test-begin-line,test-char "' )) (backward-character)
      backward-character
    ))
    }}}
    {{{  in word
    (test-char-set word-char
    (
      while and(not(test-begin-line),test-char-set word-char) (backward-character)
    ))
    }}}
    {{{  default
    default
    (
      while not(or(test-char-set word-char, test-char "), test-char "], test-char "}, test-char "", test-char "',test-begin-line))
      (
        backward-character
      )
    )
    }}}
  esac
  if test-begin-line
  (
    previous-line
    end-of-line
  ) fi
))
}}}
{{{  reference
@reference-begin
M-"p      backward-s-expression, moves the cursor backward in a syntax
          oriented way.  I am still experimenting with this function.
@reference-end
}}}
(keybind backward-s-expression (M-"p))
}}}
@fi

@if-using not (c-mode)
{{{  backward-sentence
{{{  backward-sentence
( deffun backward-sentence
   ( local
      ( x )
      ( if not(test-text) ( failed ) fi
        set-counter x 1
        {{{  search '.  '
        do
         ( do
            {{{  skip char and roff-comment
            ( previous-text-character
              if test-top ( failed ) fi
              if and(test-char ". test-begin-line)
               ( previous-text-character )
              fi
              if not(or(test-char " test-char ". ))
               ( set-counter x 0 )
              fi
            )
            }}}
           while or(x not(test-char ".))
           forward-character
           if test-char " ;
            ( forward-character
              if not(test-char "  )
               ( backward-character
                 backward-character
               )
              fi
            )
           else
            ( backward-character
            )
           fi
         )
        while not(test-char " )
        }}}
        while or(test-char "  and(test-char ". test-begin-line))
         ( if and(test-char ". test-begin-line) ( end-of-line ) fi
           forward-text-character
           if test-bottom ( failed ) fi
         )
      )
   )
)
}}}
(keybind backward-sentence (M-"())
}}}
{{{  forward-sentence
{{{  forward-sentence
( deffun forward-sentence
   ( if not(test-text) ( failed ) fi
     {{{  search ".  "
     do
      (
        {{{  search the next .
        do
         ( if test-char ".
            ( next-line
              beginning-of-line
            )
           else
            ( do
               ( if test-bottom ( failed ) fi
                 forward-text-character
               )
              while not(test-char ".)
            )
           fi
         )
        while test-begin-line
        }}}
        forward-character
        if test-char "  ( forward-character ) fi
      )
     while not(test-char " )
     }}}
     {{{  move to following non-space-char
     while or(test-char "  and(test-char ". test-begin-line))
      ( if and(test-char ". test-begin-line) ( end-of-line ) fi
        forward-text-character
        if test-bottom ( failed ) fi
      )
     }}}
   )
)
}}}
(keybind forward-sentence (M-")))
}}}

{{{  backward-paragraph
{{{  reference
@reference-begin
M-(       backward-paragraph, moves the cursor backward one paragraph.
          A paragraph is text without blank lines and without a dot in
          the first column.
@reference-end
}}}
(keybind backward-paragraph (M-"{))
}}}
{{{  forward-paragraph
{{{  reference
@reference-begin
M-)       forward-paragraph, moves the cursor forward one paragraph.
          A paragraph is text without blank lines and without a dot in
          the first column.
@reference-end
}}}
(keybind forward-paragraph (M-"}))
}}}
@fi

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  folding
{{{  begin reference
@reference-begin
---- FOLDING

@reference-end
}}}

{{{  open-fold
{{{  reference
@reference-begin
C-O       open-fold, opens the fold under the cursor
@reference-end
}}}
(keybind open-fold (C-O))
}}}
{{{  close-fold
{{{  reference
@reference-begin
C-C       close-fold, closes the current fold and folds inside it
@reference-end
}}}
(keybind close-fold (C-C))
}}}
{{{  enter-fold
{{{  reference
@reference-begin
M-C-O     enter-fold, enters the fold under the cursor
@reference-end
}}}
(keybind enter-fold (M-C-O))
}}}
{{{  exit-fold
{{{  reference
@reference-begin
M-C-C     exit-fold, exits the current fold
@reference-end
}}}
(keybind exit-fold (M-C-C))
}}}
{{{  unfold-fold
{{{  reference
@reference-begin
C-U       removes the fold marks of the fold under the cursor
@reference-end
}}}
(keybind unfold-fold (C-U))
}}}
{{{  create-fold
{{{  reference
@reference-begin
M-C-N     create-fold, marks the start line and the end line of a new
          fold and creates this fold
@reference-end
}}}
(keybind create-fold (M-C-N))
}}}
{{{  auto-header
{{{  reference
@reference-begin
C-X C-H   auto-header, copies the first in of the fold under the cursor
          to the fold header
@reference-end
}}}
(keybind auto-header (C-X C-H))
}}}
{{{  toggle-file-fold
{{{  reference
@reference-begin
C-X C-F   toggle-file-fold, toggles between a fold and a file-fold
@reference-end
}}}
(keybind toggle-file-fold (C-X C-F))
}}}
{{{  attach-file-to-fold
{{{  reference
@reference-begin
C-X C-A   attach-file-to-fold, attaches a file to a fold to create a
          file-fold for an already existing file
@reference-end
}}}
(keybind attach-file-to-fold (C-X C-A))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  editing
{{{  begin reference
@reference-begin
---- EDITING

@reference-end
}}}

{{{  newline-and-indent
{{{  reference
@reference-begin
C-M       newline-and-indent, inserts a new line and indents it as the
C-J       previous one
@reference-end
}}}
(keybind newline-and-indent (C-J))
(keybind newline-and-indent (C-M))
}}}

{{{  delete-previous-character
{{{  reference
@reference-begin
C-H       delete-previous-character, deletes the character left to the cursor
@reference-end
}}}
(keybind delete-previous-character (C-H))
}}}
{{{  delete-character
{{{  reference
@reference-begin
C-D       delete-character, deletes the character under the cursor
C-?
@reference-end
}}}
(keybind delete-character (C-D))
(keybind delete-character (C-?))
}}}

{{{  delete-word-backward
{{{  delete-word-backward
(deffun delete-word-backward
(
  {{{  go back one character in text
  if test-begin-line
  (
    if test-top ( return-from-macro ) fi
    previous-line
    end-of-line
  )
  else
  (
    backward-character
  ) fi
  }}}
  {{{  skip white space
  while not(test-char-set word-char)
  (
    if test-begin-line
    (
      if test-top ( return-from-macro ) fi
      previous-line end-of-line
    )
    else
    (
      delete-character
      backward-character
    )
    fi
  )
  }}}
  {{{  skip word
  while test-char-set word-char
  (
    if test-begin-line ( return-from-macro ) else
    (
      delete-character
      backward-character
    )
    fi
  )
  }}}
  {{{  move forward to beginning of word
  forward-character
  }}}
))
}}}
{{{  reference
@reference-begin
M-C-H     delete-word-backward, deletes word backwards from cursor position
@reference-end
}}}
(keybind delete-word-backward (M-C-H))
}}}

{{{  transpose-characters
{{{  reference
@reference-begin
C-T       transpose-characters, transposes the character left from the cursor
          with the character under the cursor, then moves the cursor forward
          one character.
@reference-end
}}}
(keybind transpose-characters (C-T))
}}}

{{{  case-word-capitalize
{{{  case-word-capitalize
(deffun case-word-capitalize (
  if not(or(test-view,and(test-top,counter-0 set-enter)))
  (
    if not(test-char-set word-char) (forward-word) fi
    if test-char-set lower (case-character-toggle) fi
    forward-character
    while test-char-set word-char
    (
      if test-char-set upper ( case-character-toggle ) fi
      forward-character
    )
  ) fi
))
}}}
{{{  reference
@reference-begin
M-"c      case-word-capitalize, capitilizes the word starting at cursor
          position and moves the cursor forward one word.
@reference-end
}}}
(keybind case-word-capitalize (M-"c))
}}}
{{{  case-word-upper
{{{  case-word-upper
(deffun case-word-upper
(
  if not(or(test-view,and(test-top counter-0 set-enter)))
  (
    if not(test-char-set word-char) (forward-word) fi
    do
    (
      if test-char-set lower ( case-character-toggle ) fi
      forward-character
    ) while test-char-set word-char
  ) fi
))
}}}
{{{  reference
@reference-begin
M-"u      case-word-upper, changes the word to upper case starting at cursor
          position and moves the cursor forward one word.
@reference-end
}}}
(keybind case-word-upper (M-"u))
}}}
{{{  case-word-lower
{{{  case-word-lower
(deffun case-word-lower
(
  if not(or(test-view,and(test-top,counter-0 set-enter)))
  (
    if not(test-char-set word-char) (forward-word) fi
    do
    (
      if test-char-set upper (case-character-toggle) fi
      forward-character
    ) while test-char-set word-char
  ) fi
))
}}}
{{{  reference
@reference-begin
M-"l      case-word-lower, changes the word to lower case starting at cursor
          position and moves the cursor forward one word.
@reference-end
}}}
(keybind case-word-lower (M-"l))
}}}

{{{  delete-to-end-of-line
{{{  reference
@reference-begin
C-K       delete-to-end-of-line, deletes from cursor position to end of line
@reference-end
}}}
(keybind delete-to-end-of-line (C-K))
}}}
{{{  delete-line
{{{  reference
@reference-begin
C-X C-K   delete-line, deletes a whole line
@reference-end
}}}
(keybind delete-line (C-X C-K))
}}}
{{{  undo-delete-line
{{{  reference
@reference-begin
C-X C-Y   undo-delete-line, yank the last deleted line back
@reference-end
}}}
(keybind undo-delete-line (C-X C-Y))
}}}
{{{  kill-line
{{{  reference
@reference-begin
M-C-K     kill-line, kills line and appends it to the kill buffer.
@reference-end
}}}
(keybind kill-line (M-C-K))
}}}
{{{  copy-to-kill-buffer
{{{  reference
@reference-begin
M-"k      copy-to-kill-buffer, appends the line to the kill buffer without
          killing it
@reference-end
}}}
(keybind copy-to-kill-buffer (M-"k))
}}}
{{{  insert-folded-kill-buffer
{{{  reference
@reference-begin
C-Y       insert-folded-kill-buffer, moves the kill buffer in a fold
          and yanks this fold back
@reference-end
}}}
(keybind insert-folded-kill-buffer (C-Y))
}}}

{{{  kill-to-char
(deffun kill-to-char
(
  ; This function has not been written yet
))

; (keybind kill-to-char (M-"z))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  search & replace
{{{  begin reference
@reference-begin
---- SEARCH & REPLACE

@reference-end
}}}

{{{  search-forward
{{{  reference
@reference-begin
M-C-S     search-forward, prompts for a text to search forward or the
          last text, if none if given
@reference-end
}}}
(keybind search-forward (M-C-S))
}}}
{{{  search-reverse
{{{  reference
@reference-begin
M-C-R     search-reverse, prompts for a text to search backward or the
          last text, if none if given
@reference-end
}}}
(keybind search-reverse (M-C-R))
}}}

{{{  incremental-search-forward
{{{  reference
@reference-begin
C-S       incremental-search-forward, switches to incremental search mode
@reference-end
}}}
(keybind incremental-search-forward (C-S))
}}}
{{{  incremental-search-reverse
{{{  reference
@reference-begin
C-R       incremental-search-reverse, switches to incremental search mode
@reference-end
}}}
(keybind incremental-search-reverse (C-R))
}}}
{{{  incremental search reference
@reference-begin
          During incremental search, you can use the following commands:
C-S       moves the cursor to the next occurence of the search string
C-R       moves to the presious occurence
return    exits incremental search, leaves the cursor where it is
C-G       aborts incremental search, sets the cursor to where it was before
@reference-end
}}}

{{{  replace-string
{{{  reference
@reference-begin
M-"R      replace-string, asks for two strings and replaces all occurences
          starting at cursor position
@reference-end
}}}
(keybind replace-string (M-"R))
}}}
{{{  query-replace-string
{{{  reference
@reference-begin
M-"r      query-replace-string, asks for two strings and asks before replacing.
@reference-end
}}}
(keybind query-replace-string (M-"r))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  files
{{{  begin reference
@reference-begin
---- FILES

@reference-end
}}}

{{{  insert-file
{{{  reference
@reference-begin
C-X C-I   insert-file, inserts the contents of a file at the current position
          into the buffer
@reference-end
}}}
(keybind insert-file (C-X C-I))
}}}
{{{  save-file
{{{  reference
@reference-begin
C-X C-S   save-file, writes the buffer back to the edited file
@reference-end
}}}
(keybind save-file (C-X C-S))
}}}
{{{  write-file
{{{  reference
@reference-begin
C-X C-W   write-file, writes the buffer to another file
@reference-end
}}}
(keybind write-file (C-X C-W))
}}}
{{{  read-file
{{{  reference
@reference-begin
C-X C-R   read-file, reads another file into the buffer
@reference-end
}}}
(keybind read-file (C-X C-R))
}}}

{{{  next-file
{{{  reference
@reference-begin
C-X C-N   next-file, reads next file from command line argument list into the
          buffer
@reference-end
}}}
( keybind next-file (C-X C-N))
}}}
{{{  previous-file
{{{  reference
@reference-begin
C-X C-P   previous-file, reads previous file from command line argument list
          into the buffer
@reference-end
}}}
(keybind previous-file (C-X C-P))
}}}

{{{  set-file-unchanged
{{{  reference
@reference-begin
M-"~      set-file-unchanged, marks the buffer as unchanged
@reference-end
}}}
(keybind set-file-unchanged (M-"~))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  macros
{{{  begin reference
@reference-begin
---- MACROS

@reference-end
}}}

{{{  define-macro
{{{  reference
@reference-begin
C-X "(    define-macro, starts recording a keyboard macro
@reference-end
}}}
(keybind define-macro (C-X "())
{{{  reference
@reference-begin
C-X ")    define-macro, ends recording a keyboard macro
@reference-end
}}}
(keybind define-macro (C-X ")))
}}}
{{{  execute-macro
{{{  reference
@reference-begin
C-X "e    execute-macro, executes a recorded keyboard macro
@reference-end
}}}
(keybind execute-macro (C-X "e))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  shell commands
{{{  begin reference
@reference-begin
---- SHELL COMMANDS

@reference-end
}}}

{{{  shell
{{{  reference
@reference-begin
C-X "c    shell, starts a sub shell
@reference-end
}}}
(keybind shell (C-X "c))
}}}
{{{  shell-command
{{{  reference
@reference-begin
C-X "!    shell-command, starts a sub shell with a given command
@reference-end
}}}
(keybind shell-command (C-X "!))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  modes
{{{  begin reference
@reference-begin
---- MODES

All modes are set with C-X "m mode-key and deleted with C-X C-M mode-key.
The following mode-keys are available:
@reference-end
}}}

{{{  view
{{{  reference
@reference-begin
"v        view, text can only be viewd but not changed
@reference-end
}}}
(keybind add-mode-view (C-X "m "v))
(keybind delete-mode-view (C-X C-M "v))
}}}
{{{  overwrite
{{{  reference
@reference-begin
"o        overwrite, new text overwrites existing text instead of being
          inserted
@reference-end
}}}
(keybind add-mode-overwrite (C-X "m "o))
(keybind delete-mode-overwrite (C-X C-M "o))
}}}
{{{  autosave
{{{  reference
@reference-begin
"a        autosave, asks for a time interval and saves the text each time
          after this interval expires
@reference-end
}}}
(keybind add-mode-autosave (C-X "m "a))
(keybind delete-mode-autosave (C-X C-M "a))
}}}
@if-using not (c-mode)
{{{  wrap
{{{  reference
@reference-begin
"w        wrap, wraps a word to the next line if neccessary
@reference-end
}}}
(keybind add-mode-wrap (C-X "m "w))
(keybind delete-mode-wrap (C-X C-M "w))
}}}
@fi

{{{  set-language
{{{  reference
@reference-begin
"l        set-language, sets a new language for fold comments.  This mode
          can not be deleted, only set with different values.
@reference-end
}}}
(keybind set-language (C-X "m "l))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  arguments
{{{  begin reference
@reference-begin
---- ARGUMENTS

Meta-Number sets number as argument for the next executed command.  Most
commands simply are executed number times, when prefixed by an argument.
@reference-end
}}}
(keybind set-argument-0 (M-"0))
(keybind set-argument-1 (M-"1))
(keybind set-argument-2 (M-"2))
(keybind set-argument-3 (M-"3))
(keybind set-argument-4 (M-"4))
(keybind set-argument-5 (M-"5))
(keybind set-argument-6 (M-"6))
(keybind set-argument-7 (M-"7))
(keybind set-argument-8 (M-"8))
(keybind set-argument-9 (M-"9))
{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  special functions
{{{  begin reference
@reference-begin
---- SPECIAL COMMANDS

@reference-end
}}}

{{{  abort
{{{  reference
@reference-begin
C-G       abort, aborts everything, no matter if prompts, running macros etc.
@reference-end
}}}
(keybind abort (C-G))
}}}

{{{  redraw-display
{{{  reference
@reference-begin
C-L       redraw, redraws screen e.g. after write(1)s from other people etc.
@reference-end
}}}
(keybind redraw-display (C-L))
}}}

{{{  help
{{{  reference
@reference-begin
M-"?      help, displays an optional helpfile
@reference-end
}}}
(keybind help (M-"?))
}}}
{{{  describe-bindings
{{{  reference
@reference-begin
C-X "?    describe-bindings, shows all commands and where they are bound to
@reference-end
}}}
(keybind describe-bindings (C-X "?))
}}}
{{{  describe-fold
{{{  reference
@reference-begin
C-X "=    describe-fold, gives you some information about your position in
          the text
@reference-end
}}}
(keybind describe-fold (C-X "=))
}}}
{{{  quote-character
{{{  reference
@reference-begin
C-Q       quote-character, simply insert the next character and do not
          parse it as a command
@reference-end
}}}
(keybind quote-character (C-Q))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  pager
(keybind pager-start (C-X "2))
(keybind pager-end (C-X "1))

(keybind pager-next (C-w))
(keybind pager-previous (M-"w))
}}}
{{{  how to get out
{{{  begin reference
@reference-begin
---- HOW TO GET OUT

@reference-end
}}}

{{{  exit-origami
{{{  reference
@reference-begin
C-X C-C   exit-origami
@reference-end
}}}
(keybind exit-origami (C-X C-C))
}}}
{{{  save-and-exit-origami
{{{  reference
@reference-begin
M-Z       save-and-exit-origami
@reference-end
}}}
(keybind save-and-exit-origami (M-"z))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
}}}
{{{  version control interface
{{{  check-out
(deffun check-out
(
  delete-mode-view
  shell-command "co "  "-l "  "$ORIFILE newline-and-indent
))
}}}
(keybind check-out (M-"x "o))
{{{  check-in
(deffun check-in
(
  save-file
  add-mode-view
  shell-command "ci "  "-u "  "$ORIFILE newline-and-indent
))
}}}
(keybind check-in (M-"x "i))
}}}
{{{  text processing features
@if-using not (c-mode)
{{{  begin reference
@reference-begin
---- TEXT PROCESSING FEATURES

@reference-end
}}}

{{{  fill functions
{{{  reference
@reference-begin
M-"q      fill-paragraph, fills paragraph from cursor to end of paragraph
@reference-end
}}}
(keybind fill-paragraph (M-"q))
{{{  reference
@reference-begin
C-X "     set-fill-column, sets fill column to argument, or cursor position
          if none is given, or asks for it if cursor if at the left margin.
@reference-end
}}}
(keybind set-fill-column (C-X "f))
(keybind wrap-word (" ))
}}}
{{{  translate-word
{{{  translate-word
(deffun translate-word
(
  shell-command "trans " "$ORIWORD "|$PAGER newline-and-indent
  newline-and-indent
))
}}}
(keybind translate-word (M-"$))
}}}
{{{  spell-it
{{{  reference
@reference-begin
M-"x "s   spell-it, runs current file through spell and puts unknown words
          in the oriarea file.
@reference-end
}}}
{{{  spell-it
(deffun spell-it
(
  save-file
  shell-command "spell "  "$ORIFILE "  ">$ORIAREA newline-and-indent
  newline-and-indent
  message-exit ("buffer "  "spelled)
))
}}}
(keybind spell-it (M-"x "s))
}}}
{{{  experimantal omail features
{{{  reply-to
(deffun reply-to
(
  shell-command "mail "  "-f "  "$ORIFILE newline-and-indent
  newline-and-indent
))
}}}
(keybind reply-to (M-"x "r))
{{{  delete-letter
(deffun delete-letter
(
  if test-filed
  (
    enter-fold
    shell-command "rm "  "$ORIFILE newline-and-indent
    newline-and-indent
    exit-fold
    delete-line
    save-file
  )
  fi
))
}}}
(keybind delete-letter (M-"x "d))
}}}

{{{  end reference
@reference-begin


@reference-end
}}}
@fi
}}}
{{{  c-mode features
@if-using (c-mode)
{{{  parens
{{{  paired parens
(deffun paired-parens
(
  "(
  if not (in-prompt)
  (
    ")
    backward-character
  )
  fi
))
}}}
(keybind paired-parens ("( ))
}}}
{{{  brackets
{{{  paired-brackets
(deffun paired-brackets
(
  "[

  if not (in-prompt)
  (
    "]
    backward-character
  )
  fi
))
}}}
(keybind paired-brackets ("[ ))
}}}
{{{  curly brackets
{{{  paired-curly-brackets
( defvar ( x_pos_cb ) )
(deffun paired-curly-brackets
(
  {{{  handle begin/end-fold/fold/prompt
  case
    (or(test-begin-fold,test-top)  (end-of-line newline-and-indent))
    (or(test-end-fold,test-bottom) (beginning-of-line newline-and-indent previous-line))
    (or(in-prompt,not(test-text))  ("{ return-from-macro))
  esac
  }}}
  {{{  correct position?
  set-counter x_pos_cb store-pos
  beginning-of-line
  if test-char "  (
    goto-counter x_pos_cb
  ) else (
    end-of-line
    newline-and-indent
  ) fi
  }}}
  "{ newline-and-indent "}
  previous-line
  end-of-line
  newline-and-indent
  forward-character forward-character
))
}}}
(keybind paired-curly-brackets ("{ ))
}}}
{{{  doublequotes
{{{  paired-doublequotes
(deffun paired-doublequotes
(
  ""
  if not (in-prompt)
  (
    ""
    backward-character
  )
  fi
))
}}}
(keybind paired-doublequotes ("" ))
}}}
{{{  singlequotes
{{{  paired singlequotes
(deffun paired-singlequotes
(
  "'
  if not (in-prompt)
  (
    "'
    backward-character
  )
  fi
))
}}}
(keybind paired-singlequotes ("' ))
}}}
{{{  semicolon
{{{  semicolon
( defvar ( x_pos_sem ) )
(deffun semicolon
(
  if in-prompt ("; )
  else
  (
    end-of-line
    backward-character
    if not(test-char ";)
    (
      if not(test-char " ) (forward-character) fi
      ";
    )
    fi
    beginning-of-line
    set-counter x_pos_sem store-pos
    next-line
    beginning-of-line
    if test-char " (previous-line beginning-of-line next-line)
    else
    (
      set-counter x_pos_sem -(x_pos_sem store-pos)
      if counter>0 x_pos_sem (previous-line end-of-line newline-and-indent) fi
    )
    fi
  )
  fi
))
}}}
(keybind semicolon (";))
}}}

{{{  call compiler
{{{  make-it
(deffun make-it
(
  save-file
  shell-command "make newline-and-indent
))
}}}
(keybind make-it (M-"x "m))
{{{  compile-it
(deffun compile-it
(
  save-file
  shell-command "cc "  "$ORIFILE newline-and-indent
))
}}}
(keybind compile-it (M-"x "c))
}}}
{{{  goto-matching-fence
(keybind goto-matching-fence (M-"#))
}}}
{{{  beautify-c-code
{{{  beautify-c-code
(deffun beautify-c-code
(
  filter-buffer "cb newline-and-indent
))
}}}
(keybind beautify-c-code (C-X "i))
}}}
@fi
}}}
{{{  towers
@if-using (towermacs)
  {{{F fun/towers
  :::F fun/towers
  }}}
  (keybind towers-of-hanoi (M-"x "h "a "n "o "i))
@fi
}}}

{{{  refer
(deffun refs
 (
  shell-command
  "wb:utilities/editor/refer
  newline-and-indent
  newline-and-indent
  pager-start
  "7
  newline-and-indent
 ))

(keybind refs (C-X "5))
}}}

{{{  NumKeys
(keybind backward-character ($csrl))
(keybind forward-character  ($csrr))
(keybind previous-line      ($csru))
(keybind next-line          ($csrd))

(keybind beginning-of-line  ($home))
(keybind end-of-line        ($end))

(keybind forward-word       ($ctcsrr))
(keybind backward-word      ($ctcsrl))
(keybind beginning-of-fold  ($ctprev_page))
(keybind end-of-fold        ($ctnext_page))

(keybind redraw-display     ($csi "F "A ".))
(keybind add-mode-overwrite ($del))
(keybind delete-mode-overwrite ($ins))

{{{  special keys needed for Workbench 2.0
(keybind "[ ($csi "F "A "Z))
(keybind "] ($csi "F "A "[))
(keybind "{ ($csi "F "B "Z))
(keybind "} ($csi "F "B "[))
(keybind "/ ($csi "F "A "\))
(keybind "* ($csi "F "A "]))
}}}
}}}
{{{  Menus
; use this only in conjunction with .origamimenu file in HOME directory

{{{  view-file
(deffun view-file
(
 read-file
 "/
 newline-and-indent
 add-mode-view
))
}}}
{{{  exit-file
(deffun exit-file
(
 save-file
 exit-origami
))
}}}
{{{  open-line
(deffun open-line
(
 end-of-line
 newline-and-indent
))
}}}

(keybind  read-file    ($menu "0 "0))
(keybind  view-file    ($menu "0 "1))
(keybind  insert-file  ($menu "0 "2))
(keybind  save-file    ($menu "0 "3))
(keybind  write-file   ($menu "0 "4))
(keybind  exit-file    ($menu "0 "5))
(keybind  shell        ($menu "0 "6))
(keybind  shell-command ($menu "0 "7))
(keybind  exit-origami ($menu "0 "8))

(keybind  transpose-characters      ($menu "1 "0))
(keybind  delete-line               ($menu "1 "1))
(keybind  undo-delete-line          ($menu "1 "2))
(keybind  delete-to-end-of-line     ($menu "1 "3))
(keybind  copy-to-kill-buffer       ($menu "1 "4))
(keybind  insert-folded-kill-buffer ($menu "1 "5))

(keybind  open-fold          ($menu "2 "0))
(keybind  close-fold         ($menu "2 "1))
(keybind  enter-fold         ($menu "2 "2))
(keybind  exit-fold          ($menu "2 "3))
(keybind  unfold-fold        ($menu "2 "4))
(keybind  create-fold        ($menu "2 "5))
(keybind  toggle-file-fold   ($menu "2 "6))
(keybind  attach-file-to-fold ($menu "2 "7))
(keybind  describe-fold      ($menu "2 "8))

(keybind  beginning-of-fold  ($menu "3 "0))
(keybind  end-of-fold        ($menu "3 "1))
(keybind  goto-line          ($menu "3 "2))
(keybind  next-page          ($menu "3 "3))
(keybind  previous-page      ($menu "3 "4))
(keybind  forward-word       ($menu "3 "5))
(keybind  backward-word      ($menu "3 "6))

(keybind  open-line          ($menu "4 "0))
(keybind  delete-line        ($menu "4 "1))
(keybind  delete-to-end-of-line ($menu "4 "2))
(keybind  beginning-of-line  ($menu "4 "3))
(keybind  end-of-line        ($menu "4 "4))
(keybind  next-line          ($menu "4 "5))
(keybind  previous-line      ($menu "4 "6))

(keybind  case-word-upper    ($menu "5 "0))
(keybind  case-word-lower    ($menu "5 "1))
(keybind  case-word-capitalize ($menu "5 "2))

(keybind  search-forward             ($menu "6 "0))
(keybind  search-reverse             ($menu "6 "1))
(keybind  replace-string             ($menu "6 "2))
(keybind  query-replace-string       ($menu "6 "3))
(keybind  incremental-search-forward ($menu "6 "4))
(keybind  incremental-search-reverse ($menu "6 "5))

(keybind  add-mode-view      ($menu "7 "0))
(keybind  delete-mode-view   ($menu "7 "1))
(keybind  add-mode-overwrite ($menu "7 "2))
(keybind  delete-mode-overwrite ($menu "7 "3))

(keybind  define-macro       ($menu "8 "0))
(keybind  define-macro       ($menu "8 "1))
(keybind  execute-macro      ($menu "8 "2))
(keybind  set-language       ($menu "8 "3))
(keybind  describe-bindings  ($menu "8 "4))
(keybind  help               ($menu "8 "5))
}}}
{{{  Mouse-Handling
{{{F fun/go-mouse
:::F fun/go-mouse
}}}

(mouse-buttons
  go-mouse-position no-operation  no-operation  no-operation  no-operation
  no-operation   no-operation  no-operation  no-operation  no-operation
  no-operation   no-operation  )
}}}
{{{  special keys
(keybind describe-bindings ($helpkey))
}}}

{{{  defmark
(defmark pascal (("< "< "< ) (". ". ". ) (": ": ": ) ("> "> "> )))
}}}