`5732b28`

Integrate title polling and cursor blink in main loop

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 5732b2883bb53bfbf05d6fa70072de5cff8e6b53
Parents: b0c1a51
Tree: 509d636

3 changed files

Status	File	+	-
M	`src/fortty.f90`	80	8
M	`src/terminal/terminal.f90`	66	3
M	`src/window/window.f90`	231	1

src/fortty.f90modified

  program fortty
    use window_mod
++  use selection_mod, only: selection_contains
    use gl_bindings
    use renderer_mod
    use font_mod, only: font_find_monospace, font_find_for_codepoint
    use screen_mod
    use cell_mod, only: cell_t, set_palette_color, set_default_colors
    use config_mod
++  use cursor_mod, only: CURSOR_BLOCK, CURSOR_UNDERLINE, CURSOR_BAR
++  use glfw_bindings, only: glfwGetTime
    implicit none
    type(window_t) :: win
    real :: x, y, r, g, b, bg_r, bg_g, bg_b
    type(cell_t), allocatable :: sb_line(:)
    integer :: cell_width, cell_height  ! From font metrics
++  real(8) :: current_time, last_time, blink_timer
++  logical :: cursor_blink_visible
++  type(selection_t) :: sel
    ! Load configuration (uses defaults if no config file found)
    cfg = config_load('')
    if (cell_height < 1) cell_height = 18  ! Fallback
    print *, "Font cell size:", cell_width, "x", cell_height
++  ! Share cell dimensions with window module for mouse selection
++  call window_set_cell_size(cell_width, cell_height)
++
    ! Calculate terminal dimensions based on font metrics
    term_cols = win_width / cell_width
    term_rows = win_height / cell_height
    call window_set_pty(pty)
    call window_set_terminal(term)
++  ! Initialize blink timer
++  last_time = glfwGetTime()
++  blink_timer = 0.0d0
++  cursor_blink_visible = .true.
++
    ! Main event loop
    do while (.not. window_should_close(win) .and. pty_is_alive(pty))
++    ! Update blink timer
++    current_time = glfwGetTime()
++    blink_timer = blink_timer + (current_time - last_time)
++    last_time = current_time
++    if (blink_timer > 0.5d0) then
++      cursor_blink_visible = .not. cursor_blink_visible
++      blink_timer = 0.0d0
++    end if
++
      ! Check for window resize
      call window_get_size(win, win_width, win_height)
      if (win_width /= prev_width .or. win_height /= prev_height) then
        end if
      end if
++    ! Check for window title changes (from OSC 0/1/2)
++    if (terminal_has_title_changed(term)) then
++      call window_set_title(win, terminal_get_title(term))
++    end if
++
      ! Clear screen with background color from config
      bg_r = real(cfg%bg_color%r) / 255.0
      bg_g = real(cfg%bg_color%g) / 255.0
      scr => terminal_active_screen(term)
      scroll_offset = terminal_get_scroll_offset(term)
++    ! Get current selection for highlighting
++    sel = window_get_selection()
++
      ! Allocate/resize scrollback line buffer if needed
      if (.not. allocated(sb_line)) then
        allocate(sb_line(term_cols))
          call terminal_get_scrollback_line(term, sb_offset - 1, sb_line, term_cols)
          do col = 1, min(term_cols, scr%cols)
            cell = sb_line(col)
--          if (cell%codepoint /= 32) then
++
--            x = real(col - 1) * cell_width
++          ! Skip continuation cells (2nd half of wide chars)
++          if (cell%is_continuation) cycle
++
++          x = real(col - 1) * cell_width
++
++          ! Draw selection background if selected
++          if (selection_contains(sel, row, col)) then
++            call renderer_draw_rect(ren, x, y, real(cell_width), real(cell_height), &
++                                    0.3, 0.3, 0.6, 1.0)
++          end if
++
++          if (cell%codepoint /= 32 .and. cell%codepoint /= 0) then
              r = real(cell%fg%r) / 255.0
              g = real(cell%fg%g) / 255.0
              b = real(cell%fg%b) / 255.0
          if (screen_row >= 1 .and. screen_row <= scr%rows) then
            do col = 1, scr%cols
              cell = screen_get_cell(scr, screen_row, col)
--            if (cell%codepoint /= 32) then
++
--              x = real(col - 1) * cell_width
++            ! Skip continuation cells (2nd half of wide chars)
++            if (cell%is_continuation) cycle
++
++            x = real(col - 1) * cell_width
++
++            ! Draw selection background if selected
++            if (selection_contains(sel, row, col)) then
++              call renderer_draw_rect(ren, x, y, real(cell_width), real(cell_height), &
++                                      0.3, 0.3, 0.6, 1.0)
++            end if
++
++            if (cell%codepoint /= 32 .and. cell%codepoint /= 0) then
                r = real(cell%fg%r) / 255.0
                g = real(cell%fg%g) / 255.0
                b = real(cell%fg%b) / 255.0
      ! Draw cursor if visible (only when not scrolled back)
      if (term%cursor%visible .and. scroll_offset == 0) then
--      x = real(term%cursor%col - 1) * cell_width
++      ! Check blink state - only hide cursor if blink is enabled and in off phase
--      y = real(term%cursor%row) * cell_height
++      if (.not. term%cursor%blink .or. cursor_blink_visible) then
--      ! Draw cursor as underscore character for visibility
++        x = real(term%cursor%col - 1) * cell_width
--      call renderer_draw_char(ren, x, y, 95, 0.7, 0.7, 0.7, 1.0)  ! '_'
++        y = real(term%cursor%row - 1) * cell_height
++
++        select case (term%cursor%style)
++          case (CURSOR_BLOCK)
++            ! Filled block cursor
++            call renderer_draw_rect(ren, x, y, real(cell_width), real(cell_height), &
++                                    0.7, 0.7, 0.7, 0.8)
++          case (CURSOR_UNDERLINE)
++            ! Underline at bottom of cell
++            call renderer_draw_rect(ren, x, y + real(cell_height) - 2.0, &
++                                    real(cell_width), 2.0, 0.7, 0.7, 0.7, 1.0)
++          case (CURSOR_BAR)
++            ! Vertical bar at left of cell
++            call renderer_draw_rect(ren, x, y, 2.0, real(cell_height), 0.7, 0.7, 0.7, 1.0)
++          case default
++            ! Fallback to block
++            call renderer_draw_rect(ren, x, y, real(cell_width), real(cell_height), &
++                                    0.7, 0.7, 0.7, 0.8)
++        end select
++      end if
      end if
      call renderer_flush(ren)

src/terminal/terminal.f90modified

    use screen_mod
    use cursor_mod
    use scrollback_mod
++  use wcwidth_mod, only: codepoint_width
    implicit none
    private
    public :: terminal_scroll_view, terminal_get_scroll_offset, terminal_reset_scroll_view
    public :: terminal_get_scrollback_count, terminal_get_scrollback_line
    public :: terminal_queue_response, terminal_get_response, terminal_has_response
++  public :: terminal_set_title, terminal_get_title, terminal_has_title_changed
    integer, parameter :: RESPONSE_BUFFER_SIZE = 256
      ! Response buffer for escape sequence replies (e.g., DA1)
      character(len=RESPONSE_BUFFER_SIZE) :: response = ''
      integer :: response_len = 0
++
++    ! Window title (set via OSC 0/1/2)
++    character(len=256) :: title = 'fortty'
++    logical :: title_changed = .false.
    end type terminal_t
  contains
    subroutine terminal_put_char(term, codepoint)
      type(terminal_t), intent(inout) :: term
      integer, intent(in) :: codepoint
--    type(cell_t) :: cell
++    type(cell_t) :: cell, cont_cell
      type(screen_t), pointer :: scr
++    integer :: width
      scr => terminal_active_screen(term)
          return
      end select
++    ! Determine character display width
++    width = codepoint_width(codepoint)
++
++    ! Skip zero-width characters (combining marks, etc.)
++    if (width == 0) return
++
++    ! Check if wide character fits before line end
++    if (width == 2 .and. term%cursor%col + 1 > term%cols) then
++      if (term%mode_autowrap) then
++        call terminal_newline(term)
++        term%cursor%col = 1
++      else
++        ! Can't fit - don't draw
++        return
++      end if
++    end if
++
      ! Printable character - create cell with current style
      cell%codepoint = codepoint
      cell%fg = term%cursor%fg
      cell%bg = term%cursor%bg
      cell%attrs = term%cursor%attrs
++    cell%width = width
++    cell%is_continuation = .false.
      ! Place in buffer
      call screen_set_cell(scr, term%cursor%row, term%cursor%col, cell)
--    ! Advance cursor
++    ! For wide characters, write continuation cell
--    term%cursor%col = term%cursor%col + 1
++    if (width == 2 .and. term%cursor%col < term%cols) then
++      cont_cell%codepoint = 0
++      cont_cell%fg = term%cursor%fg
++      cont_cell%bg = term%cursor%bg
++      cont_cell%attrs = term%cursor%attrs
++      cont_cell%width = 0
++      cont_cell%is_continuation = .true.
++      call screen_set_cell(scr, term%cursor%row, term%cursor%col + 1, cont_cell)
++    end if
++
++    ! Advance cursor by character width
++    term%cursor%col = term%cursor%col + width
      ! Handle wrap at end of line
      if (term%cursor%col > term%cols) then
      term%response_len = 0
    end subroutine terminal_get_response
++  ! Set window title (from OSC 0/1/2)
++  subroutine terminal_set_title(term, title)
++    type(terminal_t), intent(inout) :: term
++    character(len=*), intent(in) :: title
++
++    term%title = title
++    term%title_changed = .true.
++  end subroutine terminal_set_title
++
++  ! Get window title
++  function terminal_get_title(term) result(title)
++    type(terminal_t), intent(in) :: term
++    character(len=256) :: title
++
++    title = term%title
++  end function terminal_get_title
++
++  ! Check if title has changed (and clear the flag)
++  function terminal_has_title_changed(term) result(changed)
++    type(terminal_t), intent(inout) :: term
++    logical :: changed
++
++    changed = term%title_changed
++    term%title_changed = .false.
++  end function terminal_has_title_changed
++
  end module terminal_mod

src/window/window.f90modified

    use gl_bindings
    use pty_mod
    use terminal_mod
++  use selection_mod
    implicit none
    private
--  public :: window_t
++  public :: window_t, selection_t
    public :: window_create, window_destroy
    public :: window_should_close, window_swap_buffers, window_poll_events
    public :: window_get_size, window_set_pty, window_set_terminal
++  public :: window_set_title, window_set_cell_size
++  public :: window_get_selection, window_clipboard_set, window_clipboard_get
    type :: window_t
      type(c_ptr) :: handle = c_null_ptr
    ! Module-level terminal pointer for scrollback
    type(terminal_t), pointer, save :: active_term => null()
++  ! Selection state for mouse-based text selection
++  type(selection_t), save :: active_selection
++
++  ! Cell dimensions for mouse coordinate conversion
++  integer, save :: cell_width = 10
++  integer, save :: cell_height = 18
++
    ! Interface to C helper for loading OpenGL
    interface
      integer(c_int) function fortty_load_gl() bind(C, name="fortty_load_gl")
      dummy = glfwSetKeyCallback(win%handle, c_funloc(key_callback))
      dummy = glfwSetCharCallback(win%handle, c_funloc(char_callback))
      dummy = glfwSetScrollCallback(win%handle, c_funloc(scroll_callback))
++    dummy = glfwSetMouseButtonCallback(win%handle, c_funloc(mouse_button_callback))
++    dummy = glfwSetCursorPosCallback(win%handle, c_funloc(cursor_pos_callback))
    end function window_create
        call terminal_reset_scroll_view(active_term)
      end if
++    ! Handle Ctrl+Shift+V for paste
++    if (iand(mods, GLFW_MOD_CONTROL) /= 0 .and. iand(mods, GLFW_MOD_SHIFT) /= 0) then
++      if (key == GLFW_KEY_V) then
++        call handle_paste(window)
++        return
++      end if
++    end if
++
      ! Handle Ctrl combinations (these don't trigger char_callback)
      if (iand(mods, GLFW_MOD_CONTROL) /= 0) then
        if (key >= GLFW_KEY_A .and. key <= GLFW_KEY_Z) then
      call terminal_scroll_view(active_term, scroll_lines)
    end subroutine scroll_callback
++  ! Set window title
++  subroutine window_set_title(win, title)
++    type(window_t), intent(in) :: win
++    character(len=*), intent(in) :: title
++    character(len=257) :: c_title
++
++    if (.not. c_associated(win%handle)) return
++
++    c_title = trim(title) // c_null_char
++    call glfwSetWindowTitle(win%handle, c_title)
++  end subroutine window_set_title
++
++  ! Set cell dimensions for mouse coordinate conversion
++  subroutine window_set_cell_size(w, h)
++    integer, intent(in) :: w, h
++
++    cell_width = w
++    cell_height = h
++  end subroutine window_set_cell_size
++
++  ! Get selection state (for rendering)
++  function window_get_selection() result(sel)
++    type(selection_t) :: sel
++
++    sel = active_selection
++  end function window_get_selection
++
++  ! Set clipboard content
++  subroutine window_clipboard_set(win, text)
++    type(window_t), intent(in) :: win
++    character(len=*), intent(in) :: text
++    character(len=4097) :: c_text
++
++    if (.not. c_associated(win%handle)) return
++    if (len_trim(text) == 0) return
++
++    c_text = trim(text) // c_null_char
++    call glfwSetClipboardString(win%handle, c_text)
++  end subroutine window_clipboard_set
++
++  ! Get clipboard content
++  function window_clipboard_get(win) result(text)
++    type(window_t), intent(in) :: win
++    character(len=4096) :: text
++    type(c_ptr) :: clip_ptr
++    character(len=1), pointer :: chars(:)
++    integer :: i, length
++
++    text = ''
++    if (.not. c_associated(win%handle)) return
++
++    clip_ptr = glfwGetClipboardString(win%handle)
++    if (.not. c_associated(clip_ptr)) return
++
++    ! Convert C string to Fortran string
++    call c_f_pointer(clip_ptr, chars, [4096])
++    length = 0
++    do i = 1, 4096
++      if (chars(i) == c_null_char) exit
++      length = i
++    end do
++
++    do i = 1, min(length, 4096)
++      text(i:i) = chars(i)
++    end do
++  end function window_clipboard_get
++
++  ! Callback: handle mouse button events
++  subroutine mouse_button_callback(window, button, action, mods) bind(C)
++    type(c_ptr), value :: window
++    integer(c_int), value :: button, action, mods
++    real(c_double) :: xpos, ypos
++    integer :: col, row
++
++    ! Only handle left mouse button for selection
++    if (button /= GLFW_MOUSE_BUTTON_LEFT) return
++
++    call glfwGetCursorPos(window, xpos, ypos)
++
++    ! Convert pixel position to terminal cell coordinates (1-based)
++    col = int(xpos / cell_width) + 1
++    row = int(ypos / cell_height) + 1
++
++    ! Clamp to valid range
++    if (associated(active_term)) then
++      if (col < 1) col = 1
++      if (col > active_term%cols) col = active_term%cols
++      if (row < 1) row = 1
++      if (row > active_term%rows) row = active_term%rows
++    end if
++
++    if (action == GLFW_PRESS) then
++      call selection_start(active_selection, row, col)
++    else if (action == GLFW_RELEASE) then
++      call selection_end(active_selection)
++      ! Copy selection to clipboard if active
++      if (selection_is_active(active_selection)) then
++        call copy_selection_to_clipboard(window)
++      end if
++    end if
++  end subroutine mouse_button_callback
++
++  ! Callback: handle cursor position changes
++  subroutine cursor_pos_callback(window, xpos, ypos) bind(C)
++    type(c_ptr), value :: window
++    real(c_double), value :: xpos, ypos
++    integer :: col, row
++
++    ! Only update if actively selecting
++    if (.not. active_selection%selecting) return
++
++    ! Convert pixel position to terminal cell coordinates (1-based)
++    col = int(xpos / cell_width) + 1
++    row = int(ypos / cell_height) + 1
++
++    ! Clamp to valid range
++    if (associated(active_term)) then
++      if (col < 1) col = 1
++      if (col > active_term%cols) col = active_term%cols
++      if (row < 1) row = 1
++      if (row > active_term%rows) row = active_term%rows
++    end if
++
++    call selection_update(active_selection, row, col)
++  end subroutine cursor_pos_callback
++
++  ! Copy selection to clipboard
++  subroutine copy_selection_to_clipboard(window)
++    use screen_mod
++    use cell_mod
++    type(c_ptr), intent(in) :: window
++    type(screen_t), pointer :: scr
++    type(cell_t) :: cell
++    character(len=4096) :: text
++    character(len=4) :: utf8
++    integer :: r1, c1, r2, c2, row, col, pos, utf8_len
++
++    if (.not. associated(active_term)) return
++    if (.not. selection_is_active(active_selection)) return
++
++    scr => terminal_active_screen(active_term)
++    call selection_get_bounds(active_selection, r1, c1, r2, c2)
++
++    text = ''
++    pos = 1
++
++    do row = r1, r2
++      do col = 1, scr%cols
++        ! Check if this cell is in selection
++        if (.not. selection_contains(active_selection, row, col)) cycle
++
++        cell = screen_get_cell(scr, row, col)
++
++        ! Convert codepoint to UTF-8
++        if (cell%codepoint >= 32 .and. cell%codepoint < 1114112) then
++          call codepoint_to_utf8(cell%codepoint, utf8, utf8_len)
++          if (pos + utf8_len - 1 <= 4096) then
++            text(pos:pos+utf8_len-1) = utf8(1:utf8_len)
++            pos = pos + utf8_len
++          end if
++        end if
++      end do
++
++      ! Add newline between rows (except last row)
++      if (row < r2 .and. pos < 4096) then
++        text(pos:pos) = char(10)
++        pos = pos + 1
++      end if
++    end do
++
++    ! Set clipboard
++    if (pos > 1) then
++      call glfwSetClipboardString(window, trim(text(1:pos-1)) // c_null_char)
++    end if
++  end subroutine copy_selection_to_clipboard
++
++  ! Handle paste from clipboard
++  subroutine handle_paste(window)
++    type(c_ptr), intent(in) :: window
++    type(c_ptr) :: clip_ptr
++    character(len=1), pointer :: chars(:)
++    integer :: i, length
++
++    if (.not. associated(active_pty)) return
++
++    clip_ptr = glfwGetClipboardString(window)
++    if (.not. c_associated(clip_ptr)) return
++
++    ! Find length of C string
++    call c_f_pointer(clip_ptr, chars, [4096])
++    length = 0
++    do i = 1, 4096
++      if (chars(i) == c_null_char) exit
++      length = i
++    end do
++
++    ! Write to PTY
++    if (length > 0) then
++      block
++        character(len=4096) :: paste_text
++        integer :: j
++        paste_text = ''
++        do j = 1, length
++          paste_text(j:j) = chars(j)
++        end do
++        call pty_write(active_pty, paste_text, length)
++      end block
++    end if
++  end subroutine handle_paste
++
  end module window_mod