!!****************************************
!PROCEDURE UTL_FIND_BUFFER (BUFFER_NAME)
!
!local upcased_name, buffer_ptr;
!
!upcased_name := buffer_name;
!change_case (upcased_name, upper);
!buffer_ptr := get_info (buffers, "first");
!
!loop
!    exitif buffer_ptr = 0;
!    exitif upcased_name = get_info (buffer_ptr, "name");
!    buffer_ptr := get_info (buffers, "next");
!endloop;
!
!return buffer_ptr;
!
!ENDPROCEDURE;

!****************************************
PROCEDURE EVE$FILL_RANGE (RANGE_ARG; NEW_INDENT_VALUE)

! Fill a range

!
! The code in this routine for MY_INDENT_VALUE was added 900406 - RHS
!

local   the_range,
        start_mark,            ! Start of the range to fill
        the_right_margin,
        the_left_margin,
        the_indent,
        end_mark,            ! Marker for end of range
        pce_indent_value;

on_error
    [OTHERWISE]:
endon_error;

if not eve$declare_intention (eve$k_action_format) then
    return (FALSE);
endif;
                               
!
! Following code added 900406 - RHS
!
pce_indent_value := new_indent_value;
if (pce_indent_value = tpu$k_unspecified) or (pce_indent_value <= 0) then
    pce_indent_value := 0;
endif;
!
!

the_range := range_arg;
if the_range <> 0 then
    if beginning_of (the_range) <= end_of (the_range) then
        start_mark := beginning_of (the_range);
        end_mark := end_of (the_range);
    else
        end_mark := beginning_of (the_range);
        start_mark := end_of (the_range);
    endif;
    the_range := 0;

    position (start_mark);

! Move start_mark if on an DOCUMENT tag or runoff command line
    if search_quietly (eve$pattern_skip_paragraph_break, FORWARD) <> 0 then
! skip past DOCUMENT tag, runoff command line, ff's
        position (LINE_END);
        move_horizontal (1);
        start_mark := mark (NONE);
    endif;

    loop            ! Find the paragraph bounds for all paragraphs
        loop
            position (LINE_END);
            exitif mark (NONE) = end_of (current_buffer);
            move_horizontal (1);
            exitif mark (NONE) > end_mark;
            exitif eve$paragraph_break;
        endloop;
        move_horizontal (-1);

        if mark (NONE) > end_mark then
            position (end_mark);
        endif;

        the_right_margin := get_info (current_buffer, "right_margin");

        if eve$$x_word_wrap_indent {current_buffer} <> tpu$k_unspecified then
            the_left_margin := eve$$x_word_wrap_indent {current_buffer};
        else
            the_left_margin := get_info (current_buffer, "left_margin");
        endif;

        if eve$$x_paragraph_indent {current_buffer} <> tpu$k_unspecified then
            the_indent := eve$$x_paragraph_indent {current_buffer}
                  - the_left_margin;
        else
            the_indent := get_info (current_buffer, "left_margin") -
                  the_left_margin;
        endif;

        the_range := create_range (start_mark, mark (NONE), NONE);
        edit (the_range, TRIM_LEADING, OFF);
!
! Following code chg'd 900406 - RHS
!
        if (pce_indent_value <> 0) then
            fill (the_range, eve$x_fill_separators, the_left_margin,
                the_right_margin, pce_indent_value);
        else
            fill (the_range, eve$x_fill_separators, the_left_margin,
                the_right_margin, the_indent);
        endif;
!
!

        loop                ! Skip the inter-paragraph break;
            position (LINE_END);
            move_horizontal (1);
            exitif not eve$paragraph_break;
        endloop;
        start_mark := mark (NONE);
        exitif start_mark >= end_mark;
    endloop;
    position (end_mark);
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!! screen manager issue !!!!!!!!!!!!!!!!!!!!!!!!!!
    update (current_window);
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

else
    eve$message (EVE$_SELFIRST);
    eve$learn_abort;
    return (FALSE);
endif;
eve$clear_message;
return (TRUE);

ENDPROCEDURE;

!****************************************
PROCEDURE EVE_FILL (;NEW_INDENT_VALUE)

!
! The code in this routine for MY_INDENT_VALUE was added 900406 - RHS
!

local   the_selection,
        my_indent_value;

if (new_indent_value = tpu$k_unspecified) or (new_indent_value = "") then
    my_indent_value := 0;
else
    my_indent_value := new_indent_value;
endif;
the_selection   := eve$selection (FALSE);
if the_selection <> 0 then
    return (eve$fill_range (the_selection, my_indent_value));
else
    return (eve_fill_paragraph (my_indent_value));
endif;

ENDPROCEDURE;    ! EVE_FILL

!****************************************
PROCEDURE EVE_FILL_PARAGRAPH (;NEW_INDENT_VALUE)

!
! The code in this routine for MY_INDENT_VALUE was added 900406 - RHS
!

local   saved_mark,         ! Marker for current cursor position
        start_paragraph,    ! Marker for start of current paragraph
        stop_paragraph,     ! Marker for end of current paragraph
        the_right_margin,
        the_left_margin,
        the_indent,
        fill_range,         ! Range for current paragraph
        my_indent_value;

on_error
    [OTHERWISE]:
endon_error;

if (new_indent_value = tpu$k_unspecified) or (new_indent_value = "") then
    my_indent_value := 0;
else
    my_indent_value := new_indent_value;
endif;

if get_info (current_buffer, "system") then
    eve$message (EVE$_CANTSYSTEMBUF);
    eve$learn_abort;
    return (FALSE);
endif;

! Can't fill an empty buffer - avoid additional checks later on

if beginning_of (current_buffer) = end_of (current_buffer) then
    eve$message (EVE$_NOFILL);
    eve$learn_abort;
    return (FALSE);
endif;

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

position (TEXT);
saved_mark := mark (NONE);

! Find beginning of paragraph.  Paragraph breaks are blank lines, DOCUMENT tags,
! runoff commands, FF (hard FF), or FF+NL (soft FF).  If on a paragraph break
! other than a DOCUMENT tag or runoff command line, then do preceding paragraph.

position (LINE_BEGIN);
if search_quietly (ANCHOR + LINE_BEGIN +
           (("." | "<") + any (eve$x_runoff_characters)),
           FORWARD) <> 0 then
! on DOCUMENT tag or runoff command line, go to next line
    position (LINE_END);
    move_horizontal (1);
    start_paragraph := mark (NONE);
else
    loop
! stop at top of buffer
        exitif mark (NONE) = beginning_of (current_buffer);
        move_vertical (-1);
        position (LINE_BEGIN);    ! incase set(column_move_vertical,on)
! stop at a break and move to start of next line
        if eve$paragraph_break then
            position (LINE_END);
            move_horizontal (1);
            exitif;
        endif;
    endloop;
    start_paragraph := mark (NONE);
    position (saved_mark);
endif;

! find end of paragraph

loop
    position (LINE_BEGIN);
    exitif mark (NONE) = end_of (current_buffer);
    exitif eve$paragraph_break;
    move_vertical (1);
endloop;

if start_paragraph = mark (NONE) then
    eve$message (EVE$_NOFILL);
    position (saved_mark);
    eve$learn_abort;
    return (FALSE);
else
    move_horizontal (-1);
    stop_paragraph := mark (NONE);

! Now fill the paragraph
    the_right_margin := get_info (current_buffer, "right_margin");

    if eve$$x_word_wrap_indent {current_buffer} <> tpu$k_unspecified then
        the_left_margin := eve$$x_word_wrap_indent {current_buffer};
    else
        the_left_margin := get_info (current_buffer, "left_margin");
    endif;

    if eve$$x_paragraph_indent {current_buffer} <> tpu$k_unspecified then
        the_indent := eve$$x_paragraph_indent {current_buffer}
            - the_left_margin;
    else
        the_indent := get_info (current_buffer, "left_margin") -
              the_left_margin;
    endif;

    fill_range := create_range (start_paragraph, stop_paragraph, NONE);
    edit (fill_range, TRIM_LEADING, OFF);
    fill (fill_range, eve$x_fill_separators, the_left_margin, 
        the_right_margin, the_indent);


    position (stop_paragraph);
    eve$show_first_line;
endif;
return (TRUE);

ENDPROCEDURE;    ! EVE_FILL_PARAGRAPH

!****************************************
PROCEDURE EVE_FILL_RANGE (;NEW_INDENT_VALUE)

local my_indent_value;

on_error
    [OTHERWISE]:
endon_error;

my_indent_value := new_indent_value;

if get_info (current_buffer, "system") then
    eve$message (EVE$_CANTSYSTEMBUF);
    eve$learn_abort;
    return (FALSE);
endif;

eve$fill_range (eve$selection (FALSE), my_indent_value);

ENDPROCEDURE;    ! EVE_FILL_RANGE

!****************************************
PROCEDURE EVE$GET_FIND_TARGET (TARGET, HOW_EXACT, REPLACING; OLD_FIND)

! Set up for a find.
! If <FIND><FIND>, use the direction in eve$x_old_find_direction;
! otherwise, use the buffer's current direction (OR the direction specified
! by a direction-changing terminator that terminates the find prompt).
! Parameters:
!    target         String to find - input + output
!    how_exact      eve$x_find_exact or eve$x_find_no_exact - output
!    replacing      1 = called by eve_replace: allow a
!                       match at current cursor position and
!                       return if no string found
!                   2 = called by wildcard_find
!                   0 = called by a find procedure - input
!    old_find       1 = called by eve$find - optional input

local   new_target,         ! Local copy of target
        bp_return_value,    ! Value returned by eve$$build_pattern
        start_find_key,     ! String describing key used to invoke find
        stop_find_key,      ! String describing key used after prompt
        leading_whitespace, ! Boolean for including leading whitespace
        status,             ! Status from set (widget)
        result,             ! Result returned from eve$$test_find_terminator
        the_prompt,         ! Prompt string
        execute_it,         ! Boolean to execute eve$x_target_pattern
        prefix,             ! Execute arg
        postfix,            ! Execute arg
        key_is_defined,     ! Boolean for key press = "FIND xxx"
        saved_direction;    ! Direction upon entry

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;

saved_direction := current_direction;

start_find_key := last_key;
if start_find_key <> 0 then
    if eve$test_synonym ("return", 
        eve$$lookup_comment (start_find_key, "")) then
        start_find_key := DO;
    endif;
endif;

if replacing = 1 then
    eve$$remove_found_range;
endif;

eve$clear_message;

if target <> "" then
    new_target := target;
    if start_find_key <> 0 then
        eve$$test_find_terminator (last_key);    ! possibly change direction
    endif;
else
    loop
        if current_direction = FORWARD then
            if replacing <> 2 then
! <> wildcard find 
                if current_direction = eve$x_old_find_direction then
                    the_prompt := message_text (EVE$_FINDPROMPT, 1);
                else
                    if (eve$$x_state_array {eve$$k_command_line_flag} =
                        eve$k_invoked_by_menu) and
                        (eve$$x_state_array {eve$$k_dialog_box}) then
                        the_prompt := message_text (EVE$_FINDPROMPT, 1);
                    else
                        the_prompt := message_text (EVE$_FINDPROMPT2, 1);
                    endif;
                endif;
            else
                if current_direction = eve$x_old_find_direction then
                    the_prompt := message_text (EVE$_WILDFINDPROMPT, 1);
                else
                    if (eve$$x_state_array {eve$$k_command_line_flag} =
                        eve$k_invoked_by_menu) and
                        (eve$$x_state_array {eve$$k_dialog_box}) then
                        the_prompt := message_text (EVE$_WILDFINDPROMPT, 1);
                    else
                        the_prompt := message_text (EVE$_WILDFINDPROMPT2, 1);
                    endif;
                endif;
            endif;
        else
            if replacing <> 2 then
                if current_direction = eve$x_old_find_direction then
                    the_prompt := message_text (EVE$_REVPROMPT, 1);
                else
                    if (eve$$x_state_array {eve$$k_command_line_flag} =
                        eve$k_invoked_by_menu) and
                        (eve$$x_state_array {eve$$k_dialog_box}) then
                        the_prompt := message_text (EVE$_REVPROMPT, 1);
                    else
                        the_prompt := message_text (EVE$_REVPROMPT2, 1);
                    endif;
                endif;
            else
                if current_direction = eve$x_old_find_direction then
                    the_prompt := message_text (EVE$_WILDREVPROMPT, 1);
                else
                    if (eve$$x_state_array {eve$$k_command_line_flag} =
                        eve$k_invoked_by_menu) and
                        (eve$$x_state_array {eve$$k_dialog_box}) then
                        the_prompt := message_text (EVE$_WILDREVPROMPT, 1);
                    else
                        the_prompt := message_text (EVE$_WILDREVPROMPT2, 1);
                    endif;
                endif;
            endif;
        endif;
        if (eve$$x_state_array {eve$$k_command_line_flag} =
            eve$k_invoked_by_menu) and
            (eve$$x_state_array {eve$$k_dialog_box}) then
! supersede the program bound to the find_ok button
! (cant call eve$get_find_target cause data expected from widget)

%if eve$x_option_decwindows
%then
            if eve$x_decwindows_active then
                if replacing = 2 then
                    if get_info (eve$x_wildcard_find_dialog, "type") <> 
                        WIDGET then
                        eve$x_wildcard_find_dialog := create_widget
                            ("WILDCARD_FIND_DIALOG",
                            eve$x_widget_hierarchy,
                            SCREEN,
                            eve$kt_callback_routine);
                    endif;
                    if old_find = tpu$k_unspecified then
                        eve$$set_responder (eve$$k_wildcard_find_ok,
                            fao ("eve$$widget_find_ok (!UL)", replacing));
                    else
                        eve$$set_responder (eve$$k_wildcard_find_ok,
                            fao ("eve$$widget_find_ok (!UL, !UL)",
                            replacing, old_find));
                    endif;

                    status := set (WIDGET, get_info (WIDGET, "widget_id",
                        eve$x_wildcard_find_dialog,
                        "WILDCARD_FIND_DIALOG.WILDCARD_FIND_LABEL"),
                        eve$dwt$c_nlabel, the_prompt);
                    status := set (WIDGET, get_info (WIDGET, "widget_id",
                        eve$x_wildcard_find_dialog,
                        "WILDCARD_FIND_DIALOG.WILDCARD_FIND_LABEL1"),
                        eve$dwt$c_nlabel,
                        message_text (EVE$_CURRENTWILD, 1, 
                        eve$$x_wild_patterns));
                    if get_info (eve$x_target, "type") = STRING then
                        status := set (TEXT,
                            get_info (WIDGET, "widget_id",
                            eve$x_wildcard_find_dialog,
                            "WILDCARD_FIND_DIALOG.WILDCARD_FIND_TEXT"),
                            eve$x_target);
                    else
                        status := set (TEXT,
                            get_info (WIDGET, "widget_id",
                            eve$x_wildcard_find_dialog,
                            "WILDCARD_FIND_DIALOG.WILDCARD_FIND_TEXT"),
                            eve$x_printable_target);
                    endif;
                    eve$manage_widget (eve$x_wildcard_find_dialog);
                else 
                    if get_info (eve$x_find_dialog, "type") <> WIDGET then
                        eve$x_find_dialog := create_widget ("FIND_DIALOG",
                            eve$x_widget_hierarchy, SCREEN,
                            eve$kt_callback_routine);
                    endif;
                    if old_find = tpu$k_unspecified then
                        eve$$set_responder (eve$$k_find_ok,
                            fao ("eve$$widget_find_ok (!UL)", replacing));
                    else
                        eve$$set_responder (eve$$k_find_ok,
                            fao ("eve$$widget_find_ok (!UL, !UL)",
                            replacing, old_find));
                    endif;

                    status := set (WIDGET,
                        get_info (WIDGET, "widget_id",
                        eve$x_find_dialog, "FIND_DIALOG.FIND_LABEL"),
                        eve$dwt$c_nlabel, the_prompt);
                    if get_info (eve$x_target, "type") = STRING then
                        status := set (TEXT, get_info (WIDGET, "widget_id",
                            eve$x_find_dialog, "FIND_DIALOG.FIND_TEXT"),
                            eve$x_target);
                    else
                        status := set (TEXT, get_info (WIDGET, "widget_id",
                            eve$x_find_dialog, "FIND_DIALOG.FIND_TEXT"),
                            eve$x_printable_target);
                    endif;
                    eve$manage_widget (eve$x_find_dialog);
                endif;
            endif;
%endif

            return (eve$k_async_prompting);
        else
            new_target := eve$prompt_line (the_prompt, eve$$x_find_terminators);

            if new_target = 0 then
                return (FALSE);
            endif;

! Test the terminator, and change direction if it's
! a direction-setting terminator.
            if start_find_key <> 0 then
                result := eve$$test_find_terminator (last_key);
            else
                result := 0;
            endif;

! stay in loop if just a direction-setting key were pressed
            exitif not ((new_target = "") and (result));
        endif;
    endloop;
endif;

if start_find_key <> 0 then
    stop_find_key := last_key;
endif;

if new_target = "" then    
! allow both <FIND><FIND> and <FIND><some-other-FIND-key>
! (as well as wildcard versions)
    if start_find_key <> 0 then
        if (start_find_key = stop_find_key) or
            (eve$test_synonym ("find", eve$$lookup_comment 
            (stop_find_key, ""))) then
            if eve$x_target = "" then
                eve$message (EVE$_NOPREVTARG);
                return (0);
            else    ! use the direction for the prior <FIND>
                set (eve$x_old_find_direction, current_buffer);
                if get_info (eve$x_target, "type") = STRING then
                    eve$message (EVE$_FINDPREV, 0, eve$x_target);
                else
                    eve$message (EVE$_FINDPREVWILD, 0, eve$x_printable_target);
                endif;
            endif;
        else
            eve$message (EVE$_NOFIND);
            return (0);    ! let caller set direction back if needed
        endif;
    else
        eve$message (EVE$_NOFIND);
        return (0);    ! let caller set direction back if needed
    endif;
else
! restore eve$$k_find_ok widget to invalid_event program

%if eve$x_option_decwindows
%then
    if eve$x_decwindows_active then
        if replacing = 2 then            
            eve$$set_responder (eve$$k_wildcard_find_ok,
                "eve$invalid_event(" +
                str (eve$$k_wildcard_find_ok) + ")");
        else
            eve$$set_responder (eve$$k_find_ok,
                "eve$invalid_event(" + str (eve$$k_find_ok) + ")");
        endif;
    endif;
%endif

! insure a key = "FIND xxx" will always do a find next
    if start_find_key <> 0 then
        if (eve$$x_state_array {eve$$k_command_line_flag} =
            eve$k_invoked_by_key) and
            (start_find_key = stop_find_key) and
            (target <> "") then
            if (((get_info (eve$x_target, "type") = STRING) and
                (eve$x_target = target)) or
                ((get_info (eve$x_target, "type") = PATTERN) and
                (eve$x_printable_target = target))) then
                set (eve$x_old_find_direction, current_buffer);
                key_is_defined := TRUE;
            endif;
        endif;
    endif;
    if not key_is_defined then
        if replacing = 2 then
            bp_return_value := eve$$build_pattern (new_target,
                eve$x_target_pattern, leading_whitespace);
            if get_info (bp_return_value, "type") = KEYWORD then        
! (keyword means an error occurred)
                return (0);    ! let caller set direction back if needed
            else
                if bp_return_value then        
! eve$x_target_pattern is pattern string, e.g.,
! "\<abcd\>" = bol + abcd + eol
                    execute_it := TRUE;
                else        ! eve$x_target_pattern is a search string
                    eve$x_target := eve$x_target_pattern;
                endif;
            endif;
        else
            if get_info (new_target, "type") = STRING then
                if eve$$x_state_array {eve$$k_find_whitespace} then
                    if eve$$build_space_pattern (new_target,
                        eve$x_target_pattern, leading_whitespace) then    
! spaces in new_target
                        execute_it := TRUE;
                    else    ! no spaces in new_target
                        eve$x_target := eve$x_target_pattern;
                    endif;
                else
                    eve$x_target := new_target;
                endif;
            else
                execute_it := TRUE;
            endif;
        endif;

        if execute_it then
! create a pattern variable for wildcard/whitespace
            prefix := "return(";
            postfix := ")";
            if length (eve$x_target_pattern) >
                (256 - length (prefix) - length (postfix)) then
                eve$message (EVE$_TARGETTOOBIG);
                return (FALSE);
            endif;

            eve$x_target := execute (prefix + eve$x_target_pattern + postfix);
        endif;

        if get_info (new_target, "type") = STRING then
            eve$x_printable_target := new_target;
        endif;
        eve$$x_state_array {eve$$k_leading_whitespace} := leading_whitespace;
    endif;
endif;

eve$set_find_target_case (how_exact);

return (TRUE);        ! let caller set direction back if needed

ENDPROCEDURE;

!****************************************
PROCEDURE EVE_ELIMINATE_TABS

!    TABS.TPU - Routine to remove tabs assuming SET TABS EVERY 8

local   target, 
        n,
        old_mode;

old_mode := get_info (current_buffer, "mode");
set (insert, current_buffer);

loop
    target := search(ascii(9), FORWARD);
    exitif (target = 0);
    position(beginning_of(target));
    erase_character(1);
    n := current_offset;
    n := n - (8 * (n / 8));
    copy_text (substr("        ", 1, 8 - n));
endloop;

set (old_mode, current_buffer);

ENDPROCEDURE;

!****************************************
PROCEDURE EVEPLUS_FIND_BUFFER (BUFFER_NAME)
!
!    This routine translates a buffer name to a buffer pointer
!
!    Inputs:
!        buffer_name    String containing the buffer name
!
local   the_buffer, ! Used to hold the buffer pointer
        the_name;   ! A read/write copy of the name

the_name := buffer_name;
change_case (the_name, UPPER);
the_buffer := get_info (buffers, "first");

loop
    exitif (the_buffer = 0);
    exitif (the_name = get_info (the_buffer, "name"));
    the_buffer := get_info (buffer, "next");
endloop;

return the_buffer;

ENDPROCEDURE;

!****************************************
PROCEDURE EVE_REFRESH
!
! Alternate Refresh screen and clear message window routine
!
eve$clear_message;      ! clear message window without deleting messages
refresh;
update (all);

if pce$linedraw_mode = "LINEDRAW" then
    sct_gset;
endif;
update (all);

return (TRUE);

ENDPROCEDURE;