`bc16410`

implement cairo filing cabinet tab bar with card styling

Co-Authored-By: mfwolffe <wolffemf@dukes.jmu.edu>

Authored by

espadonne 6 months ago

SHA: bc164103961e89457338c1901d092390230c8506
Parents: 6528e81
Tree: dd64bbe

3 changed files

Status	File	+	-
M	`meson.build`	1	0
A	`src/gui/cairo_tab_bar.f90`	494	0
M	`src/gui/gtk_app.f90`	101	15

meson.buildmodified

    # GTK4 interface
    'src/gui/tab_manager.f90',       # Tab state management (only depends on types)
    'src/gui/tab_widget.f90',        # Tab bar UI (depends on tab_manager)
 +  'src/gui/cairo_tab_bar.f90',     # Cairo-rendered filing cabinet tabs
    'src/gui/treemap_widget.f90',    # Must come before gtk_app (dependency)
    'src/gui/breadcrumb_widget.f90',  # Must come before gtk_app (dependency)
    'src/gui/gtk_app.f90',

src/gui/cairo_tab_bar.f90added

 +! Cairo-rendered Filing Cabinet Tab Bar for Sniffly
 +! Custom tab bar with squarrounded tabs that resemble filing cabinet tabs
 +module cairo_tab_bar
 +  use, intrinsic :: iso_c_binding
 +  use gtk, only: gtk_drawing_area_new, gtk_drawing_area_set_draw_func, &
 +                 gtk_widget_set_size_request, gtk_event_controller_motion_new, &
 +                 gtk_widget_add_controller, gtk_gesture_click_new, &
 +                 gtk_widget_queue_draw, gtk_widget_set_hexpand, g_signal_connect
 +  use cairo, only: cairo_set_source_rgb, cairo_set_source_rgba, cairo_move_to, &
 +                   cairo_line_to, cairo_curve_to, cairo_fill, cairo_stroke, &
 +                   cairo_set_line_width, cairo_arc
 +  use pango, only: pango_cairo_create_layout, pango_layout_set_text, &
 +                   pango_font_description_from_string, pango_layout_set_font_description, &
 +                   pango_cairo_show_layout, pango_layout_get_pixel_size, &
 +                   pango_font_description_free
 +  implicit none
 +  private
++
 +  public :: create_cairo_tab_bar, refresh_cairo_tab_bar, get_cairo_tab_bar_widget, &
 +            register_cairo_tab_switch_callback, register_cairo_tab_close_callback, &
 +            register_cairo_new_tab_callback
++
 +  ! Tab dimensions
 +  integer, parameter :: TAB_HEIGHT = 32
 +  integer, parameter :: TAB_MIN_WIDTH = 120
 +  integer, parameter :: TAB_MAX_WIDTH = 200
 +  integer, parameter :: TAB_CORNER_RADIUS = 8
 +  integer, parameter :: TAB_OVERLAP = 10
 +  integer, parameter :: PLUS_BUTTON_WIDTH = 32
 +  integer, parameter :: CLOSE_BUTTON_SIZE = 16
 +  integer, parameter :: CLOSE_BUTTON_MARGIN = 8
++
 +  ! Tab bar state
 +  type(c_ptr), save :: tab_bar_widget = c_null_ptr
 +  integer, save :: hovered_tab = 0  ! 0 = none, -1 = plus button, 1+ = tab index
 +  integer, save :: hovered_close_button = 0  ! Which tab's close button is hovered
++
 +  ! Tab bounds for hit testing
 +  type :: tab_bounds
 +    integer :: x, y, width, height
 +    integer :: close_x, close_y  ! Close button position
 +  end type tab_bounds
++
 +  type(tab_bounds), dimension(5), save :: tab_rects  ! Max 5 tabs
 +  integer :: plus_button_x, plus_button_y
++
 +  ! Callback interfaces
 +  abstract interface
 +    subroutine tab_switch_callback(tab_index)
 +      integer, intent(in) :: tab_index
 +    end subroutine tab_switch_callback
++
 +    subroutine tab_close_callback(tab_index)
 +      integer, intent(in) :: tab_index
 +    end subroutine tab_close_callback
++
 +    subroutine new_tab_callback()
 +    end subroutine new_tab_callback
 +  end interface
++
 +  ! Registered callbacks
 +  procedure(tab_switch_callback), pointer, save :: switch_cb => null()
 +  procedure(tab_close_callback), pointer, save :: close_cb => null()
 +  procedure(new_tab_callback), pointer, save :: new_tab_cb => null()
++
 +contains
++
 +  ! Create the Cairo-rendered tab bar
 +  function create_cairo_tab_bar() result(widget)
 +    type(c_ptr) :: widget, motion_controller, click_controller
++
 +    ! Create drawing area
 +    widget = gtk_drawing_area_new()
 +    tab_bar_widget = widget
++
 +    if (.not. c_associated(widget)) then
 +      print *, "ERROR: Failed to create cairo tab bar drawing area"
 +      return
 +    end if
++
 +    ! Set fixed height, expand horizontally
 +    call gtk_widget_set_size_request(widget, -1_c_int, TAB_HEIGHT)
 +    call gtk_widget_set_hexpand(widget, 1_c_int)
++
 +    ! Set draw function
 +    call gtk_drawing_area_set_draw_func(widget, c_funloc(on_draw_tabs), &
 +                                        c_null_ptr, c_null_ptr)
++
 +    ! Add motion controller for hover effects
 +    motion_controller = gtk_event_controller_motion_new()
 +    call g_signal_connect(motion_controller, "motion"//c_null_char, &
 +                          c_funloc(on_tab_motion), c_null_ptr)
 +    call g_signal_connect(motion_controller, "leave"//c_null_char, &
 +                          c_funloc(on_tab_leave), c_null_ptr)
 +    call gtk_widget_add_controller(widget, motion_controller)
++
 +    ! Add click controller
 +    click_controller = gtk_gesture_click_new()
 +    call g_signal_connect(click_controller, "pressed"//c_null_char, &
 +                          c_funloc(on_tab_click), c_null_ptr)
 +    call gtk_widget_add_controller(widget, click_controller)
++
 +    print *, "Cairo tab bar created"
 +  end function create_cairo_tab_bar
++
 +  ! Draw the tab bar
 +  subroutine on_draw_tabs(area, cr, width, height, user_data) bind(c)
 +    use tab_manager, only: num_tabs, active_tab_index, get_tab, tab_state
 +    type(c_ptr), value :: area, cr, user_data
 +    integer(c_int), value :: width, height
 +    type(tab_state), pointer :: tab
 +    integer :: i, tab_x, tab_width, total_tabs_width
 +    real(c_double) :: r, g, b, alpha
++
 +    ! Clear background
 +    call cairo_set_source_rgb(cr, 0.95_c_double, 0.95_c_double, 0.95_c_double)
 +    call cairo_move_to(cr, 0.0_c_double, 0.0_c_double)
 +    call cairo_line_to(cr, real(width, c_double), 0.0_c_double)
 +    call cairo_line_to(cr, real(width, c_double), real(height, c_double))
 +    call cairo_line_to(cr, 0.0_c_double, real(height, c_double))
 +    call cairo_fill(cr)
++
 +    ! Calculate starting position (flush to right edge, no overlap between tabs)
 +    total_tabs_width = num_tabs * TAB_MIN_WIDTH + PLUS_BUTTON_WIDTH
 +    tab_x = width - total_tabs_width
++
 +    ! Draw plus button first (leftmost)
 +    call draw_plus_button(cr, tab_x, 0)
 +    plus_button_x = tab_x
 +    plus_button_y = 0
 +    tab_x = tab_x + PLUS_BUTTON_WIDTH
++
 +    ! First pass: calculate positions and store in tab_rects
 +    do i = 1, num_tabs
 +      tab => get_tab(i)
 +      if (.not. associated(tab)) cycle
++
 +      tab_width = TAB_MIN_WIDTH
++
 +      ! Store bounds for hit testing
 +      tab_rects(i)%x = tab_x
 +      tab_rects(i)%y = 0
 +      tab_rects(i)%width = tab_width
 +      tab_rects(i)%height = TAB_HEIGHT
++
 +      ! No overlap - tabs sit flush next to each other
 +      tab_x = tab_x + tab_width
 +    end do
++
 +    ! Second pass: draw inactive tabs first (so they appear behind)
 +    do i = 1, num_tabs
 +      if (i == active_tab_index) cycle  ! Skip active tab
 +      tab => get_tab(i)
 +      if (.not. associated(tab)) cycle
++
 +      call draw_inactive_tab(cr, tab_rects(i)%x, TAB_MIN_WIDTH, trim(tab%label), i == hovered_tab)
 +    end do
++
 +    ! Third pass: draw active tab last (so it appears on top)
 +    if (active_tab_index >= 1 .and. active_tab_index <= num_tabs) then
 +      tab => get_tab(active_tab_index)
 +      if (associated(tab)) then
 +        call draw_active_tab(cr, tab_rects(active_tab_index)%x, TAB_MIN_WIDTH, &
 +                           trim(tab%label), active_tab_index == hovered_tab)
 +      end if
 +    end if
 +  end subroutine on_draw_tabs
++
 +  ! Draw an active tab (full brightness, merges into canvas)
 +  subroutine draw_active_tab(cr, x, width, label, is_hovered)
 +    type(c_ptr), intent(in) :: cr
 +    integer, intent(in) :: x, width
 +    character(len=*), intent(in) :: label
 +    logical, intent(in) :: is_hovered
 +    real(c_double) :: x_d, y_d, w_d, h_d, radius
++
 +    x_d = real(x, c_double)
 +    y_d = 0.0_c_double
 +    w_d = real(width, c_double)
 +    h_d = real(TAB_HEIGHT, c_double)
 +    radius = real(TAB_CORNER_RADIUS, c_double)
++
 +    ! Draw squarrounded shape (rounded top, flat bottom)
 +    call cairo_move_to(cr, x_d, h_d)  ! Bottom left
 +    call cairo_line_to(cr, x_d, y_d + radius)  ! Left edge
 +    call cairo_arc(cr, x_d + radius, y_d + radius, radius, 3.14159_c_double, -1.57080_c_double)  ! Top left corner
 +    call cairo_line_to(cr, x_d + w_d - radius, y_d)  ! Top edge
 +    call cairo_arc(cr, x_d + w_d - radius, y_d + radius, radius, -1.57080_c_double, 0.0_c_double)  ! Top right corner
 +    call cairo_line_to(cr, x_d + w_d, h_d)  ! Right edge to bottom
++
 +    ! Fill with white/light gray (active color)
 +    if (is_hovered) then
 +      call cairo_set_source_rgb(cr, 1.0_c_double, 1.0_c_double, 1.0_c_double)
 +    else
 +      call cairo_set_source_rgb(cr, 0.98_c_double, 0.98_c_double, 0.98_c_double)
 +    end if
 +    call cairo_fill(cr)
++
 +    ! Draw border (but not bottom for "seeping" effect)
 +    call draw_tab_border_no_bottom(cr, x_d, y_d, w_d, h_d, radius)
++
 +    ! Draw label
 +    call draw_tab_label(cr, x, 0, width, TAB_HEIGHT, label, .false.)
++
 +    ! Draw close button
 +    call draw_close_button(cr, x, width, .false.)
 +  end subroutine draw_active_tab
++
 +  ! Draw an inactive tab (dimmed, with bottom border)
 +  subroutine draw_inactive_tab(cr, x, width, label, is_hovered)
 +    type(c_ptr), intent(in) :: cr
 +    integer, intent(in) :: x, width
 +    character(len=*), intent(in) :: label
 +    logical, intent(in) :: is_hovered
 +    real(c_double) :: x_d, y_d, w_d, h_d, radius
++
 +    x_d = real(x, c_double)
 +    y_d = 2.0_c_double  ! Slightly lower than active
 +    w_d = real(width, c_double)
 +    h_d = real(TAB_HEIGHT - 2, c_double)
 +    radius = real(TAB_CORNER_RADIUS, c_double)
++
 +    ! Draw squarrounded shape
 +    call cairo_move_to(cr, x_d, y_d + h_d)  ! Bottom left
 +    call cairo_line_to(cr, x_d, y_d + radius)  ! Left edge
 +    call cairo_arc(cr, x_d + radius, y_d + radius, radius, 3.14159_c_double, -1.57080_c_double)
 +    call cairo_line_to(cr, x_d + w_d - radius, y_d)
 +    call cairo_arc(cr, x_d + w_d - radius, y_d + radius, radius, -1.57080_c_double, 0.0_c_double)
 +    call cairo_line_to(cr, x_d + w_d, y_d + h_d)
++
 +    ! Fill with darker gray (inactive)
 +    if (is_hovered) then
 +      call cairo_set_source_rgb(cr, 0.88_c_double, 0.88_c_double, 0.88_c_double)
 +    else
 +      call cairo_set_source_rgb(cr, 0.82_c_double, 0.82_c_double, 0.82_c_double)
 +    end if
 +    call cairo_fill(cr)
++
 +    ! Draw full border including bottom
 +    call draw_tab_border_full(cr, x_d, y_d, w_d, h_d, radius)
++
 +    ! Draw label (dimmed)
 +    call draw_tab_label(cr, x, 2, width, TAB_HEIGHT - 2, label, .true.)
++
 +    ! Draw close button
 +    call draw_close_button(cr, x, width, .true.)
 +  end subroutine draw_inactive_tab
++
 +  ! Draw tab border without bottom (for active tab)
 +  subroutine draw_tab_border_no_bottom(cr, x, y, width, height, radius)
 +    type(c_ptr), intent(in) :: cr
 +    real(c_double), intent(in) :: x, y, width, height, radius
++
 +    call cairo_set_source_rgb(cr, 0.7_c_double, 0.7_c_double, 0.7_c_double)
 +    call cairo_set_line_width(cr, 1.0_c_double)
++
 +    call cairo_move_to(cr, x, y + height)
 +    call cairo_line_to(cr, x, y + radius)
 +    call cairo_arc(cr, x + radius, y + radius, radius, 3.14159_c_double, -1.57080_c_double)
 +    call cairo_line_to(cr, x + width - radius, y)
 +    call cairo_arc(cr, x + width - radius, y + radius, radius, -1.57080_c_double, 0.0_c_double)
 +    call cairo_line_to(cr, x + width, y + height)
 +    call cairo_stroke(cr)
 +  end subroutine draw_tab_border_no_bottom
++
 +  ! Draw full tab border (for inactive tabs)
 +  subroutine draw_tab_border_full(cr, x, y, width, height, radius)
 +    type(c_ptr), intent(in) :: cr
 +    real(c_double), intent(in) :: x, y, width, height, radius
++
 +    call cairo_set_source_rgb(cr, 0.6_c_double, 0.6_c_double, 0.6_c_double)
 +    call cairo_set_line_width(cr, 1.0_c_double)
++
 +    call cairo_move_to(cr, x, y + height)
 +    call cairo_line_to(cr, x, y + radius)
 +    call cairo_arc(cr, x + radius, y + radius, radius, 3.14159_c_double, -1.57080_c_double)
 +    call cairo_line_to(cr, x + width - radius, y)
 +    call cairo_arc(cr, x + width - radius, y + radius, radius, -1.57080_c_double, 0.0_c_double)
 +    call cairo_line_to(cr, x + width, y + height)
 +    call cairo_line_to(cr, x, y + height)
 +    call cairo_stroke(cr)
 +  end subroutine draw_tab_border_full
++
 +  ! Draw tab label text
 +  subroutine draw_tab_label(cr, x, y, width, height, text, is_dimmed)
 +    type(c_ptr), intent(in) :: cr
 +    integer, intent(in) :: x, y, width, height
 +    character(len=*), intent(in) :: text
 +    logical, intent(in) :: is_dimmed
 +    type(c_ptr) :: layout, font_desc
 +    integer(c_int), target :: text_width, text_height
 +    real(c_double) :: text_x, text_y
++
 +    ! Create pango layout
 +    layout = pango_cairo_create_layout(cr)
 +    call pango_layout_set_text(layout, trim(text)//c_null_char, -1_c_int)
++
 +    ! Set font
 +    font_desc = pango_font_description_from_string("Sans 10"//c_null_char)
 +    call pango_layout_set_font_description(layout, font_desc)
++
 +    ! Get text size
 +    call pango_layout_get_pixel_size(layout, c_loc(text_width), c_loc(text_height))
++
 +    ! Center text in tab (leaving room for close button)
 +    text_x = real(x, c_double) + real(width - CLOSE_BUTTON_SIZE - CLOSE_BUTTON_MARGIN - text_width, c_double) / 2.0_c_double
 +    text_y = real(y, c_double) + real(height - text_height, c_double) / 2.0_c_double
++
 +    ! Set text color
 +    if (is_dimmed) then
 +      call cairo_set_source_rgb(cr, 0.4_c_double, 0.4_c_double, 0.4_c_double)
 +    else
 +      call cairo_set_source_rgb(cr, 0.2_c_double, 0.2_c_double, 0.2_c_double)
 +    end if
++
 +    call cairo_move_to(cr, text_x, text_y)
 +    call pango_cairo_show_layout(cr, layout)
++
 +    call pango_font_description_free(font_desc)
 +  end subroutine draw_tab_label
++
 +  ! Draw close button (×)
 +  subroutine draw_close_button(cr, tab_x, tab_width, is_dimmed)
 +    type(c_ptr), intent(in) :: cr
 +    integer, intent(in) :: tab_x, tab_width
 +    logical, intent(in) :: is_dimmed
 +    real(c_double) :: btn_x, btn_y, btn_size
++
 +    btn_x = real(tab_x + tab_width - CLOSE_BUTTON_SIZE - CLOSE_BUTTON_MARGIN, c_double)
 +    btn_y = real((TAB_HEIGHT - CLOSE_BUTTON_SIZE) / 2, c_double)
 +    btn_size = real(CLOSE_BUTTON_SIZE, c_double)
++
 +    ! Draw × symbol
 +    call cairo_set_line_width(cr, 1.5_c_double)
 +    if (is_dimmed) then
 +      call cairo_set_source_rgb(cr, 0.5_c_double, 0.5_c_double, 0.5_c_double)
 +    else
 +      call cairo_set_source_rgb(cr, 0.3_c_double, 0.3_c_double, 0.3_c_double)
 +    end if
++
 +    ! Draw X
 +    call cairo_move_to(cr, btn_x + 4.0_c_double, btn_y + 4.0_c_double)
 +    call cairo_line_to(cr, btn_x + btn_size - 4.0_c_double, btn_y + btn_size - 4.0_c_double)
 +    call cairo_stroke(cr)
++
 +    call cairo_move_to(cr, btn_x + btn_size - 4.0_c_double, btn_y + 4.0_c_double)
 +    call cairo_line_to(cr, btn_x + 4.0_c_double, btn_y + btn_size - 4.0_c_double)
 +    call cairo_stroke(cr)
 +  end subroutine draw_close_button
++
 +  ! Draw plus button
 +  subroutine draw_plus_button(cr, x, y)
 +    type(c_ptr), intent(in) :: cr
 +    integer, intent(in) :: x, y
 +    real(c_double) :: btn_x, btn_y, btn_size
 +    logical :: is_hovered
++
 +    is_hovered = (hovered_tab == -1)
++
 +    btn_x = real(x, c_double) + 4.0_c_double
 +    btn_y = real(y, c_double) + 4.0_c_double
 +    btn_size = real(PLUS_BUTTON_WIDTH - 8, c_double)
++
 +    ! Draw circle background
 +    if (is_hovered) then
 +      call cairo_set_source_rgb(cr, 0.9_c_double, 0.9_c_double, 0.9_c_double)
 +    else
 +      call cairo_set_source_rgb(cr, 0.85_c_double, 0.85_c_double, 0.85_c_double)
 +    end if
 +    call cairo_arc(cr, btn_x + btn_size / 2.0_c_double, btn_y + btn_size / 2.0_c_double, &
 +                   btn_size / 2.0_c_double, 0.0_c_double, 6.28319_c_double)
 +    call cairo_fill(cr)
++
 +    ! Draw + symbol
 +    call cairo_set_line_width(cr, 2.0_c_double)
 +    call cairo_set_source_rgb(cr, 0.3_c_double, 0.3_c_double, 0.3_c_double)
++
 +    ! Horizontal line
 +    call cairo_move_to(cr, btn_x + 6.0_c_double, btn_y + btn_size / 2.0_c_double)
 +    call cairo_line_to(cr, btn_x + btn_size - 6.0_c_double, btn_y + btn_size / 2.0_c_double)
 +    call cairo_stroke(cr)
++
 +    ! Vertical line
 +    call cairo_move_to(cr, btn_x + btn_size / 2.0_c_double, btn_y + 6.0_c_double)
 +    call cairo_line_to(cr, btn_x + btn_size / 2.0_c_double, btn_y + btn_size - 6.0_c_double)
 +    call cairo_stroke(cr)
 +  end subroutine draw_plus_button
++
 +  ! Handle mouse motion for hover effects
 +  subroutine on_tab_motion(controller, x, y, user_data) bind(c)
 +    use tab_manager, only: num_tabs
 +    type(c_ptr), value :: controller, user_data
 +    real(c_double), value :: x, y
 +    integer :: i, old_hovered
++
 +    old_hovered = hovered_tab
 +    hovered_tab = 0
++
 +    ! Check plus button
 +    if (x >= plus_button_x .and. x < plus_button_x + PLUS_BUTTON_WIDTH .and. &
 +        y >= plus_button_y .and. y < plus_button_y + TAB_HEIGHT) then
 +      hovered_tab = -1
 +    else
 +      ! Check tabs
 +      do i = 1, num_tabs
 +        if (x >= tab_rects(i)%x .and. x < tab_rects(i)%x + tab_rects(i)%width .and. &
 +            y >= tab_rects(i)%y .and. y < tab_rects(i)%y + tab_rects(i)%height) then
 +          hovered_tab = i
 +          exit
 +        end if
 +      end do
 +    end if
++
 +    ! Redraw if hover state changed
 +    if (hovered_tab /= old_hovered .and. c_associated(tab_bar_widget)) then
 +      call gtk_widget_queue_draw(tab_bar_widget)
 +    end if
 +  end subroutine on_tab_motion
++
 +  ! Handle mouse leave (clear hover state)
 +  subroutine on_tab_leave(controller, user_data) bind(c)
 +    type(c_ptr), value :: controller, user_data
++
 +    ! Clear hover state when mouse leaves the tab bar
 +    if (hovered_tab /= 0 .and. c_associated(tab_bar_widget)) then
 +      hovered_tab = 0
 +      hovered_close_button = 0
 +      call gtk_widget_queue_draw(tab_bar_widget)
 +    end if
 +  end subroutine on_tab_leave
++
 +  ! Handle clicks
 +  subroutine on_tab_click(gesture, n_press, x, y, user_data) bind(c)
 +    use tab_manager, only: num_tabs
 +    type(c_ptr), value :: gesture, user_data
 +    integer(c_int), value :: n_press
 +    real(c_double), value :: x, y
 +    integer :: i
++
 +    ! Check plus button
 +    if (x >= plus_button_x .and. x < plus_button_x + PLUS_BUTTON_WIDTH .and. &
 +        y >= plus_button_y .and. y < plus_button_y + TAB_HEIGHT) then
 +      if (associated(new_tab_cb)) call new_tab_cb()
 +      return
 +    end if
++
 +    ! Check tabs
 +    do i = 1, num_tabs
 +      if (x >= tab_rects(i)%x .and. x < tab_rects(i)%x + tab_rects(i)%width .and. &
 +          y >= tab_rects(i)%y .and. y < tab_rects(i)%y + tab_rects(i)%height) then
++
 +        ! Check if close button was clicked
 +        if (x >= tab_rects(i)%x + tab_rects(i)%width - CLOSE_BUTTON_SIZE - CLOSE_BUTTON_MARGIN .and. &
 +            x < tab_rects(i)%x + tab_rects(i)%width - CLOSE_BUTTON_MARGIN) then
 +          if (associated(close_cb)) call close_cb(i)
 +        else
 +          ! Tab body clicked
 +          if (associated(switch_cb)) call switch_cb(i)
 +        end if
 +        return
 +      end if
 +    end do
 +  end subroutine on_tab_click
++
 +  ! Refresh (trigger redraw)
 +  subroutine refresh_cairo_tab_bar()
 +    if (c_associated(tab_bar_widget)) then
 +      call gtk_widget_queue_draw(tab_bar_widget)
 +    end if
 +  end subroutine refresh_cairo_tab_bar
++
 +  ! Get widget
 +  function get_cairo_tab_bar_widget() result(widget)
 +    type(c_ptr) :: widget
 +    widget = tab_bar_widget
 +  end function get_cairo_tab_bar_widget
++
 +  ! Register callbacks
 +  subroutine register_cairo_tab_switch_callback(callback)
 +    procedure(tab_switch_callback) :: callback
 +    switch_cb => callback
 +  end subroutine register_cairo_tab_switch_callback
++
 +  subroutine register_cairo_tab_close_callback(callback)
 +    procedure(tab_close_callback) :: callback
 +    close_cb => callback
 +  end subroutine register_cairo_tab_close_callback
++
 +  subroutine register_cairo_new_tab_callback(callback)
 +    procedure(new_tab_callback) :: callback
 +    new_tab_cb => callback
 +  end subroutine register_cairo_new_tab_callback
++
 +end module cairo_tab_bar

src/gui/gtk_app.f90modified

    use treemap_renderer, only: register_progress_callback, scan_directory, set_redraw_widget, &
                                 register_scan_completion_callback, set_renderer_state_from_tab
    use tab_manager, only: tab_state, init_tab_manager, create_tab, get_active_tab, &
 -                         switch_to_tab, num_tabs, active_tab_index, get_path_basename
 -  use tab_widget, only: create_tab_bar, refresh_tab_bar, register_tab_switch_callback, &
 -                        update_tab_visual_states
 +                         switch_to_tab, close_tab, num_tabs, active_tab_index, get_path_basename
 +  use cairo_tab_bar, only: create_cairo_tab_bar, refresh_cairo_tab_bar, &
 +                           register_cairo_tab_switch_callback, register_cairo_tab_close_callback, &
 +                           register_cairo_new_tab_callback
    implicit none
    private
      ! Add breadcrumb widget to breadcrumb row
      call gtk_box_append(breadcrumb_row, breadcrumb_widget)
 -    ! Create tab bar (on right side of breadcrumb row)
 -    tab_bar = create_tab_bar()
 +    ! Create Cairo-rendered tab bar (on right side of breadcrumb row)
 +    tab_bar = create_cairo_tab_bar()
      if (c_associated(tab_bar)) then
        call gtk_box_append(breadcrumb_row, tab_bar)
 -      ! Populate with tabs
 -      call refresh_tab_bar()
 -      ! Register callback for tab switching to update UI
 -      call register_tab_switch_callback(update_ui_for_active_tab)
 -      print *, "Tab bar added to breadcrumb row"
 +      ! Register callbacks for tab interactions
 +      call register_cairo_tab_switch_callback(on_cairo_tab_switch)
 +      call register_cairo_tab_close_callback(on_cairo_tab_close)
 +      call register_cairo_new_tab_callback(on_cairo_new_tab)
 +      ! Trigger initial draw
 +      call refresh_cairo_tab_bar()
 +      print *, "Cairo tab bar added to breadcrumb row"
      else
 -      print *, "ERROR: Failed to create tab bar"
 +      print *, "ERROR: Failed to create Cairo tab bar"
      end if
      ! Add breadcrumb row to main box
      ! Store pointer for later use (e.g., tab switching redraw)
      drawing_area_ptr = drawing_area
 +    ! Add CSS class for card styling (border that matches active tab)
 +    call gtk_widget_add_css_class(drawing_area, "canvas-card"//c_null_char)
++
      ! Make drawing area expand to fill space
      call gtk_widget_set_hexpand(drawing_area, 1_c_int)
      call gtk_widget_set_vexpand(drawing_area, 1_c_int)
      character(len=:), allocatable :: css_data
      ! CSS with pulsing animation for suggested-action class (empty tabs)
 +    ! and card border styling to match active tab appearance
      css_data = &
        "@keyframes pulse { " // &
        "0% { opacity: 1.0; } " // &
        "} " // &
        ".suggested-action { " // &
        "animation: pulse 1.5s ease-in-out infinite; " // &
 +      "} " // &
 +      ".canvas-card { " // &
 +      "background-color: rgba(250, 250, 250, 1.0); " // &
 +      "border: 1px solid rgba(179, 179, 179, 1.0); " // &
 +      "border-top: none; " // &
        "}"
      ! Create CSS provider
      ! Add CSS provider to display (600 = GTK_STYLE_PROVIDER_PRIORITY_APPLICATION)
      call gtk_style_context_add_provider_for_display(display, css_provider, 600_c_int)
 -    print *, "Custom CSS loaded (pulsing animation for empty tabs)"
 +    print *, "Custom CSS loaded (pulsing animation + canvas card styling)"
    end subroutine load_custom_css
    ! Callback when Open Directory button is clicked
      call sniffly_update_status("Toggled render mode (flat vs cushioned)")
    end subroutine on_toggle_render_mode_clicked
 +  ! Cairo tab bar callback wrappers
 +  subroutine on_cairo_tab_switch(tab_index)
 +    integer, intent(in) :: tab_index
++
 +    ! Skip if already on this tab
 +    if (tab_index == active_tab_index) return
++
 +    print *, "Cairo tab switch to tab ", tab_index
++
 +    ! Switch to the clicked tab
 +    call switch_to_tab(tab_index)
++
 +    ! Trigger redraw of tab bar (highlights active tab)
 +    call refresh_cairo_tab_bar()
++
 +    ! Update UI for the new active tab
 +    call update_ui_for_active_tab()
++
 +    print *, "Switched to tab ", tab_index
 +  end subroutine on_cairo_tab_switch
++
 +  subroutine on_cairo_tab_close(tab_index)
 +    integer, intent(in) :: tab_index
++
 +    print *, "Cairo tab close for tab ", tab_index
++
 +    ! Prevent closing last tab
 +    if (num_tabs <= 1) then
 +      print *, "ERROR: Cannot close last tab"
 +      return
 +    end if
++
 +    ! Close the tab
 +    call close_tab(tab_index)
++
 +    ! Trigger redraw of tab bar
 +    call refresh_cairo_tab_bar()
++
 +    ! Update UI for the new active tab
 +    call update_ui_for_active_tab()
++
 +    print *, "Tab ", tab_index, " closed - now ", num_tabs, " tabs remaining"
 +  end subroutine on_cairo_tab_close
++
 +  subroutine on_cairo_new_tab()
 +    integer :: new_tab_index
 +    character(len=512) :: new_tab_path
++
 +    print *, "Cairo new tab button clicked"
++
 +    ! New tabs start completely empty - no path to avoid accidental scans
 +    new_tab_path = ""
++
 +    ! Create a new empty tab
 +    new_tab_index = create_tab(new_tab_path)
++
 +    if (new_tab_index < 0) then
 +      print *, "ERROR: Failed to create new tab (max tabs reached?)"
 +      return
 +    end if
++
 +    print *, "Created new tab ", new_tab_index
++
 +    ! Switch to the new tab
 +    call switch_to_tab(new_tab_index)
++
 +    ! Trigger redraw of tab bar
 +    call refresh_cairo_tab_bar()
++
 +    ! Update UI for the new tab
 +    call update_ui_for_active_tab()
++
 +    print *, "Tab bar refreshed and switched to new tab ", new_tab_index
 +  end subroutine on_cairo_new_tab
++
    ! Commented out unused helper function - was used by removed search/filter feature
    ! Uncomment if needed in future
      ! Update button states now that history may have changed
      call update_history_buttons()
 -    ! Refresh tab bar to show updated label
 -    call refresh_tab_bar()
 -    call update_tab_visual_states()
 +    ! Refresh Cairo tab bar to show updated label
 +    call refresh_cairo_tab_bar()
    end subroutine breadcrumb_callback
    ! Show progress bar (now just resets to prepare for updates)