`89afb01`

resolve some rednering things with ctrl-b pane

Authored by

espadonne 6 months ago

SHA: 89afb015b0863cac22973bdfd699173585720395
Parents: aa6e7df
Tree: e0e0c2c

4 changed files

Status	File	+	-
M	`src/terminal/renderer_module.f90`	2	2
M	`src/workspace/file_tree_module.f90`	141	11
M	`src/workspace/file_tree_renderer_module.f90`	72	23
A	`test/test_tree.f90`	90	0

src/terminal/renderer_module.f90modified

          editor_start_col = tree_width + 2
          editor_width = editor%screen_cols - editor_start_col + 1
--        ! Render file tree in left pane
++        ! Render file tree in left pane (start at column 2 to avoid edge cutoff)
--        call render_file_tree(tree_state, 1, editor%screen_rows - 1, 1, tree_width)
++        call render_file_tree(tree_state, 1, editor%screen_rows - 1, 2, tree_width - 2)
          ! Render vertical separator
          call render_vertical_separator(separator_col, editor%screen_rows - 1)

src/workspace/file_tree_module.f90modified

      ! Tree node using linked list structure (first-child, next-sibling)
      type :: tree_node_t
          character(len=256) :: name = ''
++        character(len=512) :: full_path = ''  ! Full path for files (for staging)
          logical :: is_file = .false.
          logical :: is_staged = .false.
          logical :: is_unstaged = .false.
          logical :: has_incoming = .false.
      end type file_entry_t
++    ! Selectable item (files only, in tree traversal order)
++    type :: selectable_file_t
++        character(len=512) :: path = ''
++        logical :: is_staged = .false.
++        logical :: is_unstaged = .false.
++        logical :: is_untracked = .false.
++    end type selectable_file_t
++
      ! Tree state for navigation
      type :: tree_state_t
          type(file_entry_t), allocatable :: files(:)
++        type(selectable_file_t), allocatable :: selectable_files(:)
          integer :: n_files = 0
++        integer :: n_selectable = 0
          integer :: selected_index = 1
          integer :: viewport_offset = 1
          type(tree_node_t), pointer :: root => null()
          type(tree_state_t), intent(inout) :: state
          if (allocated(state%files)) deallocate(state%files)
++        if (allocated(state%selectable_files)) deallocate(state%selectable_files)
          if (associated(state%root)) call free_tree(state%root)
          state%n_files = 0
++        state%n_selectable = 0
          state%selected_index = 1
      end subroutine cleanup_tree_state
              call free_tree(state%root)
              state%root => null()
          end if
++        if (allocated(state%selectable_files)) deallocate(state%selectable_files)
          ! Get dirty files from git
          call get_dirty_files(workspace_path, state%files, state%n_files)
          ! Build tree from files
          if (state%n_files > 0) then
              call build_tree(state%files, state%n_files, state%root)
++            ! Build selectable files list in tree traversal order
++            call build_selectable_list(state%root, state%selectable_files, state%n_selectable)
++        else
++            state%n_selectable = 0
          end if
          ! Clamp selected index
--        if (state%selected_index > state%n_files .and. state%n_files > 0) then
++        if (state%selected_index > state%n_selectable .and. state%n_selectable > 0) then
--            state%selected_index = state%n_files
++            state%selected_index = state%n_selectable
--        else if (state%n_files == 0) then
++        else if (state%n_selectable == 0) then
              state%selected_index = 1
          end if
      end subroutine refresh_tree_state
          integer, intent(in) :: n_files
          type(tree_node_t), pointer, intent(out) :: root
          integer :: i
++        integer :: debug_unit
          ! Create root
          allocate(root)
          ! Sort tree
          call sort_tree(root)
++
++        ! DEBUG: Write tree structure to file (unconditional)
++        open(newunit=debug_unit, file='/tmp/fac_tree_debug.txt', status='replace', action='write')
++        write(debug_unit, '(A)') '=== FINAL TREE STRUCTURE ==='
++        call debug_print_tree(root, '', debug_unit)
++        close(debug_unit)
++
++        ! Also write to a simpler path
++        open(10, file='fac_debug.txt', status='replace', action='write')
++        write(10, '(A)') '=== FINAL TREE STRUCTURE ==='
++        call debug_print_tree(root, '', 10)
++        close(10)
      end subroutine build_tree
++    recursive subroutine debug_print_tree(node, prefix, unit)
++        type(tree_node_t), pointer, intent(in) :: node
++        character(len=*), intent(in) :: prefix
++        integer, intent(in) :: unit
++        type(tree_node_t), pointer :: child
++
++        if (.not. associated(node)) return
++
++        write(unit, '(A,A,A,L,A,L)') trim(prefix), trim(node%name), &
++            ' is_file=', node%is_file, ' has_next_sib=', associated(node%next_sibling)
++
++        child => node%first_child
++        do while (associated(child))
++            call debug_print_tree(child, prefix // '  ', unit)
++            child => child%next_sibling
++        end do
++    end subroutine debug_print_tree
++
      subroutine add_to_tree(root, path, is_staged, is_unstaged, is_untracked, has_incoming)
          type(tree_node_t), pointer, intent(inout) :: root
          character(len=*), intent(in) :: path
                  child => new_node
              end if
--            ! If this is the final component, set status
++            ! If this is the final component, set status and full path
              if (len_trim(remaining_path) == 0) then
                  child%is_staged = is_staged
                  child%is_unstaged = is_unstaged
                  child%is_untracked = is_untracked
                  child%has_incoming = has_incoming
++                child%full_path = trim(path)
              end if
              current => child
          type(tree_node_t), pointer, intent(inout) :: parent
          type(tree_node_t), pointer :: sorted, current, next_node, insert_pos, prev
          logical :: inserted
++        integer :: debug_unit
++        type(tree_node_t), pointer :: check_ptr
          if (.not. associated(parent%first_child)) return
++        ! DEBUG: Write pre-sort state (both file and stderr)
++        if (trim(parent%name) == 'workspace') then
++            open(newunit=debug_unit, file='/tmp/fac_sort_debug.txt', status='replace', action='write')
++            write(debug_unit, '(A)') '=== Sorting workspace children ==='
++            write(debug_unit, '(A)') 'Before sort:'
++            write(0, '(A)') '[DEBUG] Sorting workspace children'
++            write(0, '(A)') '[DEBUG] Before sort:'
++            check_ptr => parent%first_child
++            do while (associated(check_ptr))
++                write(debug_unit, '(A,A,A,L)') '  ', trim(check_ptr%name), ' next_sib=', associated(check_ptr%next_sibling)
++                write(0, '(A,A,A,L)') '[DEBUG]   ', trim(check_ptr%name), ' next_sib=', associated(check_ptr%next_sibling)
++                check_ptr => check_ptr%next_sibling
++            end do
++        end if
++
          sorted => null()
          current => parent%first_child
          end do
          parent%first_child => sorted
++
++        ! DEBUG: Write post-sort state (both file and stderr)
++        if (trim(parent%name) == 'workspace') then
++            write(debug_unit, '(A)') 'After sort:'
++            write(0, '(A)') '[DEBUG] After sort:'
++            check_ptr => parent%first_child
++            do while (associated(check_ptr))
++                write(debug_unit, '(A,A,A,L)') '  ', trim(check_ptr%name), ' next_sib=', associated(check_ptr%next_sibling)
++                write(0, '(A,A,A,L)') '[DEBUG]   ', trim(check_ptr%name), ' next_sib=', associated(check_ptr%next_sibling)
++                check_ptr => check_ptr%next_sibling
++            end do
++            write(debug_unit, '(A)') ''
++            close(debug_unit)
++        end if
      end subroutine sort_children
      function compare_nodes(a, b) result(cmp)
          end if
      end function compare_nodes
++    ! Build list of selectable files in tree traversal order
++    subroutine build_selectable_list(root, selectable, n_selectable)
++        type(tree_node_t), pointer, intent(in) :: root
++        type(selectable_file_t), allocatable, intent(out) :: selectable(:)
++        integer, intent(out) :: n_selectable
++        type(selectable_file_t), allocatable :: temp(:)
++        integer :: max_size, count
++
++        max_size = 1000
++        allocate(temp(max_size))
++        count = 0
++
++        ! Traverse tree and collect files
++        call collect_files_recursive(root, temp, count, max_size)
++
++        n_selectable = count
++        allocate(selectable(n_selectable))
++        if (n_selectable > 0) selectable(1:n_selectable) = temp(1:n_selectable)
++        deallocate(temp)
++    end subroutine build_selectable_list
++
++    recursive subroutine collect_files_recursive(node, list, count, max_size)
++        type(tree_node_t), pointer, intent(in) :: node
++        type(selectable_file_t), intent(inout) :: list(:)
++        integer, intent(inout) :: count
++        integer, intent(in) :: max_size
++        type(tree_node_t), pointer :: child
++
++        if (.not. associated(node)) return
++
++        ! If this is a file, add it to the list
++        if (node%is_file .and. len_trim(node%full_path) > 0) then
++            count = count + 1
++            if (count <= max_size) then
++                list(count)%path = node%full_path
++                list(count)%is_staged = node%is_staged
++                list(count)%is_unstaged = node%is_unstaged
++                list(count)%is_untracked = node%is_untracked
++            end if
++        end if
++
++        ! Recursively process children (in order)
++        child => node%first_child
++        do while (associated(child))
++            call collect_files_recursive(child, list, count, max_size)
++            child => child%next_sibling
++        end do
++    end subroutine collect_files_recursive
++
      recursive subroutine free_tree(node)
          type(tree_node_t), pointer, intent(inout) :: node
          type(tree_node_t), pointer :: child, next_child
      subroutine tree_move_down(state)
          type(tree_state_t), intent(inout) :: state
--        if (state%selected_index < state%n_files) then
++        if (state%selected_index < state%n_selectable) then
              state%selected_index = state%selected_index + 1
          end if
      end subroutine tree_move_down
          type(tree_state_t), intent(in) :: state
          character(len=:), allocatable :: path
--        if (state%selected_index >= 1 .and. state%selected_index <= state%n_files) then
++        if (state%selected_index >= 1 .and. state%selected_index <= state%n_selectable) then
--            path = trim(state%files(state%selected_index)%path)
++            path = trim(state%selectable_files(state%selected_index)%path)
          else
              path = ''
          end if
          character(len=1024) :: cmd
          integer :: status
--        if (state%selected_index < 1 .or. state%selected_index > state%n_files) return
++        if (state%selected_index < 1 .or. state%selected_index > state%n_selectable) return
          ! Stage the file
          write(cmd, '(A,A,A,A,A)') 'cd "', trim(workspace_path), '" && git add "', &
--                                  trim(state%files(state%selected_index)%path), '" 2>/dev/null'
++                                  trim(state%selectable_files(state%selected_index)%path), '" 2>/dev/null'
          call execute_command_line(trim(cmd), exitstat=status)
          ! Refresh tree
          character(len=1024) :: cmd
          integer :: status
--        if (state%selected_index < 1 .or. state%selected_index > state%n_files) return
++        if (state%selected_index < 1 .or. state%selected_index > state%n_selectable) return
          ! Unstage the file
          write(cmd, '(A,A,A,A,A)') 'cd "', trim(workspace_path), '" && git restore --staged "', &
--                                  trim(state%files(state%selected_index)%path), '" 2>/dev/null'
++                                  trim(state%selectable_files(state%selected_index)%path), '" 2>/dev/null'
          call execute_command_line(trim(cmd), exitstat=status)
          ! Refresh tree

src/workspace/file_tree_renderer_module.f90modified

          current_row = start_row
++        ! DEBUG: Visual marker at column 1
++        call terminal_move_cursor(1, 1)
++        call terminal_write('[COL1]')
++
          ! Display repo:branch info at top if available
          if (len_trim(state%repo_name) > 0 .and. len_trim(state%branch_name) > 0) then
              call terminal_move_cursor(current_row, start_col)
          integer, intent(inout) :: item_idx, current_row
          integer, intent(in) :: end_row, start_col, width
--        character(len=1024) :: line, new_prefix
++        character(len=:), allocatable :: line, new_prefix, branch
          type(tree_node_t), pointer :: child
--        integer :: n_children, i
++        logical :: is_selected, is_last_child
--        logical :: is_selected
++        integer :: prefix_len, i
--
--        ! Count children
--        n_children = 0
--        child => node%first_child
--        do while (associated(child))
--            n_children = n_children + 1
--            child => child%next_sibling
--        end do
          ! Don't print root node
          if (.not. is_root) then
              if (current_row <= end_row) then
                  ! Build line with tree structure
                  if (is_last) then
--                    line = trim(prefix) // BRANCH_LAST // ' ' // trim(node%name)
++                    branch = BRANCH_LAST
                  else
--                    line = trim(prefix) // BRANCH_MID // ' ' // trim(node%name)
++                    branch = BRANCH_MID
++                end if
++
++                ! DEBUG: Check branch assignment for root's children
++                if (len_trim(prefix) == 0 .and. trim(node%name) == 'src') then
++                    open(98, file='/tmp/fac_branch_debug.txt', status='replace')
++                    write(98, '(A,L,A,I0)') 'is_last=', is_last, ' len(branch)=', len(branch)
++                    write(98, '(A,Z2.2,Z2.2,Z2.2)') 'branch bytes: ', &
++                        ichar(branch(1:1)), ichar(branch(2:2)), ichar(branch(3:3))
++                    write(98, '(A)') 'BRANCH_MID='//BRANCH_MID
++                    write(98, '(A)') 'BRANCH_LAST='//BRANCH_LAST
++                    close(98)
++                end if
++
++                ! Construct the line - prefix can be empty string, that's fine
++                line = prefix // branch // ' ' // trim(node%name)
++
++                ! DEBUG: Check what's actually in line for src
++                if (trim(node%name) == 'src') then
++                    open(96, file='/tmp/fac_line_debug.txt', status='replace')
++                    write(96, '(A,I0)') 'len(line)=', len(line)
++                    write(96, '(A,I0)') 'len(prefix)=', len(prefix)
++                    write(96, '(A,I0)') 'len(branch)=', len(branch)
++                    write(96, '(A)') 'line bytes (first 20):'
++                    write(96, '(20(Z2.2,1X))') (ichar(line(i:i)), i=1,min(20,len(line)))
++                    write(96, '(A)') 'Full line: >'//line//'<'
++                    close(96)
                  end if
                  ! Add status indicators for files only
                  if (node%is_file) then
                      if (node%is_staged) then
--                        line = trim(line) // ' ' // ESC // '[32m↑' // ESC // '[0m'  ! Green up arrow
++                        line = line // ' ' // ESC // '[32m↑' // ESC // '[0m'  ! Green up arrow
                      end if
                      if (node%is_unstaged) then
--                        line = trim(line) // ' ' // ESC // '[31m✗' // ESC // '[0m'  ! Red X
++                        line = line // ' ' // ESC // '[31m✗' // ESC // '[0m'  ! Red X
                      end if
                      if (node%is_untracked) then
--                        line = trim(line) // ' ' // ESC // '[90m✗' // ESC // '[0m'  ! Gray X
++                        line = line // ' ' // ESC // '[90m✗' // ESC // '[0m'  ! Gray X
                      end if
                  end if
                  call terminal_move_cursor(current_row, start_col)
                  if (is_selected) then
                      ! Selection highlight (reverse video)
--                    call terminal_write(ESC // '[7m' // trim(line) // ESC // '[0m')
++                    call terminal_write(ESC // '[7m' // line // ESC // '[0m')
                  else
--                    call terminal_write(trim(line))
++                    call terminal_write(line)
                  end if
                  current_row = current_row + 1
          end if
          ! Render children
--        i = 0
          child => node%first_child
          do while (associated(child) .and. current_row <= end_row)
--            i = i + 1
++            ! Determine if this is the last sibling
++            is_last_child = .not. associated(child%next_sibling)
++
++            ! DEBUG: Write sibling info for workspace children
++            if (trim(node%name) == 'workspace') then
++                open(99, file='/tmp/fac_render_debug.txt', position='append')
++                write(99, '(A,A,A,L)') 'Child: ', trim(child%name), ' has_next_sib=', associated(child%next_sibling)
++                close(99)
++            end if
++
++            ! Build prefix for child based on current node's position
              if (is_root) then
++                ! Root's children start with no prefix
                  new_prefix = ''
              else
++                ! Non-root children inherit prefix and add continuation
++                ! IMPORTANT: Don't trim prefix! It contains accumulated indentation
                  if (is_last) then
--                    new_prefix = trim(prefix) // '    '
++                    ! Current node is last, so children get spaces (no vertical line continues)
++                    new_prefix = prefix // '    '
                  else
--                    new_prefix = trim(prefix) // VERTICAL // '   '
++                    ! Current node is not last, so vertical line continues for children
++                    new_prefix = prefix // VERTICAL // '   '
++                end if
++            end if
++
++            ! DEBUG: Log prefix building for src
++            if (trim(node%name) == 'src' .or. trim(child%name) == 'workspace') then
++                open(97, file='/tmp/fac_prefix_debug.txt', position='append')
++                write(97, '(A,A,A,L,A,A,A,A)') &
++                    'Node: ', trim(node%name), ' is_root=', is_root, ' is_last=', merge('T', 'F', is_last), &
++                    ' Child: ', trim(child%name)
++                write(97, '(A,I0,A)') 'new_prefix len=', len(new_prefix), ' content=>'//new_prefix//'<'
++                if (.not. is_root .and. .not. is_last) then
++                    write(97, '(A)') 'Should have added VERTICAL: '//VERTICAL
                  end if
++                close(97)
              end if
--            call render_tree_node(child, new_prefix, i == n_children, .false., &
++            call render_tree_node(child, new_prefix, is_last_child, .false., &
                                  state, item_idx, current_row, end_row, start_col, width)
              child => child%next_sibling
          end do

test/test_tree.f90added

++program test_tree
++    use file_tree_module
++    implicit none
++
++    type(file_entry_t), allocatable :: files(:)
++    type(tree_node_t), pointer :: root, child
++    integer :: n_files
++
++    ! Create test data matching current git status
++    n_files = 3
++    allocate(files(n_files))
++
++    files(1)%path = 'README.md'
++    files(1)%is_staged = .false.
++    files(1)%is_unstaged = .true.
++    files(1)%is_untracked = .false.
++    files(1)%has_incoming = .false.
++
++    files(2)%path = 'src/workspace/file_tree_module.f90'
++    files(2)%is_staged = .false.
++    files(2)%is_unstaged = .true.
++    files(2)%is_untracked = .false.
++    files(2)%has_incoming = .false.
++
++    files(3)%path = 'src/workspace/file_tree_renderer_module.f90'
++    files(3)%is_staged = .false.
++    files(3)%is_unstaged = .true.
++    files(3)%is_untracked = .false.
++    files(3)%has_incoming = .false.
++
++    ! Build tree
++    call build_tree(files, n_files, root)
++
++    print *, 'Tree structure:'
++    call print_tree(root, '')
++
++    ! Check workspace children specifically
++    print *, ''
++    print *, 'Checking src/workspace children:'
++    call check_workspace_children(root)
++
++contains
++
++    recursive subroutine print_tree(node, prefix)
++        type(tree_node_t), pointer, intent(in) :: node
++        character(len=*), intent(in) :: prefix
++        type(tree_node_t), pointer :: child
++
++        if (.not. associated(node)) return
++
++        print '(A,A,A,L,A,L)', trim(prefix), trim(node%name), &
++            ' is_file=', node%is_file, ' has_next_sib=', associated(node%next_sibling)
++
++        child => node%first_child
++        do while (associated(child))
++            call print_tree(child, prefix // '  ')
++            child => child%next_sibling
++        end do
++    end subroutine print_tree
++
++    recursive subroutine check_workspace_children(node)
++        type(tree_node_t), pointer, intent(in) :: node
++        type(tree_node_t), pointer :: child
++        integer :: count
++
++        if (.not. associated(node)) return
++
++        ! Found workspace directory
++        if (trim(node%name) == 'workspace') then
++            print *, 'Found workspace directory!'
++            child => node%first_child
++            count = 0
++            do while (associated(child))
++                count = count + 1
++                print '(A,I0,A,A,A,L)', '  Child ', count, ': ', trim(child%name), &
++                    ' has_next_sib=', associated(child%next_sibling)
++                child => child%next_sibling
++            end do
++            return
++        end if
++
++        ! Recurse to children
++        child => node%first_child
++        do while (associated(child))
++            call check_workspace_children(child)
++            child => child%next_sibling
++        end do
++    end subroutine check_workspace_children
++
++end program test_tree