Raxol.Terminal.ScreenBufferBehaviour behaviour (Raxol Terminal v2.6.0)

Copy Markdown View Source

Defines the behaviour for screen buffer operations in the terminal. This module specifies the callbacks that must be implemented by any module that wants to act as a screen buffer.

Summary

Types

charset()
color()
dimensions()
metric()
metric_tags()
metric_value()
position()
style()
t()

Callbacks

apply_single_shift(buffer, slot)
attribute_set?(buffer, attribute)
cleanup_file_watching(buffer)
clear_line(buffer, line)
clear_output_buffer(buffer)
clear_saved_states(buffer)
clear_screen(buffer)
clear_scroll_region(buffer)
collect_metrics(buffer, metrics)
create_chart(buffer, data, options)
current_theme()
designate_charset(buffer, slot, charset)
empty?(cell)
enqueue_control_sequence(buffer, sequence)
erase_all(buffer)
erase_all_with_scrollback(buffer)
erase_from_cursor_to_end(buffer)
erase_from_cursor_to_end_of_line(buffer)
erase_from_start_of_line_to_cursor(buffer)
erase_from_start_to_cursor(buffer)
erase_line(buffer)
flush_output(buffer)
get_background(buffer)
get_cell(buffer, x, y)
get_char(buffer, x, y)
get_config()
get_current_g_set(buffer)
get_current_state(buffer)
get_designated_charset(buffer, slot)
get_dimensions(buffer)
get_foreground(buffer)
get_height(buffer)
get_metric(buffer, metric, tags)
get_metric_value(buffer, metric)
get_metrics_by_type(buffer, type)
get_output_buffer(buffer)
get_preferences()
get_saved_states_count(buffer)
get_scroll_position(buffer)
get_scroll_region_boundaries(buffer)
get_set_attributes(buffer)
get_single_shift(buffer)
get_size(buffer)
get_state_stack(buffer)
get_style(buffer)
get_update_settings()
get_width(buffer)
handle_csi_sequence(buffer, sequence, params)
handle_debounced_events(buffer, events, timeout)
handle_file_event(buffer, event)
handle_mode(buffer, mode, value)
has_saved_states?(buffer)
invoke_g_set(buffer, slot)
light_theme()
mark_damaged(buffer, x, y, width, height)
new(width, height)
record_metric(buffer, metric, value, tags)
record_operation(buffer, operation, value)
record_performance(buffer, metric, value)
record_resource(buffer, resource, value)
reset_all_attributes(buffer)
reset_attribute(buffer, attribute)
reset_state(buffer)
restore_state(buffer)
save_state(buffer)
scroll_down(buffer, lines)
scroll_up(buffer, lines)
set_attribute(buffer, attribute)
set_background(buffer, color)
set_config(config)
set_foreground(buffer, color)
set_preferences(preferences)
set_scroll_region(buffer, start_line, end_line)
update_current_state(buffer, state)
update_state_stack(buffer, stack)
update_style(buffer, style)
verify_metrics(buffer, metrics)
write(buffer, data)
write_char(buffer, x, y, char, style)
write_string(buffer, x, y, string, style)

Types

charset()

@type charset() :: atom()

color()

@type color() :: {non_neg_integer(), non_neg_integer(), non_neg_integer()}

dimensions()

@type dimensions() :: {non_neg_integer(), non_neg_integer()}

metric()

@type metric() :: atom()

metric_tags()

@type metric_tags() :: map()

metric_value()

@type metric_value() :: number()

position()

@type position() :: {non_neg_integer(), non_neg_integer()}

style()

@type style() :: map() | nil

t()

@type t() :: term()

Callbacks

apply_single_shift(buffer, slot)

@callback apply_single_shift(buffer :: t(), slot :: atom() | integer()) :: t()

attribute_set?(buffer, attribute)

@callback attribute_set?(buffer :: t(), attribute :: atom()) :: boolean()

cleanup_file_watching(buffer)

@callback cleanup_file_watching(buffer :: t()) :: t()

clear_line(buffer, line)

@callback clear_line(buffer :: t(), line :: non_neg_integer()) :: t()

clear_output_buffer(buffer)

@callback clear_output_buffer(buffer :: t()) :: t()

clear_saved_states(buffer)

@callback clear_saved_states(buffer :: t()) :: t()

clear_screen(buffer)

@callback clear_screen(buffer :: t()) :: t()

clear_scroll_region(buffer)

@callback clear_scroll_region(buffer :: t()) :: t()

collect_metrics(buffer, metrics)

@callback collect_metrics(buffer :: t(), metrics :: [metric()]) :: map()

create_chart(buffer, data, options)

@callback create_chart(buffer :: t(), data :: map(), options :: map()) :: t()

current_theme()

@callback current_theme() :: map()

designate_charset(buffer, slot, charset)

@callback designate_charset(
  buffer :: t(),
  slot :: atom() | integer(),
  charset :: charset()
) :: t()

empty?(cell)

@callback empty?(cell :: map()) :: boolean()

enqueue_control_sequence(buffer, sequence)

@callback enqueue_control_sequence(buffer :: t(), sequence :: String.t()) :: t()

erase_all(buffer)

@callback erase_all(buffer :: t()) :: t()

erase_all_with_scrollback(buffer)

@callback erase_all_with_scrollback(buffer :: t()) :: t()

erase_from_cursor_to_end(buffer)

@callback erase_from_cursor_to_end(buffer :: t()) :: t()

erase_from_cursor_to_end_of_line(buffer)

@callback erase_from_cursor_to_end_of_line(buffer :: t()) :: t()

erase_from_start_of_line_to_cursor(buffer)

@callback erase_from_start_of_line_to_cursor(buffer :: t()) :: t()

erase_from_start_to_cursor(buffer)

@callback erase_from_start_to_cursor(buffer :: t()) :: t()

erase_line(buffer)

@callback erase_line(buffer :: t()) :: t()

flush_output(buffer)

@callback flush_output(buffer :: t()) :: t()

get_background(buffer)

@callback get_background(buffer :: t()) :: color()

get_cell(buffer, x, y)

@callback get_cell(
  buffer :: t(),
  x :: non_neg_integer(),
  y :: non_neg_integer()
) :: map()

get_char(buffer, x, y)

@callback get_char(
  buffer :: t(),
  x :: non_neg_integer(),
  y :: non_neg_integer()
) :: String.t()

get_config()

@callback get_config() :: map()

get_current_g_set(buffer)

@callback get_current_g_set(buffer :: t()) :: atom() | integer()

get_current_state(buffer)

@callback get_current_state(buffer :: t()) :: map()

get_designated_charset(buffer, slot)

@callback get_designated_charset(buffer :: t(), slot :: atom() | integer()) :: charset()

get_dimensions(buffer)

@callback get_dimensions(buffer :: t()) :: dimensions()

get_foreground(buffer)

@callback get_foreground(buffer :: t()) :: color()

get_height(buffer)

@callback get_height(buffer :: t()) :: non_neg_integer()

get_metric(buffer, metric, tags)

@callback get_metric(buffer :: t(), metric :: metric(), tags :: metric_tags()) ::
  metric_value()

get_metric_value(buffer, metric)

@callback get_metric_value(buffer :: t(), metric :: metric()) :: metric_value()

get_metrics_by_type(buffer, type)

@callback get_metrics_by_type(buffer :: t(), type :: atom()) :: [map()]

get_output_buffer(buffer)

@callback get_output_buffer(buffer :: t()) :: String.t()

get_preferences()

@callback get_preferences() :: map()

get_saved_states_count(buffer)

@callback get_saved_states_count(buffer :: t()) :: non_neg_integer()

get_scroll_position(buffer)

@callback get_scroll_position(buffer :: t()) :: non_neg_integer()

get_scroll_region_boundaries(buffer)

@callback get_scroll_region_boundaries(buffer :: t()) ::
  {non_neg_integer(), non_neg_integer()}

get_set_attributes(buffer)

@callback get_set_attributes(buffer :: t()) :: [atom()]

get_single_shift(buffer)

@callback get_single_shift(buffer :: t()) :: atom() | integer()

get_size(buffer)

@callback get_size(buffer :: t()) :: dimensions()

get_state_stack(buffer)

@callback get_state_stack(buffer :: t()) :: [map()]

get_style(buffer)

@callback get_style(buffer :: t()) :: style()

get_update_settings()

@callback get_update_settings() :: map()

get_width(buffer)

@callback get_width(buffer :: t()) :: non_neg_integer()

handle_csi_sequence(buffer, sequence, params)

@callback handle_csi_sequence(
  buffer :: t(),
  sequence :: String.t(),
  params :: [String.t()]
) :: t()

handle_debounced_events(buffer, events, timeout)

@callback handle_debounced_events(
  buffer :: t(),
  events :: [map()],
  timeout :: non_neg_integer()
) :: t()

handle_file_event(buffer, event)

@callback handle_file_event(buffer :: t(), event :: map()) :: t()

handle_mode(buffer, mode, value)

@callback handle_mode(buffer :: t(), mode :: atom(), value :: any()) :: t()

has_saved_states?(buffer)

@callback has_saved_states?(buffer :: t()) :: boolean()

invoke_g_set(buffer, slot)

@callback invoke_g_set(buffer :: t(), slot :: atom() | integer()) :: t()

light_theme()

@callback light_theme() :: map()

mark_damaged(buffer, x, y, width, height)

@callback mark_damaged(
  buffer :: t(),
  x :: non_neg_integer(),
  y :: non_neg_integer(),
  width :: non_neg_integer(),
  height :: non_neg_integer()
) :: t()

new(width, height)

@callback new(width :: non_neg_integer(), height :: non_neg_integer()) :: t()

record_metric(buffer, metric, value, tags)

@callback record_metric(
  buffer :: t(),
  metric :: metric(),
  value :: metric_value(),
  tags :: metric_tags()
) :: t()

record_operation(buffer, operation, value)

@callback record_operation(
  buffer :: t(),
  operation :: atom(),
  value :: metric_value()
) :: t()

record_performance(buffer, metric, value)

@callback record_performance(
  buffer :: t(),
  metric :: metric(),
  value :: metric_value()
) :: t()

record_resource(buffer, resource, value)

@callback record_resource(
  buffer :: t(),
  resource :: atom(),
  value :: metric_value()
) :: t()

reset_all_attributes(buffer)

@callback reset_all_attributes(buffer :: t()) :: t()

reset_attribute(buffer, attribute)

@callback reset_attribute(buffer :: t(), attribute :: atom()) :: t()

reset_state(buffer)

@callback reset_state(buffer :: t()) :: t()

restore_state(buffer)

@callback restore_state(buffer :: t()) :: t()

save_state(buffer)

@callback save_state(buffer :: t()) :: t()

scroll_down(buffer, lines)

@callback scroll_down(buffer :: t(), lines :: non_neg_integer()) :: t()

scroll_up(buffer, lines)

@callback scroll_up(buffer :: t(), lines :: non_neg_integer()) :: t()

set_attribute(buffer, attribute)

@callback set_attribute(buffer :: t(), attribute :: atom()) :: t()

set_background(buffer, color)

@callback set_background(buffer :: t(), color :: color()) :: t()

set_config(config)

@callback set_config(config :: map()) :: :ok

set_foreground(buffer, color)

@callback set_foreground(buffer :: t(), color :: color()) :: t()

set_preferences(preferences)

@callback set_preferences(preferences :: map()) :: :ok

set_scroll_region(buffer, start_line, end_line)

@callback set_scroll_region(
  buffer :: t(),
  start_line :: non_neg_integer(),
  end_line :: non_neg_integer()
) :: t()

update_current_state(buffer, state)

@callback update_current_state(buffer :: t(), state :: map()) :: t()

update_state_stack(buffer, stack)

@callback update_state_stack(buffer :: t(), stack :: [map()]) :: t()

update_style(buffer, style)

@callback update_style(buffer :: t(), style :: style()) :: t()

verify_metrics(buffer, metrics)

@callback verify_metrics(buffer :: t(), metrics :: [metric()]) :: boolean()

write(buffer, data)

@callback write(buffer :: t(), data :: String.t()) :: t()

write_char(buffer, x, y, char, style)

@callback write_char(
  buffer :: t(),
  x :: non_neg_integer(),
  y :: non_neg_integer(),
  char :: String.t(),
  style :: style()
) :: t()

write_string(buffer, x, y, string, style)

@callback write_string(
  buffer :: t(),
  x :: non_neg_integer(),
  y :: non_neg_integer(),
  string :: String.t(),
  style :: style()
) :: t()