output_handler.h File Reference

Exposes functions for outputting to the console. More...

#include <notcurses/notcurses.h>
#include <stdbool.h>

Go to the source code of this file.

Macros
#define	LAUNCH_SCREEN_MIN_DISPLAY_TIME_MS   2000

Functions
bool	init_output_handler (void)
	Initialize the output handler.
void	clear_screen (void)
	Clear the screen.
void	print_text (int y, int x, const char *text, uint64_t ncchannel)
	Print text at a specific position.
void	print_text_default (int y, int x, const char *text)
	Print text at a specific position with default colors.
void	print_text_multi_line (int y, int x, const char *text, int max_width, u_int64_t ncchannel)
	Print multi-line text with word wrapping.
void	print_text_multi_line_default (int y, int x, const char *text, int max_width)
	Print multi-line text with word wrapping and default colors.
void	print_text_multi_strings (int y, int x, const char *text[], int count, uint64_t ncchannel)
	Print multiple strings on consecutive lines.
void	print_text_multi_strings_default (int y, int x, const char *text[], int count)
	Print multiple strings on consecutive lines with default colors.
void	print_menu (const char *title, const char **options, int option_count, int selected_index, int y, int x, uint64_t title_channel, uint64_t option_channel, uint64_t selected_channel)
	Print a menu with selection highlighting.
void	print_menu_default (const char *title, const char **options, int option_count, int selected_index, int y, int x)
	Print a menu with selection highlighting using default colors.
bool	get_text_input (const char *prompt, char *buffer, int buffer_size, const char *confirm_msg, int y, int x)
	Get a text input from the user.
void	show_message_screen (const char *message, const char *continue_message, int y, int x)
	Show a message screen.
bool	render_frame (void)
	Render the current frame.
bool	get_screen_dimensions (int *width, int *height)
	Get the dimensions of the standard plane.
void	shutdown_output_handler (void)
	Shutdown the output handler.

Detailed Description

Exposes functions for outputting to the console.

Definition in file output_handler.h.

Macro Definition Documentation

LAUNCH_SCREEN_MIN_DISPLAY_TIME_MS

#define LAUNCH_SCREEN_MIN_DISPLAY_TIME_MS   2000

Definition at line 12 of file output_handler.h.

Function Documentation

clear_screen()

void clear_screen

(

void

)

Clear the screen.

Clears the entire standard plane.

Definition at line 39 of file output_handler.c.

                        {
    if (!stdplane) {
        log_msg(ERROR, "output_handler", "Output handler not initialized");
        return;
    }
 
    // Clear the plane with the default colors
    ncplane_set_base(stdplane, " ", 0, DEFAULT_COLORS);
    ncplane_erase(stdplane);
}

get_screen_dimensions()

bool get_screen_dimensions	(	int *	width,
		int *	height )

Get the dimensions of the standard plane.

Parameters

[out]	width	Pointer to store the width
[out]	height	Pointer to store the height

Returns

true on success, false on failure

Definition at line 257 of file output_handler.c.

                                                    {
    if (!stdplane || !width || !height) {
        log_msg(ERROR, "output_handler", "Invalid parameters for get_screen_dimensions");
        return false;
    }
 
    // Get the dimensions of the standard plane
    *width = ncplane_dim_x(stdplane);
    *height = ncplane_dim_y(stdplane);
 
    return true;
}

get_text_input()

bool get_text_input	(	const char *	prompt,
		char *	buffer,
		int	buffer_size,
		const char *	confirm_msg,
		int	y,
		int	x )

Get a text input from the user.

Displays a prompt and gets a text input from the user.

Parameters

prompt	The text prompt to display
buffer	The buffer to store the input in
buffer_size	The size of the buffer
confirm_msg	The text explaining that Enter confirms (can be NULL)
y	The Y coordinate (row) for the prompt
x	The X coordinate (column) for the prompt

Returns

true if input was confirmed, false if canceled

Definition at line 156 of file output_handler.c.

                                                           {
    if (!stdplane || !buffer || buffer_size <= 0) {
        log_msg(ERROR, "output_handler", "Invalid parameters for get_text_input");
        return false;
    }
 
    // Clear the buffer
    memset(buffer, 0, buffer_size);
    int text_length = 0;
    bool input_active = true;
    bool confirmed = false;
 
    while (input_active) {
        // Clear screen
        clear_screen();
 
        // Display prompt
        print_text_default(y, x, prompt);
 
        // Display current input
        print_text_default(y + 2, x, buffer);
 
        // Display confirm message if provided
        if (confirm_msg) {
            print_text_default(y + 4, x, confirm_msg);
        }
 
        // Render the frame
        render_frame();
 
        // Get input
        input_event_t input_event;
        if (!get_input_blocking(&input_event)) {
            continue;
        }
 
        // Process input
        uint32_t key_id = input_event.raw_input.id;
 
        if (input_event.type == INPUT_CONFIRM && text_length > 0) {
            // Enter was pressed and we have input
            input_active = false;
            confirmed = true;
        } else if (input_event.type == INPUT_CANCEL) {
            // Escape was pressed
            input_active = false;
            confirmed = false;
        } else if (key_id == NCKEY_BACKSPACE && text_length > 0) {
            // Backspace was pressed and we have characters to delete
            buffer[--text_length] = '\0';
        } else if (key_id != 0 && text_length < buffer_size - 1 &&
                   !(input_event.type == INPUT_UP ||
                     input_event.type == INPUT_DOWN ||
                     input_event.type == INPUT_LEFT ||
                     input_event.type == INPUT_RIGHT)) {
            // A printable character was typed
            buffer[text_length++] = key_id;
            buffer[text_length] = '\0';
        }
    }
 
    return confirmed;
}

init_output_handler()

bool init_output_handler

(

void

)

Initialize the output handler.

Sets up the output handling system. This function must be called before any other output functions.

Returns

true on success, false on failure

Definition at line 26 of file output_handler.c.

                           {
    if (!nc) {
        log_msg(ERROR, "output_handler", "Null Notcurses instance provided");
        return false;
    }
 
    if (!stdplane) {
        log_msg(ERROR, "output_handler", "Null standard plane provided");
        return false;
    }
    return true;
}

print_menu()

void print_menu	(	const char *	title,
		const char **	options,
		int	option_count,
		int	selected_index,
		int	y,
		int	x,
		uint64_t	title_channel,
		uint64_t	option_channel,
		uint64_t	selected_channel )

Print a menu with selection highlighting.

Renders a menu with the specified options, highlighting the selected option.

Parameters

title	The menu title
options	Array of option strings
option_count	Number of options
selected_index	Index of the selected option
y	The Y coordinate (row) for the menu start
x	The X coordinate (column) for the menu start
title_channel	The color channel for the title
option_channel	The color channel for the options
selected_channel	The color channel for the selected option

Returns

true on success, false on failure

Definition at line 124 of file output_handler.c.

                                           {
    if (!stdplane || !title || !options || option_count <= 0) {
        log_msg(ERROR, "output_handler", "Invalid menu parameters");
        return;
    }
 
    // Print title
    ncplane_set_channels(stdplane, title_channel);
    ncplane_putstr_yx(stdplane, y, x, title);
 
    // Print options
    for (int i = 0; i < option_count; i++) {
        if (i == selected_index) {
            // Highlight selected option
            ncplane_set_channels(stdplane, selected_channel);
        } else {
            ncplane_set_channels(stdplane, option_channel);
        }
        ncplane_putstr_yx(stdplane, y + i + 1, x, options[i]);
    }
}

print_menu_default()

void print_menu_default	(	const char *	title,
		const char **	options,
		int	option_count,
		int	selected_index,
		int	y,
		int	x )

Print a menu with selection highlighting using default colors.

Renders a menu with the specified options, highlighting the selected option. Uses default colors for normal options and inverted colors for the selected option.

Parameters

title	The menu title
options	Array of option strings
option_count	Number of options
selected_index	Index of the selected option
y	The Y coordinate (row) for the menu start
x	The X coordinate (column) for the menu start

Definition at line 150 of file output_handler.c.

                                                          {
    print_menu(title, options, option_count, selected_index, y, x,
               DEFAULT_COLORS, DEFAULT_COLORS, INVERTED_COLORS);
}

print_text()

void print_text	(	int	y,
		int	x,
		const char *	text,
		uint64_t	ncchannel )

Print text at a specific position.

Renders text at the specified coordinates with the given foreground and background colors.

Parameters

y	The Y coordinate (row)
x	The X coordinate (column)
text	The text to render
ncchannel	The color channel (foreground and background)

Returns

true on success, false on failure

Definition at line 50 of file output_handler.c.

                                                                    {
    if (!stdplane || !text) {
        log_msg(ERROR, "output_handler", "Output handler not initialized or null text");
        return;
    }
 
    // Set the channels and print the text
    ncplane_set_channels(stdplane, ncchannel);
    ncplane_putstr_yx(stdplane, y, x, text);
}

print_text_default()

void print_text_default	(	int	y,
		int	x,
		const char *	text )

Print text at a specific position with default colors.

Renders text at the specified coordinates with the default colors.

Parameters

y	The Y coordinate (row)
x	The X coordinate (column)
text	The text to render

Returns

true on success, false on failure

Definition at line 61 of file output_handler.c.

                                                        {
    print_text(y, x, text, DEFAULT_COLORS);
}

print_text_multi_line()

void print_text_multi_line	(	int	y,
		int	x,
		const char *	text,
		int	max_width,
		u_int64_t	ncchannel )

Print multi-line text with word wrapping.

Renders text with word wrapping at the specified coordinates.

Parameters

y	The Y coordinate (row)
x	The X coordinate (column)
text	The text to render
max_width	The maximum width for line wrapping
ncchannel	The color channel (foreground and background)

print_text_multi_line_default()

void print_text_multi_line_default	(	int	y,
		int	x,
		const char *	text,
		int	max_width )

Print multi-line text with word wrapping and default colors.

Renders text with word wrapping at the specified coordinates using default colors.

Parameters

y	The Y coordinate (row)
x	The X coordinate (column)
text	The text to render
max_width	The maximum width for line wrapping

Definition at line 99 of file output_handler.c.

                                                                                  {
    print_text_multi_line(y, x, text, max_width, DEFAULT_COLORS);
}

print_text_multi_strings()

void print_text_multi_strings	(	int	y,
		int	x,
		const char *	text[],
		int	count,
		uint64_t	ncchannel )

Print multiple strings on consecutive lines.

Renders an array of strings starting at the specified coordinates.

Parameters

y	The Y coordinate (row) for the first string
x	The X coordinate (column)
text	Array of strings to render
count	Number of strings in the array
ncchannel	The color channel (foreground and background)

Definition at line 103 of file output_handler.c.

                                                                                               {
    if (!stdplane || !text || count <= 0) {
        log_msg(ERROR, "output_handler", "Invalid parameters for print_text_multi_strings");
        return;
    }
 
    // Set the channels
    ncplane_set_channels(stdplane, ncchannel);
 
    // Print each string on a new line
    for (int i = 0; i < count; i++) {
        if (text[i]) {
            ncplane_putstr_yx(stdplane, y + i, x, text[i]);
        }
    }
}

print_text_multi_strings_default()

void print_text_multi_strings_default	(	int	y,
		int	x,
		const char *	text[],
		int	count )

Print multiple strings on consecutive lines with default colors.

Renders an array of strings starting at the specified coordinates using default colors.

Parameters

y	The Y coordinate (row) for the first string
x	The X coordinate (column)
text	Array of strings to render
count	Number of strings in the array

Definition at line 120 of file output_handler.c.

                                                                                   {
    print_text_multi_strings(y, x, text, count, DEFAULT_COLORS);
}

render_frame()

bool render_frame

(

void

)

Render the current frame.

Renders all changes to the screen.

Returns

true on success, false on failure

Definition at line 246 of file output_handler.c.

                        {
    if (!nc) {
        log_msg(ERROR, "output_handler", "Output handler not initialized");
        return false;
    }
 
    // Render all changes directly
    int ret = notcurses_render(nc);
    return ret >= 0;
}

show_message_screen()

void show_message_screen	(	const char *	message,
		const char *	continue_message,
		int	y,
		int	x )

Show a message screen.

Displays a message on the screen and waits for user input.

Parameters

message	The message to display
continue_message	Optional message explaining how to continue (can be NULL)
y	The Y coordinate (row) for the message
x	The X coordinate (column) for the message

Definition at line 221 of file output_handler.c.

                                                                                          {
    if (!stdplane || !message) {
        log_msg(ERROR, "output_handler", "Invalid parameters for show_message_screen");
        return;
    }
 
    // Clear screen
    clear_screen();
 
    // Display message
    print_text_default(y, x, message);
 
    // Display continue message if provided
    if (continue_message) {
        print_text_default(y + 2, x, continue_message);
    }
 
    // Render the frame
    render_frame();
 
    // Wait for any input to continue
    input_event_t input_event;
    while (!get_input_blocking(&input_event));
}

shutdown_output_handler()

void shutdown_output_handler

(

void

)

Shutdown the output handler.

Cleans up resources.

Definition at line 270 of file output_handler.c.

                                   {
    // Reset the globals
    nc = NULL;
    stdplane = NULL;
}