fortrangoingonforty/facsimile / bdabc52

             if (size(editor%cursors) > 1) then

                 ! Move all cursors

                 do i = 1, size(editor%cursors)

                 end do

                 ! Remove duplicate cursors that ended up at same position

                 call deduplicate_cursors(editor)

             else

             end if

             call sync_editor_to_pane(editor)

             call update_viewport(editor)

         last_action_was_edit = is_edit_action

     end subroutine handle_key_command

         type(cursor_t), intent(inout) :: cursor

         type(buffer_t), intent(in) :: buffer

         character(len=:), allocatable :: current_line, target_line

         cursor%has_selection = .false.  ! Clear selection

         found_col = 0

         line_count = buffer_get_line_count(buffer)

         ! Search from current position to end

         do current_line = start_line, line_count

             line = buffer_get_line(buffer, current_line)

                 pos = index(line(search_col:), pattern)

             else

                 search_line = to_lower(line(search_col:))

                 pos = index(search_line, search_pattern)

                 if (allocated(search_line)) deallocate(search_line)

             end if

                         pos = index(line(1:start_col-1), pattern)

                     else

                         search_line = to_lower(line(1:start_col-1))

                         pos = index(search_line, search_pattern)

                         if (allocated(search_line)) deallocate(search_line)

                     end if

                     pos = index(line, pattern)

                 else

                     search_line = to_lower(line)

                     pos = index(search_line, search_pattern)

                     if (allocated(search_line)) deallocate(search_line)

                 end if

         end if

     end subroutine delete_range

     ! Handle input when in fuss mode

     subroutine handle_fuss_input(key_str, editor, buffer)

                     ! Check for dirty buffers and prompt to save

                     if (allocated(editor%tabs)) then

                     end if

                     ! If user didn't cancel, perform the switch

     end subroutine handle_fortress_navigator

     !> Handle dirty buffers before workspace switch

         use save_prompt_module, only: save_prompt, save_prompt_result_t

         use text_buffer_module, only: buffer_save_file

         type(editor_state_t), intent(inout) :: editor

         logical, intent(inout) :: should_continue

         type(save_prompt_result_t) :: prompt_result

         integer :: i, save_status

             if (need_redraw) then

                 call draw_fortress_interface(rows, cols, current_dir, &

                                              current_files, current_is_dir, current_is_exec, current_count, &

                                              selected, parent_selected, scroll_offset, parent_scroll_offset, first_draw)

                 ! Update tracking variables

                     ! Check if arrow key or standalone ESC

                     if (check_arrow_key(key)) then

                         call handle_arrow_key(key, selected, current_dir, temp_dir, current_files, &

                     else

                         ! Standalone ESC - quit

                         cancelled = .true.

     subroutine adjust_scroll(sel, offset, visible_height)

         integer, intent(in) :: sel, visible_height

         integer, intent(inout) :: offset

         ! Add a margin to avoid selection being at the very edge

         margin = 3

     end function check_arrow_key

     !> Handle arrow key navigation

         character(len=1), intent(in) :: key

         character(len=MAX_PATH), intent(inout) :: curr_dir, temp_dir

         character(len=*), dimension(*), intent(in) :: files

         logical, dimension(*), intent(in) :: is_dir

         select case (key)

             case ('A')  ! Up arrow

 contains

     subroutine draw_fortress_interface(r, c, current_dir, current_files, current_is_dir, current_is_exec, &

                                        selected, parent_selected, scroll_offset, parent_scroll_offset, first_draw)

         integer, intent(in) :: r, c, current_count, parent_count, selected, parent_selected

         integer, intent(in) :: scroll_offset, parent_scroll_offset

         character(len=*), intent(in) :: current_dir

         character(len=*), dimension(*), intent(in) :: current_files, parent_files

         logical, dimension(*), intent(in) :: current_is_dir, parent_is_dir

         logical, intent(in), optional :: first_draw

         integer :: left_w, i, j, parent_idx, current_idx, vis_h

         character(len=256) :: parent_name, current_name

         do

             ! Render menu

             call render_welcome_menu(favorites, fav_count, recents, rec_count, &

             ! Get input

             call get_key_input(key_input, status)

     !> Render the welcome menu

     subroutine render_welcome_menu(favorites, fav_count, recents, rec_count, &

         type(favorite_t), intent(in) :: favorites(:)

         type(recent_t), intent(in) :: recents(:)

         integer, intent(in) :: fav_count, rec_count

         logical, intent(in) :: showing_favorites

         character(len=512) :: line

         integer :: i, display_row, visible_height, item_count

         character(len=64) :: title

     function directory_exists(path) result(exists)

         character(len=*), intent(in) :: path

         logical :: exists

         ! Try to open directory (will fail if doesn't exist)

         call execute_command_line('test -d "' // trim(path) // '"', wait=.true., exitstat=ios)

         buffer = ''

         i = 1

         ! Read until 'M' (press) or 'm' (release)

         do

         if (size(editor%tabs) > 0 .and. editor%active_tab_index > 0 .and. &

             editor%active_tab_index <= size(editor%tabs)) then

             if (allocated(editor%tabs(editor%active_tab_index)%panes)) then

                 ! Render status bar after panes

                 call render_status_bar(editor, buffer, match_mode_active, match_case_sens)

                 ! Position cursor for panes

         call render_vertical_separator(separator_col, 2, editor%screen_rows - 1)

         ! Render editor in right pane (check for multiple panes)

         ! Render status bar (full width)

         call render_status_bar(editor, buffer, match_mode_active, match_case_sens)

         end do

     end subroutine render_vertical_separator

         use editor_state_module, only: pane_t

         type(editor_state_t), intent(inout) :: editor

         integer, intent(in) :: start_col, width

         type(pane_t) :: pane

         end do

     end subroutine render_editor_pane

         use editor_state_module, only: pane_t

         type(editor_state_t), intent(inout) :: editor

         type(pane_t) :: pane

         integer :: i, tab_idx, n_panes, active_pane_idx

         character(len=*), intent(in) :: filename

         type(save_prompt_result_t), intent(out) :: result

         integer, intent(in), optional :: current_index, total_count

         character(len=32) :: key_input

         integer :: status, i, slash_pos

         logical :: show_all_option

         character(len=256) :: find_buffer, replace_buffer

         character(len=256) :: prompt

         integer :: find_pos, replace_pos, ch

         ! Initialize

         find_buffer = ''

         character(len=*), intent(in) :: pattern

         logical :: found

         integer :: found_line, found_col

         ! Compile regex if in regex mode

         if (use_regex) then

         type(editor_state_t), intent(inout) :: editor

         type(buffer_t), intent(inout) :: buffer

         integer :: match_len

         integer :: tab_i, pane_i

         if (.not. allocated(current_search_pattern)) return

         logical, intent(out) :: success

         character(len=MAX_PATH_LEN) :: backup_dir, backup_file, basename

         character(len=MAX_PATH_LEN) :: src_file, timestamp_str

         character(len=1024) :: line

         success = .false.

         type(backup_info_t), allocatable, intent(out) :: backups(:)

         integer, intent(out) :: count

         character(len=MAX_PATH_LEN) :: metadata_file, line

         count = 0

         allocate(backups(MAX_BACKUPS))

     end subroutine backup_list

     !> Restore a backup file

         logical, intent(out) :: success

         integer :: unit_src, unit_dst, ios

         character(len=1024) :: line

         close(unit_dst)

         ! Delete the backup after successful restore

         success = .true.

     end subroutine backup_restore

     !> Delete a backup file

         integer :: unit, ios

         ! Delete using Fortran file operations (avoids execute_command_line issues)

         character(len=:), allocatable, intent(out) :: config_path

         character(len=MAX_PATH_LEN) :: home_dir, xdg_config_home

         integer :: unit, ios

         ! Try XDG_CONFIG_HOME environment variable

         call get_environment_variable('XDG_CONFIG_HOME', xdg_config_home)

     ! Interface to C getpid function

     interface

             use iso_c_binding, only: c_int

     end interface

     public :: workspace_exists, workspace_init, workspace_load, workspace_save

         integer :: unit, ios, pid

         ! Get process ID for unique temp file (avoid race conditions)

         write(pid_str, '(I0)') pid

         temp_file = '/tmp/.fac_realpath_' // trim(pid_str)