frame_buffer.c

Go to the documentation of this file.

#include <ascii-chat/ui/text.h>
#include <ascii-chat/util/string.h>
 
#include <ascii-chat/ui/output.h>
#include "ascii-chat/ui/frame_buffer.h"
#include <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/terminal.h>
#include <ascii-chat/util/display.h>
#include "ascii-chat/common.h"
#include <ascii-chat/options/options.h>
#include <ascii-chat/log/log.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdarg.h>

struct frame_buffer {
  char *data;      
  size_t len;      
  size_t capacity; 
};
 
frame_buffer_t *frame_buffer_create(int rows, int cols) {
  frame_buffer_t *buf = SAFE_MALLOC(sizeof(frame_buffer_t), frame_buffer_t *);
  if (!buf) {
    return NULL;
  }
 
  // Initial capacity: rows * cols * 16 to account for ANSI codes
  size_t initial_capacity = (rows > 0 && cols > 0) ? (size_t)rows * cols * 16 : 4096;
 
  buf->data = SAFE_MALLOC(initial_capacity, char *);
  if (!buf->data) {
    SAFE_FREE(buf);
    return NULL;
  }
 
  buf->len = 0;
  buf->capacity = initial_capacity;
 
  return buf;
}
 
void frame_buffer_destroy(frame_buffer_t *buf) {
  if (!buf) {
    return;
  }
 
  SAFE_FREE(buf->data);
  SAFE_FREE(buf);
}
 
void frame_buffer_reset(frame_buffer_t *buf) {
  if (!buf) {
    return;
  }
 
  buf->len = 0;
}
 
void frame_buffer_append(frame_buffer_t *buf, const char *str, size_t len) {
  if (!buf || !str || len == 0) {
    return;
  }
 
  // Grow buffer if needed
  if (buf->len + len > buf->capacity) {
    size_t new_capacity = buf->capacity * 2;
    while (new_capacity < buf->len + len) {
      new_capacity *= 2;
    }
 
    char *new_data = SAFE_MALLOC(new_capacity, char *);
    if (!new_data) {
      return; // Failed to grow, silently ignore
    }
 
    if (buf->len > 0 && buf->data) {
      memcpy(new_data, buf->data, buf->len);
    }
 
    SAFE_FREE(buf->data);
    buf->data = new_data;
    buf->capacity = new_capacity;
  }
 
  // Append the data
  memcpy(buf->data + buf->len, str, len);
  buf->len += len;
}
 
void frame_buffer_printf(frame_buffer_t *buf, const char *fmt, ...) {
  if (!buf || !fmt) {
    return;
  }
 
  // Ensure we have space for a formatted string
  // Start with a reasonable buffer size
  size_t remaining = buf->capacity - buf->len;
  if (remaining < 256) {
    // Grow buffer to have at least 512 bytes of space
    size_t new_capacity = buf->capacity + 512;
    char *new_data = SAFE_MALLOC(new_capacity, char *);
    if (!new_data) {
      return;
    }
 
    if (buf->len > 0 && buf->data) {
      memcpy(new_data, buf->data, buf->len);
    }
 
    SAFE_FREE(buf->data);
    buf->data = new_data;
    buf->capacity = new_capacity;
    remaining = buf->capacity - buf->len;
  }
 
  // Format the string into the buffer
  va_list args;
  va_start(args, fmt);
  int written = vsnprintf(buf->data + buf->len, remaining, fmt, args);
  va_end(args);
 
  if (written > 0 && written < (int)remaining) {
    buf->len += (size_t)written;
  }
  // If vsnprintf failed or truncated, we silently ignore (buffer may be full)
}
 
void frame_buffer_cursor_home(frame_buffer_t *buf) {
  if (!buf) {
    return;
  }
 
  frame_buffer_append(buf, "\033[H", 3);
}
 
void frame_buffer_clear_screen(frame_buffer_t *buf) {
  if (!buf) {
    return;
  }
 
  // Combine clear screen and home in one operation
  static const char clear[] = "\033[2J\033[H";
  frame_buffer_append(buf, clear, sizeof(clear) - 1);
}
 
// Global configuration for terminal screen output FD (used by splash/status screens)
static _Thread_local int g_terminal_screen_output_fd = STDOUT_FILENO;
 
void frame_buffer_flush(frame_buffer_t *buf) {
  if (!buf || buf->len == 0 || !buf->data) {
    return;
  }
 
  // Repaint from the top while erasing each line before writing it. A full
  // screen erase on every animation frame exposes a black frame on Windows
  // terminals and makes the splash appear to flicker.
  size_t line_count = 1;
  for (size_t i = 0; i < buf->len; i++) {
    if (buf->data[i] == '\n') {
      line_count++;
    }
  }
 
  size_t output_size = 3 + buf->len + (line_count * 4);
  char *output = SAFE_MALLOC(output_size, char *);
  if (!output) {
    return;
  }
 
  size_t output_len = 0;
  memcpy(output + output_len, "\033[H", 3);
  output_len += 3;
  bool at_line_start = true;
  for (size_t i = 0; i < buf->len; i++) {
    if (at_line_start) {
      memcpy(output + output_len, "\033[2K", 4);
      output_len += 4;
      at_line_start = false;
    }
    output[output_len++] = buf->data[i];
    if (buf->data[i] == '\n') {
      at_line_start = true;
    }
  }
 
  ui_output_write(g_terminal_screen_output_fd, output, output_len);
  SAFE_FREE(output);
}
 
void frame_buffer_set_screen_output_fd(int fd) {
  g_terminal_screen_output_fd = fd;
  colored_string_set_output_fd(fd);
}
 
int frame_buffer_get_screen_output_fd(void) {
  return g_terminal_screen_output_fd;
}
 
size_t frame_buffer_get_length(const frame_buffer_t *buf) {
  if (!buf) {
    return 0;
  }
  return buf->len;
}
 
const char *frame_buffer_get_content(const frame_buffer_t *buf) {
  if (!buf || !buf->data) {
    return NULL;
  }
  return buf->data;
}
 
static void render_rule(frame_buffer_t *buf, int width, const char *color, bool use_utf8) {
  if (!buf || width <= 0)
    return;
  if (color)
    frame_buffer_printf(buf, "%s", color);
  for (int i = 0; i < width; ++i)
    frame_buffer_printf(buf, "%s", use_utf8 ? "━" : "-");
  if (color)
    frame_buffer_printf(buf, "\033[0m");
  frame_buffer_printf(buf, "\n");
}
 
void frame_buffer_render_border(frame_buffer_t *buf, int cols, const char *color) {
  render_rule(buf, cols - 1, color, terminal_should_use_utf8(GET_OPTION(force_utf8)));
}
 
void frame_buffer_render_divider(frame_buffer_t *buf, int width, bool use_utf8, bool use_colors) {
  render_rule(buf, width, use_colors ? ui_text_color_prefix(LOG_COLOR_DEBUG) : NULL, use_utf8);
}
 
int frame_buffer_render_centered(frame_buffer_t *buf, const char *text, int cols) {
  if (!buf || !text || cols <= 0) {
    return 0;
  }
 
  // Calculate visible width accounting for ANSI codes
  int visible_width = display_width(text);
  if (visible_width < 0) {
    visible_width = (int)strlen(text);
  }
 
  int padding = (cols - visible_width) / 2;
  if (padding < 0) {
    padding = 0;
  }
 
  for (int i = 0; i < padding; i++) {
    frame_buffer_printf(buf, " ");
  }
  frame_buffer_printf(buf, "%s\n", text);
 
  return padding;
}