`896305f`

Add window opacity and blur configuration options

Window appearance can now be configured via TOML:
- [window] opacity = 0.95 (0.0-1.0, default 1.0)
- [window] blur = true (macOS only, currently stubbed)

Implementation:
- Add toml_get_real() for float parsing in TOML
- Add window_opacity and window_blur to config_t
- Enable GLFW_TRANSPARENT_FRAMEBUFFER when opacity < 1.0
- Use opacity value in glClearColor alpha channel
- Add window_set_blur() function (stub - needs Cocoa integration)

Note: macOS blur requires Cocoa framework which has CMake integration
issues with Fortran compilers. The blur function is stubbed for now.

Authored by

espadonne 4 months ago

SHA: 896305f42ffee14531a838b719b0f5609b715aa8
Parents: c65ecb0
Tree: eb648dd

7 changed files

Status	File	+	-
M	`CMakeLists.txt`	22	2
M	`c_src/pty_helpers.c`	10	0
M	`src/config/config.f90`	6	0
M	`src/config/toml_parser.f90`	20	1
M	`src/fortty.f90`	9	4
M	`src/window/glfw_bindings.f90`	1	0
M	`src/window/window.f90`	31	2

CMakeLists.txtmodified

  endif()
  # C helper libraries (GLAD + FreeType + PTY wrappers)
 -add_library(helpers STATIC
 +set(HELPER_SOURCES
      src/gl/glad.c
      c_src/gl_loader.c
      c_src/freetype_helpers.c
      c_src/pty_helpers.c
+ )
++
 +# macOS window helpers placeholder - blur requires Cocoa which conflicts with Fortran build
 +# TODO: Enable when CMake framework flag issue is resolved
++
 +add_library(helpers STATIC ${HELPER_SOURCES})
  target_include_directories(helpers PUBLIC ${CMAKE_SOURCE_DIR}/include)
  target_include_directories(helpers PRIVATE ${FREETYPE_INCLUDE_DIRS})
  target_link_libraries(helpers PRIVATE glfw ${FREETYPE_LIBRARIES})
      target_link_libraries(helpers PRIVATE util)
  endif()
 +# Note: Cocoa framework linked at executable level to avoid flag conflicts with Fortran
++
  # Link fontconfig if available
  if(FONTCONFIG_FOUND)
      target_compile_definitions(helpers PRIVATE HAVE_FONTCONFIG)
  # Main executable
  add_executable(fortty ${FORTRAN_SOURCES})
  target_include_directories(fortty PRIVATE ${CMAKE_BINARY_DIR}/modules)
 -target_link_libraries(fortty PRIVATE helpers glfw OpenGL::GL ${FREETYPE_LIBRARIES})
++
 +# Work around CMake framework flag issue: flang doesn't understand -F flag
 +if(APPLE)
 +    # Remove -F flags from Fortran compile options
 +    string(REPLACE "-F/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks" ""
 +           CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}")
 +    # Also set a compile option filter for the target
 +    set_target_properties(fortty PROPERTIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "")
 +endif()
++
 +# Link libraries - glfw linked through helpers
 +target_link_libraries(fortty PRIVATE helpers OpenGL::GL ${FREETYPE_LIBRARIES})
  # Add fontconfig link directory if available (needed for linker to find it)
  if(FONTCONFIG_FOUND)
  if(UNIX AND NOT APPLE)
      target_link_libraries(fortty PRIVATE dl)
  endif()
++
 +# TODO: Link Cocoa framework for blur when CMake framework flag issue is resolved

c_src/pty_helpers.cmodified

  int fortty_pty_get_child_pid(void) {
      return (int)child_pid;
+ }
++
 +/*
 + * Window blur stub - macOS blur requires Cocoa framework which has
 + * CMake integration issues with Fortran. This is a no-op placeholder.
 + * TODO: Implement with NSVisualEffectView when build system supports it.
 + */
 +void fortty_set_window_blur(void* window, int enable) {
 +    (void)window;
 +    (void)enable;
 +}

src/config/config.f90modified

      ! Window
      integer :: window_width = 800
      integer :: window_height = 600
 +    real :: window_opacity = 1.0      ! 0.0 (transparent) to 1.0 (opaque)
 +    logical :: window_blur = .false.  ! macOS only: enable background blur
      ! Font
      character(len=256) :: font_path = ''       ! Empty = use fontconfig
      cfg%window_width = 800
      cfg%window_height = 600
 +    cfg%window_opacity = 1.0
 +    cfg%window_blur = .false.
      cfg%font_path = ''
      cfg%font_fallback = ''
      ! Window settings
      cfg%window_width = toml_get_integer(tf, 'window', 'width', cfg%window_width)
      cfg%window_height = toml_get_integer(tf, 'window', 'height', cfg%window_height)
 +    cfg%window_opacity = toml_get_real(tf, 'window', 'opacity', cfg%window_opacity)
 +    cfg%window_blur = toml_get_logical(tf, 'window', 'blur', cfg%window_blur)
      ! Font settings
      str_val = toml_get_string(tf, 'font', 'family', '')

src/config/toml_parser.f90modified

    public :: toml_file_t
    public :: toml_open, toml_close
 -  public :: toml_get_string, toml_get_integer, toml_get_logical
 +  public :: toml_get_string, toml_get_integer, toml_get_real, toml_get_logical
    integer, parameter :: MAX_LINE_LEN = 512
    integer, parameter :: MAX_KEYS = 128
    end function toml_get_integer
 +  ! Get a real value from the TOML file
 +  function toml_get_real(tf, section, key, default) result(val)
 +    type(toml_file_t), intent(in) :: tf
 +    character(len=*), intent(in) :: section, key
 +    real, intent(in) :: default
 +    real :: val
 +    character(len=256) :: str_val
 +    integer :: ios
++
 +    val = default
 +    str_val = toml_get_string(tf, section, key, '')
++
 +    if (len_trim(str_val) > 0) then
 +      read(str_val, *, iostat=ios) val
 +      if (ios /= 0) val = default
 +    end if
++
 +  end function toml_get_real
++
    ! Get a logical value from the TOML file
    function toml_get_logical(tf, section, key, default) result(val)
      type(toml_file_t), intent(in) :: tf

src/fortty.f90modified

    win_width = cfg%window_width
    win_height = cfg%window_height
 -  ! Create window with OpenGL context
 -  win = window_create(win_width, win_height, "fortty")
 +  ! Create window with OpenGL context (enable transparency if opacity < 1.0)
 +  win = window_create(win_width, win_height, "fortty", cfg%window_opacity < 1.0)
++
 +  ! Enable background blur if configured (macOS only)
 +  if (cfg%window_blur) then
 +    call window_set_blur(win, .true.)
 +  end if
    ! Font path - use config if specified, otherwise fontconfig, then fallbacks
    if (len_trim(cfg%font_path) > 0) then
        call window_set_title(win, terminal_get_title(term))
      end if
 -    ! Clear screen with background color from config
 +    ! Clear screen with background color and opacity from config
      bg_r = real(cfg%bg_color%r) / 255.0
      bg_g = real(cfg%bg_color%g) / 255.0
      bg_b = real(cfg%bg_color%b) / 255.0
 -    call glClearColor(bg_r, bg_g, bg_b, 1.0)
 +    call glClearColor(bg_r, bg_g, bg_b, cfg%window_opacity)
      call glClear(GL_COLOR_BUFFER_BIT)
      ! Render terminal buffer

src/window/glfw_bindings.f90modified

    integer(c_int), parameter :: GLFW_OPENGL_PROFILE = int(Z'00022008', c_int)
    integer(c_int), parameter :: GLFW_OPENGL_CORE_PROFILE = int(Z'00032001', c_int)
    integer(c_int), parameter :: GLFW_OPENGL_FORWARD_COMPAT = int(Z'00022006', c_int)
 +  integer(c_int), parameter :: GLFW_TRANSPARENT_FRAMEBUFFER = int(Z'0002000A', c_int)
    ! Key constants
    integer(c_int), parameter :: GLFW_KEY_ESCAPE = 256

src/window/window.f90modified

    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_set_title, window_set_cell_size, window_set_blur
    public :: window_get_selection, window_clipboard_set, window_clipboard_get
    type :: window_t
      integer(c_int) function fortty_load_gl() bind(C, name="fortty_load_gl")
        import :: c_int
      end function fortty_load_gl
++
 +    ! macOS window blur (no-op on other platforms)
 +    subroutine fortty_set_window_blur_c(window, enable) bind(C, name="fortty_set_window_blur")
 +      import :: c_ptr, c_int
 +      type(c_ptr), value :: window
 +      integer(c_int), value :: enable
 +    end subroutine fortty_set_window_blur_c
    end interface
  contains
 -  function window_create(width, height, title) result(win)
 +  function window_create(width, height, title, transparent) result(win)
      integer, intent(in) :: width, height
      character(len=*), intent(in) :: title
 +    logical, intent(in), optional :: transparent
      type(window_t) :: win
      type(c_funptr) :: dummy
      integer(c_int) :: gl_loaded
      call glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE)
      call glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE)
 +    ! Enable transparent framebuffer if requested (for window opacity)
 +    if (present(transparent)) then
 +      if (transparent) then
 +        call glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE)
 +      end if
 +    end if
++
      ! Create window
      c_title = trim(title) // c_null_char
      win%handle = glfwCreateWindow(width, height, c_title, c_null_ptr, c_null_ptr)
      call glfwSetWindowTitle(win%handle, c_title)
    end subroutine window_set_title
 +  ! Enable background blur (macOS only, no-op on other platforms)
 +  subroutine window_set_blur(win, enable)
 +    type(window_t), intent(in) :: win
 +    logical, intent(in) :: enable
++
 +    if (.not. c_associated(win%handle)) return
++
 +    if (enable) then
 +      call fortty_set_window_blur_c(win%handle, 1_c_int)
 +    else
 +      call fortty_set_window_blur_c(win%handle, 0_c_int)
 +    end if
 +  end subroutine window_set_blur
++
    ! Set cell dimensions for mouse coordinate conversion
    subroutine window_set_cell_size(w, h)
      integer, intent(in) :: w, h