! EVE$WPS.TPU 			31-DEC-1992 12:22			Page 1

module eve$wps ident "V03-007"

!
!	       COPYRIGHT © 1986,1992 BY
!	DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS
!		    ALL RIGHTS RESERVED
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
! ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE
! INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR ANY OTHER
! COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
! OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
! TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
! AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
! CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!
!++
! FACILITY:
!	DECTPU - Text Processing Utility
!	EVE - Extensible Versatile Editor
!
! ABSTRACT:
!	This is the source program for the EVE interface advanced move
!	and delete features. This file was obtained from the old
!	evesecini.tpu file.
!
! ENVIRONMENT:
!	OpenVMS VAX, OpenVMS AXP, RISC/ULTRIX
!
!Author: Bill Robinson (among others)
!
! CREATION DATE: 10-Oct-1986
!
! MODIFIED BY:
!
!--

! EVE$WPS.TPU 								Page 2

!++
!				Table of Contents 
!
!				   EVE$WPS.TPU
!				31-DEC-1992 12:22
!
!	Procedure name			Page	Description
!	--------------			----	------------
!
!	eve_set_keypad_wps 		   3	Define WPS emulation keypad keys
!	eve$set_wps_keypad 		   3	Set keypad subprocedure
!	eve_set_keypad_nowps 		   4	Remove WPS keypad keys
!	eve$set_keypad_nowps1 		   4	Remove WPS keypad keys
!	eve$set_nowps_keypad 		   5	Set keypad nowps subprocedure
!	eve_restore_sentence 		   6	Restore sentence
!	eve$wps_down 			   7	Down arrow (bound or free)
!	eve$wps_up 			   8	Up arrow in (bound or free cursor)
!	eve$wps_left 			   9	Left arrow (bound or free cursor)
!	eve$wps_right 			  10	Right arrow (bound or free cursor)
!	eve$wps_advance 		  11	WPS advance
!	eve$wps_backup 			  12	WPS backup
!	eve$$case_change 		  13	Change case from mark to current position
!	eve$wps_lower_case 		  14	WPS lower case
!	eve$wps_upper_case 		  14	WPS upper case
!	eve$wps_adv_scroll 		  15	WPS GOLD advance function
!	eve$wps_back_scroll 		  15	WPS GOLD backup function
!	eve$wps_bottom 			  16	WPS go to bottom of document
!	eve$wps_top 			  16	WPS go to top of document
!	eve$$choose_paste_buffer 	  17	Choose a paste buffer
!	eve$wps_select 			  17	Select and set Forward
!	eve$wps_remove 			  17	Remove into a paste buffer
!	eve$wps_replace 		  17	WPS replace
!	eve$wps_copy 			  18	WPS copy select range
!	eve$wps_insert_here 		  19	WPS paste
!	eve$wps_date_time 		  20	Insert date + time
!	eve$wps_delete_start_sent 	  21	WPS delete to beginning of sentence
!	eve$wps_continue_search 	  22	Continue search
!	eve$wps_continue_search_select 	  23	WPS continue search/select
!	eve$wps_word 			  24	WPS move by word
!	eve$wps_line 			  24	WPS line
!	eve$wps_sentence 		  25	WPS sentence
!	eve$wps_paragraph 		  26	WPS next paragraph
!	eve$wps_page 			  27	WPS page
!	eve$wps_page_marker 		  28	Page marker (GOLD/P) soft FF
!	eve_paginate 			  29	Paginate
!	eve$wps_paginate 		  29	GOLD/PAGE - paginate
!	eve$wps_next_screen 		  30	WPS next screen
!	eve$wps_previous_screen 	  30	WPS previous screen
!	eve$wps_right_angle 		  31	WPS <>
!	eve$wps_swap 			  31	WPS swap characters
!	eve$$display_ruler 		  32	GOLD/R: Display and modify ruler
!	eve$$save_ruler 		  33	- Shift 0-9: Save a ruler
!	eve$$get_ruler 			  34	- 0-9: recall a saved ruler
!	eve$$ruler_set_tab_stop 	  35	- T: set a tab stop here
!	eve$$ruler_set_left_margin 	  36	- L: set left margin here
!	eve$$ruler_set_right_margin 	  37	- R: set right margin here
!	eve$$ruler_set_word_wrap 	  38	- W: set word wrap marker here
!	eve$$ruler_set_paragraph 	  39	- P or I: set paragraph indent here
!	eve$$ruler_set_space 		  40	- SPACE: set space here
!	eve$$ruler_advance 		  41	- KP0: Advance
!	eve$$ruler_backup 		  41	- KP1: Backup
!	eve$$ruler_line 		  41	- KP2: Line
!	eve$$ruler_word 		  41	- KP4: Word
!	eve$$ruler_tab 			  42	- TAB
!	eve$$ruler_ctrl_e 		  43	- CTRL/E: End of Line
!	eve$$ruler_ctrl_h 		  43	- CTRL/H: Start of Line
!	eve$$exit_ruler 		  44	- [GOLD]RETURN: exit this ruler
!	eve$$undefined_ruler_key 	  45	- Reject any other ruler key
!	eve$$construct_ruler 		  46	Build a ruler to display
!	eve$$ruler_status 		  47	Create ruler's own status-line
!	eve$$ruled_status 		  48	Ruled buffer's status line
!	eve$$ruler_scale 		  49	Create the ruler scale
!	eve$$ruler_mouse 		  50	Snag mouse events in the ruler
!	eve$$ruler_previous_screen 	  51	Previous screen in ruler help
!	eve$$ruler_next_screen 		  51	Next screen in ruler help
!	eve$define_ruler 		  52	Create a ruler
!	eve$wps_set_direction 		  53	Set direction + enable auto-forward in reverse
!	eve$$undefined_key_wps 		  54	Printable keys during BACKUP
!	eve$wps_tab_pos 		  55	move by tab
!	eve$wps_halt 			  56	GOLD ~ = halt GOLD ADVANCE/BACKUP
!--

! EVE$WPS.TPU 								Page 3

procedure eve_set_keypad_wps		! Define WPS emulation keypad keys

! Turn the WPS keypad on
!
eve$set_wps_keypad;
eve$message (EVE$_WPSON);
return (TRUE);

endprocedure;	! eve_set_keypad_wps

procedure eve$set_wps_keypad		! Set keypad subprocedure

eve$x_bound_cursor := TRUE;			! bound cursor by default
return (eve$set_keypad (eve$x_wps_keys, PF1));	! PF1 = GOLD key

endprocedure;	! eve$set_wps_keypad

! EVE$WPS.TPU 								Page 4

procedure eve_set_keypad_nowps		! Remove WPS keypad keys

return (eve$set_keypad_nowps1);

endprocedure;	! eve_set_keypad_nowps

procedure eve$set_keypad_nowps1	 ! Remove WPS keypad keys
    (; define_do_flag)

! Turn the WPS keypad off
! Parameter: define_do_flag
! = 0 if ok to do only code past call to eve$set_nowps_keypad
! = 1 if ok to call eve$set_nowps_keypad and all code past it
! = 2 or "" or tpu$k_unspecified if ok to do all code

local   the_keypad,
	pointer,
	doit,
	status;

on_error
    [OTHERWISE]:
endon_error;

if (define_do_flag = tpu$k_unspecified) or (define_do_flag = "")
then
    doit := 2;
else
    doit := define_do_flag;
endif;

if doit = 2
then
    the_keypad := eve$current_keypad;
else
    the_keypad := eve$x_wps_keys;	! widget callback after changing keypad
endif;
if the_keypad = eve$x_wps_keys
then
    if doit <> 0
    then
	status := eve$set_nowps_keypad (define_do_flag);
	if status <> eve$k_success
	then
	    return (status);
	endif;
    endif;
    eve$message (EVE$_WPSOFF);
    return (TRUE);
else
    ! Assume EVE keypads are of the form EVE$xxx_KEYS.
    if index (substr (the_keypad, 1, 4), "EVE$") <> 0
    then
	the_keypad := substr (the_keypad, 5, length (the_keypad));
	pointer := index (the_keypad, "_KEYS");
	if (pointer <> 0) and (pointer <> 1)
	then
	    the_keypad := substr (the_keypad, 1, pointer - 1);
	endif;
    endif;
    eve$message (EVE$_WPSNOTNO, 0, the_keypad);
    return (FALSE);			! no learn_abort here
endif;

endprocedure;	! eve$set_keypad_nowps1

! EVE$WPS.TPU 								Page 5

procedure eve$set_nowps_keypad		! Set keypad nowps subprocedure
    (; define_do_flag)

! Parameter
!    define_do_flag = 0 if ok to do only code past call to eve$vt100_keys
!		    = 1 if ok to call eve$vt100_keys and all code past it
!		    = 2 or "" or tpu$k_unspecified if ok to do all code

local   status,
	doit;

on_error
    [TPU$_CONTROLC]:
	eve$set_nowps_keypad;
	eve$learn_abort;
	abort;
    [OTHERWISE]:
endon_error;

if (define_do_flag = tpu$k_unspecified) or (define_do_flag = "")
then
    doit := 2;
else
    doit := define_do_flag;
endif;

if doit = 2
then
    eve$set_keypad_gold_off (eve$x_wps_keys);
endif;

if eve$on_a_pre_lk201
then
    if doit <> 0
    then	! 2 for WPS keypad in eve$init_do_key
	status := eve$vt100_keys (2, define_do_flag);
	if status <> eve$k_success
	then
	    return (status);
	endif;
    endif;
else
    eve$numeric_keys;
endif;
return (TRUE);

endprocedure;	! eve$set_nowps_keypad

! EVE$WPS.TPU 								Page 6

procedure eve_restore_sentence		! Restore sentence

local   the_range,
	here,
	line_left_margin;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_add_text)
then
    return (FALSE);
endif;

if eve$x_restore_sentence = 0
then
    eve$message (EVE$_NOREST);
    eve$learn_abort;
    return (FALSE);
endif;

if not eve$test_if_modifiable (current_buffer)
then
    eve$learn_abort;
    return (FALSE);
endif;

if current_offset = 0
then
    if mark (FREE_CURSOR) <> end_of (current_buffer)
    then	! remember to honor this line's left margin
	line_left_margin := get_info (mark (FREE_CURSOR), "left_margin");
    else
	line_left_margin := get_info (current_buffer, "left_margin");
    endif;
endif;

the_range := eve$insert_text (eve$x_restore_sentence);
if the_range = 0
then
    eve$learn_abort;
    return (FALSE);
endif;

if line_left_margin <> 0
then
    here := mark (NONE);
    position (the_range);
    ! restore line's left margin
    set (RECORD_ATTRIBUTE, mark (FREE_CURSOR), LEFT_MARGIN, line_left_margin);
    position (here);
endif;

if mark (NONE) = end_of (current_buffer)
then
    eve$append_line;
endif;

if current_offset = 0
then
    eve$show_first_line;
endif;

return (TRUE);

endprocedure;	! eve_restore_sentence

! EVE$WPS.TPU 								Page 7

procedure eve$wps_down  		! Down arrow (bound or free)

eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (eve_move_down);

endprocedure;	! eve$wps_down

! EVE$WPS.TPU 								Page 8

procedure eve$wps_up  		! Up arrow in (bound or free cursor)

eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (eve_move_up);

endprocedure;	! eve$wps_up

! EVE$WPS.TPU 								Page 9

procedure eve$wps_left		! Left arrow (bound or free cursor)

eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (eve_move_left);

endprocedure;	! eve$wps_left

! EVE$WPS.TPU 								Page 10

procedure eve$wps_right		! Right arrow (bound or free cursor)

eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (eve_move_right);

endprocedure;	! eve$wps_right

! EVE$WPS.TPU 								Page 11

procedure eve$wps_advance		! WPS advance

eve$wps_set_direction (FORWARD);
return (eve$wps_right);

endprocedure;	! eve$wps_advance

! EVE$WPS.TPU 								Page 12

procedure eve$wps_backup		! WPS backup

eve$wps_set_direction (REVERSE);
return (eve$wps_left);

endprocedure;	! eve$wps_backup

! EVE$WPS.TPU 								Page 13

procedure eve$$case_change	! Change case from mark to current position
    (old_mark)

local   the_case;

on_error
    [OTHERWISE]:
endon_error;

if not (eve$$x_state_array {eve$$k_wps_upper_case} or
	eve$$x_state_array {eve$$k_wps_lower_case})
then
    return (TRUE);
endif;
if (old_mark = mark (NONE))
then
    return (TRUE);
endif;
the_case := UPPER;

if eve$$x_state_array {eve$$k_wps_lower_case}
then
    the_case := LOWER;
endif;

if (old_mark <= mark (NONE))
then					! forward direction (don't chngcase
    move_horizontal (-1);		! of 1st char in next entity)
    change_case (create_range (old_mark, mark (NONE), NONE), the_case);
    move_horizontal (1);
else				! reverse direction
    change_case (create_range (mark (NONE), old_mark, NONE), the_case);
endif;

return (TRUE);

endprocedure;	! eve$$case_change

! EVE$WPS.TPU 								Page 14

procedure eve$wps_lower_case		! WPS lower case

local   lower_range,
	a_range,
	the_index;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_change_case)
then
    return (FALSE);
endif;

eve$wps_set_direction (FORWARD);
lower_range := eve$selection (FALSE,,, eve$x_select_remove_flag,, TRUE);
if lower_range <> 0
then
    if get_info (lower_range, "type") = ARRAY
    then
	! a box selection
	the_index := 1;
	loop
	    a_range := lower_range {the_index};
	    exitif a_range = tpu$k_unspecified;
	    change_case (a_range, LOWER);
	    the_index := the_index + 1;
	endloop;
    else
	! a standard selection
	change_case (lower_range, LOWER);
    endif;
    lower_range := 0;
else
    if (mark (NONE) <> end_of (current_buffer))
    then
	change_case (create_range (mark (NONE), mark (NONE), NONE), LOWER);
    endif;
    move_horizontal (1);
    eve$$x_state_array {eve$$k_wps_lower_case} := TRUE;
    eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
endif;

eve$clear_message;
return (TRUE);

endprocedure;	! eve$wps_lower_case

procedure eve$wps_upper_case		! WPS upper case

local   upper_range,
	a_range,
	the_index;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_change_case)
then
    return (FALSE);
endif;

eve$wps_set_direction (FORWARD);
upper_range := eve$selection (FALSE,,, eve$x_select_remove_flag,, TRUE);
if upper_range <> 0
then
    if get_info (upper_range, "type") = ARRAY
    then
	! a box selection
	the_index := 1;
	loop
	    a_range := upper_range {the_index};
	    exitif a_range = tpu$k_unspecified;
	    change_case (a_range, UPPER);
	    the_index := the_index + 1;
	endloop;
    else
	! a standard selection
	change_case (upper_range, UPPER);
    endif;
    upper_range := 0;
else
    if (mark (NONE) <> end_of (current_buffer))
    then
	change_case (create_range (mark (NONE), mark (NONE), NONE), UPPER);
    endif;
    move_horizontal (1);
    eve$$x_state_array {eve$$k_wps_upper_case} := TRUE;
    eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
endif;

eve$clear_message;
return (TRUE);

endprocedure;	! eve$wps_upper_case

! EVE$WPS.TPU 								Page 15

procedure eve$wps_adv_scroll		! WPS GOLD advance function

on_error
    [OTHERWISE]:
endon_error;

if current_window = eve$prompt_window
then
    return (TRUE);
endif;
if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

eve$wps_set_direction (FORWARD);

scroll (current_window);	! scroll until EOB or any key hit
eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;

return (TRUE);

endprocedure;	! eve$wps_adv_scroll

procedure eve$wps_back_scroll		! WPS GOLD backup function

on_error
    [OTHERWISE]:
endon_error;

if current_window = eve$prompt_window
then
    return (TRUE);
endif;
if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

eve$wps_set_direction (REVERSE);

scroll (current_window);	! scroll until Begin_of_buffer or any key hit
eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;

return (TRUE);

endprocedure;	! eve$wps_back_scroll

! EVE$WPS.TPU 								Page 16

procedure eve$wps_bottom		! WPS go to bottom of document

local   status,
	the_mark;

on_error
    [OTHERWISE]:
endon_error;

the_mark := mark (FREE_CURSOR);
status := eve_bottom;
eve$$case_change (the_mark);		!Change case if we really moved
return (status);

endprocedure;	! eve$wps_bottom

procedure eve$wps_top			! WPS go to top of document

local   status,
	the_mark;

on_error
    [OTHERWISE]:
endon_error;

the_mark := mark (FREE_CURSOR);
status := eve_top;
eve$$case_change (the_mark);		!Change case if we really moved
return (status);

endprocedure;	! eve$wps_top

! EVE$WPS.TPU 								Page 17

procedure eve$$choose_paste_buffer	! Choose a paste buffer

local   ix,
	the_number,
	the_string,
	the_buffer;

on_error
    [OTHERWISE]:
endon_error;

! Use latest repeat count in the array

if eve$x_repeat_count = 0
then
    eve$init_repeat;
endif;
ix := get_info (eve$x_repeat_count, "last");
if ix = tpu$k_unspecified
then
    return (paste_buffer);			! no repeat count
endif;

if eve$x_repeat_types {ix} <> KEYWORD
then
    return (paste_buffer);			! repeat count not for us
endif;

the_number := eve$x_repeat_count {ix};
eve$x_repeat_count {ix} := 1;	! This stops eve$repeat 

if the_number <= 0
then
    return (paste_buffer);
endif;

if the_number > 9
then
    eve$message (EVE$_BADPASTENUM);
    return (FALSE);
endif;

the_string := fao ("PASTE_BUFFER_!UL", the_number);
the_buffer := get_info (BUFFERS, "find_buffer", the_string);
if the_buffer = 0
then
    the_buffer := eve$init_buffer (the_string, "");
endif;

return (the_buffer);

endprocedure;	! eve$$choose_paste_buffer

procedure eve$wps_select		! Select and set Forward

local   status;

on_error
    [OTHERWISE]:
endon_error;

status := eve_select;
if not status
then
    return (FALSE);
endif;
if current_direction <> FORWARD
then
    eve_forward;
endif;
return (TRUE);

endprocedure;	! eve$wps_select

procedure eve$wps_remove 			! Remove into a paste buffer

local   the_paste_buffer;

on_error
    [OTHERWISE]:
endon_error;

if current_buffer = eve$x_bufed_buffer
then
    if eve$$bufed_remove
    then
	return (TRUE);
    else
	eve$learn_abort;
	return (FALSE);
    endif;
endif;

if not eve$declare_intention (eve$k_action_cut)
then
    return (FALSE);
endif;

the_paste_buffer := eve$$choose_paste_buffer;
if the_paste_buffer <> 0
then
    return (eve$$store_remove (the_paste_buffer,
			       get_info (current_buffer, "modifiable")));
endif;

eve$learn_abort;
return (FALSE);

endprocedure;	! eve$wps_remove

procedure eve$wps_replace 				! WPS replace

local   remove_range,
	the_paste_buffer,
	status,
	saved_box_flag;

on_error
    [OTHERWISE]:
	eve$x_box_select_flag := saved_box_flag;
	eve$learn_abort;
endon_error;

if not eve$declare_intention (eve$k_action_modify)
then
    return (FALSE);
endif;

saved_box_flag := eve$x_box_select_flag;
remove_range := eve$selection (TRUE,,, eve$x_select_remove_flag,, TRUE);
if remove_range <> 0
then
    the_paste_buffer := eve$$choose_paste_buffer;
    if the_paste_buffer <> 0
    then
	! delete the selection even if paste buffer is empty
	if get_info (remove_range, "type") = ARRAY
	then
	    ! either a box selection or a standard/find/mouse selection in
	    ! box select mode
	    if not eve$$reserve_scratch_buffer
	    then
		eve$message (EVE$_ILLSCRATCHRES);
		return (FALSE);
	    endif;
	    eve$x_box_select_flag := TRUE;
	    erase (eve$$x_scratch_buffer);
	    position (remove_range {1});
	    eve$$box_cut (remove_range, eve$$x_scratch_buffer,
			  TRUE,		! delete the box
			  FALSE);	! no messages
	    eve$$release_scratch_buffer;
	else
	    erase (remove_range);
	endif;
	if beginning_of (the_paste_buffer) <> end_of (the_paste_buffer)
	then				! avoid clipboard in eve_insert_here
	    status := eve$$insert_here (the_paste_buffer);
	    eve$x_box_select_flag := saved_box_flag;
	    return (status);
	endif;
	eve$x_box_select_flag := saved_box_flag;
	eve$message (EVE$_NOINSERT);
    endif;
endif;

eve$learn_abort;
return (FALSE);

endprocedure;	! eve$wps_replace

! EVE$WPS.TPU 								Page 18

procedure eve$wps_copy 			! WPS copy select range

local   the_paste_buffer;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_copy)
then
    return (FALSE);
endif;

the_paste_buffer := eve$$choose_paste_buffer;
if the_paste_buffer <> 0
then
    return (eve$$store_remove (the_paste_buffer, FALSE));
endif;

eve$learn_abort;
return (FALSE);

endprocedure;	! eve$wps_copy

! EVE$WPS.TPU 								Page 19

procedure eve$wps_insert_here 				! WPS paste

local   the_paste_buffer;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_paste)
then
    return (FALSE);
endif;

the_paste_buffer := eve$$choose_paste_buffer;
if the_paste_buffer <> 0
then
    return (eve$$insert_here (the_paste_buffer));
endif;

eve$learn_abort;
return (FALSE);

endprocedure;	! eve$wps_insert_here

! EVE$WPS.TPU 								Page 20

procedure eve$wps_date_time		! Insert date + time

on_error
    [OTHERWISE]:
endon_error;

if not eve$test_if_modifiable (current_buffer)
then
    eve$learn_abort;
    return (FALSE);
endif;

if not eve$declare_intention (eve$k_action_add_text)
then
    return (FALSE);
endif;

eve$insert_text (fao ('!20%D', 0));	!** Internationalize this

return (TRUE);

endprocedure;	! eve$wps_date_time

! EVE$WPS.TPU 								Page 21

procedure eve$wps_delete_start_sent	! WPS delete to beginning of sentence

local   the_mark,
	saved_mark,
	end_of_range,
	temp,
	temp_range,
	flag,
	punctuation_range,
	symbol_range,
	punctuation_mark,
	symbol_mark;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

if not eve$declare_intention (eve$k_action_erase_to_left)
then
    return (FALSE);
endif;

saved_mark := mark (FREE_CURSOR);

if not get_info (current_window, "beyond_eob")
then
    if not (get_info (current_window, "before_bol") or
	    get_info (current_window, "middle_of_tab"))
    then
	position (TEXT);	! snap to text
    endif;
else
    position (TEXT);	! snap to text
    saved_mark := mark (FREE_CURSOR);
endif;

! fail at beginning of buffer
if mark (NONE) = beginning_of (current_buffer)
then
    position (saved_mark);
    eve$message (EVE$_BOSNOTFOUND);
    eve$learn_abort;
    return (FALSE);
endif;

move_horizontal (-1);
the_mark := mark (NONE);
move_horizontal (1);
end_of_range := mark (NONE);

! Look for 1st sentence delimiter and for 1st symbol character to the left,
! then compare their relative positions.

punctuation_range := search_quietly (any (eve$x_wps_sentence_delimiters),
				     REVERSE);
symbol_range := search_quietly (span (eve$x_symbol_characters), REVERSE);
if punctuation_range <> 0
then
    position (end_of (punctuation_range));
    punctuation_mark := mark (NONE);
endif;
if symbol_range <> 0
then
    position (end_of (symbol_range));
    symbol_mark := mark (NONE);
endif;

if (punctuation_range = 0) and (symbol_range <> 0)
then	! No other end-of-sentence punctuation on this line.
	! Erase backwards to (1st symbol character after start of this line)
    position (LINE_BEGIN);
    temp_range := search_quietly (span (eve$x_symbol_characters), FORWARD);
    if temp_range <> 0
    then
	position (temp_range);
	end_of_range := mark (NONE);
    endif;
endif;

if (punctuation_range <> 0) and (symbol_range = 0)
then	! No other symbol chars on this line.
	! See if there's another end-of_sentence punctuation on this line.
    position (punctuation_mark);
    temp_range := search_quietly (any (eve$x_wps_sentence_delimiters), REVERSE);

    if temp_range = 0
    then	! No other end-of-sentence punctuation on this line.
		! Erase backwards to (1st punctuation after start of this line)
	position (LINE_BEGIN);
	temp_range := search_quietly (any (eve$x_wps_sentence_delimiters),
				      FORWARD);
	if temp_range <> 0
	then
	    position (temp_range);
	    move_horizontal (1);
	    end_of_range := mark (NONE);
	endif;
    else	! Another end-of-sentence punctuation on this line found.
		! Erase backwards to (1st nonwhitespace after that punctuation)
	position (end_of (temp_range));
	temp_range := search_quietly (scan (eve$x_whitespace), FORWARD);
	if temp_range <> 0
	then
	    position (temp_range);
	    end_of_range := mark (NONE);
	endif;
    endif;
endif;

if (punctuation_range <> 0) and (symbol_range <> 0)
then	! Both other symbol chars and punctuation on this line.
	! Compare which is closer.
    if punctuation_mark < symbol_mark
    then    ! End-of-sentence punctuation is before symbols chars.
	    ! Erase backwards to (1st nonwhitespace after that punctuation)
	position (punctuation_mark);
	move_horizontal (1);
	temp_range := search_quietly (scan (eve$x_whitespace), FORWARD);
	if temp_range <> 0
	then
	    position (temp_range);
	endif;
	end_of_range := mark (NONE);
    else    ! End-of-sentence punctuation is after symbols chars.
	    ! See if there's another end-of_sentence punctuation on this line.
	position (punctuation_mark);
	move_horizontal (-1);
	temp_range := search_quietly (any (eve$x_wps_sentence_delimiters),
				      REVERSE);

	if temp_range = 0
	then	! No other end-of-sentence punctuation on this line.
		! Erase backwards to (1st symbol chars after start of this line)
	    position (LINE_BEGIN);
	    temp_range := search_quietly (span (eve$x_symbol_characters),
					  FORWARD);
	    if temp_range <> 0
	    then
		position (temp_range);
		end_of_range := mark (NONE);
	    endif;
	else	! Another end-of-sentence punctuation on this line found.
		! Erase backwards to (1st nonwhitespace after that punctuation)
	    position (end_of (temp_range));
	    if mark (NONE) <> punctuation_mark
	    then
		move_horizontal (1);	! get past the punctuation
	    endif;
	    temp_range := search_quietly (scan (eve$x_whitespace), FORWARD);
	    if temp_range <> 0
	    then
		position (temp_range);
	    endif;
	    end_of_range := mark (NONE);
	endif;
    endif;
endif;

eve$x_restore_sentence := eve$erase_text (create_range (the_mark, end_of_range,
							NONE),
					  eve$x_sentence_buffer, FALSE);

return (TRUE);

endprocedure;	! eve$wps_delete_start_sent

! EVE$WPS.TPU 								Page 22

procedure eve$wps_continue_search	! Continue search

local   no_find_yet;	! Set if nothing to find again

if not eve$find_next (no_find_yet)
then
    if no_find_yet
    then
	eve$learn_abort;
    endif;
    return (FALSE);
endif;

return (TRUE);

endprocedure;	! eve$wps_continue_search

! EVE$WPS.TPU 								Page 23

procedure eve$wps_continue_search_select	! WPS continue search/select

local   status,
	saved_direction,
	the_find,
	how_exact;

on_error
    [TPU$_CONTROLC]:
	if (saved_direction <> current_direction) and
	    (get_info (saved_direction, "type") = KEYWORD)
	then
	    set (saved_direction, current_buffer);
	endif;
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	if (saved_direction <> current_direction) and
	    (get_info (saved_direction, "type") = KEYWORD)
	then
	    set (saved_direction, current_buffer);
	endif;
endon_error;

if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

saved_direction := current_direction;

eve$clear_select_position;
eve$$remove_found_range;		! Remove current found range
saved_direction := current_direction;
status := eve$get_find_target (eve$x_target, how_exact, 0);
if status
then
    the_find := eve$find_target (how_exact, 0, 1);
    status := eve$remember_found (the_find);
else
    eve$learn_abort;	! eve$find_target does its own learn_abort
endif;
if not status
then
    return (FALSE);
endif;
if (the_find <> 0)
then
    position (beginning_of (the_find));
    eve$x_select_position := select (eve$x_highlighting);
    position (end_of (the_find));
    if (mark (NONE) <> end_of (current_buffer))
    then
	move_horizontal (1);
    endif;
endif;
eve$x_old_find_direction := current_direction;
set (saved_direction, current_buffer);

return (TRUE);

endprocedure;	! eve$wps_continue_search_select

! EVE$WPS.TPU 								Page 24

procedure eve$wps_word			! WPS move by word

local   status,
	the_mark,
	saved_mark;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

if not eve$declare_intention (eve$k_action_short_move)
then
    return (FALSE);
endif;

saved_mark := mark (FREE_CURSOR);

if not get_info (current_window, "bound")
then
    if get_info (current_window, "beyond_eob")
    then
	position (TEXT);		! snap to text
	return (TRUE);
    else
	if get_info (current_window, "before_bol")
	then
	    position (TEXT);		! snap to text at left margin
	    if current_direction = REVERSE
	    then
		move_horizontal (-1);	! force error if at BOB
	    endif;
	    return (TRUE);
	else
	    if get_info (current_window, "middle_of_tab")
	    then
		position (TEXT);		! snap to text (left of tab)
		if current_direction = FORWARD
		then
		    move_horizontal (1);	! move right over tab
		else
		    saved_mark := mark (FREE_CURSOR);
		    move_horizontal (-1);	! move left off of tab
		endif;
		return (TRUE);
	    else		! beyond_eol
		position (TEXT);		! snap to text at EOL
	    endif;
	endif;
    endif;
endif;

the_mark := mark (NONE);
loop
    if (mark (NONE) = end_of (current_buffer))
    then
	if current_direction = FORWARD
	then
	    move_horizontal (1);	! force error message at bottom
	endif;
    endif;
    if (mark (NONE) = beginning_of (current_buffer))
    then
	if current_direction = REVERSE
	then
	    saved_mark := mark (FREE_CURSOR);
	    move_horizontal (-1);	! force error message at top
	endif;
    endif;
    status := eve_move_by_word;

    ! stop moving if we're on a word (not a separator, EOL)
    exitif (mark (FREE_CURSOR) = end_of (current_buffer)) or
	(mark (FREE_CURSOR) = beginning_of (current_buffer));
    exitif (index (eve$$x_word_separators, current_character) = 0) and
	(current_character <> "");
    exitif (eve$in_prompting_window and (current_character = ""));
endloop;

eve$$case_change (the_mark);		! Change case if we really moved
return (status);

endprocedure;	! eve$wps_word

procedure eve$wps_line			! WPS line

local   status,
	saved_mark;

on_error
    [OTHERWISE]:
endon_error;

saved_mark := mark (FREE_CURSOR);
status := eve$edt_line;
eve$$case_change (saved_mark);		!Change case if we really moved
return (status);

endprocedure;	! eve$wps_line

! EVE$WPS.TPU 								Page 25

procedure eve$wps_sentence		! WPS sentence

local   the_target,
	the_find,
	saved_mark;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

saved_mark := mark (FREE_CURSOR);
the_find := search_quietly (eve$x_wps_pattern_sentence, current_direction);
if (the_find <> 0)
then
    position (the_find);
    if (current_direction = REVERSE)
    then
	! We're on the end of the previous sentence, now move to the
	! beginning of it (go backwards to end of previous sentence, and
	! then forward to the beginning of this one).
	if (mark (NONE) <> beginning_of (current_buffer))
	then
	    move_horizontal (-1);
	    the_target := search_quietly (eve$x_wps_pattern_sentence, REVERSE);
	    if (the_target <> 0)
	    then
		position (the_target);
	    else
		position (beginning_of (current_buffer));
	    endif;
	endif;
    endif;
    ! We've found end of sentence, now move to start of the next sentence.
    the_find := search_quietly (eve$x_wps_pattern_symbols, FORWARD);
    if (the_find <> 0)
    then
	position (the_find);
    else
	position (end_of (current_buffer));
    endif;
    eve$$case_change (saved_mark);		!Change case if we really moved
    return (TRUE);
else
    if (current_direction = REVERSE)
    then
	position (beginning_of (current_buffer));
    else
	if (current_direction = FORWARD)
	then
	    position (end_of (current_buffer));
	endif;
    endif;
    eve$message (EVE$_EOSNOTFOUND);
    eve$learn_abort;
    return (FALSE);
endif;

endprocedure;

! EVE$WPS.TPU 								Page 26

procedure eve$wps_paragraph		! WPS next paragraph

local   saved_mark;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

! An EVE paragraph_break is the blank line above the 1st line of text in the
! paragraph.

saved_mark := mark (FREE_CURSOR);
if (current_direction = FORWARD)
then
    if saved_mark = end_of (current_buffer)
    then
	move_vertical (1);	! force error message + return
    endif;
else
    if (current_direction = REVERSE)
    then
	if saved_mark = beginning_of (current_buffer)
	then
	    move_vertical (-1);	! force error message + return
	endif;
    endif;
endif;

position (LINE_BEGIN);
if (current_direction = FORWARD)
then
    if mark (NONE) = end_of (current_buffer)
    then
	return (TRUE);
    endif;
    loop
	exitif (mark (NONE) = end_of (current_buffer));
	position (LINE_END);
	move_horizontal (1);
	exitif eve$paragraph_break;
    endloop;
    loop
	exitif (mark (NONE) = end_of (current_buffer));
	position (LINE_END);
	move_horizontal (1);
	exitif not eve$paragraph_break;
    endloop;
else
    if mark (NONE) = beginning_of (current_buffer)
    then
	return (TRUE);
    else
	if eve$paragraph_break
	then
	    loop	! move up to non-break (skipping over all breaks)
		exitif (mark (NONE) = beginning_of (current_buffer));
		move_vertical (-1);
		position (LINE_BEGIN);
		exitif not eve$paragraph_break;
	    endloop;
	else
	    move_vertical (-1);
	    position (LINE_BEGIN);
	    if eve$paragraph_break
	    then	! we were on 1st line of text in para
		loop
			! move up to non - break (skipping over all breaks)
		    exitif (mark (NONE) = beginning_of (current_buffer));
		    move_vertical (-1);
		    position (LINE_BEGIN);
		    exitif not eve$paragraph_break;
		endloop;
	    endif;
	endif;
	loop	! move up to start of paragraph we're in
	    exitif (mark (NONE) = beginning_of (current_buffer));
	    move_vertical (-1);
	    position (LINE_BEGIN);
	    exitif eve$paragraph_break;
	endloop;
	if mark (NONE) <> beginning_of (current_buffer)
	then
	    position (LINE_END);
	    move_horizontal (1); ! now move down to start of text in this para
	endif;
    endif;
endif;

eve$$case_change (saved_mark);

return (TRUE);

endprocedure;	! eve$wps_paragraph

! EVE$WPS.TPU 								Page 27

procedure eve$wps_page			! WPS page

local   status,
	saved_mark;

on_error
    [OTHERWISE]:
endon_error;

saved_mark := mark (FREE_CURSOR);
status := eve_move_by_page;
eve$$case_change (saved_mark);		!Change case if we really moved
return (status);

endprocedure;	! eve$wps_page

! EVE$WPS.TPU 								Page 28

procedure eve$wps_page_marker		! Page marker (GOLD/P) soft FF

on_error
    [TPU$_NOEOBSTR]:    ! prevent current_character error at EOB
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_page_break)
then
    return (FALSE);
endif;

if not eve$test_if_modifiable (current_buffer)
then
    eve$learn_abort;
    return (FALSE);
endif;

if eve$in_prompting_window
then
    copy_text (ascii (12) + ascii (0));
    return (TRUE);
endif;

if current_offset <> 0
then
    split_line;
endif;

if current_character = ""
then
    copy_text (ascii (12) + ascii (0));
    move_horizontal (1);
else
    eve$insert_text (ascii (12) + ascii (0));
    split_line;
endif;

return (TRUE);

endprocedure;	! eve$wps_page_marker

! EVE$WPS.TPU 								Page 29

procedure eve_paginate				! Paginate

return (eve$wps_paginate);

endprocedure;	! eve_paginate

procedure eve$wps_paginate			! GOLD/PAGE - paginate

local   start_page,
	end_page,
	saved_left_margin,
	already_there,
	the_page_break,
	hard_range,
	soft_range;

on_error
    [TPU$_CONTROLC]:
	if saved_left_margin <> 0
	then
	    set (LEFT_MARGIN, current_buffer, saved_left_margin);
	endif;
	eve$learn_abort;
	abort;
    [TPU$_ENDOFBUF, TPU$_BEGOFBUF]:
    [OTHERWISE]:
	if saved_left_margin <> 0
	then
	    set (LEFT_MARGIN, current_buffer, saved_left_margin);
	endif;
endon_error;

if not eve$declare_intention (eve$k_action_paginate)
then
    return (FALSE);
endif;

eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
eve$wps_set_direction (FORWARD);	!*** WPS does this, DPE doesn't--WPS+?

if not eve$test_if_modifiable (current_buffer)
then
    eve$learn_abort;
    return (FALSE);
endif;

start_page := search_quietly ((LINE_BEGIN + (ascii (12) + (ascii (0) | "")) +
			       LINE_END) |
			      (ascii (12) + (ascii (0) | "")),
			      REVERSE, EXACT);
if start_page = 0
then
    start_page := beginning_of (current_buffer);
    position (start_page);
    move_vertical (eve$$x_page_size);
else
    position (start_page);
    move_vertical (eve$$x_page_size + 1);
endif;

position (LINE_BEGIN);
already_there := (search_quietly (ANCHOR + PAGE_BREAK, FORWARD, EXACT) <> 0);
move_horizontal (-1);
end_page := mark (NONE);

position (start_page);
loop
    move_horizontal (1);
    the_page_break := search_quietly ((LINE_BEGIN +
				       ((ascii (12) + ascii (0) @ soft_range) |
					(ascii (12) @ hard_range)) +
				       LINE_END) |
				      ((ascii (12) + ascii (0) @ soft_range) |
				       (ascii (12) @ hard_range)),
				      FORWARD,
				      NO_EXACT,
				      create_range (mark (NONE), end_page,
						    NONE));
    exitif the_page_break = 0;
    if get_info (hard_range, "type") = RANGE
    then				! Found an intervening hard FF
	position (beginning_of (the_page_break));
	move_horizontal (-1);
	end_page := mark (NONE);
	already_there := TRUE;
	exitif 1;
    else				! Found a soft one
	if the_page_break <> soft_range
	then				! Soft FF on a line by itself
	    position (end_page);
	    move_vertical (1);
	    position (LINE_END);
	    end_page := mark (NONE);
	    position (the_page_break);
	endif;
	erase (the_page_break);
    endif;
endloop;

position (end_page);
move_horizontal (1);

if mark (NONE) <> end_of (current_buffer)
then
    if not already_there
    then
	saved_left_margin := get_info (current_buffer, "left_margin");
	set (LEFT_MARGIN, current_buffer, 1);
	split_line;
	move_horizontal (-1);
	eve$insert_text (ascii (12) + ascii (0));
	move_horizontal (1);
	set (LEFT_MARGIN, current_buffer, saved_left_margin);
    else
	position (LINE_END);
	move_horizontal (1);
    endif;
endif;

eve$position_in_middle (mark (NONE));

return (TRUE);

endprocedure;	! eve$wps_paginate

! EVE$WPS.TPU 								Page 30

procedure eve$wps_next_screen		! WPS next screen

local   status;

status := eve_next_screen;
eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (status);

endprocedure;	! eve$wps_next_screen

procedure eve$wps_previous_screen	! WPS previous screen

local   status;

status := eve_previous_screen;
eve$$x_state_array {eve$$k_wps_upper_case} := FALSE;
eve$$x_state_array {eve$$k_wps_lower_case} := FALSE;
return (status);

endprocedure;	! eve$wps_previous_screen

! EVE$WPS.TPU 								Page 31

procedure eve$wps_right_angle		! WPS <>

! find the next > without altering the Cont Srch find string (eve$x_target)

local   saved_target,
	saved_mark,
	the_target,
	the_find;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	if saved_target <> 0
	then
	    eve$x_target := saved_target;
	endif;
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
	if saved_target <> 0
	then
	    eve$x_target := saved_target;
	endif;
endon_error;

if not eve$declare_intention (eve$k_action_reposition)
then
    return (FALSE);
endif;

saved_mark := mark (FREE_CURSOR);

position (TEXT);	! snap to text

saved_target := eve$x_target;	! don't blow away the old target
eve$x_target := ">";

if current_direction = REVERSE
then
    if (mark (NONE) <> beginning_of (current_buffer))
    then
	move_horizontal (-1);
    endif;
endif;

the_find := eve$find_target (EXACT, 0, 1);	! does eve$learn_abort if fails

eve$x_target := saved_target;
if (the_find <> 0)
then
    if (mark (NONE) <> end_of (current_buffer))
    then
	move_horizontal (1);
    endif;
else
    if current_direction = REVERSE
    then
	if (mark (NONE) <> end_of (current_buffer))
	then
	    move_horizontal (1);	! adjust for initial m_h(-1)
	endif;
    endif;
endif;

if (the_find = 0)
then
    position (saved_mark);
    return (FALSE);
else
    return (TRUE);
endif;

endprocedure;	! eve$wps_right_angle

procedure eve$wps_swap			! WPS swap characters

local   the_buf,
	old_mode,
	the_char;

on_error
    [OTHERWISE]:
	if old_mode <> 0
	then
	    set (old_mode, the_buf);
	endif;
endon_error;

if not eve$declare_intention (eve$k_action_modify)
then
    return (FALSE);
endif;

the_buf := current_buffer;
if get_info (the_buf, "record_number") <= get_info (the_buf, "record_count")
then
    if get_info (the_buf, "middle_of_tab")
    then
        position (text);  ! snap to tab
    else
        if not get_info (the_buf, "bound")
	then
	    return true;  ! No characters to swap
	endif;
    endif;
    the_char := erase_character (1);
    if the_char = ""
    then 
        return TRUE;
    endif;
    move_horizontal (1);
    old_mode := set (INSERT, the_buf);
    copy_text (the_char);
    set (old_mode, the_buf);
    move_horizontal (-1);
endif;

return (TRUE);
endprocedure;	! eve$wps_swap

! EVE$WPS.TPU 								Page 32

procedure eve$$display_ruler		! GOLD/R: Display and modify ruler

! Display a ruler at the bottom of the current window.  Make the ruler window
! look like it's put over the bottom 2 lines of the current window by
!   1. making the ruler window's status line look like the current window's
!      status line
!   2. making the ruled window's status line look like the special graphics
!      line in the ruler
! Thusly:
!      1---|---1|0---|---2|0---|..............8| <--- ruled window status line
!      L	T	T	..............R  <--- ruler buffer text
!       BUFFER FOO.BAR ........|Insert| Forward  <--- ruler window status line

local   this_buffer,		! Local version of current_buffer
	this_window,		! Local version of current_window
	how_shifted,		! Amount that ruled window is shifted by
	the_bottom,		! Bottom of ruled window
	enter_column,		! Current_column when we started
	the_width,		! Width of the ruler needed
	adjust_lines;		! Distance to move the ruler by

on_error
    [TPU$_CONTROLC]:
	eve$$exit_ruler;	! clean up the status line
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$exit_ruler;	! clean up the status line
endon_error;

eve$check_bad_window;
enter_column := current_column;
this_buffer := current_buffer;
this_window := current_window;

if get_info (eve$$x_ruler_window, "type") <> WINDOW
then
    eve$$x_ruler_window := create_window (get_info (SCREEN, "visible_length")
					  - 3, 2, ON);
else
    if get_info (eve$$x_ruler_window, "buffer") <> 0
    then
	eve$$exit_ruler;
    endif;
endif;

eve$$x_ruled_buffer := this_buffer;
eve$$x_ruled_window := this_window;

if not eve$key_map_list_exists ("eve$$ruler_mouse_list")
then
    create_key_map ("EVE$$RULER_MOUSE");
    create_key_map_list ("EVE$$RULER_MOUSE_LIST", "EVE$$RULER_MOUSE");
    set (UNDEFINED_KEY, "EVE$$RULER_MOUSE_LIST", "eve$$ruler_mouse");
endif;
set (KEY_MAP_LIST, "EVE$$RULER_MOUSE_LIST", eve$$x_ruler_window);

if get_info (eve$$x_ruler_buffer, "type") <> BUFFER
then
    if eve$$x_buf_str_wps_ruler = tpu$k_unspecified
    then
	eve$$x_buf_str_wps_ruler := "$WPS$Ruler$";
    endif;
    eve$$x_ruler_buffer := eve$init_buffer (eve$$x_buf_str_wps_ruler,
					    "[End of ruler]");
endif;

%if eve$x_option_decwindows
%then

if eve$x_decwindows_active
then
    the_bottom := get_info (eve$$x_ruled_window, "visible_bottom") +
		  (get_info (eve$$x_ruled_window, "scroll_bar", VERTICAL) <> 0);
else
    the_bottom := get_info (eve$$x_ruled_window, "visible_bottom");
endif;

%else
the_bottom := get_info (eve$$x_ruled_window, "visible_bottom");
%endif

! ruled window status line floats to above the ruler window

map (eve$$x_ruler_window, eve$$x_ruler_buffer);

adjust_lines := the_bottom - get_info (eve$$x_ruler_window, "visible_bottom");
adjust_window (eve$$x_ruler_window, adjust_lines, adjust_lines);

the_width := get_info (eve$$x_ruled_window, "width");

! Set-up status-lines

eve$set_fixed_status_line (eve$$x_ruler_buffer,
			   compile ("return eve$$ruler_status"));
eve$set_fixed_status_line (eve$$x_ruled_buffer,
			   compile ("return eve$$ruled_status"));

eve$set_status_line (eve$$x_ruler_window);
eve$set_status_line (eve$$x_ruled_window);

! now build the ruler

erase (eve$$x_ruler_buffer);
set (OVERSTRIKE, eve$$x_ruler_buffer);
copy_text (" " * (the_width + how_shifted));

eve$$construct_ruler;

set (KEY_MAP_LIST, eve$$x_ruler_list, eve$$x_ruler_buffer);

eve$$x_state_array {eve$$k_ruler_margin_changed} := FALSE;

    ! start in same column as in user buffer

position (beginning_of (eve$$x_ruler_buffer));
move_horizontal (enter_column + how_shifted - 1);
return (TRUE);

endprocedure;	! eve$$display_ruler

! EVE$WPS.TPU 								Page 33

procedure eve$$save_ruler		! - Shift 0-9: Save a ruler
    (ruler_no)

! ruler_no = 0-9 for main-keyboard-SHIFT-key + 0-9 (like WPS)
!	   = -1  for "S" or "s" + 0-9 (like DPE)

local   the_key,
	the_ruler;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

the_ruler := ruler_no;
if ruler_no = -1
then	! DPE's save ruler
    the_key := eve$alphabetic (eve$prompt_key
			       (message_text (EVE$_RULERNUM)));
    if index ("0123456789", the_key) = 0
    then
	eve$message (EVE$_BADRULERNUM);
	eve$learn_abort;
	return (FALSE);
    endif;
    the_ruler := int (the_key);
endif;
if (the_ruler < 0)
    or (the_ruler > 9)
then
    eve$message (EVE$_BADRULERNUM);
    eve$learn_abort;
    return (FALSE);
endif;

eve$$x_ruler_left_margin := get_info (eve$$x_ruled_buffer, "left_margin");
eve$$x_ruler_right_margin := get_info (eve$$x_ruled_buffer, "right_margin");
eve$$x_ruler_tab_stops := get_info (eve$$x_ruled_buffer, "tab_stops");

eve$$x_ruler_left_margin_array {the_ruler} := eve$$x_ruler_left_margin;
eve$$x_ruler_right_margin_array {the_ruler} := eve$$x_ruler_right_margin;
eve$$x_ruler_tab_stops_array {the_ruler} := eve$$x_ruler_tab_stops;


eve$$x_ruler_word_wrap_array {the_ruler} := eve$$x_word_wrap_indent
					    {eve$$x_ruled_buffer};

eve$$x_ruler_paragraph_array {the_ruler} := eve$$x_paragraph_indent
					    {eve$$x_ruled_buffer};

eve$message (EVE$_RULERSAVED, 1, the_ruler);
return (TRUE);

endprocedure;	! eve$$save_ruler

! EVE$WPS.TPU 								Page 34

procedure eve$$get_ruler	    	! - 0-9: recall a saved ruler
    (ruler_no)

! Get a ruler into the ruler buffer, and apply the ruler's margins and
! tab stops to the ruled buffer.

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

if (ruler_no < 0)
    or (ruler_no > 9)
then
    eve$message (EVE$_BADRULERNUM);
    eve$learn_abort;
    return (FALSE);
endif;

eve$$x_ruler_left_margin := eve$$x_ruler_left_margin_array {ruler_no};
eve$$x_ruler_right_margin := eve$$x_ruler_right_margin_array {ruler_no};
eve$$x_ruler_tab_stops := eve$$x_ruler_tab_stops_array {ruler_no};

eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := eve$$x_ruler_word_wrap_array
						 {ruler_no};

eve$$x_paragraph_indent {eve$$x_ruled_buffer} := eve$$x_ruler_paragraph_array
						 {ruler_no};

if (eve$$x_ruler_left_margin = -1) or
    (eve$$x_ruler_right_margin = -1)
then
    eve$message (EVE$_RULERNOTSAVED, 0, ruler_no);
    return;
endif;

set (MARGINS, eve$$x_ruled_buffer, eve$$x_ruler_left_margin,
     eve$$x_ruler_right_margin);
if eve$$x_ruler_tab_stops <> get_info (eve$$x_ruled_buffer, "tab_stops")
then	! always set tabs in the user's buffer to the current ruler
    set (TAB_STOPS, eve$$x_ruled_buffer, eve$$x_ruler_tab_stops);
endif;

eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
eve$message (EVE$_RULERRECALLED, 0, ruler_no);
return (TRUE);

endprocedure;	! eve$$get_ruler

! EVE$WPS.TPU 								Page 35

procedure eve$$ruler_set_tab_stop		! - T: set a tab stop here

local   new_tab_integer,
	tab_setting,
	tab_string,
	tab_location,
	the_length,
	the_left_margin,
	the_right_margin,
	how_shifted,
	pointer,
	start_mark,
	the_column;

on_error
    [OTHERWISE]:
endon_error;

new_tab_integer := current_offset + 1;

    ! get old tab_stop setting, and add new one

the_left_margin := get_info (eve$$x_ruled_buffer, "left_margin");
the_right_margin := get_info (eve$$x_ruled_buffer, "right_margin");
tab_setting := get_info (eve$$x_ruled_buffer, "tab_stops");
how_shifted := get_info (eve$$x_ruled_window, "shift_amount");
the_length := get_info (eve$$x_ruler_window, "width") + how_shifted;

if (new_tab_integer >= the_right_margin)
then	! too big
    eve$message (EVE$_TABTOOBIG);
    eve$learn_abort;
    return (FALSE);
endif;
if (new_tab_integer = 1)
then	! col 1
    eve$message (EVE$_TABTOOSMALL);
    eve$learn_abort;
    return (FALSE);
endif;

eve$clear_message;

if get_info (tab_setting, "type") = INTEGER
then
	! convert tabs-every to tabs-at
    tab_string := "";
    tab_location := 1;
    loop
	tab_location := tab_location + tab_setting;
	exitif (tab_location) > the_length;
	exitif (tab_location >= the_right_margin);
	if (tab_location > the_left_margin)
	then
	    tab_string := tab_string + " " + str (tab_location);
	endif;
    endloop;
    tab_setting := substr (tab_string, 2, length (tab_string) - 1);
endif;

tab_setting := tab_setting + " ";	! insure all have a space after them
tab_string := tab_setting;

    ! add the new_tab stop to the string

start_mark := 1;
pointer := index (tab_setting, " ");
loop
    the_column := substr (tab_setting, start_mark,
			  pointer - start_mark);
    if (int (the_column) = new_tab_integer)
    then  ! same column, remove TAB
	tab_string := substr (tab_setting, 1, start_mark - 1) +
		      substr (tab_setting, pointer,
			      length (tab_setting));
	exitif;
    endif;

    if (int (the_column) > the_left_margin) and
	(int (the_column) > new_tab_integer)
    then
	tab_string := substr (tab_setting, 1, start_mark - 1) +
		      str (new_tab_integer) + " " +
		      substr (tab_setting, start_mark,
			      length (tab_setting));
	exitif;
    endif;
    start_mark := pointer + 1;
    pointer := start_mark - 1 + index (substr (tab_setting, start_mark,
					       length (tab_setting)), " ");
    if pointer < start_mark
    then
	tab_string := tab_setting + str (new_tab_integer); ! new biggest tab
	exitif;
    endif;
endloop;

if substr (tab_string, length (tab_string), 1) = " "
then
    tab_string := substr (tab_string, 1, length (tab_string) - 1);
endif;

    ! make change visible
eve$$x_ruler_tab_stops := tab_string;
set (TAB_STOPS, eve$$x_ruled_buffer, eve$$x_ruler_tab_stops);
eve$$construct_ruler;
eve$message (EVE$_NEWTABS);
return (TRUE);

endprocedure;	! eve$$ruler_set_tab_stop

! EVE$WPS.TPU 								Page 36

procedure eve$$ruler_set_left_margin		! - L: set left margin here

local   the_cur_char,
	new_left;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

new_left := current_offset + 1;
set (MARGINS, eve$$x_ruled_buffer, new_left,
     get_info (eve$$x_ruled_buffer, "right_margin"));

the_cur_char := current_character;

!check current character here if it is W or P make it unspecified

if (the_cur_char = "W") or (the_cur_char = "w")
then
    eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

if (the_cur_char = "P") or (the_cur_char = "p")
then
    eve$$x_paragraph_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
return (TRUE);

endprocedure;	! eve$$ruler_set_left_margin

! EVE$WPS.TPU 								Page 37

procedure eve$$ruler_set_right_margin		! - R: set right margin here

local   new_right,
	the_cur_char;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

new_right := current_offset + 1;
set (MARGINS, eve$$x_ruled_buffer,
     get_info (eve$$x_ruled_buffer, "left_margin"), new_right);

the_cur_char := current_character;
!check current character here if it is W or P make it unspecified

if (the_cur_char = "W") or (the_cur_char = "w")
then
    eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

if (the_cur_char = "P") or (the_cur_char = "p")
then
    eve$$x_paragraph_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;


eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
return (TRUE);

endprocedure;	! eve$$ruler_set_right_margin

! EVE$WPS.TPU 								Page 38

procedure eve$$ruler_set_word_wrap     ! - W: set word wrap marker here

local   the_cur_char;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := current_offset + 1;

the_cur_char := current_character;

!check current character here if it is P make it unspecified
!if it was an L or an R don't type out W and make it unspecified

if (the_cur_char = "P") or (the_cur_char = "p")
then
    eve$$x_paragraph_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

if (the_cur_char = "L") or (the_cur_char = "l") or (the_cur_char = "r")
    or
    (the_cur_char = "R")
then
    eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
return (TRUE);

endprocedure;	! eve$$ruler_set_word_wrap

! EVE$WPS.TPU 								Page 39

procedure eve$$ruler_set_paragraph     ! - P or I: set paragraph indent here

local   the_cur_char;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

eve$$x_paragraph_indent {eve$$x_ruled_buffer} := current_offset + 1;

the_cur_char := current_character;

!check current character here if it is W make it unspecified
!if it was an L or an R don't type out P and make it unspecified

if (the_cur_char = "W") or (the_cur_char = "w")
then
    eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

if (the_cur_char = "L") or (the_cur_char = "l") or (the_cur_char = "r")
    or
    (the_cur_char = "R")
then
    eve$$x_paragraph_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
return (TRUE);

endprocedure;	! eve$$ruler_set_paragraph

! EVE$WPS.TPU 								Page 40

procedure eve$$ruler_set_space		! - SPACE: set space here

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

if eve$$x_word_wrap_indent {eve$$x_ruled_buffer} = current_offset + 1
then
    eve$$x_word_wrap_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

if eve$$x_paragraph_indent {eve$$x_ruled_buffer} = current_offset + 1
then
    eve$$x_paragraph_indent {eve$$x_ruled_buffer} := tpu$k_unspecified;
endif;

eve$$construct_ruler;
eve$$x_state_array {eve$$k_ruler_margin_changed} := TRUE;
return (TRUE);

endprocedure;	! eve$$ruler_set_space

! EVE$WPS.TPU 								Page 41

procedure eve$$ruler_advance			! - KP0: Advance

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

set (FORWARD, eve$$x_ruler_buffer);
if current_offset < length (current_line)
then
    move_horizontal (1);
endif;
return (TRUE);

endprocedure;	! eve$$ruler_advance

procedure eve$$ruler_backup			! - KP1: Backup

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

set (REVERSE, eve$$x_ruler_buffer);
if current_offset > get_info (eve$$x_ruler_window, "shift_amount")
then
    move_horizontal (-1);
endif;
return (TRUE);

endprocedure;	! eve$$ruler_backup

procedure eve$$ruler_line			! - KP2: Line

on_error
    [OTHERWISE]:
endon_error;

if get_info (eve$$x_ruler_buffer, "direction") = FORWARD
then
    return (eve$$ruler_ctrl_e);
else
    return (eve$$ruler_ctrl_h);
endif;

endprocedure;	! eve$$ruler_line

procedure eve$$ruler_word			! - KP4: Word

local   ptr,
	the_direction;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

the_direction := get_info (eve$$x_ruler_buffer, "direction");
if the_direction = FORWARD
then
    move_horizontal (1);
else
    if current_offset <> 0
    then
	move_horizontal (-1);
    endif;
endif;

ptr := search_quietly (notany (eve$$x_word_separators), the_direction);
if ptr <> 0
then
    position (ptr);
else
    if the_direction = FORWARD
    then
	move_horizontal (-1);
    else
	move_horizontal (1);
    endif;
endif;
return (TRUE);

endprocedure;	! eve$$ruler_word

! EVE$WPS.TPU 								Page 42

procedure eve$$ruler_tab			! - TAB

local   ptr,
	the_direction;

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

the_direction := get_info (eve$$x_ruler_buffer, "direction");
if the_direction = FORWARD
then
    move_horizontal (1);
else
    move_horizontal (-1);
endif;

ptr := search_quietly ("T", the_direction);
if ptr <> 0
then
    position (ptr);
else
    if the_direction = FORWARD
    then			! move back
	move_horizontal (-1);
    else
	move_horizontal (1);
    endif;
endif;
return (TRUE);

endprocedure;	! eve$$ruler_tab

! EVE$WPS.TPU 								Page 43

procedure eve$$ruler_ctrl_e			! - CTRL/E: End of Line

on_error
    [OTHERWISE]:
endon_error;

eve$clear_message;

position (LINE_END);
if current_offset > 0
then
    move_horizontal (-1);
endif;
return (TRUE);

endprocedure;	! eve$$ruler_ctrl_e

procedure eve$$ruler_ctrl_h			! - CTRL/H: Start of Line

eve$clear_message;

position (LINE_BEGIN);
return (TRUE);

endprocedure;	! eve$$ruler_ctrl_h

! EVE$WPS.TPU 								Page 44

procedure eve$$exit_ruler		! - [GOLD]RETURN: exit this ruler

on_error
    [TPU$_CONTROLC]:
	eve$$exit_ruler;		! CTRL/C after we're done, thank you
	eve$learn_abort;
	abort;
    [OTHERWISE]:
endon_error;

set (KEY_MAP_LIST, eve$x_key_map_list, eve$$x_ruler_buffer);

if current_window = eve$$x_ruler_window
then
    eve$$restore_position (eve$$x_ruled_buffer, eve$$x_ruled_window);
endif;

eve$unmap_if_mapped (eve$$x_ruler_window);

eve$set_fixed_status_line (eve$$x_ruler_buffer, "");
eve$set_fixed_status_line (eve$$x_ruled_buffer, "");

if get_info (eve$$x_ruled_window, "type") = WINDOW
then
    set (STATUS_LINE, eve$$x_ruled_window, NONE, " ");
endif;

eve$set_status_line (eve$$x_ruled_window);

if eve$$x_state_array {eve$$k_ruler_margin_changed}
then
    eve$message (EVE$_USEFILL);
else
    eve$clear_message;
endif;
return (TRUE);

endprocedure;	! eve$$exit_ruler

! EVE$WPS.TPU 								Page 45

procedure eve$$undefined_ruler_key		! - Reject any other ruler key

local   the_topic,
	the_char;

on_error
    [OTHERWISE]:
endon_error;

the_topic := eve$$lookup_comment (last_key, "");
if (length (the_topic) <> 0)
then
    if eve$test_synonym ("help", eve$$lookup_comment (last_key, ""))
    then
	return (eve_help ("ruler keys"));
    endif;
endif;
the_char := eve$alphabetic (last_key);
change_case (the_char, UPPER);
case the_char
	!
	! All the legal codes, regardless of whether they are implemented
	!
    [".", ">", "C", "D", "F", "H", "I", "J", "L", "N", "P", "R", "T",
	"=", "W"]:
	eve$message (EVE$_FORMATNOSUPORT, 0, the_char);
    [OTHERWISE]:
	eve$message (EVE$_RETEXITSRULER);
endcase;
return (TRUE);

endprocedure;	! eve$$undefined_ruler_key

! EVE$WPS.TPU 								Page 46

procedure eve$$construct_ruler		! Build a ruler to display

local   saved_mark,
	tab_setting,
	the_length,
	the_left_margin,
	the_right_margin,
	the_word_wrap,
	the_space,
	how_shifted,
	pointer,
	the_column;

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

saved_mark := mark (FREE_CURSOR);

the_left_margin := get_info (eve$$x_ruled_buffer, "left_margin");
the_right_margin := get_info (eve$$x_ruled_buffer, "right_margin");
tab_setting := get_info (eve$$x_ruled_buffer, "tab_stops");
how_shifted := get_info (eve$$x_ruled_window, "shift_amount");

the_length := get_info (eve$$x_ruler_window, "width") + how_shifted;

position (beginning_of (eve$$x_ruler_buffer));
set (OVERSTRIKE, eve$$x_ruler_buffer);
copy_text (fao ("!#* ", the_length));

shift (eve$$x_ruler_window, how_shifted - get_info (eve$$x_ruler_window,
						    "shift_amount"));

if get_info (tab_setting, "type") = INTEGER
then
    position (LINE_BEGIN);
    loop
	exitif (current_offset + tab_setting) >= the_length;
	exitif (current_offset + tab_setting) >= the_right_margin;
	move_horizontal (tab_setting);
	if (current_offset > the_left_margin)
	then
	    copy_text ("T");
	    move_horizontal (-1);
	endif;
    endloop;
else
    loop
	exitif tab_setting = "";
	pointer := index (tab_setting, " ");
	if pointer = 0
	then
	    pointer := length (tab_setting) + 1;
	endif;
	the_column := int (substr (tab_setting, 1, pointer - 1));
	exitif the_column >= the_length;
	tab_setting := substr (tab_setting, pointer + 1,
			       length (tab_setting
				       ));
	if (the_column > the_left_margin) and
	    (the_column < the_right_margin)
	then
	    position (LINE_BEGIN);
	    move_horizontal (the_column - 1);
	    copy_text ("T");
	endif;
    endloop;
endif;

position (LINE_BEGIN);
move_horizontal (the_left_margin - 1);


copy_text ("L");

if the_right_margin <= the_length
then
    position (LINE_BEGIN);
    move_horizontal (the_right_margin - 1);


    copy_text ("R");
endif;

the_word_wrap := eve$$x_paragraph_indent {eve$$x_ruled_buffer};
if the_word_wrap <> tpu$k_unspecified
then
    if the_word_wrap <= the_length
    then
	position (LINE_BEGIN);
	move_horizontal (the_word_wrap - 1);

	copy_text ("P");

    endif;
endif;

the_word_wrap := eve$$x_word_wrap_indent {eve$$x_ruled_buffer};
if the_word_wrap <> tpu$k_unspecified
then
    if the_word_wrap <= the_length
    then
	position (LINE_BEGIN);
	move_horizontal (the_word_wrap - 1);


	copy_text ("W");

    endif;
endif;

position (saved_mark);

endprocedure;	! eve$$construct_ruler

! EVE$WPS.TPU 								Page 47

procedure eve$$ruler_status		! Create ruler's own status-line

!
! First, be sure that the ruled buffer is still in the ruled window
!
if get_info (eve$$x_ruled_window, "type") = WINDOW
then
    if get_info (eve$$x_ruled_window, "buffer") = eve$$x_ruled_buffer
    then
	!
	! Display the ruled window's status below the ruler
	!
!***
! use saved ruled-window status-line, if any
!***
	return eve$get_status_line (eve$$x_ruled_window);
    endif;
endif;

!
! Too much has changed--remove the ruler
!

eve$$exit_ruler;
return "";

endprocedure;	! eve$$ruler_status

! EVE$WPS.TPU 								Page 48

procedure eve$$ruled_status		! Ruled buffer's status line

!
! First, be sure that the ruled buffer is still in the ruled window
!
if get_info (eve$$x_ruled_window, "type") = WINDOW
then
    if get_info (eve$$x_ruled_window, "buffer") = eve$$x_ruled_buffer
    then
	!
	! Ruler's still up. Only put the tic marks in the ruled window.
	!
	if current_window = eve$$x_ruled_window
	then
	    return eve$$ruler_scale
	else
	    return (eve$get_fixed_status_line (eve$$x_ruler_window));
	endif;
    endif;
endif;

!
! Too much has changed--remove the ruler
!

eve$$exit_ruler;
return "";

endprocedure;	! eve$$ruled_status

! EVE$WPS.TPU 								Page 49

procedure eve$$ruler_scale		! Create the ruler scale

! Decsription
!
!	EVE$$RULER creates the status string to be applied to the ruled
!	window. It contains the characters needed to get the special-
!	graphics ruler.
!
!	It looks sort of like this:
!
!	1+++|+++1|0+++|+++2|0+++|+++3|0+++|+++4|0+++|+++5|0+++|+++6|
!
!	Where "+" represents an invers T and "|" a full-cell "+".
!
!	This routine also sets the SPECIAL_GRAPHICS attribute on the
!	ruled-window status line and counts on EVE$SET_STATUS_LINE
!	to remove it before constructing the ruler.

local   how_shifted,		! Amount window is shifted right
	the_width,		! Width ofthe window
	the_column,		! Counter for walking up the decades
	digits,			! Digits of the decade counter
	left_half,		! Decade digits to left of the tick mark
	right_half,		! Decade digits to right of the tick mark
	the_line;		! resulting status line

on_error
    [TPU$_CONTROLC]:
	eve$learn_abort;
	abort;
    [OTHERWISE]:
endon_error;

! use the ruler_buffer to construct the new status line for the ruled window

position (end_of (eve$$x_ruler_buffer));
set (INSERT, eve$$x_ruler_buffer);
set (FORWARD, eve$$x_ruler_buffer);
how_shifted := get_info (eve$$x_ruled_window, "shift_amount");
the_width := get_info (eve$$x_ruled_window, "width");
copy_text ("qvvvnvvvqn" * ((the_width + how_shifted + 9) / 10));

set (OVERSTRIKE, eve$$x_ruler_buffer);
position (LINE_BEGIN);
copy_text ("1");

the_column := 10;
loop
    exitif the_column > the_width + how_shifted;
    digits := str (the_column);
    left_half := substr (digits, 1, (length (digits) + 1) / 2);
    right_half := substr (digits, length (left_half) + 1, length (digits));
    move_horizontal ((the_column - (length (left_half) + 1)) -
		     current_offset);
    copy_text (left_half);
    move_horizontal (1);
    copy_text (right_half);
    the_column := the_column + 10;
endloop;

the_line := substr (erase_line, 1 + how_shifted, the_width);

set (STATUS_LINE, eve$$x_ruled_window, SPECIAL_GRAPHICS, the_line);

return (the_line);

endprocedure;	! eve$$ruler_scale

! EVE$WPS.TPU 								Page 50

procedure eve$$ruler_mouse		! Snag mouse events in the ruler

local   the_window,
	the_column,
	the_row;

on_error
    [OTHERWISE]:
endon_error;

if locate_mouse (the_window, the_column, the_row)
then
    if the_row = 0
    then
	eve$$exit_ruler;
	execute (last_key, get_info (eve$$x_ruled_window, "key_map_list"));
    else
	if last_key = M1DOWN
	then
	    execute (last_key, "eve$mouse_keys");
	endif;
    endif;
endif;

endprocedure;	! eve$$ruler_mouse

! EVE$WPS.TPU 								Page 51

procedure eve$$ruler_previous_screen	! Previous screen in ruler help

if eve$$x_state_array {eve$$k_help_active} = 1
then			! help is active
    eve_previous_screen;
else
    eve$$undefined_ruler_key;
endif;

endprocedure;	! eve$$ruler_previous_screen

procedure eve$$ruler_next_screen	! Next screen in ruler help

if eve$$x_state_array {eve$$k_help_active} = 1
then			! help is active
    eve_next_screen;
else
    eve$$undefined_ruler_key;
endif;

endprocedure;	! eve$$ruler_next_screen

! EVE$WPS.TPU 								Page 52


procedure eve$define_ruler		! Create a ruler
    (ruler_no,
     leftmargin,
     rightmargin,
     tabstops,
     wordwrap,
     paragraph)

if (ruler_no < 0) or (ruler_no > 9)
then
    eve$message (EVE$_BADRULERNUM);
    eve$learn_abort;
    return (FALSE);
endif;

eve$$x_ruler_left_margin_array {ruler_no} := leftmargin;
eve$$x_ruler_right_margin_array {ruler_no} := rightmargin;
eve$$x_ruler_tab_stops_array {ruler_no} := tabstops;
eve$$x_ruler_word_wrap_array {ruler_no} := wordwrap;
eve$$x_ruler_paragraph_array {ruler_no} := paragraph;

endprocedure;	! eve$define_ruler

! EVE$WPS.TPU 								Page 53

procedure eve$wps_set_direction	! Set direction + enable auto-forward in reverse
    (the_direction)

! This procedure is called to change direction in the wps buffer.
! If reverse, then insure any typing key will change direction back
! to forward (by setting up an undefined_key procedure).

on_error
    [TPU$_CONTROLC]:
	set (SELF_INSERT, eve$current_key_map_list, ON);
	set (UNDEFINED_KEY, eve$current_key_map_list,
	     "eve$undefined_key (last_key)");
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	set (SELF_INSERT, eve$current_key_map_list, ON);
	set (UNDEFINED_KEY, eve$current_key_map_list,
	     "eve$undefined_key (last_key)");
endon_error;

if the_direction = REVERSE
then
    if the_direction <> current_direction
    then
	eve_reverse;
	set (SELF_INSERT, eve$current_key_map_list, OFF);
	set (UNDEFINED_KEY, eve$current_key_map_list, "eve$$undefined_key_wps");
    endif;
else
    if the_direction <> current_direction
    then
	eve_forward;
	set (SELF_INSERT, eve$current_key_map_list, ON);
	set (UNDEFINED_KEY, eve$current_key_map_list,
	     "eve$undefined_key (last_key)");
    endif;
endif;
return (TRUE);

endprocedure;	! eve$wps_set_direction

! EVE$WPS.TPU 								Page 54

procedure eve$$undefined_key_wps		! Printable keys during BACKUP

! The procedure called when direction = BACKUP, and an undefined
! printable (typing or otherwise) key is pressed.  In WPS, typing
! keys should always change direction to ADVANCE.

on_error
    [OTHERWISE]:
endon_error;

set (SELF_INSERT, eve$current_key_map_list, ON);
set (UNDEFINED_KEY, eve$current_key_map_list, "eve$undefined_key (last_key)");

if eve$current_keypad = eve$x_wps_keys
then
    eve$wps_set_direction (FORWARD);
endif;

execute (last_key);

endprocedure;	! eve$$undefined_key_wps

! EVE$WPS.TPU 								Page 55

procedure eve$wps_tab_pos		! move by tab

! Move to the text after the next TAB, or to the next line.
! (the algorithm was empirically determined on WPS+)

local   the_begin,
	the_end,
	saved_mark,
	here,
	search_range;	! For searching for <HT>

on_error
    [TPU$_CONTROLC]:
	eve$$restore_position (saved_mark);
	eve$learn_abort;
	abort;
    [OTHERWISE]:
	eve$$restore_position (saved_mark);
endon_error;

if not eve$declare_intention (eve$k_action_short_move)
then
    return (FALSE);
endif;

saved_mark := mark (FREE_CURSOR);

position (TEXT);	! snap to text

if current_direction = REVERSE
then
	! REVERSE
    if mark (NONE) = beginning_of (current_buffer)
    then
	position (saved_mark);
	return (eve$wps_line);			! force error message
    endif;

    if mark (NONE) = end_of (current_buffer)
    then
	move_horizontal (-1);
    else
	if current_character = ascii (9)
	then		! We're on a TAB.
	    move_horizontal (-1);			! Move past the TAB.
	    if (current_character = ascii (9)) or (current_offset = 0)
	    then		! Landed on 2nd TAB or begin of line
		return (TRUE);
	    endif;
	else
	    move_horizontal (-1);			! Move past cur_char
	    if current_character = ascii (9)
	    then	! Landed on a TAB,
		if current_offset = 0
		then
		    return (TRUE);
		endif;
		move_horizontal (-1);			! move past the TAB.
		if (current_character = ascii (9)) or	! Landed on another TAB
		    (current_offset = 0)			! or null line?
		then	! if offset=0, we're on new line
		    move_horizontal (1);		! Move over TAB forward.
		    return (TRUE);
		endif;
	    endif;
	endif;
    endif;

    here := mark (NONE);
    position (LINE_BEGIN);
    the_begin := mark (NONE);
    position (here);
    search_range := search_quietly (ascii (9), REVERSE); ! tab in this line?
    if search_range = 0
    then
	if not (length (current_line) = 0)
	then
	    return (eve$wps_line); ! take care of upper/lowercasing + moving +
	endif;			   ! learn_abort
    else
	if beginning_of (search_range) >= the_begin
	then
	    position (search_range);	! tab's in this line
	    move_horizontal (1);		! goto 1st char after TAB
	    eve$$case_change (here); 	! Change case if moved
	else
	    if not (length (current_line) = 0)
	    then
		return (eve$wps_line);	! take care of upper/lowercasing +
	    endif;			! moving + learn_abort
	endif;
    endif;

else		! FORWARD
    if mark (NONE) = end_of (current_buffer)
    then
	position (saved_mark);
	return (eve$wps_line);			! force error message
    endif;
    if current_character = ascii (9)
    then	! we're on a TAB
	move_horizontal (1);
	return (TRUE);
    else
	move_horizontal (1);
	if current_offset = 0
	then	! if offset=0, we're on new line
	    if current_character = ascii (9)
	    then				! we landed on a TAB,
		move_horizontal (1);	! move past the tab
	    endif;
	    return (TRUE);
	endif;
	if current_character = ascii (9)
	then	! we landed on a TAB,
	    move_horizontal (1);			! move past the tab
	    return (TRUE);
	endif;
    endif;
    here := mark (NONE);
    position (LINE_END);
    the_end := mark (NONE);
    position (here);
    search_range := search_quietly (ascii (9), FORWARD); ! tab in this line?
    if search_range = 0
    then
	if current_offset <> 0
	then
	    if eve$wps_line
	    then
		if current_character = ascii (9)
		then				! we landed on a TAB,
		    move_horizontal (1);	! move past the tab
		    return (TRUE);
		endif;
	    else
		return (FALSE);
	    endif;
	endif;
    else
	if (beginning_of (search_range) > here) and
	    (beginning_of (search_range) < the_end)
	then
	    position (beginning_of (search_range));	! tab's in this line
	    move_horizontal (1);		! go to 1st char after TAB
	    eve$$case_change (here);	! Change case if we really moved
	else
	    if current_offset <> 0
	    then	! if offset=0, don't move:
		if eve$wps_line
		then
		    if current_character = ascii (9)
		    then				! we landed on a TAB,
			move_horizontal (1);	! move past the tab
			return (TRUE);
		    endif;
		else
		    return (FALSE);
		endif;
	    endif;
	endif;
    endif;
endif;
return (TRUE);

endprocedure;	! eve$wps_tab_pos

! EVE$WPS.TPU 								Page 56

procedure eve$wps_halt			! GOLD ~ = halt GOLD ADVANCE/BACKUP

! No code is needed since eve$wps_adv_scroll and eve$wps_back_scroll
! start a continuous scroll that is halted by any key (actually
! the GOLD key will stop it!).

eve$$remember (FALSE);

endprocedure;	! eve$wps_halt

! EVE$WPS.TPU 								Page 57

! Module initialization code

eve$x_wps_keys := "EVE$WPS_KEYS";

eve$$x_ruler_keys := "EVE$RULER_KEYS";
eve$$x_ruler_list := "EVE$RULER_LIST";

eve$x_wps_pattern_symbols := "" + any (eve$x_symbol_characters);

if get_info (eve$$x_ruler_window, "type") <> WINDOW
then
    eve$$x_ruler_window := create_window (get_info (SCREEN, "visible_length")
					  - 3, 2, ON);
endif;

eve$$x_page_size := 54;
eve$$x_ruler_left_margin := -1;
eve$$x_ruler_right_margin := -1;
eve$$x_ruler_tab_stops := 0;

eve$$x_ruler_left_margin_array := create_array (10, 0);
eve$$x_ruler_right_margin_array := create_array (10, 0);
eve$$x_ruler_tab_stops_array := create_array (10, 0);
eve$$x_ruler_word_wrap_array := create_array (10, 0);
eve$$x_ruler_paragraph_array := create_array (10, 0);

eve$$x_ruler_left_margin_array {0} := -1;
eve$$x_ruler_right_margin_array {0} := -1;
eve$$x_ruler_tab_stops_array {0} := 0;
eve$$x_ruler_left_margin_array {1} := -1;
eve$$x_ruler_right_margin_array {1} := -1;
eve$$x_ruler_tab_stops_array {1} := 0;
eve$$x_ruler_left_margin_array {2} := -1;
eve$$x_ruler_right_margin_array {2} := -1;
eve$$x_ruler_tab_stops_array {2} := 0;
eve$$x_ruler_left_margin_array {3} := -1;
eve$$x_ruler_right_margin_array {3} := -1;
eve$$x_ruler_tab_stops_array {3} := 0;
eve$$x_ruler_left_margin_array {4} := -1;
eve$$x_ruler_right_margin_array {4} := -1;
eve$$x_ruler_tab_stops_array {4} := 0;
eve$$x_ruler_left_margin_array {5} := -1;
eve$$x_ruler_right_margin_array {5} := -1;
eve$$x_ruler_tab_stops_array {5} := 0;
eve$$x_ruler_left_margin_array {6} := -1;
eve$$x_ruler_right_margin_array {6} := -1;
eve$$x_ruler_tab_stops_array {6} := 0;
eve$$x_ruler_left_margin_array {7} := -1;
eve$$x_ruler_right_margin_array {7} := -1;
eve$$x_ruler_tab_stops_array {7} := 0;
eve$$x_ruler_left_margin_array {8} := -1;
eve$$x_ruler_right_margin_array {8} := -1;
eve$$x_ruler_tab_stops_array {8} := 0;
eve$$x_ruler_left_margin_array {9} := -1;
eve$$x_ruler_right_margin_array {9} := -1;
eve$$x_ruler_tab_stops_array {9} := 0;

eve$x_restore_sentence := 0;

endmodule;

! EVE$WPS.TPU 								Page 58

!
! Executable code
!

eve$x_wps_keys := create_key_map ("EVE$WPS_KEYS");
add_key_map (eve$x_keypad_list, "last", eve$x_wps_keys);
!
! Define the keypad first.
!
! NOTE: Some key comments start with the facility code "KEYPAD".  This
!	points to the EVE$KT_HELP_LIBRARY_KEYPAD library as defined
!	in EVE$EDT.TPU

define_key (eve$$kt_return + "eve$wps_page", PF2,
	    "move_by_page", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_delete_word", PF3,
	    "KEYPAD delete_word", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_delete_char", PF4,
	    "KEYPAD delete_character", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_sentence", KP7,
	    "KEYPAD sentence", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_tab_pos", KP8,
	    "KEYPAD tab_position", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_remove", MINUS,
	    "KEYPAD WPS_cut", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_word", KP4,
	    "move_by_word", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_paragraph", KP5,
	    "KEYPAD paragraph", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_insert_here", COMMA,
	    "KEYPAD WPS_paste", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_line", KP2, "KEYPAD WPS_line",
	    eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_upper_case", KP3,
	    "KEYPAD upper_case", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_select", PERIOD, "select",
	    eve$x_wps_keys);

define_key (eve$$kt_return + "eve$wps_down", DOWN,
	    "move_down", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_up", UP,
	    "move_up", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_left", LEFT,
	    "move_left", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_right", RIGHT,
	    "move_right", eve$x_wps_keys);


define_key (eve$$kt_return + "eve$wps_down", key_name (DOWN, SHIFT_MODIFIED),
	    "move_down", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_up", key_name (UP, SHIFT_MODIFIED),
	    "move_up", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_left", key_name (LEFT, SHIFT_MODIFIED),
	    "move_left", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_right", key_name (RIGHT, SHIFT_MODIFIED),
	    "move_right", eve$x_wps_keys);

define_key (eve$$kt_return + "eve$wps_down", key_name (DOWN, CTRL_MODIFIED),
	    "move_down", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_up", key_name (UP, CTRL_MODIFIED),
	    "move_up", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_left", key_name (LEFT, CTRL_MODIFIED),
	    "move_left", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_right", key_name (RIGHT, CTRL_MODIFIED),
	    "move_right", eve$x_wps_keys);

define_key (eve$$kt_return + "eve$wps_backup", KP1,
	    "KEYPAD backup", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_advance", KP0,
	    "KEYPAD advance", eve$x_wps_keys);

!
! Define the gold keypad
!
define_key (eve$$kt_return + "eve$wps_paginate", key_name (PF2, SHIFT_KEY),
	    "paginate", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_restore", key_name (PF3, SHIFT_KEY),
	    " restore", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_restore", key_name (PF4, SHIFT_KEY),
	    " restore", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_sentence", key_name (KP7, SHIFT_KEY),
	    "KEYPAD sentence", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_copy", key_name (MINUS, SHIFT_KEY),
	    "KEYPAD WPS_copy", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_word", key_name (KP4, SHIFT_KEY),
	    "move_by_word", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_fill", key_name (KP5, SHIFT_KEY),
	    "fill", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_insert_here",
	    key_name (COMMA, SHIFT_KEY), "KEYPAD WPS_paste", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_back_scroll", key_name (KP1, SHIFT_KEY),
	    "KEYPAD back_scroll (scroll_backup)", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_line", key_name (KP2, SHIFT_KEY),
	    "KEYPAD WPS_line", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_lower_case", key_name (KP3, SHIFT_KEY),
	    "KEYPAD lower_case", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_adv_scroll", key_name (KP0, SHIFT_KEY),
	    "KEYPAD adv_scroll (scroll_advance)", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_reset", key_name (PERIOD, SHIFT_KEY),
	    "reset", eve$x_wps_keys);
!
! Editing keypad
!
define_key (eve$$kt_return + "eve_delete", DEL_KEY, "delete", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_delete_start_word", LF_KEY,
	    "KEYPAD delete_previous_word", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_delete_start_word", F13,
	    "KEYPAD delete_previous_word", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_right_angle", ENTER,
	    "KEYPAD search_right_angle (<>)", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_find('')", E1, "find", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_insert_here", E2,
	    "KEYPAD WPS_paste", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_remove", E3,
	    "KEYPAD WPS_cut", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_select", E4, "select", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_previous_screen", E5,
	    "previous_screen", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_next_screen", E6,
	    "next_screen", eve$x_wps_keys);
!
! Gold editing keypad
!
define_key (eve$$kt_return + "eve$delete_start_line",
	    key_name (DEL_KEY, SHIFT_KEY),
	    "KEYPAD delete_start_line", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_delete_start_sent",
	    key_name (LF_KEY, SHIFT_KEY), "KEYPAD delete_beginning_sentence",
	    eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_delete_start_sent",
	    key_name (F13, SHIFT_KEY), "KEYPAD delete_beginning_sentence",
	    eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_swap", key_name (ENTER, SHIFT_KEY),
	    "KEYPAD swap", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_end_of_line", key_name (RIGHT, SHIFT_KEY),
	    "end_of_line", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_start_of_line", key_name (LEFT, SHIFT_KEY),
	    "start_of_line", eve$x_wps_keys);
!
! Control keys
!
define_key (eve$$kt_return + "eve_learn", CTRL_K_KEY, "learn", eve$x_wps_keys);
!
! Gold letters and digits
!
define_key (eve$$kt_return + "eve$edt_repeat (1)", key_name ("1", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (2)", key_name ("2", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (3)", key_name ("3", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (4)", key_name ("4", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (5)", key_name ("5", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (6)", key_name ("6", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (7)", key_name ("7", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (8)", key_name ("8", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (9)", key_name ("9", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$edt_repeat (0)", key_name ("0", SHIFT_KEY),
	    "KEYPAD repeat", eve$x_wps_keys);

define_key (eve$$kt_return + "eve$wps_bottom", key_name ("b", SHIFT_KEY),
	    "bottom", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_center_line", key_name ("c", SHIFT_KEY),
	    "center_line", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_exit", key_name ("f", SHIFT_KEY),
	    "exit", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_include_file ('')", key_name ("g", SHIFT_KEY),
	    "include_file", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_help('keypad')", key_name ("h", SHIFT_KEY),
	    "help (help keypad)", eve$x_wps_keys);             !help
define_key (eve$$kt_return + "eve_quit", key_name ("k", SHIFT_KEY),
	    "quit", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_insert_page_break", key_name ("n", SHIFT_KEY),
	    "insert_page_break", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_page_marker", key_name ("p", SHIFT_KEY),
	    "KEYPAD page_marker", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$$display_ruler", key_name ("r", SHIFT_KEY),
	    "KEYPAD ruler", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_spell", key_name ("s", SHIFT_KEY),
	    "spell", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_top", key_name ("t", SHIFT_KEY),
	    "top", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_write_file ('')", key_name ("w", SHIFT_KEY),
	    "write_file", eve$x_wps_keys);

define_key (eve$$kt_return + "eve$wps_date_time",
	    key_name ("\", SHIFT_KEY),
	    "KEYPAD insert_date_time (insert date/time)", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_date_time",
	    key_name ("|", SHIFT_KEY),
	    "KEYPAD insert_date_time (insert date/time)", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_find('')", key_name (",", SHIFT_KEY),
	    "find", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_continue_search",
	    key_name (".", SHIFT_KEY),
	    "KEYPAD continue_search_key", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_continue_search_select",
	    key_name ("/", SHIFT_KEY),
	    "KEYPAD continue_search_select (continue search/select)",
	    eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_continue_search_select",
	    key_name ("?", SHIFT_KEY),
	    "KEYPAD continue_search_select (continue search/select)",
	    eve$x_wps_keys);
define_key (eve$$kt_return + "eve_replace('','')", key_name (";", SHIFT_KEY),
	    "replace", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_replace('','')", key_name (":", SHIFT_KEY),
	    "replace", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_replace", key_name ("'", SHIFT_KEY),
	    "KEYPAD WPS_replace", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_replace", key_name ('"', SHIFT_KEY),
	    "KEYPAD WPS_replace", eve$x_wps_keys);
define_key (eve$$kt_return + "eve$wps_halt", key_name ("`", SHIFT_KEY),
	    "KEYPAD halt", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_spawn('')", key_name ("$", SHIFT_KEY),
	    "spawn", eve$x_wps_keys);
define_key (eve$$kt_return + "eve_do('')", key_name ("[", SHIFT_KEY), "do",
	    eve$x_wps_keys);
eve$$add_do_key (key_name ("[", SHIFT_KEY), eve$x_wps_keys);
define_key (eve$$kt_return + "eve_learn", key_name (">", SHIFT_KEY), "learn",
	    eve$x_wps_keys);
!
! Key bindings in rulers
!
eve$$x_ruler_keys := create_key_map ("EVE$RULER_KEYS");
eve$$x_ruler_list := create_key_map_list ("EVE$RULER_LIST",
					  eve$$x_ruler_keys);
set (SELF_INSERT, eve$$x_ruler_list, OFF);
set (UNDEFINED_KEY, eve$$x_ruler_list, "eve$$undefined_ruler_key");
!
! Function (and control) keys
!
define_key ("eve_help ('ruler_keys')", HELP, " help", eve$$x_ruler_keys);
define_key ("eve_help ('ruler_keys')", key_name (HELP, SHIFT_KEY),
	    " help", eve$$x_ruler_keys);
define_key ("eve_help ('ruler_keys')", key_name ("h", SHIFT_KEY),
	    " help", eve$$x_ruler_keys);
define_key ("eve$$exit_ruler", RET_KEY, "return", eve$$x_ruler_keys);
define_key ("eve$$exit_ruler", key_name (RET_KEY, SHIFT_KEY),
	    "return", eve$$x_ruler_keys);
define_key ("eve_move_left", LEFT, "move_left", eve$$x_ruler_keys);
define_key ("eve_move_right", RIGHT, "move_right", eve$$x_ruler_keys);
define_key ("eve$$ruler_advance", KP0, "KEYPAD advance", eve$$x_ruler_keys);
define_key ("eve$$ruler_backup", KP1, "KEYPAD backup", eve$$x_ruler_keys);
define_key ("eve$$ruler_line", KP2, "KEYPAD WPS_line", eve$$x_ruler_keys);
define_key ("eve$$ruler_word", KP4, "KEYPAD WPS_word", eve$$x_ruler_keys);
define_key ("eve$$ruler_tab", TAB_KEY, "KEYPAD tab_key", eve$$x_ruler_keys);
define_key ("eve$$ruler_ctrl_e", CTRL_E_KEY, "KEYPAD ctrl_e_key",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_ctrl_h", CTRL_H_KEY, "KEYPAD ctrl_h_key",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_previous_screen", E5, " previous_screen",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_next_screen", E6, " next_screen", eve$$x_ruler_keys);
!
! Letters as ruler format commands
!
define_key ("eve$$ruler_set_left_margin", key_name ("L"),
	    "KEYPAD set_left_margin", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_left_margin", key_name ("l"),
	    "KEYPAD set_left_margin", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_right_margin", key_name ("R"),
	    "KEYPAD set_right_margin", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_right_margin", key_name ("r"),
	    "KEYPAD set_right_margin", eve$$x_ruler_keys);
define_key ("eve$$save_ruler(-1)", key_name ("S"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(-1)", key_name ("s"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_set_tab_stop", key_name ("T"), "KEYPAD set_tab_stop",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_set_tab_stop", key_name ("t"), "KEYPAD set_tab_stop",
	    eve$$x_ruler_keys);
define_key ("eve$$ruler_set_word_wrap", key_name ("W"),
	    "KEYPAD set_word_wrap", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_word_wrap", key_name ("w"),
	    "KEYPAD set_word_wrap", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_paragraph", key_name ("P"),
	    "KEYPAD set_paragraph", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_paragraph", key_name ("p"),
	    "KEYPAD set_paragraph", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_paragraph", key_name ("I"),
	    "KEYPAD set_paragraph", eve$$x_ruler_keys);
define_key ("eve$$ruler_set_paragraph", key_name ("i"),
	    "KEYPAD set_paragraph", eve$$x_ruler_keys);
!
define_key ("eve$$ruler_set_space", key_name (" "),
	    "KEYPAD set_space", eve$$x_ruler_keys);
!
! Digits as ruler numbers (to display or save a ruler)
!
define_key ("eve$$get_ruler(0)", key_name ("0"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(1)", key_name ("1"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(2)", key_name ("2"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(3)", key_name ("3"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(4)", key_name ("4"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(5)", key_name ("5"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(6)", key_name ("6"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(7)", key_name ("7"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(8)", key_name ("8"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$get_ruler(9)", key_name ("9"), "KEYPAD get_ruler",
	    eve$$x_ruler_keys);

define_key ("eve$$save_ruler(0)", key_name (")"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(1)", key_name ("!"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(2)", key_name ("@"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(3)", key_name ("#"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(4)", key_name ("$"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(5)", key_name ("%"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(6)", key_name ("^"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(7)", key_name ("&"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(8)", key_name ("*"), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);
define_key ("eve$$save_ruler(9)", key_name ("("), "KEYPAD save_ruler",
	    eve$$x_ruler_keys);

eve$$require ("eve$core");		! Build dependencies
eve$$require ("eve$file");
eve$$require ("eve$format");
eve$$require ("eve$extend");
eve$$require ("eve$edit");
eve$$require ("eve$advanced");
eve$$require ("eve$help");
eve$$require ("eve$edt");
eve$$require ("eve$extras");