`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
 -        call render_file_tree(tree_state, 1, editor%screen_rows - 1, 1, tree_width)
 +        ! 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, 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
 -            state%selected_index = state%n_files
 -        else if (state%n_files == 0) then
 +        if (state%selected_index > state%n_selectable .and. state%n_selectable > 0) then
 +            state%selected_index = state%n_selectable
 +        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
 -            path = trim(state%files(state%selected_index)%path)
 +        if (state%selected_index >= 1 .and. state%selected_index <= state%n_selectable) then
 +            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
+-
 -        ! Count children
 -        n_children = 0
 -        child => node%first_child
 -        do while (associated(child))
 -            n_children = n_children + 1
 -            child => child%next_sibling
 -        end do
 +        logical :: is_selected, is_last_child
 +        integer :: prefix_len, i
          ! 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