#include <time.h>
#include <ctype.h>
#include <wchar.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <limits.h>
#include <stdbool.h>
#include <notcurses/ncport.h>
#include <notcurses/nckeys.h>
#include <notcurses/ncseqs.h>

Include dependency graph for notcurses.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	nccell

struct	notcurses_options

struct	ncinput

struct	ncplane_options

struct	ncpalette

struct	nccapabilities

struct	ncstats

struct	ncvisual_options

struct	ncvgeom

struct	ncreel_options

struct	ncselector_item

struct	ncselector_options

struct	ncmselector_item

struct	ncmultiselector_options

struct	nctree_item

struct	nctree_options

struct	ncmenu_item

struct	ncmenu_section

struct	ncmenu_options

struct	ncprogbar_options

struct	nctabbed_options

struct	ncplot_options

struct	ncfdplane_options

struct	ncsubproc_options

struct	ncreader_options

Macros
#define	RESTRICT restrict

#define	API __attribute__((visibility("default")))

#define	ALLOC __attribute__((malloc)) __attribute__((warn_unused_result))

#define	NCALIGN_TOP NCALIGN_LEFT

#define	NCALIGN_BOTTOM NCALIGN_RIGHT

#define	NCALPHA_HIGHCONTRAST 0x30000000ull

#define	NCALPHA_TRANSPARENT 0x20000000ull

#define	NCALPHA_BLEND 0x10000000ull

#define	NCALPHA_OPAQUE 0x00000000ull

#define	NCPALETTESIZE 256

#define	NC_NOBACKGROUND_MASK 0x8700000000000000ull

#define	NC_BGDEFAULT_MASK 0x0000000040000000ull

#define	NC_BG_RGB_MASK 0x0000000000ffffffull

#define	NC_BG_PALETTE 0x0000000008000000ull

#define	NC_BG_ALPHA_MASK 0x30000000ull

#define	NCCHANNEL_INITIALIZER(r, g, b) (((uint32_t)(r) << 16u) + ((uint32_t)(g) << 8u) + (b) + NC_BGDEFAULT_MASK)

#define	NCCHANNELS_INITIALIZER(fr, fg, fb, br, bg, bb)

#define	WCHAR_MAX_UTF8BYTES 4

#define	NCCELL_INITIALIZER(c, s, chan)

#define	NCCELL_CHAR_INITIALIZER(c)

#define	NCCELL_TRIVIAL_INITIALIZER

#define	NCSTYLE_MASK 0xffffu

#define	NCSTYLE_ITALIC 0x0010u

#define	NCSTYLE_UNDERLINE 0x0008u

#define	NCSTYLE_UNDERCURL 0x0004u

#define	NCSTYLE_BOLD 0x0002u

#define	NCSTYLE_STRUCK 0x0001u

#define	NCSTYLE_NONE 0

#define	NCOPTION_INHIBIT_SETLOCALE 0x0001ull

#define	NCOPTION_NO_CLEAR_BITMAPS 0x0002ull

#define	NCOPTION_NO_WINCH_SIGHANDLER 0x0004ull

#define	NCOPTION_NO_QUIT_SIGHANDLERS 0x0008ull

#define	NCOPTION_PRESERVE_CURSOR 0x0010ull

#define	NCOPTION_SUPPRESS_BANNERS 0x0020ull

#define	NCOPTION_NO_ALTERNATE_SCREEN 0x0040ull

#define	NCOPTION_NO_FONT_CHANGES 0x0080ull

#define	NCOPTION_DRAIN_INPUT 0x0100ull

#define	NCOPTION_SCROLLING 0x0200ull

#define	NCOPTION_CLI_MODE

#define	NCINPUT_MAX_EFF_TEXT_CODEPOINTS 4

#define	NCMICE_NO_EVENTS 0

#define	NCMICE_MOVE_EVENT 0x1

#define	NCMICE_BUTTON_EVENT 0x2

#define	NCMICE_DRAG_EVENT 0x4

#define	NCMICE_ALL_EVENTS 0x7

#define	NCPLANE_OPTION_HORALIGNED 0x0001ull

#define	NCPLANE_OPTION_VERALIGNED 0x0002ull

#define	NCPLANE_OPTION_MARGINALIZED 0x0004ull

#define	NCPLANE_OPTION_FIXED 0x0008ull

#define	NCPLANE_OPTION_AUTOGROW 0x0010ull

#define	NCPLANE_OPTION_VSCROLL 0x0020ull

#define	NCBOXMASK_TOP 0x0001

#define	NCBOXMASK_RIGHT 0x0002

#define	NCBOXMASK_BOTTOM 0x0004

#define	NCBOXMASK_LEFT 0x0008

#define	NCBOXGRAD_TOP 0x0010

#define	NCBOXGRAD_RIGHT 0x0020

#define	NCBOXGRAD_BOTTOM 0x0040

#define	NCBOXGRAD_LEFT 0x0080

#define	NCBOXCORNER_MASK 0x0300

#define	NCBOXCORNER_SHIFT 8u

#define	NCVISUAL_OPTION_NODEGRADE 0x0001ull

#define	NCVISUAL_OPTION_BLEND 0x0002ull

#define	NCVISUAL_OPTION_HORALIGNED 0x0004ull

#define	NCVISUAL_OPTION_VERALIGNED 0x0008ull

#define	NCVISUAL_OPTION_ADDALPHA 0x0010ull

#define	NCVISUAL_OPTION_CHILDPLANE 0x0020ull

#define	NCVISUAL_OPTION_NOINTERPOLATE 0x0040ull

#define	NCREEL_OPTION_INFINITESCROLL 0x0001ull

#define	NCREEL_OPTION_CIRCULAR 0x0002ull

#define	NCPREFIXCOLUMNS 7

#define	NCIPREFIXCOLUMNS 8

#define	NCBPREFIXCOLUMNS 9

#define	NCPREFIXSTRLEN (NCPREFIXCOLUMNS + 1)

#define	NCIPREFIXSTRLEN (NCIPREFIXCOLUMNS + 1)

#define	NCBPREFIXSTRLEN (NCBPREFIXCOLUMNS + 1)

#define	NCMETRICFWIDTH(x, cols) ((int)(strlen(x) - ncstrwidth(x, NULL, NULL) + (cols)))

#define	NCPREFIXFMT(x) NCMETRICFWIDTH((x), NCPREFIXCOLUMNS), (x)

#define	NCIPREFIXFMT(x) NCMETRICFWIDTH((x), NCIPREFIXCOLUMNS), (x)

#define	NCBPREFIXFMT(x) NCMETRICFWIDTH((x), NCBPREFIXCOLUMNS), (x)

#define	NCMENU_OPTION_BOTTOM 0x0001ull

#define	NCMENU_OPTION_HIDING 0x0002ull

#define	NCPROGBAR_OPTION_RETROGRADE 0x0001u

#define	NCTABBED_OPTION_BOTTOM 0x0001ull

#define	NCPLOT_OPTION_LABELTICKSD 0x0001u

#define	NCPLOT_OPTION_EXPONENTIALD 0x0002u

#define	NCPLOT_OPTION_VERTICALI 0x0004u

#define	NCPLOT_OPTION_NODEGRADE 0x0008u

#define	NCPLOT_OPTION_DETECTMAXONLY 0x0010u

#define	NCPLOT_OPTION_PRINTSAMPLE 0x0020u

#define	NCREADER_OPTION_HORSCROLL 0x0001ull

#define	NCREADER_OPTION_VERSCROLL 0x0002ull

#define	NCREADER_OPTION_NOCMDKEYS 0x0004ull

#define	NCREADER_OPTION_CURSOR 0x0008ull

Typedefs
typedef API int struct nccell	nccell

typedef struct notcurses_options	notcurses_options

typedef struct ncinput	ncinput

typedef struct ncplane_options	ncplane_options

typedef struct ncpalette	ncpalette

typedef struct nccapabilities	nccapabilities

typedef struct ncstats	ncstats

typedef int(*	fadecb) (struct notcurses nc, struct ncplane n, const struct timespec , void curry)

typedef struct ncvgeom	ncvgeom

typedef int(*	ncstreamcb) (struct ncvisual , struct ncvisual_options , const struct timespec , void )

typedef struct ncreel_options	ncreel_options

typedef int(*	tabletcb) (struct nctablet *t, bool drawfromtop)

typedef struct ncselector_options	ncselector_options

typedef struct ncmultiselector_options	ncmultiselector_options

typedef struct nctree_options	nctree_options

typedef struct ncmenu_options	ncmenu_options

typedef struct ncprogbar_options	ncprogbar_options

typedef struct nctabbed_options	nctabbed_options

typedef void(*	tabcb) (struct nctab t, struct ncplane ncp, void *curry)

typedef struct ncplot_options	ncplot_options

typedef int(*	ncfdplane_callback) (struct ncfdplane n, const void buf, size_t s, void *curry)

typedef int(*	ncfdplane_done_cb) (struct ncfdplane n, int fderrno, void curry)

typedef struct ncfdplane_options	ncfdplane_options

typedef struct ncsubproc_options	ncsubproc_options

typedef struct ncreader_options	ncreader_options

Enumerations
enum	ncblitter_e { NCBLIT_DEFAULT , NCBLIT_1x1 , NCBLIT_2x1 , NCBLIT_2x2 , NCBLIT_3x2 , NCBLIT_4x2 , NCBLIT_BRAILLE , NCBLIT_PIXEL , NCBLIT_4x1 , NCBLIT_8x1 }

enum	ncalign_e { NCALIGN_UNALIGNED , NCALIGN_LEFT , NCALIGN_CENTER , NCALIGN_RIGHT }

enum	ncscale_e { NCSCALE_NONE , NCSCALE_SCALE , NCSCALE_STRETCH , NCSCALE_NONE_HIRES , NCSCALE_SCALE_HIRES }

enum	ncloglevel_e { NCLOGLEVEL_SILENT = -1 , NCLOGLEVEL_PANIC = 0 , NCLOGLEVEL_FATAL = 1 , NCLOGLEVEL_ERROR = 2 , NCLOGLEVEL_WARNING = 3 , NCLOGLEVEL_INFO = 4 , NCLOGLEVEL_VERBOSE = 5 , NCLOGLEVEL_DEBUG = 6 , NCLOGLEVEL_TRACE = 7 }

enum	ncintype_e { NCTYPE_UNKNOWN , NCTYPE_PRESS , NCTYPE_REPEAT , NCTYPE_RELEASE }

enum	ncpixelimpl_e { NCPIXEL_NONE = 0 , NCPIXEL_SIXEL , NCPIXEL_LINUXFB , NCPIXEL_ITERM2 , NCPIXEL_KITTY_STATIC , NCPIXEL_KITTY_ANIMATED , NCPIXEL_KITTY_SELFREF }

Functions
API const char *	notcurses_version (void)

API void	notcurses_version_components (int major, int minor, int patch, int tweak)

API int	ncstrwidth (const char egcs, int validbytes, int *validwidth) __attribute__((nonnull(1)))

API int	notcurses_ucs32_to_utf8 (const uint32_t ucs32, unsigned ucs32count, unsigned char resultbuf, size_t buflen) __attribute__((nonnull(1

API int	nccell_load (struct ncplane n, nccell c, const char *gcluster)

API int	nccell_duplicate (struct ncplane n, nccell targ, const nccell *c)

API void	nccell_release (struct ncplane n, nccell c)

API	__attribute__ ((returns_nonnull)) const char nccell_extended_gcluster(const struct ncplane n

API int	notcurses_lex_margins (const char op, notcurses_options opts) __attribute__((nonnull(1)))

API int	notcurses_lex_blitter (const char op, ncblitter_e blitter) __attribute__((nonnull(1)))

API const char *	notcurses_str_blitter (ncblitter_e blitter)

API int	notcurses_lex_scalemode (const char op, ncscale_e scalemode) __attribute__((nonnull(1)))

API const char *	notcurses_str_scalemode (ncscale_e scalemode)

API ALLOC struct notcurses *	notcurses_init (const notcurses_options opts, FILE fp)

API ALLOC struct notcurses *	notcurses_core_init (const notcurses_options opts, FILE fp)

API int	notcurses_stop (struct notcurses *nc)

API int	notcurses_enter_alternate_screen (struct notcurses *nc) __attribute__((nonnull(1)))

API int	notcurses_leave_alternate_screen (struct notcurses *nc) __attribute__((nonnull(1)))

API struct ncplane *	notcurses_stdplane (struct notcurses *nc) __attribute__((nonnull(1)))

API const struct ncplane *	notcurses_stdplane_const (const struct notcurses *nc) __attribute__((nonnull(1)))

API struct ncplane *	ncpile_top (struct ncplane *n) __attribute__((nonnull(1)))

API struct ncplane *	ncpile_bottom (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncpile_render (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncpile_rasterize (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncpile_render_to_buffer (struct ncplane p, char buf, size_t buflen) __attribute__((nonnull(1

API int API int	ncpile_render_to_file (struct ncplane p, FILE fp) __attribute__((nonnull(1

API int API int API void	notcurses_drop_planes (struct notcurses *nc) __attribute__((nonnull(1)))

API uint32_t	notcurses_get (struct notcurses n, const struct timespec ts, ncinput *ni) __attribute__((nonnull(1)))

API int	notcurses_getvec (struct notcurses n, const struct timespec ts, ncinput *ni, int vcount) __attribute__((nonnull(1

API int API int	notcurses_inputready_fd (struct notcurses *n) __attribute__((nonnull(1)))

API int	notcurses_mice_enable (struct notcurses *n, unsigned eventmask) __attribute__((nonnull(1)))

	__attribute__ ((nonnull(1))) static inline int notcurses_mice_disable(struct notcurses *n)

API int	notcurses_linesigs_disable (struct notcurses *n) __attribute__((nonnull(1)))

API int	notcurses_linesigs_enable (struct notcurses *n) __attribute__((nonnull(1)))

API int	notcurses_refresh (struct notcurses n, unsigned RESTRICT y, unsigned *RESTRICT x) __attribute__((nonnull(1)))

API struct notcurses *	ncplane_notcurses (const struct ncplane *n) __attribute__((nonnull(1)))

API const struct notcurses *	ncplane_notcurses_const (const struct ncplane *n) __attribute__((nonnull(1)))

API void	ncplane_dim_yx (const struct ncplane n, unsigned RESTRICT y, unsigned *RESTRICT x) __attribute__((nonnull(1)))

API void	ncplane_pixel_geom (const struct ncplane n, unsigned RESTRICT pxy, unsigned RESTRICT pxx, unsigned RESTRICT celldimy, unsigned RESTRICT celldimx, unsigned RESTRICT maxbmapy, unsigned *RESTRICT maxbmapx) __attribute__((nonnull(1)))

API char *	notcurses_at_yx (struct notcurses nc, unsigned yoff, unsigned xoff, uint16_t stylemask, uint64_t *channels) __attribute__((nonnull(1)))

API ALLOC struct ncplane *	ncplane_create (struct ncplane n, const ncplane_options nopts) __attribute__((nonnull(1

API ALLOC struct ncplane API ALLOC struct ncplane *	ncpile_create (struct notcurses nc, const ncplane_options nopts) __attribute__((nonnull(1

API ALLOC struct ncplane API ALLOC struct ncplane API int	ncplane_resize_maximize (struct ncplane *n)

API int	ncplane_resize_marginalized (struct ncplane *n)

API int	ncplane_resize_realign (struct ncplane *n)

API int	ncplane_resize_placewithin (struct ncplane *n)

API void	ncplane_set_resizecb (struct ncplane n, int(resizecb)(struct ncplane *))

API int	ncplane_set_name (struct ncplane n, const char name) __attribute__((nonnull(1)))

API ALLOC char *	ncplane_name (const struct ncplane *n) __attribute__((nonnull(1)))

API struct ncplane *	ncplane_reparent (struct ncplane n, struct ncplane newparent) __attribute__((nonnull(1

API struct ncplane API struct ncplane *	ncplane_reparent_family (struct ncplane n, struct ncplane newparent) __attribute__((nonnull(1

API struct ncplane API struct ncplane API ALLOC struct ncplane *	ncplane_dup (const struct ncplane n, void opaque) __attribute__((nonnull(1)))

API void	ncplane_translate (const struct ncplane src, const struct ncplane dst, int RESTRICT y, int RESTRICT x) __attribute__((nonnull(1)))

API bool	ncplane_translate_abs (const struct ncplane n, int RESTRICT y, int *RESTRICT x) __attribute__((nonnull(1)))

API bool	ncplane_set_scrolling (struct ncplane *n, unsigned scrollp) __attribute__((nonnull(1)))

API bool	ncplane_scrolling_p (const struct ncplane *n) __attribute__((nonnull(1)))

API bool	ncplane_set_autogrow (struct ncplane *n, unsigned growp) __attribute__((nonnull(1)))

API bool	ncplane_autogrow_p (const struct ncplane *n) __attribute__((nonnull(1)))

API ALLOC ncpalette *	ncpalette_new (struct notcurses *nc) __attribute__((nonnull(1)))

API int	ncpalette_use (struct notcurses nc, const ncpalette p) __attribute__((nonnull(1

API void	ncpalette_free (ncpalette *p)

API uint16_t	notcurses_supported_styles (const struct notcurses *nc) __attribute__((nonnull(1))) __attribute__((pure))

API unsigned	notcurses_palette_size (const struct notcurses *nc) __attribute__((nonnull(1))) __attribute__((pure))

ALLOC API char *	notcurses_detected_terminal (const struct notcurses *nc) __attribute__((nonnull(1)))

API const nccapabilities *	notcurses_capabilities (const struct notcurses *n) __attribute__((nonnull(1)))

API ncpixelimpl_e	notcurses_check_pixel_support (const struct notcurses *nc) __attribute__((nonnull(1))) __attribute__((pure))

API bool	notcurses_canopen_images (const struct notcurses *nc) __attribute__((pure))

API bool	notcurses_canopen_videos (const struct notcurses *nc) __attribute__((pure))

API ALLOC ncstats *	notcurses_stats_alloc (const struct notcurses *nc __attribute__((unused))) __attribute__((nonnull(1)))

API void	notcurses_stats (struct notcurses nc, ncstats stats) __attribute__((nonnull(1

API void API void	notcurses_stats_reset (struct notcurses nc, ncstats stats) __attribute__((nonnull(1)))

API int	ncplane_resize (struct ncplane *n, int keepy, int keepx, unsigned keepleny, unsigned keeplenx, int yoff, int xoff, unsigned ylen, unsigned xlen)

API int	ncplane_destroy (struct ncplane *n)

API int	ncplane_set_base_cell (struct ncplane n, const nccell c)

API int	ncplane_set_base (struct ncplane n, const char egc, uint16_t stylemask, uint64_t channels)

API int	ncplane_base (struct ncplane n, nccell c)

API void	ncplane_yx (const struct ncplane n, int RESTRICT y, int *RESTRICT x) __attribute__((nonnull(1)))

API int	ncplane_y (const struct ncplane *n) __attribute__((pure))

API int	ncplane_x (const struct ncplane *n) __attribute__((pure))

API int	ncplane_move_yx (struct ncplane *n, int y, int x)

	ncplane_yx (n, &oy, &ox)

return	ncplane_move_yx (n, oy+y, ox+x)

API void	ncplane_abs_yx (const struct ncplane n, int RESTRICT y, int *RESTRICT x) __attribute__((nonnull(1)))

API int	ncplane_abs_y (const struct ncplane *n) __attribute__((pure))

API int	ncplane_abs_x (const struct ncplane *n) __attribute__((pure))

API struct ncplane *	ncplane_parent (struct ncplane *n) __attribute__((nonnull(1)))

API const struct ncplane *	ncplane_parent_const (const struct ncplane *n) __attribute__((nonnull(1)))

API int	ncplane_move_above (struct ncplane RESTRICT n, struct ncplane RESTRICT above) __attribute__((nonnull(1)))

API int	ncplane_move_below (struct ncplane RESTRICT n, struct ncplane RESTRICT below) __attribute__((nonnull(1)))

API int	ncplane_move_family_above (struct ncplane n, struct ncplane targ) __attribute__((nonnull(1)))

API int	ncplane_move_family_below (struct ncplane n, struct ncplane targ) __attribute__((nonnull(1)))

API struct ncplane *	ncplane_below (struct ncplane *n) __attribute__((nonnull(1)))

API struct ncplane *	ncplane_above (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncplane_scrollup (struct ncplane *n, int r) __attribute__((nonnull(1)))

API int	ncplane_scrollup_child (struct ncplane n, const struct ncplane child) __attribute__((nonnull(1

API int API int	ncplane_rotate_cw (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncplane_rotate_ccw (struct ncplane *n) __attribute__((nonnull(1)))

API char *	ncplane_at_cursor (const struct ncplane n, uint16_t stylemask, uint64_t *channels) __attribute__((nonnull(1)))

API int	ncplane_at_cursor_cell (struct ncplane n, nccell c) __attribute__((nonnull(1

API int API char *	ncplane_at_yx (const struct ncplane n, int y, int x, uint16_t stylemask, uint64_t *channels) __attribute__((nonnull(1)))

API int	ncplane_at_yx_cell (struct ncplane n, int y, int x, nccell c) __attribute__((nonnull(1

API int API char *	ncplane_contents (struct ncplane *n, int begy, int begx, unsigned leny, unsigned lenx) __attribute__((nonnull(1)))

API void *	ncplane_set_userptr (struct ncplane n, void opaque) __attribute__((nonnull(1)))

API void *	ncplane_userptr (struct ncplane *n) __attribute__((nonnull(1)))

API void	ncplane_center_abs (const struct ncplane n, int RESTRICT y, int *RESTRICT x) __attribute__((nonnull(1)))

API ALLOC uint32_t *	ncplane_as_rgba (const struct ncplane n, ncblitter_e blit, int begy, int begx, unsigned leny, unsigned lenx, unsigned pxdimy, unsigned *pxdimx) __attribute__((nonnull(1)))

API int	ncplane_cursor_move_yx (struct ncplane *n, int y, int x) __attribute__((nonnull(1)))

API int	ncplane_cursor_move_rel (struct ncplane *n, int y, int x) __attribute__((nonnull(1)))

API void	ncplane_home (struct ncplane *n) __attribute__((nonnull(1)))

API void	ncplane_cursor_yx (const struct ncplane n, unsigned RESTRICT y, unsigned *RESTRICT x) __attribute__((nonnull(1)))

API uint64_t	ncplane_channels (const struct ncplane *n) __attribute__((nonnull(1)))

API uint16_t	ncplane_styles (const struct ncplane *n) __attribute__((nonnull(1)))

API int	ncplane_putc_yx (struct ncplane n, int y, int x, const nccell c) __attribute__((nonnull(1

API int	ncplane_putchar_stained (struct ncplane *n, char c) __attribute__((nonnull(1)))

API int	ncplane_putegc_yx (struct ncplane n, int y, int x, const char gclust, size_t *sbytes) __attribute__((nonnull(1

API int	ncplane_putegc_stained (struct ncplane n, const char gclust, size_t *sbytes) __attribute__((nonnull(1

API int	ncplane_putwegc_stained (struct ncplane n, const wchar_t gclust, size_t *sbytes) __attribute__((nonnull(1

API int	ncplane_putnstr_aligned (struct ncplane n, int y, ncalign_e align, size_t s, const char str) __attribute__((nonnull(1

API int	ncplane_putwstr_stained (struct ncplane n, const wchar_t gclustarr) __attribute__((nonnull(1

API int	ncplane_vprintf_aligned (struct ncplane n, int y, ncalign_e align, const char format, va_list ap) __attribute__((nonnull(1

API int	__attribute__ ((format(printf, 4, 0)))

API int	ncplane_vprintf_yx (struct ncplane n, int y, int x, const char format, va_list ap) __attribute__((nonnull(1

API int	ncplane_vprintf_stained (struct ncplane n, const char format, va_list ap) __attribute__((nonnull(1

API int	__attribute__ ((format(printf, 2, 0)))

static int	__attribute__ ((format(printf, 2, 3)))

static int	__attribute__ ((format(printf, 4, 5)))

API int	ncplane_puttext (struct ncplane n, int y, ncalign_e align, const char text, size_t *bytes) __attribute__((nonnull(1

API int API int	ncplane_hline_interp (struct ncplane n, const nccell c, unsigned len, uint64_t c1, uint64_t c2) __attribute__((nonnull(1

API int API int	__attribute__ ((nonnull(1, 2))) static inline int ncplane_hline(struct ncplane *n

API int	ncplane_vline_interp (struct ncplane n, const nccell c, unsigned len, uint64_t c1, uint64_t c2) __attribute__((nonnull(1

API int	ncplane_box (struct ncplane n, const nccell ul, const nccell ur, const nccell ll, const nccell lr, const nccell hline, const nccell *vline, unsigned ystop, unsigned xstop, unsigned ctlword)

API int	ncplane_polyfill_yx (struct ncplane n, int y, int x, const nccell c) __attribute__((nonnull(1

API int API int	ncplane_gradient (struct ncplane n, int y, int x, unsigned ylen, unsigned xlen, const char egc, uint16_t styles, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr) __attribute__((nonnull(1

API int API int API int	ncplane_gradient2x1 (struct ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint32_t ul, uint32_t ur, uint32_t ll, uint32_t lr) __attribute__((nonnull(1)))

API int	ncplane_format (struct ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint16_t stylemask) __attribute__((nonnull(1)))

API int	ncplane_stain (struct ncplane *n, int y, int x, unsigned ylen, unsigned xlen, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr) __attribute__((nonnull(1)))

API int	ncplane_mergedown_simple (struct ncplane RESTRICT src, struct ncplane RESTRICT dst) __attribute__((nonnull(1

API int API int	ncplane_mergedown (struct ncplane RESTRICT src, struct ncplane RESTRICT dst, int begsrcy, int begsrcx, unsigned leny, unsigned lenx, int dsty, int dstx) __attribute__((nonnull(1

API int API int API void	ncplane_erase (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncplane_erase_region (struct ncplane *n, int ystart, int xstart, int ylen, int xlen) __attribute__((nonnull(1)))

API void	ncplane_set_channels (struct ncplane *n, uint64_t channels) __attribute__((nonnull(1)))

API uint64_t	ncplane_set_bchannel (struct ncplane *n, uint32_t channel) __attribute__((nonnull(1)))

API uint64_t	ncplane_set_fchannel (struct ncplane *n, uint32_t channel) __attribute__((nonnull(1)))

API void	ncplane_set_styles (struct ncplane *n, unsigned stylebits) __attribute__((nonnull(1)))

API void	ncplane_on_styles (struct ncplane *n, unsigned stylebits) __attribute__((nonnull(1)))

API void	ncplane_off_styles (struct ncplane *n, unsigned stylebits) __attribute__((nonnull(1)))

API int	ncplane_set_fg_rgb8 (struct ncplane *n, unsigned r, unsigned g, unsigned b)

API int	ncplane_set_bg_rgb8 (struct ncplane *n, unsigned r, unsigned g, unsigned b)

API void	ncplane_set_bg_rgb8_clipped (struct ncplane *n, int r, int g, int b)

API void	ncplane_set_fg_rgb8_clipped (struct ncplane *n, int r, int g, int b)

API int	ncplane_set_fg_rgb (struct ncplane *n, uint32_t channel)

API int	ncplane_set_bg_rgb (struct ncplane *n, uint32_t channel)

API void	ncplane_set_fg_default (struct ncplane *n)

API void	ncplane_set_bg_default (struct ncplane *n)

API int	ncplane_set_fg_palindex (struct ncplane *n, unsigned idx)

API int	ncplane_set_bg_palindex (struct ncplane *n, unsigned idx)

API int	ncplane_set_fg_alpha (struct ncplane *n, int alpha)

API int	ncplane_set_bg_alpha (struct ncplane *n, int alpha)

API int	ncplane_fadeout (struct ncplane n, const struct timespec ts, fadecb fader, void *curry) __attribute__((nonnull(1)))

API int	ncplane_fadein (struct ncplane n, const struct timespec ts, fadecb fader, void *curry) __attribute__((nonnull(1)))

API ALLOC struct ncfadectx *	ncfadectx_setup (struct ncplane *n) __attribute__((nonnull(1)))

API int	ncfadectx_iterations (const struct ncfadectx *nctx) __attribute__((nonnull(1)))

API int	ncplane_fadeout_iteration (struct ncplane n, struct ncfadectx nctx, int iter, fadecb fader, void *curry) __attribute__((nonnull(1

API int API int	ncplane_fadein_iteration (struct ncplane n, struct ncfadectx nctx, int iter, fadecb fader, void *curry) __attribute__((nonnull(1

API int API int API int	ncplane_pulse (struct ncplane n, const struct timespec ts, fadecb fader, void *curry) __attribute__((nonnull(1)))

API void	ncfadectx_free (struct ncfadectx *nctx)

API ALLOC struct ncvisual *	ncvisual_from_file (const char *file) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_rgba (const void *rgba, int rows, int rowstride, int cols) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_rgb_packed (const void *rgba, int rows, int rowstride, int cols, int alpha) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_rgb_loose (const void *rgba, int rows, int rowstride, int cols, int alpha) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_bgra (const void *bgra, int rows, int rowstride, int cols) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_palidx (const void data, int rows, int rowstride, int cols, int palsize, int pstride, const uint32_t palette) __attribute__((nonnull(1

API ALLOC struct ncvisual API ALLOC struct ncvisual *	ncvisual_from_plane (const struct ncplane *n, ncblitter_e blit, int begy, int begx, unsigned leny, unsigned lenx) __attribute__((nonnull(1)))

API ALLOC struct ncvisual *	ncvisual_from_sixel (const char *s, unsigned leny, unsigned lenx) __attribute__((nonnull(1)))

API int	ncvisual_geom (const struct notcurses nc, const struct ncvisual n, const struct ncvisual_options vopts, ncvgeom geom) __attribute__((nonnull(4)))

API void	ncvisual_destroy (struct ncvisual *ncv)

API int	ncvisual_decode (struct ncvisual *nc) __attribute__((nonnull(1)))

API int	ncvisual_decode_loop (struct ncvisual *nc) __attribute__((nonnull(1)))

API int	ncvisual_rotate (struct ncvisual *n, double rads) __attribute__((nonnull(1)))

API int	ncvisual_resize (struct ncvisual *n, int rows, int cols) __attribute__((nonnull(1)))

API int	ncvisual_resize_noninterpolative (struct ncvisual *n, int rows, int cols) __attribute__((nonnull(1)))

API int	ncvisual_polyfill_yx (struct ncvisual *n, unsigned y, unsigned x, uint32_t rgba) __attribute__((nonnull(1)))

API int	ncvisual_at_yx (const struct ncvisual n, unsigned y, unsigned x, uint32_t pixel) __attribute__((nonnull(1

API int API int	ncvisual_set_yx (const struct ncvisual *n, unsigned y, unsigned x, uint32_t pixel) __attribute__((nonnull(1)))

API struct ncplane *	ncvisual_blit (struct notcurses nc, struct ncvisual ncv, const struct ncvisual_options *vopts) __attribute__((nonnull(2)))

	__attribute__ ((nonnull(1, 2, 3))) static inline struct ncplane ncvisualplane_create(struct notcurses nc

	if (vopts &&vopts->n)

	if (newn==NULL)

	if (!vopts)

	if (ncvisual_blit(nc, ncv, vopts)==NULL)

API ALLOC struct ncplane *	ncvisual_subtitle_plane (struct ncplane parent, const struct ncvisual ncv) __attribute__((nonnull(1

API ALLOC struct ncplane API ncblitter_e	ncvisual_media_defblitter (const struct notcurses *nc, ncscale_e scale) __attribute__((nonnull(1)))

API int	ncvisual_simple_streamer (struct ncvisual ncv, struct ncvisual_options vopts, const struct timespec tspec, void curry) __attribute__((nonnull(1)))

API int	ncvisual_stream (struct notcurses nc, struct ncvisual ncv, float timescale, ncstreamcb streamer, const struct ncvisual_options vopts, void curry) __attribute__((nonnull(1

API int API int	ncblit_rgba (const void data, int linesize, const struct ncvisual_options vopts) __attribute__((nonnull(1)))

API int	ncblit_bgrx (const void data, int linesize, const struct ncvisual_options vopts) __attribute__((nonnull(1)))

API int	ncblit_rgb_packed (const void data, int linesize, const struct ncvisual_options vopts, int alpha) __attribute__((nonnull(1)))

API int	ncblit_rgb_loose (const void data, int linesize, const struct ncvisual_options vopts, int alpha) __attribute__((nonnull(1)))

API ALLOC struct ncreel *	ncreel_create (struct ncplane n, const ncreel_options popts) __attribute__((nonnull(1)))

API struct ncplane *	ncreel_plane (struct ncreel *nr) __attribute__((nonnull(1)))

API ALLOC struct nctablet *	ncreel_add (struct ncreel nr, struct nctablet after, struct nctablet before, tabletcb cb, void opaque) __attribute__((nonnull(1)))

API int	ncreel_tabletcount (const struct ncreel *nr) __attribute__((nonnull(1)))

API int	ncreel_del (struct ncreel nr, struct nctablet t) __attribute__((nonnull(1)))

API int	ncreel_redraw (struct ncreel *nr) __attribute__((nonnull(1)))

API bool	ncreel_offer_input (struct ncreel nr, const ncinput ni) __attribute__((nonnull(1

API bool API struct nctablet *	ncreel_focused (struct ncreel *nr) __attribute__((nonnull(1)))

API struct nctablet *	ncreel_next (struct ncreel *nr) __attribute__((nonnull(1)))

API struct nctablet *	ncreel_prev (struct ncreel *nr) __attribute__((nonnull(1)))

API void	ncreel_destroy (struct ncreel *nr)

API void *	nctablet_userptr (struct nctablet *t)

API struct ncplane *	nctablet_plane (struct nctablet *t)

API const char *	ncnmetric (uintmax_t val, size_t s, uintmax_t decimal, char *buf, int omitdec, uintmax_t mult, int uprefix) __attribute__((nonnull(4)))

API int	notcurses_default_foreground (const struct notcurses nc, uint32_t fg) __attribute__((nonnull(1)))

API int	notcurses_default_background (const struct notcurses nc, uint32_t bg) __attribute__((nonnull(1)))

API int	notcurses_cursor_enable (struct notcurses *nc, int y, int x) __attribute__((nonnull(1)))

API int	notcurses_cursor_disable (struct notcurses *nc) __attribute__((nonnull(1)))

API int	notcurses_cursor_yx (const struct notcurses nc, int y, int *x) __attribute__((nonnull(1)))

API void	ncplane_greyscale (struct ncplane *n) __attribute__((nonnull(1)))

API ALLOC struct ncselector *	ncselector_create (struct ncplane n, const ncselector_options opts) __attribute__((nonnull(1)))

API int	ncselector_additem (struct ncselector n, const struct ncselector_item item)

API int	ncselector_delitem (struct ncselector n, const char item)

API const char *	ncselector_selected (const struct ncselector *n) __attribute__((nonnull(1)))

API struct ncplane *	ncselector_plane (struct ncselector *n) __attribute__((nonnull(1)))

API const char *	ncselector_previtem (struct ncselector *n) __attribute__((nonnull(1)))

API const char *	ncselector_nextitem (struct ncselector *n) __attribute__((nonnull(1)))

API bool	ncselector_offer_input (struct ncselector n, const ncinput nc) __attribute__((nonnull(1

API bool API void	ncselector_destroy (struct ncselector n, char *item)

API ALLOC struct ncmultiselector *	ncmultiselector_create (struct ncplane n, const ncmultiselector_options opts) __attribute__((nonnull(1)))

API int	ncmultiselector_selected (struct ncmultiselector n, bool selected, unsigned count)

API struct ncplane *	ncmultiselector_plane (struct ncmultiselector *n)

API bool	ncmultiselector_offer_input (struct ncmultiselector n, const ncinput nc) __attribute__((nonnull(1

API bool API void	ncmultiselector_destroy (struct ncmultiselector *n)

API ALLOC struct nctree *	nctree_create (struct ncplane n, const nctree_options opts) __attribute__((nonnull(1

API ALLOC struct nctree API struct ncplane *	nctree_plane (struct nctree *n) __attribute__((nonnull(1)))

API int	nctree_redraw (struct nctree *n) __attribute__((nonnull(1)))

API bool	nctree_offer_input (struct nctree n, const ncinput ni) __attribute__((nonnull(1

API bool API void *	nctree_focused (struct nctree *n) __attribute__((nonnull(1)))

API void *	nctree_next (struct nctree *n) __attribute__((nonnull(1)))

API void *	nctree_prev (struct nctree *n) __attribute__((nonnull(1)))

API void *	nctree_goto (struct nctree n, const unsigned spec, int *failspec)

API int	nctree_add (struct nctree n, const unsigned spec, const struct nctree_item *add) __attribute__((nonnull(1

API int API int	nctree_del (struct nctree n, const unsigned spec) __attribute__((nonnull(1

API int API int API void	nctree_destroy (struct nctree *n)

API ALLOC struct ncmenu *	ncmenu_create (struct ncplane n, const ncmenu_options opts) __attribute__((nonnull(1)))

API int	ncmenu_unroll (struct ncmenu *n, int sectionidx)

API int	ncmenu_rollup (struct ncmenu *n) __attribute__((nonnull(1)))

API int	ncmenu_nextsection (struct ncmenu *n) __attribute__((nonnull(1)))

API int	ncmenu_prevsection (struct ncmenu *n) __attribute__((nonnull(1)))

API int	ncmenu_nextitem (struct ncmenu *n) __attribute__((nonnull(1)))

API int	ncmenu_previtem (struct ncmenu *n) __attribute__((nonnull(1)))

API int	ncmenu_item_set_status (struct ncmenu n, const char section, const char *item, bool enabled)

API const char *	ncmenu_selected (const struct ncmenu n, ncinput ni)

API const char *	ncmenu_mouse_selected (const struct ncmenu n, const ncinput click, ncinput *ni)

API struct ncplane *	ncmenu_plane (struct ncmenu *n)

API bool	ncmenu_offer_input (struct ncmenu n, const ncinput nc) __attribute__((nonnull(1

API bool API void	ncmenu_destroy (struct ncmenu *n)

API ALLOC struct ncprogbar *	ncprogbar_create (struct ncplane n, const ncprogbar_options opts) __attribute__((nonnull(1)))

API struct ncplane *	ncprogbar_plane (struct ncprogbar *n) __attribute__((nonnull(1)))

API int	ncprogbar_set_progress (struct ncprogbar *n, double p) __attribute__((nonnull(1)))

API double	ncprogbar_progress (const struct ncprogbar *n) __attribute__((nonnull(1)))

API void	ncprogbar_destroy (struct ncprogbar *n)

API ALLOC struct nctabbed *	nctabbed_create (struct ncplane n, const nctabbed_options opts) __attribute((nonnull(1)))

API void	nctabbed_destroy (struct nctabbed *nt)

API void	nctabbed_redraw (struct nctabbed *nt) __attribute__((nonnull(1)))

API void	nctabbed_ensure_selected_header_visible (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct nctab *	nctabbed_selected (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct nctab *	nctabbed_leftmost (struct nctabbed *nt) __attribute__((nonnull(1)))

API int	nctabbed_tabcount (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct ncplane *	nctabbed_plane (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct ncplane *	nctabbed_content_plane (struct nctabbed *nt) __attribute__((nonnull(1)))

API tabcb	nctab_cb (struct nctab *t) __attribute__((nonnull(1)))

API const char *	nctab_name (struct nctab *t) __attribute__((nonnull(1)))

API int	nctab_name_width (struct nctab *t) __attribute__((nonnull(1)))

API void *	nctab_userptr (struct nctab *t) __attribute__((nonnull(1)))

API struct nctab *	nctab_next (struct nctab *t) __attribute__((nonnull(1)))

API struct nctab *	nctab_prev (struct nctab *t) __attribute__((nonnull(1)))

API ALLOC struct nctab *	nctabbed_add (struct nctabbed nt, struct nctab after, struct nctab before, tabcb tcb, const char name, void *opaque) __attribute__((nonnull(1

API ALLOC struct nctab API int	nctabbed_del (struct nctabbed nt, struct nctab t) __attribute__((nonnull(1)))

API int	nctab_move (struct nctabbed nt, struct nctab t, struct nctab after, struct nctab before) __attribute__((nonnull(1

API int API void	nctab_move_right (struct nctabbed nt, struct nctab t) __attribute__((nonnull(1

API int API void API void	nctab_move_left (struct nctabbed nt, struct nctab t) __attribute__((nonnull(1

API int API void API void API void	nctabbed_rotate (struct nctabbed *nt, int amt) __attribute__((nonnull(1)))

API struct nctab *	nctabbed_next (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct nctab *	nctabbed_prev (struct nctabbed *nt) __attribute__((nonnull(1)))

API struct nctab *	nctabbed_select (struct nctabbed nt, struct nctab t) __attribute__((nonnull(1

API struct nctab API void	nctabbed_channels (struct nctabbed nt, uint64_t RESTRICT hdrchan, uint64_t RESTRICT selchan, uint64_t RESTRICT sepchan) __attribute__((nonnull(1)))

API const char *	nctabbed_separator (struct nctabbed *nt) __attribute__((nonnull(1)))

API int	nctabbed_separator_width (struct nctabbed *nt) __attribute__((nonnull(1)))

API void	nctabbed_set_hdrchan (struct nctabbed *nt, uint64_t chan) __attribute__((nonnull(1)))

API void	nctabbed_set_selchan (struct nctabbed *nt, uint64_t chan) __attribute__((nonnull(1)))

API void	nctabbed_set_sepchan (struct nctabbed *nt, uint64_t chan) __attribute__((nonnull(1)))

API tabcb	nctab_set_cb (struct nctab *t, tabcb newcb) __attribute__((nonnull(1)))

API int	nctab_set_name (struct nctab t, const char newname) __attribute__((nonnull(1

API int API void *	nctab_set_userptr (struct nctab t, void newopaque) __attribute__((nonnull(1)))

API int	nctabbed_set_separator (struct nctabbed nt, const char separator) __attribute__((nonnull(1

API ALLOC struct ncuplot *	ncuplot_create (struct ncplane n, const ncplot_options opts, uint64_t miny, uint64_t maxy) __attribute__((nonnull(1)))

API ALLOC struct ncdplot *	ncdplot_create (struct ncplane n, const ncplot_options opts, double miny, double maxy) __attribute__((nonnull(1)))

API struct ncplane *	ncuplot_plane (struct ncuplot *n) __attribute__((nonnull(1)))

API struct ncplane *	ncdplot_plane (struct ncdplot *n) __attribute__((nonnull(1)))

API int	ncuplot_add_sample (struct ncuplot *n, uint64_t x, uint64_t y) __attribute__((nonnull(1)))

API int	ncdplot_add_sample (struct ncdplot *n, uint64_t x, double y) __attribute__((nonnull(1)))

API int	ncuplot_set_sample (struct ncuplot *n, uint64_t x, uint64_t y) __attribute__((nonnull(1)))

API int	ncdplot_set_sample (struct ncdplot *n, uint64_t x, double y) __attribute__((nonnull(1)))

API int	ncuplot_sample (const struct ncuplot n, uint64_t x, uint64_t y) __attribute__((nonnull(1)))

API int	ncdplot_sample (const struct ncdplot n, uint64_t x, double y) __attribute__((nonnull(1)))

API void	ncuplot_destroy (struct ncuplot *n)

API void	ncdplot_destroy (struct ncdplot *n)

API ALLOC struct ncfdplane *	ncfdplane_create (struct ncplane n, const ncfdplane_options opts, int fd, ncfdplane_callback cbfxn, ncfdplane_done_cb donecbfxn) __attribute__((nonnull(1)))

API struct ncplane *	ncfdplane_plane (struct ncfdplane *n) __attribute__((nonnull(1)))

API int	ncfdplane_destroy (struct ncfdplane *n)

API ALLOC struct ncsubproc *	ncsubproc_createv (struct ncplane n, const ncsubproc_options opts, const char bin, const char const arg[], ncfdplane_callback cbfxn, ncfdplane_done_cb donecbfxn) __attribute__((nonnull(1)))

API ALLOC struct ncsubproc *	ncsubproc_createvp (struct ncplane n, const ncsubproc_options opts, const char bin, const char const arg[], ncfdplane_callback cbfxn, ncfdplane_done_cb donecbfxn) __attribute__((nonnull(1)))

API ALLOC struct ncsubproc *	ncsubproc_createvpe (struct ncplane n, const ncsubproc_options opts, const char bin, const char const arg[], const char *const env[], ncfdplane_callback cbfxn, ncfdplane_done_cb donecbfxn) __attribute__((nonnull(1)))

API struct ncplane *	ncsubproc_plane (struct ncsubproc *n) __attribute__((nonnull(1)))

API int	ncsubproc_destroy (struct ncsubproc *n)

API int	ncplane_qrcode (struct ncplane n, unsigned ymax, unsigned xmax, const void data, size_t len) __attribute__((nonnull(1

API ALLOC struct ncreader *	ncreader_create (struct ncplane n, const ncreader_options opts) __attribute__((nonnull(1)))

API int	ncreader_clear (struct ncreader *n) __attribute__((nonnull(1)))

API struct ncplane *	ncreader_plane (struct ncreader *n) __attribute__((nonnull(1)))

API bool	ncreader_offer_input (struct ncreader n, const ncinput ni) __attribute__((nonnull(1

API bool API int	ncreader_move_left (struct ncreader *n) __attribute__((nonnull(1)))

API int	ncreader_move_right (struct ncreader *n) __attribute__((nonnull(1)))

API int	ncreader_move_up (struct ncreader *n) __attribute__((nonnull(1)))

API int	ncreader_move_down (struct ncreader *n) __attribute__((nonnull(1)))

API int	ncreader_write_egc (struct ncreader n, const char egc) __attribute__((nonnull(1

API int API char *	ncreader_contents (const struct ncreader *n) __attribute__((nonnull(1)))

API void	ncreader_destroy (struct ncreader n, char *contents)

API ALLOC char *	notcurses_accountname (void)

API ALLOC char *	notcurses_hostname (void)

API ALLOC char *	notcurses_osversion (void)

API void	notcurses_debug (const struct notcurses nc, FILE debugfp) __attribute__((nonnull(1

Variables
API const nccell *	c

API int()(struct ncplane )	ncplane_resizecb (const struct ncplane *n)

int	y

int int	x

API int API int const nccell unsigned	len

const struct ncplane_options *	opts

const struct ncplane_options struct ncvisual *	ncv

const struct ncplane_options struct ncvisual struct ncvisual_options *	vopts

	else

struct ncvisual_options	v

vopts	n = newn

return	newn

Macro Definition Documentation

◆ ALLOC

#define ALLOC __attribute__((malloc)) __attribute__((warn_unused_result))

Definition at line 36 of file notcurses.h.

◆ API

#define API __attribute__((visibility("default")))

Definition at line 32 of file notcurses.h.

◆ NC_BG_ALPHA_MASK

#define NC_BG_ALPHA_MASK 0x30000000ull

Definition at line 125 of file notcurses.h.

◆ NC_BG_PALETTE

#define NC_BG_PALETTE 0x0000000008000000ull

Definition at line 123 of file notcurses.h.

◆ NC_BG_RGB_MASK

#define NC_BG_RGB_MASK 0x0000000000ffffffull

Definition at line 120 of file notcurses.h.

◆ NC_BGDEFAULT_MASK

#define NC_BGDEFAULT_MASK 0x0000000040000000ull

Definition at line 118 of file notcurses.h.

◆ NC_NOBACKGROUND_MASK

#define NC_NOBACKGROUND_MASK 0x8700000000000000ull

Definition at line 116 of file notcurses.h.

◆ NCALIGN_BOTTOM

#define NCALIGN_BOTTOM NCALIGN_RIGHT

Definition at line 88 of file notcurses.h.

◆ NCALIGN_TOP

#define NCALIGN_TOP NCALIGN_LEFT

Definition at line 87 of file notcurses.h.

◆ NCALPHA_BLEND

#define NCALPHA_BLEND 0x10000000ull

Definition at line 107 of file notcurses.h.

◆ NCALPHA_HIGHCONTRAST

#define NCALPHA_HIGHCONTRAST 0x30000000ull

Definition at line 105 of file notcurses.h.

◆ NCALPHA_OPAQUE

#define NCALPHA_OPAQUE 0x00000000ull

Definition at line 108 of file notcurses.h.

◆ NCALPHA_TRANSPARENT

#define NCALPHA_TRANSPARENT 0x20000000ull

Definition at line 106 of file notcurses.h.

◆ NCBOXCORNER_MASK

#define NCBOXCORNER_MASK 0x0300

Definition at line 2609 of file notcurses.h.

◆ NCBOXCORNER_SHIFT

#define NCBOXCORNER_SHIFT 8u

Definition at line 2610 of file notcurses.h.

◆ NCBOXGRAD_BOTTOM

#define NCBOXGRAD_BOTTOM 0x0040

Definition at line 2607 of file notcurses.h.

◆ NCBOXGRAD_LEFT

#define NCBOXGRAD_LEFT 0x0080

Definition at line 2608 of file notcurses.h.

◆ NCBOXGRAD_RIGHT

#define NCBOXGRAD_RIGHT 0x0020

Definition at line 2606 of file notcurses.h.

◆ NCBOXGRAD_TOP

#define NCBOXGRAD_TOP 0x0010

Definition at line 2605 of file notcurses.h.

◆ NCBOXMASK_BOTTOM

#define NCBOXMASK_BOTTOM 0x0004

Definition at line 2603 of file notcurses.h.

◆ NCBOXMASK_LEFT

#define NCBOXMASK_LEFT 0x0008

Definition at line 2604 of file notcurses.h.

◆ NCBOXMASK_RIGHT

#define NCBOXMASK_RIGHT 0x0002

Definition at line 2602 of file notcurses.h.

◆ NCBOXMASK_TOP

#define NCBOXMASK_TOP 0x0001

Definition at line 2601 of file notcurses.h.

◆ NCBPREFIXCOLUMNS

#define NCBPREFIXCOLUMNS 9

Definition at line 3827 of file notcurses.h.

◆ NCBPREFIXFMT

#define NCBPREFIXFMT ( x ) NCMETRICFWIDTH((x), NCBPREFIXCOLUMNS), (x)

Definition at line 3837 of file notcurses.h.

◆ NCBPREFIXSTRLEN

#define NCBPREFIXSTRLEN (NCBPREFIXCOLUMNS + 1)

Definition at line 3830 of file notcurses.h.

◆ NCCELL_CHAR_INITIALIZER

#define NCCELL_CHAR_INITIALIZER ( c )

Value:

{ .gcluster = (htole(c)), .gcluster_backstop = 0,\

.width = (uint8_t)((wcwidth(c) < 0 || !c) ? 1 : wcwidth(c)), .stylemask = 0, .channels = 0, }

htole

#define htole(x)

Definition ncport.h:36

c

API const nccell * c

Definition notcurses.h:861

Definition at line 734 of file notcurses.h.

734 { .gcluster = (htole(c)), .gcluster_backstop = 0,\

735 .width = (uint8_t)((wcwidth(c) < 0 || !c) ? 1 : wcwidth(c)), .stylemask = 0, .channels = 0, }

◆ NCCELL_INITIALIZER

#define NCCELL_INITIALIZER	(	c,
		s,
		chan
	)

Value:

{ .gcluster = (htole(c)), .gcluster_backstop = 0,\

.width = (uint8_t)((wcwidth(c) < 0 || !c) ? 1 : wcwidth(c)), .stylemask = (s), .channels = (chan), }

Definition at line 731 of file notcurses.h.

731 { .gcluster = (htole(c)), .gcluster_backstop = 0,\

732 .width = (uint8_t)((wcwidth(c) < 0 || !c) ? 1 : wcwidth(c)), .stylemask = (s), .channels = (chan), }

◆ NCCELL_TRIVIAL_INITIALIZER

#define NCCELL_TRIVIAL_INITIALIZER

Value:

{ .gcluster = 0, .gcluster_backstop = 0,\

.width = 1, .stylemask = 0, .channels = 0, }

Definition at line 737 of file notcurses.h.

737 { .gcluster = 0, .gcluster_backstop = 0,\

738 .width = 1, .stylemask = 0, .channels = 0, }

◆ NCCHANNEL_INITIALIZER

#define NCCHANNEL_INITIALIZER	(	r,
		g,
		b
	)	(((uint32_t)(r) << 16u) + ((uint32_t)(g) << 8u) + (b) + NC_BGDEFAULT_MASK)

Definition at line 128 of file notcurses.h.

◆ NCCHANNELS_INITIALIZER

#define NCCHANNELS_INITIALIZER	(	fr,
		fg,
		fb,
		br,
		bg,
		bb
	)

Value:

((NCCHANNEL_INITIALIZER((fr), (fg), (fb)) << 32ull) + \

(NCCHANNEL_INITIALIZER((br), (bg), (bb))))

NCCHANNEL_INITIALIZER

#define NCCHANNEL_INITIALIZER(r, g, b)

Definition notcurses.h:128

Definition at line 132 of file notcurses.h.

◆ NCINPUT_MAX_EFF_TEXT_CODEPOINTS

#define NCINPUT_MAX_EFF_TEXT_CODEPOINTS 4

Definition at line 1203 of file notcurses.h.

◆ NCIPREFIXCOLUMNS

#define NCIPREFIXCOLUMNS 8

Definition at line 3826 of file notcurses.h.

◆ NCIPREFIXFMT

#define NCIPREFIXFMT ( x ) NCMETRICFWIDTH((x), NCIPREFIXCOLUMNS), (x)

Definition at line 3836 of file notcurses.h.

◆ NCIPREFIXSTRLEN

#define NCIPREFIXSTRLEN (NCIPREFIXCOLUMNS + 1)

Definition at line 3829 of file notcurses.h.

◆ NCMENU_OPTION_BOTTOM

#define NCMENU_OPTION_BOTTOM 0x0001ull

Definition at line 4127 of file notcurses.h.

◆ NCMENU_OPTION_HIDING

#define NCMENU_OPTION_HIDING 0x0002ull

Definition at line 4128 of file notcurses.h.

◆ NCMETRICFWIDTH

#define NCMETRICFWIDTH	(	x,
		cols
	)	((int)(strlen(x) - ncstrwidth(x, NULL, NULL) + (cols)))

Definition at line 3833 of file notcurses.h.

◆ NCMICE_ALL_EVENTS

#define NCMICE_ALL_EVENTS 0x7

Definition at line 1344 of file notcurses.h.

◆ NCMICE_BUTTON_EVENT

#define NCMICE_BUTTON_EVENT 0x2

Definition at line 1342 of file notcurses.h.

◆ NCMICE_DRAG_EVENT

#define NCMICE_DRAG_EVENT 0x4

Definition at line 1343 of file notcurses.h.

◆ NCMICE_MOVE_EVENT

#define NCMICE_MOVE_EVENT 0x1

Definition at line 1341 of file notcurses.h.

◆ NCMICE_NO_EVENTS

#define NCMICE_NO_EVENTS 0

Definition at line 1340 of file notcurses.h.

◆ NCOPTION_CLI_MODE

#define NCOPTION_CLI_MODE

Value:

                           (NCOPTION_NO_ALTERNATE_SCREEN \
                           |NCOPTION_NO_CLEAR_BITMAPS \
                           |NCOPTION_PRESERVE_CURSOR \
                           |NCOPTION_SCROLLING)

Definition at line 1037 of file notcurses.h.

◆ NCOPTION_DRAIN_INPUT

#define NCOPTION_DRAIN_INPUT 0x0100ull

Definition at line 1030 of file notcurses.h.

◆ NCOPTION_INHIBIT_SETLOCALE

#define NCOPTION_INHIBIT_SETLOCALE 0x0001ull

Definition at line 990 of file notcurses.h.

◆ NCOPTION_NO_ALTERNATE_SCREEN

#define NCOPTION_NO_ALTERNATE_SCREEN 0x0040ull

Definition at line 1019 of file notcurses.h.

◆ NCOPTION_NO_CLEAR_BITMAPS

#define NCOPTION_NO_CLEAR_BITMAPS 0x0002ull

Definition at line 996 of file notcurses.h.

◆ NCOPTION_NO_FONT_CHANGES

#define NCOPTION_NO_FONT_CHANGES 0x0080ull

Definition at line 1025 of file notcurses.h.

◆ NCOPTION_NO_QUIT_SIGHANDLERS

#define NCOPTION_NO_QUIT_SIGHANDLERS 0x0008ull

Definition at line 1005 of file notcurses.h.

◆ NCOPTION_NO_WINCH_SIGHANDLER

#define NCOPTION_NO_WINCH_SIGHANDLER 0x0004ull

Definition at line 1000 of file notcurses.h.

◆ NCOPTION_PRESERVE_CURSOR

#define NCOPTION_PRESERVE_CURSOR 0x0010ull

Definition at line 1011 of file notcurses.h.

◆ NCOPTION_SCROLLING

#define NCOPTION_SCROLLING 0x0200ull

Definition at line 1034 of file notcurses.h.

◆ NCOPTION_SUPPRESS_BANNERS

#define NCOPTION_SUPPRESS_BANNERS 0x0020ull

Definition at line 1015 of file notcurses.h.

◆ NCPALETTESIZE

#define NCPALETTESIZE 256

Definition at line 111 of file notcurses.h.

◆ NCPLANE_OPTION_AUTOGROW

#define NCPLANE_OPTION_AUTOGROW 0x0010ull

Definition at line 1458 of file notcurses.h.

◆ NCPLANE_OPTION_FIXED

#define NCPLANE_OPTION_FIXED 0x0008ull

Definition at line 1454 of file notcurses.h.

◆ NCPLANE_OPTION_HORALIGNED

#define NCPLANE_OPTION_HORALIGNED 0x0001ull

Definition at line 1441 of file notcurses.h.

◆ NCPLANE_OPTION_MARGINALIZED

#define NCPLANE_OPTION_MARGINALIZED 0x0004ull

Definition at line 1450 of file notcurses.h.

◆ NCPLANE_OPTION_VERALIGNED

#define NCPLANE_OPTION_VERALIGNED 0x0002ull

Definition at line 1443 of file notcurses.h.

◆ NCPLANE_OPTION_VSCROLL

#define NCPLANE_OPTION_VSCROLL 0x0020ull

Definition at line 1462 of file notcurses.h.

◆ NCPLOT_OPTION_DETECTMAXONLY

#define NCPLOT_OPTION_DETECTMAXONLY 0x0010u

Definition at line 4484 of file notcurses.h.

◆ NCPLOT_OPTION_EXPONENTIALD

#define NCPLOT_OPTION_EXPONENTIALD 0x0002u

Definition at line 4481 of file notcurses.h.

◆ NCPLOT_OPTION_LABELTICKSD

#define NCPLOT_OPTION_LABELTICKSD 0x0001u

Definition at line 4480 of file notcurses.h.

◆ NCPLOT_OPTION_NODEGRADE

#define NCPLOT_OPTION_NODEGRADE 0x0008u

Definition at line 4483 of file notcurses.h.

◆ NCPLOT_OPTION_PRINTSAMPLE

#define NCPLOT_OPTION_PRINTSAMPLE 0x0020u

Definition at line 4485 of file notcurses.h.

◆ NCPLOT_OPTION_VERTICALI

#define NCPLOT_OPTION_VERTICALI 0x0004u

Definition at line 4482 of file notcurses.h.

◆ NCPREFIXCOLUMNS

#define NCPREFIXCOLUMNS 7

Definition at line 3825 of file notcurses.h.

◆ NCPREFIXFMT

#define NCPREFIXFMT ( x ) NCMETRICFWIDTH((x), NCPREFIXCOLUMNS), (x)

Definition at line 3835 of file notcurses.h.

◆ NCPREFIXSTRLEN

#define NCPREFIXSTRLEN (NCPREFIXCOLUMNS + 1)

Definition at line 3828 of file notcurses.h.

◆ NCPROGBAR_OPTION_RETROGRADE

#define NCPROGBAR_OPTION_RETROGRADE 0x0001u

Definition at line 4203 of file notcurses.h.

◆ NCREADER_OPTION_CURSOR

#define NCREADER_OPTION_CURSOR 0x0008ull

Definition at line 4618 of file notcurses.h.

◆ NCREADER_OPTION_HORSCROLL

#define NCREADER_OPTION_HORSCROLL 0x0001ull

Definition at line 4611 of file notcurses.h.

◆ NCREADER_OPTION_NOCMDKEYS

#define NCREADER_OPTION_NOCMDKEYS 0x0004ull

Definition at line 4615 of file notcurses.h.

◆ NCREADER_OPTION_VERSCROLL

#define NCREADER_OPTION_VERSCROLL 0x0002ull

Definition at line 4613 of file notcurses.h.

◆ NCREEL_OPTION_CIRCULAR

#define NCREEL_OPTION_CIRCULAR 0x0002ull

Definition at line 3698 of file notcurses.h.

◆ NCREEL_OPTION_INFINITESCROLL

#define NCREEL_OPTION_INFINITESCROLL 0x0001ull

Definition at line 3694 of file notcurses.h.

◆ NCSTYLE_BOLD

#define NCSTYLE_BOLD 0x0002u

Definition at line 773 of file notcurses.h.

◆ NCSTYLE_ITALIC

#define NCSTYLE_ITALIC 0x0010u

Definition at line 770 of file notcurses.h.

◆ NCSTYLE_MASK

#define NCSTYLE_MASK 0xffffu

Definition at line 769 of file notcurses.h.

◆ NCSTYLE_NONE

#define NCSTYLE_NONE 0

Definition at line 775 of file notcurses.h.

◆ NCSTYLE_STRUCK

#define NCSTYLE_STRUCK 0x0001u

Definition at line 774 of file notcurses.h.

◆ NCSTYLE_UNDERCURL

#define NCSTYLE_UNDERCURL 0x0004u

Definition at line 772 of file notcurses.h.

◆ NCSTYLE_UNDERLINE

#define NCSTYLE_UNDERLINE 0x0008u

Definition at line 771 of file notcurses.h.

◆ NCTABBED_OPTION_BOTTOM

#define NCTABBED_OPTION_BOTTOM 0x0001ull

Definition at line 4237 of file notcurses.h.

◆ NCVISUAL_OPTION_ADDALPHA

#define NCVISUAL_OPTION_ADDALPHA 0x0010ull

Definition at line 3341 of file notcurses.h.

◆ NCVISUAL_OPTION_BLEND

#define NCVISUAL_OPTION_BLEND 0x0002ull

Definition at line 3338 of file notcurses.h.

◆ NCVISUAL_OPTION_CHILDPLANE

#define NCVISUAL_OPTION_CHILDPLANE 0x0020ull

Definition at line 3342 of file notcurses.h.

◆ NCVISUAL_OPTION_HORALIGNED

#define NCVISUAL_OPTION_HORALIGNED 0x0004ull

Definition at line 3339 of file notcurses.h.

◆ NCVISUAL_OPTION_NODEGRADE

#define NCVISUAL_OPTION_NODEGRADE 0x0001ull

Definition at line 3337 of file notcurses.h.

◆ NCVISUAL_OPTION_NOINTERPOLATE

#define NCVISUAL_OPTION_NOINTERPOLATE 0x0040ull

Definition at line 3343 of file notcurses.h.

◆ NCVISUAL_OPTION_VERALIGNED

#define NCVISUAL_OPTION_VERALIGNED 0x0008ull

Definition at line 3340 of file notcurses.h.

◆ RESTRICT

#define RESTRICT restrict

Definition at line 24 of file notcurses.h.

◆ WCHAR_MAX_UTF8BYTES

#define WCHAR_MAX_UTF8BYTES 4

Definition at line 594 of file notcurses.h.

Typedef Documentation

◆ fadecb

typedef int(* fadecb) (struct notcurses *nc, struct ncplane *n, const struct timespec *, void *curry)

Definition at line 3029 of file notcurses.h.

◆ nccapabilities

typedef struct nccapabilities nccapabilities

◆ nccell

typedef API int struct nccell nccell

◆ ncfdplane_callback

typedef int(* ncfdplane_callback) (struct ncfdplane *n, const void *buf, size_t s, void *curry)

Definition at line 4546 of file notcurses.h.

◆ ncfdplane_done_cb

typedef int(* ncfdplane_done_cb) (struct ncfdplane *n, int fderrno, void *curry)

Definition at line 4547 of file notcurses.h.

◆ ncfdplane_options

typedef struct ncfdplane_options ncfdplane_options

◆ ncinput

typedef struct ncinput ncinput

◆ ncmenu_options

typedef struct ncmenu_options ncmenu_options

◆ ncmultiselector_options

typedef struct ncmultiselector_options ncmultiselector_options

◆ ncpalette

typedef struct ncpalette ncpalette

◆ ncplane_options

typedef struct ncplane_options ncplane_options

◆ ncplot_options

typedef struct ncplot_options ncplot_options

◆ ncprogbar_options

typedef struct ncprogbar_options ncprogbar_options

◆ ncreader_options

typedef struct ncreader_options ncreader_options

◆ ncreel_options

typedef struct ncreel_options ncreel_options

◆ ncselector_options

typedef struct ncselector_options ncselector_options

◆ ncstats

typedef struct ncstats ncstats

◆ ncstreamcb

typedef int(* ncstreamcb) (struct ncvisual *, struct ncvisual_options *, const struct timespec *, void *)

Definition at line 3533 of file notcurses.h.

◆ ncsubproc_options

typedef struct ncsubproc_options ncsubproc_options

◆ nctabbed_options

typedef struct nctabbed_options nctabbed_options

◆ nctree_options

typedef struct nctree_options nctree_options

◆ ncvgeom

typedef struct ncvgeom ncvgeom

◆ notcurses_options

typedef struct notcurses_options notcurses_options

◆ tabcb

typedef void(* tabcb) (struct nctab *t, struct ncplane *ncp, void *curry)

Definition at line 4250 of file notcurses.h.

◆ tabletcb

typedef int(* tabletcb) (struct nctablet *t, bool drawfromtop)

Definition at line 3728 of file notcurses.h.

Enumeration Type Documentation

◆ ncalign_e

enum ncalign_e

Enumerator
NCALIGN_UNALIGNED
NCALIGN_LEFT
NCALIGN_CENTER
NCALIGN_RIGHT

Definition at line 80 of file notcurses.h.

             {
  NCALIGN_UNALIGNED,
  NCALIGN_LEFT,
  NCALIGN_CENTER,
  NCALIGN_RIGHT,
} ncalign_e;

◆ ncblitter_e

enum ncblitter_e

Enumerator
NCBLIT_DEFAULT
NCBLIT_1x1
NCBLIT_2x1
NCBLIT_2x2
NCBLIT_3x2
NCBLIT_4x2
NCBLIT_BRAILLE
NCBLIT_PIXEL
NCBLIT_4x1
NCBLIT_8x1

Definition at line 65 of file notcurses.h.

             {
  NCBLIT_DEFAULT, // let the ncvisual pick
  NCBLIT_1x1,     // space, compatible with ASCII
  NCBLIT_2x1,     // halves + 1x1 (space)     ▄▀
  NCBLIT_2x2,     // quadrants + 2x1          ▗▐ ▖▀▟▌▙
  NCBLIT_3x2,     // sextants + 2x1           🬀🬁🬂🬃🬄🬅🬆🬇🬈🬉🬊🬋🬌🬍🬎🬏🬐🬑🬒🬓🬔🬕🬖🬗🬘🬙🬚🬛🬜🬝🬞
  NCBLIT_4x2,     // octants + 2x2            there are a great many octants
  NCBLIT_BRAILLE, // 4 rows, 2 cols (braille) ⡀⡄⡆⡇⢀⣀⣄⣆⣇⢠⣠⣤⣦⣧⢰⣰⣴⣶⣷⢸⣸⣼⣾⣿
  NCBLIT_PIXEL,   // pixel graphics
  // these blitters are suitable only for plots, not general media
  NCBLIT_4x1,     // four vertical levels     █▆▄▂
  NCBLIT_8x1,     // eight vertical levels    █▇▆▅▄▃▂▁
} ncblitter_e;

◆ ncintype_e

enum ncintype_e

Enumerator
NCTYPE_UNKNOWN
NCTYPE_PRESS
NCTYPE_REPEAT
NCTYPE_RELEASE

Definition at line 1194 of file notcurses.h.

             {
  NCTYPE_UNKNOWN,
  NCTYPE_PRESS,
  NCTYPE_REPEAT,
  NCTYPE_RELEASE,
} ncintype_e;

◆ ncloglevel_e

enum ncloglevel_e

Enumerator
NCLOGLEVEL_SILENT
NCLOGLEVEL_PANIC
NCLOGLEVEL_FATAL
NCLOGLEVEL_ERROR
NCLOGLEVEL_WARNING
NCLOGLEVEL_INFO
NCLOGLEVEL_VERBOSE
NCLOGLEVEL_DEBUG
NCLOGLEVEL_TRACE

Definition at line 968 of file notcurses.h.

             {
  NCLOGLEVEL_SILENT = -1,// default. print nothing once fullscreen service begins
  NCLOGLEVEL_PANIC = 0,  // print diagnostics related to catastrophic failure
  NCLOGLEVEL_FATAL = 1,  // we're hanging around, but we've had a horrible fault
  NCLOGLEVEL_ERROR = 2,  // we can't keep doing this, but we can do other things
  NCLOGLEVEL_WARNING = 3,// you probably don't want what's happening to happen
  NCLOGLEVEL_INFO = 4,   // "standard information"
  NCLOGLEVEL_VERBOSE = 5,// "detailed information"
  NCLOGLEVEL_DEBUG = 6,  // this is honestly a bit much
  NCLOGLEVEL_TRACE = 7,  // there's probably a better way to do what you want
} ncloglevel_e;

◆ ncpixelimpl_e

enum ncpixelimpl_e

Enumerator
NCPIXEL_NONE
NCPIXEL_SIXEL
NCPIXEL_LINUXFB
NCPIXEL_ITERM2
NCPIXEL_KITTY_STATIC
NCPIXEL_KITTY_ANIMATED
NCPIXEL_KITTY_SELFREF

Definition at line 1672 of file notcurses.h.

             {
  NCPIXEL_NONE = 0,
  NCPIXEL_SIXEL,           // sixel
  NCPIXEL_LINUXFB,         // linux framebuffer
  NCPIXEL_ITERM2,          // iTerm2
  // C=1 (disabling scrolling) was only introduced in 0.20.0, at the same
  // time as animation. prior to this, graphics had to be entirely redrawn
  // on any change, and it wasn't possible to use the bottom line.
  NCPIXEL_KITTY_STATIC,
  // until 0.22.0's introduction of 'a=c' for self-referential composition, we
  // had to keep a complete copy of the RGBA data, in case a wiped cell needed
  // to be rebuilt. we'd otherwise have to unpack the glyph and store it into
  // the auxvec on the fly.
  NCPIXEL_KITTY_ANIMATED,
  // with 0.22.0, we only ever write transparent cells after writing the
  // original image (which we now deflate, since we needn't unpack it later).
  // the only data we need keep is the auxvecs.
  NCPIXEL_KITTY_SELFREF,
} ncpixelimpl_e;

◆ ncscale_e

enum ncscale_e

Enumerator
NCSCALE_NONE
NCSCALE_SCALE
NCSCALE_STRETCH
NCSCALE_NONE_HIRES
NCSCALE_SCALE_HIRES

Definition at line 96 of file notcurses.h.

             {
  NCSCALE_NONE,
  NCSCALE_SCALE,
  NCSCALE_STRETCH,
  NCSCALE_NONE_HIRES,
  NCSCALE_SCALE_HIRES,
} ncscale_e;

Function Documentation

◆ attribute() [1/8]

API int __attribute__ ( (format(printf, 2, 0)) )

◆ attribute() [2/8]

static int __attribute__ ( (format(printf, 2, 3)) )

Here is the call graph for this function:

◆ attribute() [3/8]

API int __attribute__ ( (format(printf, 4, 0)) )

◆ attribute() [4/8]

static int __attribute__ ( (format(printf, 4, 5)) )

Here is the call graph for this function:

◆ attribute() [5/8]

__attribute__ ( (nonnull(1)) )

Definition at line 1353 of file notcurses.h.

                                           {
  return notcurses_mice_enable(n, NCMICE_NO_EVENTS);
}

Here is the call graph for this function:

◆ attribute() [6/8]

API int API int __attribute__ ( (nonnull(1, 2)) )

◆ attribute() [7/8]

__attribute__ ( (nonnull(1, 2, 3)) )

◆ attribute() [8/8]

API __attribute__ ( (returns_nonnull) ) const

◆ if() [1/4]

if ( ! vopts )

Definition at line 3498 of file notcurses.h.

            {
    vopts = &v;
    memset(vopts, 0, sizeof(*vopts));
  }

◆ if() [2/4]

if ( ncvisual_blit(nc, ncv, vopts) = = NULL )

Definition at line 3503 of file notcurses.h.

                                           {
    ncplane_destroy(newn);
    vopts->n = NULL;
    return NULL;
  }

Here is the call graph for this function:

◆ if() [3/4]

if ( newn = = NULL )

Definition at line 3494 of file notcurses.h.

                  {
    return NULL;
  }

◆ if() [4/4]

if ( vopts &&vopts-> n )

Definition at line 3486 of file notcurses.h.

                       {
    if(vopts->flags & NCVISUAL_OPTION_CHILDPLANE){
      return NULL; // the whole point is to create a new plane
    }
    newn = ncplane_create(vopts->n, opts);
  }else{

Here is the call graph for this function:

◆ ncblit_bgrx()

API int ncblit_bgrx	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts
	)

Definition at line 1408 of file blit.c.

                                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    logerror("invalid lengths %u %u", vopts->leny, vopts->lenx);
    return -1;
  }
  if(vopts->n == NULL){
    logerror("prohibited null plane");
    return -1;
  }
  void* rdata = bgra_to_rgba(data, vopts->leny, &linesize, vopts->lenx, 0xff);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncblit_rgb_loose()

API int ncblit_rgb_loose	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts,
		int	alpha
	)

Definition at line 1426 of file blit.c.

                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    return -1;
  }
  void* rdata = rgb_loose_to_rgba(data, vopts->leny, &linesize, vopts->lenx, alpha);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

◆ ncblit_rgb_packed()

API int ncblit_rgb_packed	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts,
		int	alpha
	)

Definition at line 1440 of file blit.c.

                                                                      {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    return -1;
  }
  void* rdata = rgb_packed_to_rgba(data, vopts->leny, &linesize, vopts->lenx, alpha);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

◆ ncblit_rgba()

API int API int ncblit_rgba	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts
	)

Definition at line 1454 of file blit.c.

                                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    logerror("invalid lengths %u %u", vopts->leny, vopts->lenx);
    return -1;
  }
  if(vopts->n == NULL){
    logerror("prohibited null plane");
    return -1;
  }
  struct ncvisual* ncv = ncvisual_from_rgba(data, vopts->leny, linesize, vopts->lenx);
  if(ncv == NULL){
    return -1;
  }
  if(ncvisual_blit(ncplane_notcurses(vopts->n), ncv, vopts) == NULL){
    ncvisual_destroy(ncv);
    return -1;
  }
  ncvisual_destroy(ncv);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nccell_duplicate()

API int nccell_duplicate	(	struct ncplane *	n,
		nccell *	targ,
		const nccell *	c
	)

Definition at line 133 of file render.c.

                                                               {
  if(cell_duplicate_far(&n->pool, targ, n, c) < 0){
    logerror("failed duplicating cell");
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

◆ nccell_load()

API int nccell_load	(	struct ncplane *	n,
		nccell *	c,
		const char *	gcluster
	)

Definition at line 1833 of file notcurses.c.

                                                            {
  int cols;
  int bytes = utf8_egc_len(gcluster, &cols);
  return pool_load_direct(&n->pool, c, gcluster, bytes, cols);
}

Here is the caller graph for this function:

◆ nccell_release()

API void nccell_release	(	struct ncplane *	n,
		nccell *	c
	)

Definition at line 128 of file render.c.

                                          {
  pool_release(&n->pool, c);
}

Here is the caller graph for this function:

◆ ncdplot_add_sample()

API int ncdplot_add_sample	(	struct ncdplot *	n,
		uint64_t	x,
		double	y
	)

Definition at line 709 of file plot.c.

                               {
  if(n){
    ncplot_destroy(&n->plot);
    free(n->slots);
    free(n);
  }
}
 
// takes ownership of n on all paths
ncdplot* ncdplot_create(ncplane* n, const ncplot_options* opts, double miny, double maxy){
  ncdplot* ret = malloc(sizeof(*ret));
  if(ret == NULL){
    ncplane_destroy(n);
    return NULL;
  }
  memset(ret, 0, sizeof(*ret));
  const struct blitset* bset = create_double(ret, n, opts, miny, maxy, -DBL_MAX, DBL_MAX);
  if(bset == NULL){ // create_double() destroys n on error
    ncdplot_destroy(ret);
    return NULL;
  }
  return ret;
}
 
ncplane* ncdplot_plane(ncdplot* n){
  return n->plot.ncp;
}
 
int ncdplot_add_sample(ncdplot* n, uint64_t x, double y){
  return add_sample_double(n, x, y);
}
 
int ncdplot_set_sample(ncdplot* n, uint64_t x, double y){
  if(window_slide_double(n, x)){
    return -1;
  }
  update_sample_double(n, x, y, true);
  if(update_domain_double(n, x)){
    return -1;
  }
  return redraw_plot_double(n);
}
 
int ncuplot_sample(const ncuplot* n, uint64_t x, uint64_t* y){
  return sample_uint64_t(n, x, y);
}
 
int ncdplot_sample(const ncdplot* n, uint64_t x, double* y){
  return sample_double(n, x, y);
}
 
void ncdplot_destroy(ncdplot* n) {
  if(n){
    ncplot_destroy(&n->plot);
    free(n->slots);
    free(n);
  }
}

Here is the caller graph for this function:

◆ ncdplot_create()

API ALLOC struct ncdplot * ncdplot_create	(	struct ncplane *	n,
		const ncplot_options *	opts,
		double	miny,
		double	maxy
	)

Definition at line 690 of file plot.c.

                                  {
  return n->plot.ncp;
}
 
int ncuplot_add_sample(ncuplot* n, uint64_t x, uint64_t y){
  return add_sample_uint64_t(n, x, y);
}
 
int ncuplot_set_sample(ncuplot* n, uint64_t x, uint64_t y){
  if(window_slide_uint64_t(n, x)){
    return -1;

Here is the caller graph for this function:

◆ ncdplot_destroy()

API void ncdplot_destroy ( struct ncdplot * n )

Definition at line 732 of file plot.c.

                                  {
  return n->plot.ncp;
}

Here is the caller graph for this function:

◆ ncdplot_plane()

API struct ncplane * ncdplot_plane ( struct ncdplot * n )

Definition at line 705 of file plot.c.

706 {

707 return -1;

◆ ncdplot_sample()

API int ncdplot_sample	(	const struct ncdplot *	n,
		uint64_t	x,
		double *	y
	)

◆ ncdplot_set_sample()

API int ncdplot_set_sample	(	struct ncdplot *	n,
		uint64_t	x,
		double	y
	)

Definition at line 713 of file plot.c.

       {
    ncplot_destroy(&n->plot);
    free(n->slots);
    free(n);
  }
}
 
// takes ownership of n on all paths
ncdplot* ncdplot_create(ncplane* n, const ncplot_options* opts, double miny, double maxy){
  ncdplot* ret = malloc(sizeof(*ret));

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncfadectx_free()

API void ncfadectx_free ( struct ncfadectx * nctx )

Definition at line 253 of file fade.c.

                                    {
  if(nctx){
    free(nctx->channels);
    free(nctx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncfadectx_iterations()

API int ncfadectx_iterations ( const struct ncfadectx * nctx )

◆ ncfadectx_setup()

API ALLOC struct ncfadectx * ncfadectx_setup ( struct ncplane * n )

Definition at line 249 of file fade.c.

                                      {
  return ncfadectx_setup_internal(n, NULL);
}

◆ ncfdplane_create()

API ALLOC struct ncfdplane * ncfdplane_create	(	struct ncplane *	n,
		const ncfdplane_options *	opts,
		int	fd,
		ncfdplane_callback	cbfxn,
		ncfdplane_done_cb	donecbfxn
	)

Definition at line 120 of file fd.c.

                                                                                  {
  ncfdplane_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(fd < 0 || !cbfxn || !donecbfxn){
    return NULL;
  }
  return ncfdplane_create_internal(n, opts, fd, cbfxn, donecbfxn, true);
}

◆ ncfdplane_destroy()

API int ncfdplane_destroy ( struct ncfdplane * n )

Definition at line 136 of file fd.c.

                                   {
  int ret = 0;
  if(n){
    if(pthread_equal(pthread_self(), n->tid)){
      n->destroyed = true; // ncfdplane_destroy_inner() is called on thread exit
    }else{
      void* vret = NULL;
      ret |= cancel_and_join("fdplane", n->tid, &vret);
      ret |= ncfdplane_destroy_inner(n);
    }
  }
  return ret;
}

Here is the caller graph for this function:

◆ ncfdplane_plane()

API struct ncplane * ncfdplane_plane ( struct ncfdplane * n )

Definition at line 132 of file fd.c.

                                      {
  return n->ncp;
}

Here is the caller graph for this function:

◆ ncmenu_create()

API ALLOC struct ncmenu * ncmenu_create	(	struct ncplane *	n,
		const ncmenu_options *	opts
	)

Definition at line 377 of file menu.c.

                                                             {
  ncmenu_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(opts->sectioncount <= 0 || !opts->sections){
    logerror("invalid %d-ary section information", opts->sectioncount);
    return NULL;
  }
  if(opts->flags >= (NCMENU_OPTION_HIDING << 1u)){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  unsigned totalheight = 1;
  unsigned totalwidth = 2; // start with two-character margin on the left
  ncmenu* ret = malloc(sizeof(*ret));
  ret->sectioncount = opts->sectioncount;
  ret->sections = NULL;
  unsigned dimy, dimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  if(ret){
    ret->bottom = !!(opts->flags & NCMENU_OPTION_BOTTOM);
    if(dup_menu_sections(ret, opts, &totalwidth, &totalheight) == 0){
      ret->headerwidth = totalwidth;
      if(totalwidth < dimx){
        totalwidth = dimx;
      }
      struct ncplane_options nopts = {
        .y = ret->bottom ? dimy - totalheight : 0,
        .x = 0,
        .rows = totalheight,
        .cols = totalwidth,
        .userptr = ret,
        .name = "menu",
        .resizecb = resize_menu,
        .flags = NCPLANE_OPTION_FIXED,
      };
      ret->ncp = ncplane_create(n, &nopts);
      if(ret->ncp){
        if(ncplane_set_widget(ret->ncp, ret, (void(*)(void*))ncmenu_destroy) == 0){
          ret->unrolledsection = -1;
          ret->headerchannels = opts->headerchannels;
          ret->dissectchannels = opts->headerchannels;
          ncchannels_set_fg_rgb(&ret->dissectchannels, 0xdddddd);
          ret->sectionchannels = opts->sectionchannels;
          ret->disablechannels = ret->sectionchannels;
          ncchannels_set_fg_rgb(&ret->disablechannels, 0xdddddd);
          nccell c = NCCELL_TRIVIAL_INITIALIZER;
          nccell_set_fg_alpha(&c, NCALPHA_TRANSPARENT);
          nccell_set_bg_alpha(&c, NCALPHA_TRANSPARENT);
          ncplane_set_base_cell(ret->ncp, &c);
          nccell_release(ret->ncp, &c);
          if(write_header(ret) == 0){
            return ret;
          }
        }
        ncplane_destroy(ret->ncp);
      }
      free_menu_sections(ret);
    }
    free(ret);
  }
  logerror("error creating ncmenu");
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_destroy()

API bool API void ncmenu_destroy ( struct ncmenu * n )

Definition at line 825 of file menu.c.

                              {
  if(n){
    free_menu_sections(n);
    if(ncplane_set_widget(n->ncp, NULL, NULL) == 0){
      ncplane_destroy(n->ncp);
    }
    free(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_item_set_status()

API int ncmenu_item_set_status	(	struct ncmenu *	n,
		const char *	section,
		const char *	item,
		bool	enabled
	)

Definition at line 784 of file menu.c.

                                        {
  for(int si = 0 ; si < n->sectioncount ; ++si){
    struct ncmenu_int_section* sec = &n->sections[si];
    if(strcmp(sec->name, section) == 0){
      for(unsigned ii = 0 ; ii < sec->itemcount ; ++ii){
        struct ncmenu_int_item* i = &sec->items[ii];
        if(strcmp(i->desc, item) == 0){
          const bool changed = (i->disabled != enabled);
          i->disabled = !enabled;
          if(changed){
            if(i->disabled){
              if(--sec->enabled_item_count == 0){
                write_header(n);
              }
            }else{
              if(++sec->enabled_item_count == 1){
                write_header(n);
              }
            }
            if(n->unrolledsection == si){
              if(sec->enabled_item_count == 0){
                ncmenu_rollup(n);
              }else{
                ncmenu_unroll(n, n->unrolledsection);
              }
            }
          }
          return 0;
        }
      }
      break;
    }
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_mouse_selected()

API const char * ncmenu_mouse_selected	(	const struct ncmenu *	n,
		const ncinput *	click,
		ncinput *	ni
	)

◆ ncmenu_nextitem()

API int ncmenu_nextitem ( struct ncmenu * n )

Definition at line 593 of file menu.c.

                              {
  if(n->unrolledsection == -1){
    if(ncmenu_unroll(n, 0)){
      return -1;
    }
  }
  ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  int origselected = sec->itemselected;
  if(origselected >= 0){
    do{
      if((unsigned)++sec->itemselected == sec->itemcount){
        sec->itemselected = 0;
      }
      if(sec->itemselected == origselected){
        break;
      }
    }while(!sec->items[sec->itemselected].desc || sec->items[sec->itemselected].disabled);
  }
  return ncmenu_unroll(n, n->unrolledsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_nextsection()

API int ncmenu_nextsection ( struct ncmenu * n )

Definition at line 563 of file menu.c.

                                 {
  int nextsection = n->unrolledsection;
  int origselected = n->unrolledsection;
  do{
    if(++nextsection == n->sectioncount){
      nextsection = 0;
    }
    if(nextsection == origselected){
      break;
    }
  }while(n->sections[nextsection].name == NULL ||
         n->sections[nextsection].enabled_item_count == 0);
  return ncmenu_unroll(n, nextsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_offer_input()

API bool ncmenu_offer_input	(	struct ncmenu *	n,
		const ncinput *	nc
	)

◆ ncmenu_plane()

API struct ncplane * ncmenu_plane ( struct ncmenu * n )

Definition at line 821 of file menu.c.

                                   {
  return menu->ncp;
}

◆ ncmenu_previtem()

API int ncmenu_previtem ( struct ncmenu * n )

Definition at line 614 of file menu.c.

                              {
  if(n->unrolledsection == -1){
    if(ncmenu_unroll(n, 0)){
      return -1;
    }
  }
  ncmenu_int_section* sec = &n->sections[n->unrolledsection];
  int origselected = sec->itemselected;
  if(origselected >= 0){
    do{
      if(sec->itemselected-- == 0){
        sec->itemselected = sec->itemcount - 1;
      }
      if(sec->itemselected == origselected){
        break;
      }
    }while(!sec->items[sec->itemselected].desc || sec->items[sec->itemselected].disabled);
  }
  return ncmenu_unroll(n, n->unrolledsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_prevsection()

API int ncmenu_prevsection ( struct ncmenu * n )

Definition at line 578 of file menu.c.

                                 {
  int prevsection = n->unrolledsection;
  int origselected = n->unrolledsection;
  do{
    if(--prevsection < 0){
      prevsection = n->sectioncount - 1;
    }
    if(prevsection == origselected){
      break;
    }
  }while(n->sections[prevsection].name == NULL ||
         n->sections[prevsection].enabled_item_count == 0);
  return ncmenu_unroll(n, prevsection);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_rollup()

API int ncmenu_rollup ( struct ncmenu * n )

Definition at line 554 of file menu.c.

                            {
  if(n->unrolledsection < 0){
    return 0;
  }
  n->unrolledsection = -1;
  ncplane_erase(n->ncp);
  return write_header(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmenu_selected()

API const char * ncmenu_selected	(	const struct ncmenu *	n,
		ncinput *	ni
	)

◆ ncmenu_unroll()

API int ncmenu_unroll	(	struct ncmenu *	n,
		int	sectionidx
	)

Definition at line 452 of file menu.c.

                                            {
  if(ncmenu_rollup(n)){ // roll up any unrolled section
    return -1;
  }
  if(sectionidx < 0 || sectionidx >= n->sectioncount){
    logerror("unrolled invalid sectionidx %d", sectionidx);
    return -1;
  }
  if(n->sections[sectionidx].enabled_item_count <= 0){
    return 0;
  }
  if(n->sections[sectionidx].name == NULL){
    return -1;
  }
  n->unrolledsection = sectionidx;
  unsigned dimy, dimx;
  ncplane_dim_yx(n->ncp, &dimy, &dimx);
  const int height = section_height(n, sectionidx);
  const int width = section_width(n, sectionidx);
  int xpos = n->sections[sectionidx].xoff < 0 ?
    (int)dimx + (n->sections[sectionidx].xoff - 2) : n->sections[sectionidx].xoff;
  if(xpos + width >= (int)dimx){
    xpos = dimx - (width + 2);
  }
  int ypos = n->bottom ? dimy - height - 1 : 1;
  if(ncplane_cursor_move_yx(n->ncp, ypos, xpos)){
    return -1;
  }
  if(ncplane_rounded_box_sized(n->ncp, 0, n->headerchannels, height, width, 0)){
    return -1;
  }
  ncmenu_int_section* sec = &n->sections[sectionidx];
  for(unsigned i = 0 ; i < sec->itemcount ; ++i){
    ++ypos;
    if(sec->items[i].desc){
      // FIXME the user ought be able to configure the disabled channel
      if(!sec->items[i].disabled){
        ncplane_set_channels(n->ncp, n->sectionchannels);
        if(sec->itemselected < 0){
          sec->itemselected = i;
        }
      }else{
        ncplane_set_channels(n->ncp, n->disablechannels);
      }
      if(sec->itemselected >= 0){
        if(i == (unsigned)sec->itemselected){
          ncplane_set_channels(n->ncp, ncchannels_reverse(ncplane_channels(n->ncp)));
        }
      }
      ncplane_set_styles(n->ncp, 0);
      int cols = ncplane_putstr_yx(n->ncp, ypos, xpos + 1, sec->items[i].desc);
      if(cols < 0){
        return -1;
      }
      // we need pad out the remaining columns of this line with spaces. if
      // there's a shortcut description, we align it to the right, printing
      // spaces only through the start of the aligned description.
      int thiswidth = width;
      if(sec->items[i].shortdesc){
        thiswidth -= sec->items[i].shortdesccols;
      }
      // print any necessary padding spaces
      for(int j = cols + 1 ; j < thiswidth - 1 ; ++j){
        if(ncplane_putchar(n->ncp, ' ') < 0){
          return -1;
        }
      }
      if(sec->items[i].shortdesc){
        if(ncplane_putstr(n->ncp, sec->items[i].shortdesc) < 0){
          return -1;
        }
      }
      if(sec->items[i].shortcut_offset >= 0){
        nccell cl = NCCELL_TRIVIAL_INITIALIZER;
        if(ncplane_at_yx_cell(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
          return -1;
        }
        nccell_on_styles(&cl, NCSTYLE_UNDERLINE|NCSTYLE_BOLD);
        if(ncplane_putc_yx(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
          return -1;
        }
        nccell_release(n->ncp, &cl);
      }
    }else{
      n->ncp->channels = n->headerchannels;
      ncplane_set_styles(n->ncp, 0);
      if(ncplane_putegc_yx(n->ncp, ypos, xpos, "├", NULL) < 0){
        return -1;
      }
      for(int j = 1 ; j < width - 1 ; ++j){
        if(ncplane_putegc(n->ncp, "─", NULL) < 0){
          return -1;
        }
      }
      if(ncplane_putegc(n->ncp, "┤", NULL) < 0){
        return -1;
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmultiselector_create()

API ALLOC struct ncmultiselector * ncmultiselector_create	(	struct ncplane *	n,
		const ncmultiselector_options *	opts
	)

Definition at line 885 of file selector.c.

                                                                                        {
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    logerror("won't use the standard plane"); // would fail later on resize
    return NULL;
  }
  ncmultiselector_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(opts->flags > 0){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  unsigned itemcount = 0;
  if(opts->items){
    for(const struct ncmselector_item* i = opts->items ; i->option ; ++i){
      ++itemcount;
    }
  }
  ncmultiselector* ns = malloc(sizeof(*ns));
  if(ns == NULL){
    return NULL;
  }
  memset(ns, 0, sizeof(*ns));
  ns->title = opts->title ? strdup(opts->title) : NULL;
  ns->titlecols = opts->title ? ncstrwidth(opts->title, NULL, NULL) : 0;
  ns->secondary = opts->secondary ? strdup(opts->secondary) : NULL;
  ns->secondarycols = opts->secondary ? ncstrwidth(opts->secondary, NULL, NULL) : 0;
  ns->footer = opts->footer ? strdup(opts->footer) : NULL;
  ns->footercols = opts->footer ? ncstrwidth(opts->footer, NULL, NULL) : 0;
  ns->current = 0;
  ns->startdisp = 0;
  ns->longitem = 0;
  ns->maxdisplay = opts->maxdisplay;
  ns->opchannels = opts->opchannels;
  ns->boxchannels = opts->boxchannels;
  ns->descchannels = opts->descchannels;
  ns->titlechannels = opts->titlechannels;
  ns->footchannels = opts->footchannels;
  ns->boxchannels = opts->boxchannels;
  ns->darrowy = ns->uarrowy = ns->arrowx = -1;
  if(itemcount){
    if(!(ns->items = malloc(sizeof(*ns->items) * itemcount))){
      goto freeitems;
    }
  }else{
    ns->items = NULL;
  }
  for(ns->itemcount = 0 ; ns->itemcount < itemcount ; ++ns->itemcount){
    const struct ncmselector_item* src = &opts->items[ns->itemcount];
    int unsafe = ncstrwidth(src->option, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols = unsafe;
    if(cols > ns->longitem){
      ns->longitem = cols;
    }
    unsafe = ncstrwidth(src->desc, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols2 = unsafe;
    if(cols + cols2 > ns->longitem){
      ns->longitem = cols + cols2;
    }
    ns->items[ns->itemcount].option = strdup(src->option);
    ns->items[ns->itemcount].desc = strdup(src->desc);
    ns->items[ns->itemcount].selected = src->selected;
    if(!(ns->items[ns->itemcount].desc && ns->items[ns->itemcount].option)){
      free(ns->items[ns->itemcount].option);
      free(ns->items[ns->itemcount].desc);
      goto freeitems;
    }
  }
  unsigned dimy, dimx;
  ns->ncp = n;
  if(ncmultiselector_dim_yx(ns, &dimy, &dimx)){
    goto freeitems;
  }
  if(ncplane_resize_simple(ns->ncp, dimy, dimx)){
    goto freeitems;
  }
  if(ncplane_set_widget(ns->ncp, ns, (void(*)(void*))ncmultiselector_destroy)){
    goto freeitems;
  }
  ncmultiselector_draw(ns); // deal with error here?
  return ns;
 
freeitems:
  while(ns->itemcount--){
    free(ns->items[ns->itemcount].option);
    free(ns->items[ns->itemcount].desc);
  }
  free(ns->items);
  free(ns->title); free(ns->secondary); free(ns->footer);
  free(ns);
  ncplane_destroy(n);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmultiselector_destroy()

API bool API void ncmultiselector_destroy ( struct ncmultiselector * n )

Definition at line 985 of file selector.c.

                                                {
  if(n){
    while(n->itemcount--){
      free(n->items[n->itemcount].option);
      free(n->items[n->itemcount].desc);
    }
    if(ncplane_set_widget(n->ncp, NULL, NULL) == 0){
      ncplane_destroy(n->ncp);
    }
    free(n->items);
    free(n->title);
    free(n->secondary);
    free(n->footer);
    free(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncmultiselector_offer_input()

API bool ncmultiselector_offer_input	(	struct ncmultiselector *	n,
		const ncinput *	nc
	)

◆ ncmultiselector_plane()

API struct ncplane * ncmultiselector_plane ( struct ncmultiselector * n )

Definition at line 586 of file selector.c.

                                                  {
  return n->ncp;
}

◆ ncmultiselector_selected()

API int ncmultiselector_selected	(	struct ncmultiselector *	n,
		bool *	selected,
		unsigned	count
	)

Definition at line 1002 of file selector.c.

                                                                                {
  if(n->itemcount != count || n->itemcount < 1){
    return -1;
  }
  while(--count){
    selected[count] = n->items[count].selected;
  }
  return 0;
}

Here is the caller graph for this function:

◆ ncnmetric()

API const char * ncnmetric	(	uintmax_t	val,
		size_t	s,
		uintmax_t	decimal,
		char *	buf,
		int	omitdec,
		uintmax_t	mult,
		int	uprefix
	)

Definition at line 28 of file metric.c.

                                  {
  fesetround(FE_TONEAREST); // FIXME global to the process...ick :/
  // these two must have the same number of elements
  const wchar_t* subprefixes = SUBPREFIXES;
  const wchar_t prefixes[] = L"KMGTPEZY"; // 10^21-1 encompasses 2^64-1
  if(decimal == 0 || mult == 0){
    return NULL;
  }
  if(decimal > UINTMAX_MAX / 10){
    return NULL;
  }
  unsigned consumed = 0;
  uintmax_t dv = mult;
  if(decimal <= val || val == 0){
    // FIXME verify that input < 2^89
    while((val / decimal) >= dv && consumed < sizeof(prefixes) / sizeof(*prefixes)){
      dv *= mult;
      ++consumed;
      if(UINTMAX_MAX / dv < mult){ // near overflow--can't scale dv again
        break;
      }
    }
  }else{
    while(val < decimal && consumed < sizeof(prefixes) / sizeof(*prefixes)){
      val *= mult;
      ++consumed;
      if(UINTMAX_MAX / dv < mult){ // near overflow--can't scale dv again
        break;
      }
    }
  }
  int sprintfed;
  if(dv != mult){ // if consumed == 0, dv must equal mult
    if((val / decimal) / dv > 0){
      ++consumed;
    }else{
      dv /= mult;
    }
    val /= decimal;
    // Remainder is val % dv, but we want a percentage as scaled integer.
    // Ideally we would multiply by 100 and divide the result by dv, for
    // maximum accuracy (dv might not be a multiple of 10--it is not for
    // 1,024). That can overflow with large 64-bit values, but we can first
    // divide both sides by mult, and then scale by 100.
    if(omitdec && (val % dv) == 0){
      sprintfed = snprintf(buf, s, "%" PRIu64 "%lc", (uint64_t)(val / dv),
                          (wint_t)prefixes[consumed - 1]);
    }else{
      sprintfed = snprintf(buf, s, "%.2f%lc", (double)val / dv,
                          (wint_t)prefixes[consumed - 1]);
    }
    if(sprintfed < 0){
      return NULL;
    }
    if(uprefix){
      if((size_t)sprintfed < s){
        buf[sprintfed] = uprefix;
        buf[++sprintfed] = '\0';
      }
    }
    return buf;
  }
  // unscaled output, consumed == 0, dv == mult
  // val / decimal < dv (or we ran out of prefixes)
  if(omitdec && val % decimal == 0){
    if(consumed){
      sprintfed = snprintf(buf, s, "%" PRIu64 "%lc", (uint64_t)(val / decimal),
                          (wint_t)subprefixes[consumed - 1]);
    }else{
      sprintfed = snprintf(buf, s, "%" PRIu64, (uint64_t)(val / decimal));
    }
  }else{
    if(consumed){
      sprintfed = snprintf(buf, s, "%.2f%lc", (double)val / decimal,
                          (wint_t)subprefixes[consumed - 1]);
    }else{
      sprintfed = snprintf(buf, s, "%.2f", (double)val / decimal);
    }
  }
  if(sprintfed < 0){
    return NULL;
  }
  if(consumed && uprefix){
    if((size_t)sprintfed < s){
      buf[sprintfed] = uprefix;
      buf[++sprintfed] = '\0';
    }
  }
  return buf;
}

◆ ncpalette_free()

API void ncpalette_free ( ncpalette * p )

Definition at line 2586 of file notcurses.c.

                                 {
  free(p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncpalette_new()

API ALLOC ncpalette * ncpalette_new ( struct notcurses * nc )

Definition at line 2563 of file notcurses.c.

                                       {
  ncpalette* p = malloc(sizeof(*p));
  if(p){
    memcpy(p, &nc->palette, sizeof(*p));
  }
  return p;
}

Here is the caller graph for this function:

◆ ncpalette_use()

API int ncpalette_use	(	struct notcurses *	nc,
		const ncpalette *	p
	)

◆ ncpile_bottom()

API struct ncplane * ncpile_bottom ( struct ncplane * n )

Definition at line 2544 of file notcurses.c.

                                  {
  return ncplane_pile(n)->bottom;
}

Here is the caller graph for this function:

◆ ncpile_create()

API ALLOC struct ncplane API ALLOC struct ncplane * ncpile_create	(	struct notcurses *	nc,
		const ncplane_options *	nopts
	)

◆ ncpile_rasterize()

API int ncpile_rasterize ( struct ncplane * n )

Definition at line 1517 of file render.c.

                                {
  struct timespec start, rasterdone, writedone;
  clock_gettime(CLOCK_MONOTONIC, &start);
  ncpile* pile = ncplane_pile(n);
  struct notcurses* nc = ncpile_notcurses(pile);
  const struct tinfo* ti = &ncplane_notcurses_const(n)->tcache;
  postpaint(nc, ti, nc->lastframe, pile->dimy, pile->dimx, pile->crender, &nc->pool);
  clock_gettime(CLOCK_MONOTONIC, &rasterdone);
  int bytes = notcurses_rasterize(nc, pile, &nc->rstate.f);
  clock_gettime(CLOCK_MONOTONIC, &writedone);
  pthread_mutex_lock(&nc->stats.lock);
    // accepts negative |bytes| as an indication of failure
    update_raster_bytes(&nc->stats.s, bytes);
    update_raster_stats(&rasterdone, &start, &nc->stats.s);
    update_write_stats(&writedone, &rasterdone, &nc->stats.s, bytes);
  pthread_mutex_unlock(&nc->stats.lock);
  // we want to refresh if the screen geometry changed (or if we were just
  // woken up from SIGSTOP), but we mustn't do so until after rasterizing
  // the solved rvec, since this might result in a geometry update.
  if(sigcont_seen_for_render){
    sigcont_seen_for_render = 0;
    notcurses_refresh(ncplane_notcurses(n), NULL, NULL);
  }
  if(bytes < 0){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncpile_render()

API int ncpile_render ( struct ncplane * n )

Definition at line 1569 of file render.c.

                             {
  scroll_lastframe(ncplane_notcurses(n), ncplane_pile(n)->scrolls);
  struct timespec start, renderdone;
  clock_gettime(CLOCK_MONOTONIC, &start);
  notcurses* nc = ncplane_notcurses(n);
  ncpile* pile = ncplane_pile(n);
  // update our notion of screen geometry, and render against that
  unsigned pgeo_changed = 0;
  notcurses_resize_internal(n, NULL, NULL);
  if(pile->cellpxy != nc->tcache.cellpxy || pile->cellpxx != nc->tcache.cellpxx){
    pile->cellpxy = nc->tcache.cellpxy;
    pile->cellpxx = nc->tcache.cellpxx;
    pgeo_changed = 1;
  }
  if(engorge_crender_vector(pile)){
    return -1;
  }
  ncpile_render_internal(pile, pgeo_changed);
  clock_gettime(CLOCK_MONOTONIC, &renderdone);
  pthread_mutex_lock(&nc->stats.lock);
    update_render_stats(&renderdone, &start, &nc->stats.s);
  pthread_mutex_unlock(&nc->stats.lock);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncpile_render_to_buffer()

API int ncpile_render_to_buffer	(	struct ncplane *	p,
		char **	buf,
		size_t *	buflen
	)

◆ ncpile_render_to_file()

API int API int ncpile_render_to_file	(	struct ncplane *	p,
		FILE *	fp
	)

◆ ncpile_top()

API struct ncplane * ncpile_top ( struct ncplane * n )

Definition at line 2540 of file notcurses.c.

                               {
  return ncplane_pile(n)->top;
}

Here is the caller graph for this function:

◆ ncplane_above()

API struct ncplane * ncplane_above ( struct ncplane * n )

Definition at line 2552 of file notcurses.c.

                                  {
  return n->above;
}

Here is the caller graph for this function:

◆ ncplane_abs_x()

API int ncplane_abs_x ( const struct ncplane * n )

◆ ncplane_abs_y()

API int ncplane_abs_y ( const struct ncplane * n )

◆ ncplane_abs_yx()

API void ncplane_abs_yx	(	const struct ncplane *	n,
		int *RESTRICT	y,
		int *RESTRICT	x
	)

◆ ncplane_as_rgba()

API ALLOC uint32_t * ncplane_as_rgba	(	const struct ncplane *	n,
		ncblitter_e	blit,
		int	begy,
		int	begx,
		unsigned	leny,
		unsigned	lenx,
		unsigned *	pxdimy,
		unsigned *	pxdimx
	)

◆ ncplane_at_cursor()

API char * ncplane_at_cursor	(	const struct ncplane *	n,
		uint16_t *	stylemask,
		uint64_t *	channels
	)

◆ ncplane_at_cursor_cell()

API int ncplane_at_cursor_cell	(	struct ncplane *	n,
		nccell *	c
	)

◆ ncplane_at_yx()

API int API char * ncplane_at_yx	(	const struct ncplane *	n,
		int	y,
		int	x,
		uint16_t *	stylemask,
		uint64_t *	channels
	)

◆ ncplane_at_yx_cell()

API int ncplane_at_yx_cell	(	struct ncplane *	n,
		int	y,
		int	x,
		nccell *	c
	)

◆ ncplane_autogrow_p()

API bool ncplane_autogrow_p ( const struct ncplane * n )

◆ ncplane_base()

API int ncplane_base	(	struct ncplane *	n,
		nccell *	c
	)

Definition at line 1569 of file notcurses.c.

                                         {
  return nccell_duplicate(ncp, c, &ncp->basecell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_below()

API struct ncplane * ncplane_below ( struct ncplane * n )

Definition at line 2548 of file notcurses.c.

                                  {
  return n->below;
}

Here is the caller graph for this function:

◆ ncplane_box()

API int ncplane_box	(	struct ncplane *	n,
		const nccell *	ul,
		const nccell *	ur,
		const nccell *	ll,
		const nccell *	lr,
		const nccell *	hline,
		const nccell *	vline,
		unsigned	ystop,
		unsigned	xstop,
		unsigned	ctlword
	)

Definition at line 2271 of file notcurses.c.

                                 {
  unsigned yoff, xoff;
  ncplane_cursor_yx(n, &yoff, &xoff);
  // must be at least 2x2, with its upper-left corner at the current cursor
  if(ystop < yoff + 1){
    logerror("ystop (%u) insufficient for yoff (%d)", ystop, yoff);
    return -1;
  }
  if(xstop < xoff + 1){
    logerror("xstop (%u) insufficient for xoff (%d)", xstop, xoff);
    return -1;
  }
  unsigned ymax, xmax;
  ncplane_dim_yx(n, &ymax, &xmax);
  // must be within the ncplane
  if(xstop >= xmax || ystop >= ymax){
    logerror("boundary (%ux%u) beyond plane (%dx%d)", ystop, xstop, ymax, xmax);
    return -1;
  }
  unsigned edges;
  edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_LEFT);
  if(edges >= box_corner_needs(ctlword)){
    if(ncplane_putc(n, ul) < 0){
      return -1;
    }
  }
  if(!(ctlword & NCBOXMASK_TOP)){ // draw top border, if called for
    if(xstop - xoff >= 2){
      if(ncplane_cursor_move_yx(n, yoff, xoff + 1)){
        return -1;
      }
      if(!(ctlword & NCBOXGRAD_TOP)){ // cell styling, hl
        if(ncplane_hline(n, hl, xstop - xoff - 1) < 0){
          return -1;
        }
      }else{ // gradient, ul -> ur
        if(ncplane_hline_interp(n, hl, xstop - xoff - 1, ul->channels, ur->channels) < 0){
          return -1;
        }
      }
    }
  }
  edges = !(ctlword & NCBOXMASK_TOP) + !(ctlword & NCBOXMASK_RIGHT);
  if(edges >= box_corner_needs(ctlword)){
    if(ncplane_cursor_move_yx(n, yoff, xstop)){
      return -1;
    }
    if(ncplane_putc(n, ur) < 0){
      return -1;
    }
  }
  ++yoff;
  // middle rows (vertical lines)
  if(yoff < ystop){
    if(!(ctlword & NCBOXMASK_LEFT)){
      if(ncplane_cursor_move_yx(n, yoff, xoff)){
        return -1;
      }
      if((ctlword & NCBOXGRAD_LEFT)){ // grad styling, ul->ll
        if(ncplane_vline_interp(n, vl, ystop - yoff, ul->channels, ll->channels) < 0){
          return -1;
        }
      }else{
        if(ncplane_vline(n, vl, ystop - yoff) < 0){
          return -1;
        }
      }
    }
    if(!(ctlword & NCBOXMASK_RIGHT)){
      if(ncplane_cursor_move_yx(n, yoff, xstop)){
        return -1;
      }
      if((ctlword & NCBOXGRAD_RIGHT)){ // grad styling, ur->lr
        if(ncplane_vline_interp(n, vl, ystop - yoff, ur->channels, lr->channels) < 0){
          return -1;
        }
      }else{
        if(ncplane_vline(n, vl, ystop - yoff) < 0){
          return -1;
        }
      }
    }
  }
  // bottom line
  yoff = ystop;
  edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_LEFT);
  if(edges >= box_corner_needs(ctlword)){
    if(ncplane_cursor_move_yx(n, yoff, xoff)){
      return -1;
    }
    if(ncplane_putc(n, ll) < 0){
      return -1;
    }
  }
  if(!(ctlword & NCBOXMASK_BOTTOM)){
    if(xstop - xoff >= 2){
      if(ncplane_cursor_move_yx(n, yoff, xoff + 1)){
        return -1;
      }
      if(!(ctlword & NCBOXGRAD_BOTTOM)){ // cell styling, hl
        if(ncplane_hline(n, hl, xstop - xoff - 1) < 0){
          return -1;
        }
      }else{
        if(ncplane_hline_interp(n, hl, xstop - xoff - 1, ll->channels, lr->channels) < 0){
          return -1;
        }
      }
    }
  }
  edges = !(ctlword & NCBOXMASK_BOTTOM) + !(ctlword & NCBOXMASK_RIGHT);
  if(edges >= box_corner_needs(ctlword)){
    if(ncplane_cursor_move_yx(n, yoff, xstop)){
      return -1;
    }
    if(ncplane_putc(n, lr) < 0){
      return -1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_center_abs()

API void ncplane_center_abs	(	const struct ncplane *	n,
		int *RESTRICT	y,
		int *RESTRICT	x
	)

◆ ncplane_channels()

API uint64_t ncplane_channels ( const struct ncplane * n )

◆ ncplane_contents()

API int API char * ncplane_contents	(	struct ncplane *	n,
		int	begy,
		int	begx,
		unsigned	leny,
		unsigned	lenx
	)

Definition at line 3228 of file notcurses.c.

                                                                                     {
  unsigned ystart, xstart;
  if(check_geometry_args(nc, begy, begx, &leny, &lenx, &ystart, &xstart)){
    return NULL;
  }
  size_t retlen = 1;
  char* ret = malloc(retlen);
  if(ret){
    for(unsigned y = ystart, targy = 0 ; y < ystart + leny ; ++y, targy += 2){
      for(unsigned x = xstart, targx = 0 ; x < xstart + lenx ; ++x, ++targx){
        nccell ncl = NCCELL_TRIVIAL_INITIALIZER;
        // we need ncplane_at_yx_cell() here instead of ncplane_at_yx(),
        // because we should only have one copy of each wide EGC.
        int clen;
        if((clen = ncplane_at_yx_cell(nc, y, x, &ncl)) < 0){
          free(ret);
          return NULL;
        }
        const char* c = nccell_extended_gcluster(nc, &ncl);
        if(clen){
          char* tmp = realloc(ret, retlen + clen);
          if(!tmp){
            free(ret);
            return NULL;
          }
          ret = tmp;
          memcpy(ret + retlen - 1, c, clen);
          retlen += clen;
        }
      }
    }
    ret[retlen - 1] = '\0';
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_create()

API ALLOC struct ncplane * ncplane_create	(	struct ncplane *	n,
		const ncplane_options *	nopts
	)

Here is the caller graph for this function:

◆ ncplane_cursor_move_rel()

API int ncplane_cursor_move_rel	(	struct ncplane *	n,
		int	y,
		int	x
	)

Definition at line 750 of file notcurses.c.

                                                     {
  if((int)n->y + y == -1){
    logerror("invalid target y -1");
    return -1;
  }else if((int)n->x + x == -1){
    logerror("invalid target x -1");
    return -1;
  }else return ncplane_cursor_move_yx(n, n->y + y, n->x + x);
}

Here is the call graph for this function:

◆ ncplane_cursor_move_yx()

API int ncplane_cursor_move_yx	(	struct ncplane *	n,
		int	y,
		int	x
	)

Definition at line 720 of file notcurses.c.

                                                    {
  if(x < 0){
    if(x < -1){
      logerror("negative target x %d", x);
      return -1;
    }
  }else if((unsigned)x >= n->lenx){
    logerror("target x %d >= width %u", x, n->lenx);
    return -1;
  }else{
    n->x = x;
  }
  if(y < 0){
    if(y < -1){
      logerror("negative target y %d", y);
      return -1;
    }
  }else if((unsigned)y >= n->leny){
    logerror("target y %d >= height %u", y, n->leny);
    return -1;
  }else{
    n->y = y;
  }
  if(cursor_invalid_p(n)){
    logerror("invalid cursor following move (%d/%d)", n->y, n->x);
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

◆ ncplane_cursor_yx()

API void ncplane_cursor_yx	(	const struct ncplane *	n,
		unsigned *RESTRICT	y,
		unsigned *RESTRICT	x
	)

◆ ncplane_destroy()

API int ncplane_destroy ( struct ncplane * n )

Definition at line 1018 of file notcurses.c.

                                 {
  if(ncp == NULL){
    return 0;
  }
  if(ncplane_notcurses(ncp)->stdplane == ncp){
    logerror("won't destroy standard plane");
    return -1;
  }
//notcurses_debug(ncplane_notcurses(ncp), stderr);
  loginfo("destroying %dx%d plane \"%s\" @ %dx%d",
          ncp->leny, ncp->lenx, ncp->name ? ncp->name : NULL, ncp->absy, ncp->absx);
  int ret = 0;
  // dissolve our binding from behind (->bprev is either NULL, or its
  // predecessor on the bound list's ->bnext, or &ncp->boundto->blist)
  if(ncp->bprev){
    if( (*ncp->bprev = ncp->bnext) ){
      ncp->bnext->bprev = ncp->bprev;
    }
  }else if(ncp->bnext){
    //assert(ncp->boundto->blist == ncp);
    ncp->bnext->bprev = NULL;
  }
  // recursively reparent our children to the plane to which we are bound.
  // this will extract each one from the sibling list.
  struct ncplane* bound = ncp->blist;
  while(bound){
    struct ncplane* tmp = bound->bnext;
    ncplane* bindto = ((ncp == ncp->boundto) ? bound : ncp->boundto);
    if(ncplane_reparent_family(bound, bindto) == NULL){
      ret = -1;
    }
    bound = tmp;
  }
  // extract ourselves from the z-axis. do this *after* reparenting, in case
  // reparenting shifts up the z-axis somehow (though i don't think it can,
  // at least not within a pile?).
  if(ncp->above){
    ncp->above->below = ncp->below;
  }else{
    ncplane_pile(ncp)->top = ncp->below;
  }
  if(ncp->below){
    ncp->below->above = ncp->above;
  }else{
    ncplane_pile(ncp)->bottom = ncp->above;
  }
  free_plane(ncp);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_dim_yx()

API void ncplane_dim_yx	(	const struct ncplane *	n,
		unsigned *RESTRICT	y,
		unsigned *RESTRICT	x
	)

◆ ncplane_dup()

API struct ncplane API struct ncplane API ALLOC struct ncplane * ncplane_dup	(	const struct ncplane *	n,
		void *	opaque
	)

◆ ncplane_erase()

API int API int API void ncplane_erase ( struct ncplane * n )

Definition at line 2458 of file notcurses.c.

                              {
  loginfo("erasing %dx%d plane", n->leny, n->lenx);
  if(n->sprite){
    sprixel_hide(n->sprite);
    destroy_tam(n);
  }
  // we must preserve the background, but a pure nccell_duplicate() would be
  // wiped out by the egcpool_dump(). do a duplication (to get the stylemask
  // and channels), and then reload.
  char* egc = nccell_strdup(n, &n->basecell);
  memset(n->fb, 0, sizeof(*n->fb) * n->leny * n->lenx);
  egcpool_dump(&n->pool);
  egcpool_init(&n->pool);
  // we need to zero out the EGC before handing this off to nccell_load, but
  // we don't want to lose the channels/attributes, so explicit gcluster load.
  n->basecell.gcluster = 0;
  nccell_load(n, &n->basecell, egc);
  free(egc);
  n->y = n->x = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_erase_region()

API int ncplane_erase_region	(	struct ncplane *	n,
		int	ystart,
		int	xstart,
		int	ylen,
		int	xlen
	)

Definition at line 2479 of file notcurses.c.

                                                                                {
  if(ystart == -1){
    ystart = n->y;
  }
  if(xstart == -1){
    xstart = n->x;
  }
  if(ystart < 0 || xstart < 0){
    logerror("illegal start of erase (%d, %d)", ystart, xstart);
    return -1;
  }
  if(ystart >= (int)ncplane_dim_y(n) || xstart >= (int)ncplane_dim_x(n)){
    logerror("illegal start of erase (%d, %d)", ystart, xstart);
    return -1;
  }
  if(xlen < 0){
    if(xlen + 1 < -xstart){
      xlen = -xstart - 1;
    }
    xstart = xstart + xlen + 1;
    xlen = -xlen;
  }else if(xlen == 0){
    xstart = 0;
    xlen = ncplane_dim_x(n);
  }
  if(xlen > (int)ncplane_dim_x(n) || xstart + xlen > (int)ncplane_dim_x(n)){
    xlen = ncplane_dim_x(n) - xstart;
  }
  if(ylen < 0){
    if(ylen + 1 < -ystart){
      ylen = -ystart - 1;
    }
    ystart = ystart + ylen + 1;
    ylen = -ylen;
  }else if(ylen == 0){
    ystart = 0;
    ylen = ncplane_dim_y(n);
  }
  if(ylen > (int)ncplane_dim_y(n) || ystart + ylen > (int)ncplane_dim_y(n)){
    ylen = ncplane_dim_y(n) - ystart;
  }
  // special-case the full plane erasure, as it's powerfully optimized (O(1))
  if(ystart == 0 && xstart == 0 &&
      ylen == (int)ncplane_dim_y(n) && xlen == (int)ncplane_dim_x(n)){
    int tmpy = n->y; // preserve cursor location
    int tmpx = n->x;
    ncplane_erase(n);
    n->y = tmpy;
    n->x = tmpx;
    return 0;
  }
  loginfo("erasing %d/%d - %d/%d", ystart, xstart, ystart + ylen, xstart + xlen);
  for(int y = ystart ; y < ystart + ylen ; ++y){
    for(int x = xstart ; x < xstart + xlen ; ++x){
      nccell_release(n, &n->fb[nfbcellidx(n, y, x)]);
      nccell_init(&n->fb[nfbcellidx(n, y, x)]);
    }
  }
  return 0;
}

Here is the call graph for this function:

◆ ncplane_fadein()

API int ncplane_fadein	(	struct ncplane *	n,
		const struct timespec *	ts,
		fadecb	fader,
		void *	curry
	)

Definition at line 284 of file fade.c.

                                                                                    {
  ncfadectx* nctx = ncfadectx_setup_internal(n, ts);
  if(nctx == NULL){
    struct timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    if(fader){
      fader(ncplane_notcurses(n), n, &now, curry);
    }else{
      notcurses_render(ncplane_notcurses(n));
    }
    return -1;
  }
  int ret = ncplane_fadein_internal(n, fader, nctx, curry);
  ncfadectx_free(nctx);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_fadein_iteration()

API int API int ncplane_fadein_iteration	(	struct ncplane *	n,
		struct ncfadectx *	nctx,
		int	iter,
		fadecb	fader,
		void *	curry
	)

◆ ncplane_fadeout()

API int ncplane_fadeout	(	struct ncplane *	n,
		const struct timespec *	ts,
		fadecb	fader,
		void *	curry
	)

Definition at line 260 of file fade.c.

                                                                                     {
  ncfadectx* pp = ncfadectx_setup_internal(n, ts);
  if(!pp){
    return -1;
  }
  struct timespec times;
  ns_to_timespec(pp->startns, &times);
  do{
    uint64_t curns = times.tv_sec * NANOSECS_IN_SEC + times.tv_nsec;
    int iter = (curns - pp->startns) / pp->nanosecs_step + 1;
    if(iter > pp->maxsteps){
      break;
    }
    int r = ncplane_fadeout_iteration(n, pp, iter, fader, curry);
    if(r){
      ncfadectx_free(pp);
      return r;
    }
    clock_gettime(CLOCK_MONOTONIC, &times);
  }while(true);
  ncfadectx_free(pp);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_fadeout_iteration()

API int ncplane_fadeout_iteration	(	struct ncplane *	n,
		struct ncfadectx *	nctx,
		int	iter,
		fadecb	fader,
		void *	curry
	)

◆ ncplane_format()

API int ncplane_format	(	struct ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint16_t	stylemask
	)

Definition at line 296 of file fill.c.

                                                     {
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      targc->stylemask = stylemask;
      ++total;
    }
  }
  return total;
}

Here is the caller graph for this function:

◆ ncplane_gradient()

API int API int ncplane_gradient	(	struct ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		const char *	egc,
		uint16_t	styles,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	ll,
		uint64_t	lr
	)

◆ ncplane_gradient2x1()

API int API int API int ncplane_gradient2x1	(	struct ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint32_t	ul,
		uint32_t	ur,
		uint32_t	ll,
		uint32_t	lr
	)

Definition at line 179 of file fill.c.

                                                                           {
  if(!notcurses_canutf8(ncplane_notcurses(n))){
    logerror("highdef gradients require utf8");
    return -1;
  }
  if(check_gradient_channel_args(ul, ur, ll, lr)){
    return -1;
  }
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  if(xlen == 1){
    if(ul != ur || ll != lr){
      logerror("horizontal channel variation in single column");
      return -1;
    }
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      targc->channels = 0;
      if(pool_blit_direct(&n->pool, targc, "▀", strlen("▀"), 1) <= 0){
        return -1;
      }
      calc_highgradient(targc, ul, ur, ll, lr, yy - ystart, xx - xstart, ylen * 2, xlen);
      ++total;
    }
  }
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_greyscale()

API void ncplane_greyscale ( struct ncplane * n )

Definition at line 3 of file fill.c.

                                  {
  for(unsigned y = 0 ; y < n->leny ; ++y){
    for(unsigned x = 0 ; x < n->lenx ; ++x){
      nccell* c = &n->fb[nfbcellidx(n, y, x)];
      unsigned r, g, b;
      nccell_fg_rgb8(c, &r, &g, &b);
      int gy = rgb_greyscale(r, g, b);
      nccell_set_fg_rgb8(c, gy, gy, gy);
      nccell_bg_rgb8(c, &r, &g, &b);
      gy = rgb_greyscale(r, g, b);
      nccell_set_bg_rgb8(c, gy, gy, gy);
    }
  }
}

Here is the caller graph for this function:

◆ ncplane_hline_interp()

API int API int ncplane_hline_interp	(	struct ncplane *	n,
		const nccell *	c,
		unsigned	len,
		uint64_t	c1,
		uint64_t	c2
	)

◆ ncplane_home()

API void ncplane_home ( struct ncplane * n )

Definition at line 715 of file notcurses.c.

                             {
  n->x = 0;
  n->y = 0;
}

Here is the caller graph for this function:

◆ ncplane_mergedown()

API int API int ncplane_mergedown	(	struct ncplane *RESTRICT	src,
		struct ncplane *RESTRICT	dst,
		int	begsrcy,
		int	begsrcx,
		unsigned	leny,
		unsigned	lenx,
		int	dsty,
		int	dstx
	)

◆ ncplane_mergedown_simple()

API int ncplane_mergedown_simple	(	struct ncplane *RESTRICT	src,
		struct ncplane *RESTRICT	dst
	)

◆ ncplane_move_above()

API int ncplane_move_above	(	struct ncplane *RESTRICT	n,
		struct ncplane *RESTRICT	above
	)

◆ ncplane_move_below()

API int ncplane_move_below	(	struct ncplane *RESTRICT	n,
		struct ncplane *RESTRICT	below
	)

◆ ncplane_move_family_above()

API int ncplane_move_family_above	(	struct ncplane *	n,
		struct ncplane *	targ
	)

◆ ncplane_move_family_below()

API int ncplane_move_family_below	(	struct ncplane *	n,
		struct ncplane *	targ
	)

◆ ncplane_move_yx() [1/2]

return ncplane_move_yx	(	n	,
		oy+	y,
		ox+	x
	)

◆ ncplane_move_yx() [2/2]

API int ncplane_move_yx	(	struct ncplane *	n,
		int	y,
		int	x
	)

Definition at line 2411 of file notcurses.c.

                                             {
  if(n == ncplane_notcurses(n)->stdplane){
    return -1;
  }
  int dy, dx; // amount moved
  if(n->boundto == n){
    dy = y - n->absy;
    dx = x - n->absx;
  }else{
    dy = (n->boundto->absy + y) - n->absy;
    dx = (n->boundto->absx + x) - n->absx;
  }
  if(dy || dx){ // don't want to trigger sprixel_movefrom() if unneeded
    if(n->sprite){
      sprixel_movefrom(n->sprite, n->absy, n->absx);
    }
    n->absx += dx;
    n->absy += dy;
    move_bound_planes(n->blist, dy, dx);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_name()

API ALLOC char * ncplane_name ( const struct ncplane * n )

◆ ncplane_notcurses()

API struct notcurses * ncplane_notcurses ( const struct ncplane * n )

◆ ncplane_notcurses_const()

API const struct notcurses * ncplane_notcurses_const ( const struct ncplane * n )

◆ ncplane_off_styles()

API void ncplane_off_styles	(	struct ncplane *	n,
		unsigned	stylebits
	)

Definition at line 2081 of file notcurses.c.

                                                       {
  n->stylemask &= ~(stylebits & NCSTYLE_MASK);
}

Here is the caller graph for this function:

◆ ncplane_on_styles()

API void ncplane_on_styles	(	struct ncplane *	n,
		unsigned	stylebits
	)

Definition at line 2076 of file notcurses.c.

                                                      {
  n->stylemask |= (stylebits & NCSTYLE_MASK);
}

Here is the caller graph for this function:

◆ ncplane_parent()

API struct ncplane * ncplane_parent ( struct ncplane * n )

Definition at line 2651 of file notcurses.c.

                                   {
  return n->boundto;
}

Here is the caller graph for this function:

◆ ncplane_parent_const()

API const struct ncplane * ncplane_parent_const ( const struct ncplane * n )

◆ ncplane_pixel_geom()

API void ncplane_pixel_geom	(	const struct ncplane *	n,
		unsigned *RESTRICT	pxy,
		unsigned *RESTRICT	pxx,
		unsigned *RESTRICT	celldimy,
		unsigned *RESTRICT	celldimx,
		unsigned *RESTRICT	maxbmapy,
		unsigned *RESTRICT	maxbmapx
	)

◆ ncplane_polyfill_yx()

API int ncplane_polyfill_yx	(	struct ncplane *	n,
		int	y,
		int	x,
		const nccell *	c
	)

◆ ncplane_pulse()

API int API int API int ncplane_pulse	(	struct ncplane *	n,
		const struct timespec *	ts,
		fadecb	fader,
		void *	curry
	)

Definition at line 301 of file fade.c.

                                                                                   {
  ncfadectx pp;
  int ret;
  if(!notcurses_canfade(ncplane_notcurses(n))){
    return -1;
  }
  if(alloc_ncplane_palette(n, &pp, ts)){
    return -1;
  }
  for(;;){
    ret = ncplane_fadein_internal(n, fader, &pp, curry);
    if(ret){
      break;
    }
    ret = ncplane_fadeout(n, ts, fader, curry);
    if(ret){
      break;
    }
  }
  free(pp.channels);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_putc_yx()

API int ncplane_putc_yx	(	struct ncplane *	n,
		int	y,
		int	x,
		const nccell *	c
	)

◆ ncplane_putchar_stained()

API int ncplane_putchar_stained	(	struct ncplane *	n,
		char	c
	)

Definition at line 2008 of file notcurses.c.

                                               {
  uint64_t channels = n->channels;
  uint16_t stylemask = n->stylemask;
  const nccell* targ = &n->fb[nfbcellidx(n, n->y, n->x)];
  n->channels = targ->channels;
  n->stylemask = targ->stylemask;
  int ret = ncplane_putchar(n, c);
  n->channels = channels;
  n->stylemask = stylemask;
  return ret;
}

Here is the caller graph for this function:

◆ ncplane_putegc_stained()

API int ncplane_putegc_stained	(	struct ncplane *	n,
		const char *	gclust,
		size_t *	sbytes
	)

◆ ncplane_putegc_yx()

API int ncplane_putegc_yx	(	struct ncplane *	n,
		int	y,
		int	x,
		const char *	gclust,
		size_t *	sbytes
	)

◆ ncplane_putnstr_aligned()

API int ncplane_putnstr_aligned	(	struct ncplane *	n,
		int	y,
		ncalign_e	align,
		size_t	s,
		const char *	str
	)

◆ ncplane_puttext()

API int ncplane_puttext	(	struct ncplane *	n,
		int	y,
		ncalign_e	align,
		const char *	text,
		size_t *	bytes
	)

◆ ncplane_putwegc_stained()

API int ncplane_putwegc_stained	(	struct ncplane *	n,
		const wchar_t *	gclust,
		size_t *	sbytes
	)

◆ ncplane_putwstr_stained()

API int ncplane_putwstr_stained	(	struct ncplane *	n,
		const wchar_t *	gclustarr
	)

◆ ncplane_qrcode()

API int ncplane_qrcode	(	struct ncplane *	n,
		unsigned *	ymax,
		unsigned *	xmax,
		const void *	data,
		size_t	len
	)

◆ ncplane_reparent()

API struct ncplane * ncplane_reparent	(	struct ncplane *	n,
		struct ncplane *	newparent
	)

◆ ncplane_reparent_family()

API struct ncplane API struct ncplane * ncplane_reparent_family	(	struct ncplane *	n,
		struct ncplane *	newparent
	)

◆ ncplane_resize()

API int ncplane_resize	(	struct ncplane *	n,
		int	keepy,
		int	keepx,
		unsigned	keepleny,
		unsigned	keeplenx,
		int	yoff,
		int	xoff,
		unsigned	ylen,
		unsigned	xlen
	)

Definition at line 1006 of file notcurses.c.

                                                {
  if(n == ncplane_notcurses(n)->stdplane){
//fprintf(stderr, "Can't resize standard plane\n");
    return -1;
  }
  return ncplane_resize_internal(n, keepy, keepx, keepleny, keeplenx,
                                 yoff, xoff, ylen, xlen);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_resize_marginalized()

API int ncplane_resize_marginalized ( struct ncplane * n )

Definition at line 2723 of file notcurses.c.

                                           {
  const ncplane* parent = ncplane_parent_const(n);
  // a marginalized plane cannot be larger than its oppressor plane =]
  unsigned maxy, maxx;
  if(parent == n){ // root plane, need to use pile size
    ncpile* p = ncplane_pile(n);
    maxy = p->dimy;
    maxx = p->dimx;
  }else{
    ncplane_dim_yx(parent, &maxy, &maxx);
  }
  if((maxy -= (n->margin_b + (n->absy - n->boundto->absy))) < 1){
    maxy = 1;
  }
  if((maxx -= (n->margin_r + (n->absx - n->boundto->absx))) < 1){
    maxx = 1;
  }
  unsigned oldy, oldx;
  ncplane_dim_yx(n, &oldy, &oldx); // current dimensions of 'n'
  unsigned keepleny = oldy > maxy ? maxy : oldy;
  unsigned keeplenx = oldx > maxx ? maxx : oldx;
  if(ncplane_resize_internal(n, 0, 0, keepleny, keeplenx, 0, 0, maxy, maxx)){
    return -1;
  }
  int targy = maxy - n->margin_b;
  int targx = maxx - n->margin_b;
  loginfo("marg %d/%d, pdim %d/%d, move %d/%d", n->margin_b, n->margin_r, maxy, maxx, targy, targx);
  return ncplane_move_yx(n, targy, targx);
}

Here is the call graph for this function:

◆ ncplane_resize_maximize()

API ALLOC struct ncplane API ALLOC struct ncplane API int ncplane_resize_maximize ( struct ncplane * n )

Definition at line 2753 of file notcurses.c.

                                       {
  const ncpile* pile = ncplane_pile(n); // FIXME should be taken against parent
  const unsigned rows = pile->dimy;
  const unsigned cols = pile->dimx;
  unsigned oldy, oldx;
  ncplane_dim_yx(n, &oldy, &oldx); // current dimensions of 'n'
  unsigned keepleny = oldy > rows ? rows : oldy;
  unsigned keeplenx = oldx > cols ? cols : oldx;
  return ncplane_resize_internal(n, 0, 0, keepleny, keeplenx, 0, 0, rows, cols);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_resize_placewithin()

API int ncplane_resize_placewithin ( struct ncplane * n )

Definition at line 2681 of file notcurses.c.

                                          {
  if(n->boundto == n){
    return 0;
  }
  int absy = ncplane_abs_y(n);
  int absx = ncplane_abs_x(n);
  int ret = 0;
  if(absy + ncplane_dim_y(n) > ncplane_dim_y(n->boundto)){
    const int dy = (absy + ncplane_dim_y(n)) - ncplane_dim_y(n->boundto);
    logdebug("moving up %d", dy);
    if(ncplane_move_rel(n, -dy, 0)){
      ret = -1;
    }
    absy = ncplane_abs_y(n);
  }
  if(absx + ncplane_dim_x(n) > ncplane_dim_x(n->boundto)){
    const int dx = ncplane_dim_x(n->boundto) - (absx + ncplane_dim_x(n));
    logdebug("moving left %d", dx);
    if(ncplane_move_rel(n, 0, dx)){
      ret = -1;
    }
    absx = ncplane_abs_x(n);
  }
  // this will prefer upper-left material if the child plane is larger than
  // the parent. we might want a smarter rule, one based on origin?
  if(absy < 0){
    logdebug("moving down %d", -absy);
    // we're at least partially above our parent
    if(ncplane_move_rel(n, -absy, 0)){
      ret = -1;
    }
  }
  if(absx < 0){
    logdebug("moving right %d", -absx);
    // we're at least partially to the left of our parent
    if(ncplane_move_rel(n, 0, -absx)){
      ret = -1;
    }
  }
  return ret;
}

Here is the call graph for this function:

◆ ncplane_resize_realign()

API int ncplane_resize_realign ( struct ncplane * n )

Definition at line 2764 of file notcurses.c.

                                      {
  const ncplane* parent = ncplane_parent_const(n);
  if(parent == n){
    logerror("can't realign a root plane");
    return 0;
  }
  if(n->halign == NCALIGN_UNALIGNED && n->valign == NCALIGN_UNALIGNED){
    logerror("passed a non-aligned plane");
    return -1;
  }
  int xpos = ncplane_x(n);
  if(n->halign != NCALIGN_UNALIGNED){
    xpos = ncplane_halign(parent, n->halign, ncplane_dim_x(n));
  }
  int ypos = ncplane_y(n);
  if(n->valign != NCALIGN_UNALIGNED){
    ypos = ncplane_valign(parent, n->valign, ncplane_dim_y(n));
  }
  return ncplane_move_yx(n, ypos, xpos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_rotate_ccw()

API int ncplane_rotate_ccw ( struct ncplane * n )

Definition at line 515 of file fill.c.

                                  {
  ncplane* newp = rotate_plane(n);
  if(newp == NULL){
    return -1;
  }
  unsigned dimy, dimx, targdimy, targdimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  ncplane_dim_yx(newp, &targdimy, &targdimx);
  int x = (int)dimx - 2;
  int y;
  // Each row of the target plane is taken from a column of the source plane.
  // As the target row grows (down), the source column shrinks (moves left).
  for(unsigned targy = 0 ; targy < targdimy ; ++targy){
    y = 0;
    for(unsigned targx = 0 ; targx < targdimx ; targx += 2){
      if(rotate_2x1_ccw(n, newp, y, x, targy, targx)){
        ncplane_destroy(newp);
        return -1;
      }
      ++y;
    }
    x -= 2;
  }
  int ret = rotate_merge(n, newp);
  ret |= ncplane_destroy(newp);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_rotate_cw()

API int API int ncplane_rotate_cw ( struct ncplane * n )

Definition at line 484 of file fill.c.

                                 {
  ncplane* newp = rotate_plane(n);
  if(newp == NULL){
    return -1;
  }
  unsigned dimy, dimx;
  ncplane_dim_yx(n, &dimy, &dimx);
  int centy, centx;
  ncplane_center_abs(n, &centy, &centx);
  // the topmost row consists of the leftmost two columns. the rightmost column
  // of the topmost row consists of the top half of the top two leftmost cells.
  // the penultimate column of the topmost row consists of the bottom half of
  // the top two leftmost cells. work from the bottom up on the source, so we
  // can copy to the top row from the left to the right.
  int targx, targy = 0;
  for(unsigned x = 0 ; x < dimx ; x += 2){
    targx = 0;
    for(int y = (int)dimy - 1 ; y >= 0 ; --y){
      if(rotate_2x1_cw(n, newp, y, x, targy, targx)){
        ncplane_destroy(newp);
        return -1;
      }
      targx += 2;
    }
    ++targy;
  }
  int ret = rotate_merge(n, newp);
  ret |= ncplane_destroy(newp);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_scrolling_p()

API bool ncplane_scrolling_p ( const struct ncplane * n )

◆ ncplane_scrollup()

API int ncplane_scrollup	(	struct ncplane *	n,
		int	r
	)

Definition at line 1792 of file notcurses.c.

                                       {
  if(!ncplane_scrolling_p(n)){
    logerror("can't scroll %d on non-scrolling plane", r);
    return -1;
  }
  if(r < 0){
    logerror("can't scroll %d lines", r);
    return -1;
  }
  while(r-- > 0){
    scroll_down(n);
  }
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    notcurses_render(ncplane_notcurses(n));
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_scrollup_child()

API int ncplane_scrollup_child	(	struct ncplane *	n,
		const struct ncplane *	child
	)

◆ ncplane_set_autogrow()

API bool ncplane_set_autogrow	(	struct ncplane *	n,
		unsigned	growp
	)

Definition at line 3003 of file notcurses.c.

                                                     {
  if(n == notcurses_stdplane_const(ncplane_notcurses_const(n))){
    logerror("can't set the standard plane autogrow");
    return false;
  }
  bool old = n->autogrow;
  n->autogrow = growp;
  return old;
}

Here is the call graph for this function:

◆ ncplane_set_base()

API int ncplane_set_base	(	struct ncplane *	n,
		const char *	egc,
		uint16_t	stylemask,
		uint64_t	channels
	)

Definition at line 1565 of file notcurses.c.

                                                                                          {
  return nccell_prime(ncp, &ncp->basecell, egc, stylemask, channels);
}

Here is the caller graph for this function:

◆ ncplane_set_base_cell()

API int ncplane_set_base_cell	(	struct ncplane *	n,
		const nccell *	c
	)

Definition at line 1558 of file notcurses.c.

                                                        {
  if(nccell_wide_right_p(c)){
    return -1;
  }
  return nccell_duplicate(ncp, &ncp->basecell, c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_set_bchannel()

API uint64_t ncplane_set_bchannel	(	struct ncplane *	n,
		uint32_t	channel
	)

Definition at line 1530 of file notcurses.c.

                                                           {
  return ncchannels_set_bchannel(&n->channels, channel);
}

◆ ncplane_set_bg_alpha()

API int ncplane_set_bg_alpha	(	struct ncplane *	n,
		int	alpha
	)

Definition at line 1546 of file notcurses.c.

                                               {
  return ncchannels_set_bg_alpha(&n->channels, alpha);
}

Here is the caller graph for this function:

◆ ncplane_set_bg_default()

API void ncplane_set_bg_default ( struct ncplane * n )

Definition at line 1506 of file notcurses.c.

                                       {
  ncchannels_set_bg_default(&n->channels);
}

Here is the caller graph for this function:

◆ ncplane_set_bg_palindex()

API int ncplane_set_bg_palindex	(	struct ncplane *	n,
		unsigned	idx
	)

Definition at line 1554 of file notcurses.c.

                                                     {
  return ncchannels_set_bg_palindex(&n->channels, idx);
}

◆ ncplane_set_bg_rgb()

API int ncplane_set_bg_rgb	(	struct ncplane *	n,
		uint32_t	channel
	)

◆ ncplane_set_bg_rgb8()

API int ncplane_set_bg_rgb8	(	struct ncplane *	n,
		unsigned	r,
		unsigned	g,
		unsigned	b
	)

Definition at line 1514 of file notcurses.c.

                                                                       {
  return ncchannels_set_bg_rgb8(&n->channels, r, g, b);
}

Here is the caller graph for this function:

◆ ncplane_set_bg_rgb8_clipped()

API void ncplane_set_bg_rgb8_clipped	(	struct ncplane *	n,
		int	r,
		int	g,
		int	b
	)

Definition at line 1510 of file notcurses.c.

                                                                 {
  ncchannels_set_bg_rgb8_clipped(&n->channels, r, g, b);
}

Here is the caller graph for this function:

◆ ncplane_set_channels()

API void ncplane_set_channels	(	struct ncplane *	n,
		uint64_t	channels
	)

Definition at line 1494 of file notcurses.c.

                                                        {
  ncchannels_set_channels(&n->channels, channels);
}

Here is the caller graph for this function:

◆ ncplane_set_fchannel()

API uint64_t ncplane_set_fchannel	(	struct ncplane *	n,
		uint32_t	channel
	)

Definition at line 1534 of file notcurses.c.

                                                           {
  return ncchannels_set_fchannel(&n->channels, channel);
}

◆ ncplane_set_fg_alpha()

API int ncplane_set_fg_alpha	(	struct ncplane *	n,
		int	alpha
	)

Definition at line 1542 of file notcurses.c.

                                               {
  return ncchannels_set_fg_alpha(&n->channels, alpha);
}

Here is the caller graph for this function:

◆ ncplane_set_fg_default()

API void ncplane_set_fg_default ( struct ncplane * n )

Definition at line 1502 of file notcurses.c.

                                       {
  ncchannels_set_fg_default(&n->channels);
}

Here is the caller graph for this function:

◆ ncplane_set_fg_palindex()

API int ncplane_set_fg_palindex	(	struct ncplane *	n,
		unsigned	idx
	)

Definition at line 1550 of file notcurses.c.

                                                     {
  return ncchannels_set_fg_palindex(&n->channels, idx);
}

Here is the caller graph for this function:

◆ ncplane_set_fg_rgb()

API int ncplane_set_fg_rgb	(	struct ncplane *	n,
		uint32_t	channel
	)

◆ ncplane_set_fg_rgb8()

API int ncplane_set_fg_rgb8	(	struct ncplane *	n,
		unsigned	r,
		unsigned	g,
		unsigned	b
	)

Definition at line 1522 of file notcurses.c.

                                                                       {
  return ncchannels_set_fg_rgb8(&n->channels, r, g, b);
}

Here is the caller graph for this function:

◆ ncplane_set_fg_rgb8_clipped()

API void ncplane_set_fg_rgb8_clipped	(	struct ncplane *	n,
		int	r,
		int	g,
		int	b
	)

Definition at line 1518 of file notcurses.c.

                                                                 {
  ncchannels_set_fg_rgb8_clipped(&n->channels, r, g, b);
}

Here is the caller graph for this function:

◆ ncplane_set_name()

API int ncplane_set_name	(	struct ncplane *	n,
		const char *	name
	)

Definition at line 2659 of file notcurses.c.

                                                  {
  char* copy = name ? strdup(name) : NULL;
  if(copy == NULL && name != NULL){
    return -1;
  }
  free(n->name);
  n->name = copy;
  return 0;
}

Here is the call graph for this function:

◆ ncplane_set_resizecb()

API void ncplane_set_resizecb	(	struct ncplane *	n,
		int()(struct ncplane )	resizecb
	)

◆ ncplane_set_scrolling()

API bool ncplane_set_scrolling	(	struct ncplane *	n,
		unsigned	scrollp
	)

Definition at line 2993 of file notcurses.c.

                                                        {
  bool old = n->scrolling;
  n->scrolling = scrollp;
  return old;
}

Here is the caller graph for this function:

◆ ncplane_set_styles()

API void ncplane_set_styles	(	struct ncplane *	n,
		unsigned	stylebits
	)

Definition at line 2071 of file notcurses.c.

                                                       {
  n->stylemask = (stylebits & NCSTYLE_MASK);
}

Here is the caller graph for this function:

◆ ncplane_set_userptr()

API void * ncplane_set_userptr	(	struct ncplane *	n,
		void *	opaque
	)

Definition at line 186 of file notcurses.c.

                                                   {
  void* ret = n->userptr;
  n->userptr = opaque;
  return ret;
}

Here is the caller graph for this function:

◆ ncplane_stain()

API int ncplane_stain	(	struct ncplane *	n,
		int	y,
		int	x,
		unsigned	ylen,
		unsigned	xlen,
		uint64_t	ul,
		uint64_t	ur,
		uint64_t	ll,
		uint64_t	lr
	)

Definition at line 272 of file fill.c.

                                                                     {
  // Can't use default or palette-indexed colors in a gradient
  if(check_gradient_args(tl, tr, bl, br)){
    return -1;
  }
  unsigned ystart, xstart;
  if(check_geometry_args(n, y, x, &ylen, &xlen, &ystart, &xstart)){
    return -1;
  }
  int total = 0;
  for(unsigned yy = ystart ; yy < ystart + ylen ; ++yy){
    for(unsigned xx = xstart ; xx < xstart + xlen ; ++xx){
      nccell* targc = ncplane_cell_ref_yx(n, yy, xx);
      if(targc->gcluster){
        calc_gradient_channels(&targc->channels, tl, tr, bl, br,
                               yy - ystart, xx - xstart, ylen, xlen);
      }
      ++total;
    }
  }
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_styles()

API uint16_t ncplane_styles ( const struct ncplane * n )

◆ ncplane_translate()

API void ncplane_translate	(	const struct ncplane *	src,
		const struct ncplane *	dst,
		int *RESTRICT	y,
		int *RESTRICT	x
	)

◆ ncplane_translate_abs()

API bool ncplane_translate_abs	(	const struct ncplane *	n,
		int *RESTRICT	y,
		int *RESTRICT	x
	)

◆ ncplane_userptr()

API void * ncplane_userptr ( struct ncplane * n )

Definition at line 192 of file notcurses.c.

                                 {
  return n->userptr;
}

Here is the caller graph for this function:

◆ ncplane_vline_interp()

API int ncplane_vline_interp	(	struct ncplane *	n,
		const nccell *	c,
		unsigned	len,
		uint64_t	c1,
		uint64_t	c2
	)

◆ ncplane_vprintf_aligned()

API int ncplane_vprintf_aligned	(	struct ncplane *	n,
		int	y,
		ncalign_e	align,
		const char *	format,
		va_list	ap
	)

◆ ncplane_vprintf_stained()

API int ncplane_vprintf_stained	(	struct ncplane *	n,
		const char *	format,
		va_list	ap
	)

◆ ncplane_vprintf_yx()

API int ncplane_vprintf_yx	(	struct ncplane *	n,
		int	y,
		int	x,
		const char *	format,
		va_list	ap
	)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncplane_x()

API int ncplane_x ( const struct ncplane * n )

◆ ncplane_y()

API int ncplane_y ( const struct ncplane * n )

◆ ncplane_yx() [1/2]

API void ncplane_yx	(	const struct ncplane *	n,
		int *RESTRICT	y,
		int *RESTRICT	x
	)

◆ ncplane_yx() [2/2]

ncplane_yx	(	n	,
		&	oy,
		&	ox
	)

◆ ncprogbar_create()

API ALLOC struct ncprogbar * ncprogbar_create	(	struct ncplane *	n,
		const ncprogbar_options *	opts
	)

Definition at line 4 of file progbar.c.

                                                                      {
  ncprogbar_options default_opts;
  if(opts == NULL){
    memset(&default_opts, 0, sizeof(default_opts));
    opts = &default_opts;
  }
  if(opts->flags > (NCPROGBAR_OPTION_RETROGRADE << 1u)){
    logwarn("invalid flags %016" PRIx64, opts->flags);
  }
  ncprogbar* ret = malloc(sizeof(*ret));
  if(ret == NULL){
    ncplane_destroy(n);
    return NULL;
  }
  ret->ncp = n;
  ret->ulchannel = opts->ulchannel;
  ret->urchannel = opts->urchannel;
  ret->blchannel = opts->blchannel;
  ret->brchannel = opts->brchannel;
  ret->retrograde = opts->flags & NCPROGBAR_OPTION_RETROGRADE;
  if(ncplane_set_widget(n, ret, (void(*)(void*))ncprogbar_destroy)){
    ncplane_destroy(n);
    free(ret);
    return NULL;
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncprogbar_destroy()

API void ncprogbar_destroy ( struct ncprogbar * n )

Definition at line 190 of file progbar.c.

                                    {
  if(n){
    if(ncplane_set_widget(n->ncp, NULL, NULL) == 0){
      ncplane_destroy(n->ncp);
    }
    free(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncprogbar_plane()

API struct ncplane * ncprogbar_plane ( struct ncprogbar * n )

Definition at line 32 of file progbar.c.

                                      {
  return n->ncp;
}

Here is the caller graph for this function:

◆ ncprogbar_progress()

API double ncprogbar_progress ( const struct ncprogbar * n )

◆ ncprogbar_set_progress()

API int ncprogbar_set_progress	(	struct ncprogbar *	n,
		double	p
	)

Definition at line 176 of file progbar.c.

                                                  {
//fprintf(stderr, "PROGRESS: %g\n", p);
  if(p < 0 || p > 1){
    logerror("invalid progress %g", p);
    return -1;
  }
  n->progress = p;
  return progbar_redraw(n);
}

Here is the caller graph for this function:

◆ ncreader_clear()

API int ncreader_clear ( struct ncreader * n )

Definition at line 73 of file reader.c.

                               {
  ncplane_erase(n->ncp);
  ncplane_erase(n->textarea);
  n->xproject = 0;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_contents()

API int API char * ncreader_contents ( const struct ncreader * n )

◆ ncreader_create()

API ALLOC struct ncreader * ncreader_create	(	struct ncplane *	n,
		const ncreader_options *	opts
	)

Definition at line 26 of file reader.c.

                                                                   {
  ncreader_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  if(opts->flags > NCREADER_OPTION_CURSOR){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  ncreader* nr = malloc(sizeof(*nr));
  if(nr == NULL){
    ncplane_destroy(n);
    return NULL;
  }
  nr->ncp = n;
  // do *not* bind it to the visible plane; we always want it offscreen,
  // to the upper left of the true origin
  struct ncplane_options nopts = {
    .y = -ncplane_dim_y(n),
    .x = -ncplane_dim_x(n),
    .rows = ncplane_dim_y(n),
    .cols = ncplane_dim_x(n),
    .name = "text",
  };
  if((nr->textarea = ncplane_create(notcurses_stdplane(ncplane_notcurses(n)), &nopts)) == NULL){
    ncplane_destroy(nr->ncp);
    free(nr);
    return NULL;
  }
 
  nr->horscroll = opts->flags & NCREADER_OPTION_HORSCROLL;
  nr->xproject = 0;
  nr->tchannels = opts->tchannels;
  nr->tattrs = opts->tattrword;
  nr->no_cmd_keys = opts->flags & NCREADER_OPTION_NOCMDKEYS;
  nr->manage_cursor = opts->flags & NCREADER_OPTION_CURSOR;
  ncplane_set_channels(nr->ncp, opts->tchannels);
  ncplane_set_styles(nr->ncp, opts->tattrword);
  if(ncplane_set_widget(n, nr, (void(*)(void*))ncreader_destroy_internal)){
    ncplane_destroy(nr->textarea);
    ncplane_destroy(nr->ncp);
    free(nr);
    return NULL;
  }
  return nr;
}

Here is the call graph for this function:

◆ ncreader_destroy()

API void ncreader_destroy	(	struct ncreader *	n,
		char **	contents
	)

Definition at line 17 of file reader.c.

                                                   {
  if(n){
    if(contents){
      *contents = ncreader_contents(n);
    }
    ncreader_destroy_internal(n);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_move_down()

API int ncreader_move_down ( struct ncreader * n )

Definition at line 202 of file reader.c.

                                   {
  unsigned y = n->ncp->y;
  if(y >= n->textarea->leny - 1){
    // are we on the last row of the textarea? if so, we can't move.
    return -1;
  }
  ++y;
  ncplane_cursor_move_yx(n->textarea, y, -1);
  ncplane_cursor_move_yx(n->ncp, y, -1);
  ncreader_redraw(n);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_move_left()

API bool API int ncreader_move_left ( struct ncreader * n )

Definition at line 115 of file reader.c.

                                   {
  int viewx = n->ncp->x;
  int textx = n->textarea->x;
  int y = n->ncp->y;
//fprintf(stderr, "moving left: tcurs: %dx%d vcurs: %dx%d xproj: %d\n", y, textx, y, viewx, n->xproject);
  if(textx == 0){
    // are we on the first column of the textarea? if so, we must also be on
    // the first column of the viewarea. try to move up.
    if(y == 0){
      return -1; // no move possible
    }
    viewx = n->ncp->lenx - 1; // FIXME find end of particular row
    --y;
    textx = n->textarea->lenx - 1;
    n->xproject = n->textarea->x - n->ncp->x;
  }else{
    // if we're on the first column of the viewarea, but not the first column
    // of the textarea, we must be able to scroll to the left. do so.
    // if we're not on the last column anywhere, move cursor right everywhere.
    if(viewx == 0){
      --n->xproject;
    }else{
      --viewx;
    }
    --textx;
  }
  ncplane_cursor_move_yx(n->textarea, y, textx);
  ncplane_cursor_move_yx(n->ncp, y, viewx);
//fprintf(stderr, "moved left: tcurs: %dx%d vcurs: %dx%d xproj: %d\n", y, textx, y, viewx, n->xproject);
  ncreader_redraw(n);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_move_right()

API int ncreader_move_right ( struct ncreader * n )

Definition at line 152 of file reader.c.

                                    {
  unsigned textx = n->textarea->x;
  unsigned y = n->ncp->y;
  unsigned viewx = n->ncp->x;
//fprintf(stderr, "moving right: tcurs: %dx%d vcurs: %dx%d xproj: %d\n", y, textx, y, viewx, n->xproject);
  if(textx >= n->textarea->lenx - 1){
    // are we on the last column of the textarea? if so, we must also be on
    // the first column of the viewarea. try to move down.
    if(y >= n->textarea->leny - 1){
      return -1; // no move possible
    }
    viewx = 0;
    ++y;
    textx = viewx;
    n->xproject = 0;
  }else{
    // if we're on the first column of the viewarea, but not the first column
    // of the textarea, we must be able to scroll to the left. do so.
    // if we're not on the last column anywhere, move cursor right everywhere.
    if(viewx >= n->ncp->lenx - 1){
      ++n->xproject;
    }else{
      ++viewx;
    }
    ++textx;
  }
  ncplane_cursor_move_yx(n->textarea, y, textx);
  ncplane_cursor_move_yx(n->ncp, y, viewx);
//fprintf(stderr, "moved right: tcurs: %dx%d vcurs: %dx%d xproj: %d\n", y, textx, y, viewx, n->xproject);
  ncreader_redraw(n);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_move_up()

API int ncreader_move_up ( struct ncreader * n )

Definition at line 187 of file reader.c.

                                 {
  int y = n->ncp->y;
  if(y == 0){
    // are we on the last row of the textarea? if so, we can't move.
    return -1;
  }
  --y;
  ncplane_cursor_move_yx(n->textarea, y, -1);
  ncplane_cursor_move_yx(n->ncp, y, -1);
  ncreader_redraw(n);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreader_offer_input()

API bool ncreader_offer_input	(	struct ncreader *	n,
		const ncinput *	ni
	)

◆ ncreader_plane()

API struct ncplane * ncreader_plane ( struct ncreader * n )

Definition at line 80 of file reader.c.

                                    {
  return n->ncp;
}

Here is the caller graph for this function:

◆ ncreader_write_egc()

API int ncreader_write_egc	(	struct ncreader *	n,
		const char *	egc
	)

◆ ncreel_add()

API ALLOC struct nctablet * ncreel_add	(	struct ncreel *	nr,
		struct nctablet *	after,
		struct nctablet *	before,
		tabletcb	cb,
		void *	opaque
	)

Definition at line 838 of file reel.c.

                                                  {
  nctablet* t;
  if(after && before){
    if(after->next != before || before->prev != after){
      logerror("bad before (%p) / after (%p) spec", before, after);
      return NULL;
    }
  }else if(!after && !before){
    // This way, without user interaction or any specification, new tablets are
    // inserted at the "end" relative to the focus. The first one to be added
    // gets and keeps the focus. New ones will go on the bottom, until we run
    // out of space. New tablets are then created off-screen.
    before = nr->tablets;
  }
  if((t = malloc(sizeof(*t))) == NULL){
    return NULL;
  }
//fprintf(stderr, "--------->NEW TABLET %p\n", t);
  if(after){
    t->next = after->next;
    after->next = t;
    t->prev = after;
    t->next->prev = t;
  }else if(before){
    t->prev = before->prev;
    before->prev = t;
    t->next = before;
    t->prev->next = t;
  }else{ // we're the first tablet
    t->prev = t->next = t;
    nr->tablets = t;
  }
  t->cbfxn = cbfxn;
  t->curry = opaque;
  ++nr->tabletcount;
  t->p = NULL;
  t->cbp = NULL;
  ncreel_redraw(nr);
  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_create()

API ALLOC struct ncreel * ncreel_create	(	struct ncplane *	n,
		const ncreel_options *	popts
	)

Definition at line 807 of file reel.c.

                                                              {
  ncreel_options zeroed = {0};
  ncreel* nr;
  if(!ropts){
    ropts = &zeroed;
  }
  if(!validate_ncreel_opts(n, ropts)){
    return NULL;
  }
  if((nr = malloc(sizeof(*nr))) == NULL){
    return NULL;
  }
  nr->tablets = NULL;
  nr->tabletcount = 0;
  nr->direction = LASTDIRECTION_DOWN; // draw down after the initial tablet
  memcpy(&nr->ropts, ropts, sizeof(*ropts));
  nr->p = n;
  nr->vft = NULL;
  if(ncplane_set_widget(nr->p, nr, (void(*)(void*))ncreel_destroy)){
    ncplane_destroy(nr->p);
    free(nr);
    return NULL;
  }
  if(ncreel_redraw(nr)){
    ncplane_destroy(nr->p);
    free(nr);
    return NULL;
  }
  return nr;
}

Here is the call graph for this function:

◆ ncreel_del()

API int ncreel_del	(	struct ncreel *	nr,
		struct nctablet *	t
	)

Definition at line 285 of file reel.c.

                                              {
  if(t == NULL){
    return -1;
  }
  if(nr->tablets == t){
    if((nr->tablets = t->next) == t){
      nr->tablets = NULL;
    }
    // FIXME ought set direction based on actual location of replacement tablet
    nr->direction = LASTDIRECTION_DOWN;
  }
  if(nr->vft == t){
    clean_reel(nr); // maybe just make nr->tablets the vft?
  }
  nctablet_delete_internal(t);
  --nr->tabletcount;
  ncreel_redraw(nr);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_destroy()

API void ncreel_destroy ( struct ncreel * nr )

Definition at line 880 of file reel.c.

                                  {
  if(nreel){
    if(ncplane_set_widget(nreel->p, NULL, NULL) == 0){
      nctablet* t;
      while( (t = nreel->tablets) ){
        ncreel_del(nreel, t);
      }
      ncplane_destroy(nreel->p);
    }
    free(nreel);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_focused()

API bool API struct nctablet * ncreel_focused ( struct ncreel * nr )

Definition at line 901 of file reel.c.

                                    {
  return nr->tablets;
}

Here is the caller graph for this function:

◆ ncreel_next()

API struct nctablet * ncreel_next ( struct ncreel * nr )

Definition at line 905 of file reel.c.

                                 {
  if(nr->tablets){
    nr->tablets = nr->tablets->next;
//fprintf(stderr, "---------------> moved to next, %p to %p <----------\n", nr->tablets->prev, nr->tablets);
    nr->direction = LASTDIRECTION_DOWN;
    ncreel_redraw(nr);
  }
  return nr->tablets;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_offer_input()

API bool ncreel_offer_input	(	struct ncreel *	nr,
		const ncinput *	ni
	)

◆ ncreel_plane()

API struct ncplane * ncreel_plane ( struct ncreel * nr )

Definition at line 803 of file reel.c.

                                 {
  return nr->p;
}

◆ ncreel_prev()

API struct nctablet * ncreel_prev ( struct ncreel * nr )

Definition at line 915 of file reel.c.

                                 {
  if(nr->tablets){
    nr->tablets = nr->tablets->prev;
//fprintf(stderr, "----------------> moved to prev, %p to %p <----------\n", nr->tablets->next, nr->tablets);
    nr->direction = LASTDIRECTION_UP;
    ncreel_redraw(nr);
  }
  return nr->tablets;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_redraw()

API int ncreel_redraw ( struct ncreel * nr )

Definition at line 677 of file reel.c.

                             {
//fprintf(stderr, "\n--------> BEGIN REDRAW <--------\n");
  nctablet* focused = nr->tablets;
  int fulcrum; // target line
  if(nr->direction == LASTDIRECTION_UP){
    // case i iff the last direction was UP, and either the focused tablet is
    // not visible, or below the visibly-focused tablet, or there is no
    // visibly-focused tablet.
    if(!focused || !focused->p || !nr->vft){
      fulcrum = 0;
//fprintf(stderr, "case i fulcrum %d\n", fulcrum);
    }else{
      int focy, vfty;
      ncplane_yx(focused->p, &focy, NULL);
      ncplane_yx(nr->vft->p, &vfty, NULL);
      if(focy > vfty){
        fulcrum = 0;
//fprintf(stderr, "case i fulcrum %d (%d %d) %p %p\n", fulcrum, focy, vfty, focused, nr->vft);
      }else{
        ncplane_yx(focused->p, &fulcrum, NULL); // case iii
//fprintf(stderr, "case iii fulcrum %d (%d %d) %p %p lastdir: %d\n", fulcrum, focy, vfty, focused, nr->vft, nr->direction);
      }
    }
  }else{
    // case ii iff the last direction was DOWN, and either the focused tablet
    // is not visible, or above the visibly-focused tablet, or there is no
    // visibly-focused tablet.
    if(!focused || !focused->p || !nr->vft){
      fulcrum = ncplane_dim_y(nr->p) - 1;
//fprintf(stderr, "case ii fulcrum %d\n", fulcrum);
    }else{
      int focy, vfty;
//fprintf(stderr, "focused: %p\n", focused);
      ncplane_yx(focused->p, &focy, NULL);
      ncplane_yx(nr->vft->p, &vfty, NULL);
      if(focy < vfty){
        fulcrum = ncplane_dim_y(nr->p) - 1;
//fprintf(stderr, "case ii fulcrum %d (%d %d) %p %p\n", fulcrum, focy, vfty, focused, nr->vft);
      }else{
        ncplane_yx(focused->p, &fulcrum, NULL); // case iii
//fprintf(stderr, "case iiib fulcrum %d (%d %d) %p %p lastdir: %d\n", fulcrum, focy, vfty, focused, nr->vft, nr->direction);
      }
    }
  }
  clean_reel(nr);
  if(focused){
//fprintf(stderr, "drawing focused tablet %p dir: %d fulcrum: %d!\n", focused, nr->direction, fulcrum);
    if(ncreel_draw_tablet(nr, focused, fulcrum, fulcrum, DIRECTION_DOWN)){
      logerror("error drawing tablet");
      return -1;
    }
//fprintf(stderr, "drew focused tablet %p -> %p lastdir: %d!\n", focused, focused->p, nr->direction);
    nctablet* otherend = focused;
    int frontiertop, frontierbottom;
    ncplane_yx(nr->tablets->p, &frontiertop, NULL);
    frontierbottom = frontiertop + ncplane_dim_y(nr->tablets->p) + 1;
    frontiertop -= 2;
    if(nr->direction == LASTDIRECTION_DOWN){
      otherend = draw_previous_tablets(nr, otherend, &frontiertop, frontierbottom);
      if(otherend == NULL){
        logerror("error drawing higher tablets");
        return -1;
      }
      otherend = draw_following_tablets(nr, otherend, frontiertop, &frontierbottom);
    }else{ // DIRECTION_UP
      otherend = draw_previous_tablets(nr, otherend, &frontiertop, frontierbottom);
      if(otherend == NULL){
        logerror("error drawing higher tablets");
        return -1;
      }
      otherend = draw_following_tablets(nr, otherend, frontiertop, &frontierbottom);
    }
    if(otherend == NULL){
      logerror("error drawing following tablets");
      return -1;
    }
//notcurses_debug(ncplane_notcurses(nr->p), stderr);
    if(tighten_reel(nr)){
      logerror("error tightening reel");
      return -1;
    }
//notcurses_debug(ncplane_notcurses(nr->p), stderr);
  }
  nr->vft = nr->tablets; // update the visually-focused tablet pointer
//fprintf(stderr, "DONE ARRANGING\n");
  if(draw_ncreel_borders(nr)){
    logerror("error drawing reel borders");
    return -1; // enforces specified dimensional minima
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncreel_tabletcount()

API int ncreel_tabletcount ( const struct ncreel * nr )

◆ ncselector_additem()

API int ncselector_additem	(	struct ncselector *	n,
		const struct ncselector_item *	item
	)

Definition at line 392 of file selector.c.

                                                                         {
  unsigned origdimy, origdimx;
  ncselector_dim_yx(n, &origdimy, &origdimx);
  size_t newsize = sizeof(*n->items) * (n->itemcount + 1);
  struct ncselector_int* items = realloc(n->items, newsize);
  if(!items){
    return -1;
  }
  n->items = items;
  n->items[n->itemcount].option = strdup(item->option);
  const char *desc = item->desc ? item->desc : "";
  n->items[n->itemcount].desc = strdup(desc);
  int usafecols = ncstrwidth(item->option, NULL, NULL);
  if(usafecols < 0){
    return -1;
  }
  unsigned cols = usafecols;
  n->items[n->itemcount].opcolumns = cols;
  if(cols > n->longop){
    n->longop = cols;
  }
  cols = ncstrwidth(desc, NULL, NULL);
  n->items[n->itemcount].desccolumns = cols;
  if(cols > n->longdesc){
    n->longdesc = cols;
  }
  ++n->itemcount;
  unsigned dimy, dimx;
  ncselector_dim_yx(n, &dimy, &dimx);
  if(origdimx < dimx || origdimy < dimy){ // resize if too small
    ncplane_resize_simple(n->ncp, dimy, dimx);
  }
  return ncselector_draw(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncselector_create()

API ALLOC struct ncselector * ncselector_create	(	struct ncplane *	n,
		const ncselector_options *	opts
	)

Definition at line 280 of file selector.c.

                                                                         {
  if(n == notcurses_stdplane(ncplane_notcurses(n))){
    logerror("won't use the standard plane"); // would fail later on resize
    return NULL;
  }
  ncselector_options zeroed = {0};
  if(!opts){
    opts = &zeroed;
  }
  unsigned itemcount = 0;
  if(opts->flags > 0){
    logwarn("provided unsupported flags %016" PRIx64, opts->flags);
  }
  if(opts->items){
    for(const struct ncselector_item* i = opts->items ; i->option ; ++i){
      ++itemcount;
    }
  }
  ncselector* ns = malloc(sizeof(*ns));
  if(ns == NULL){
    return NULL;
  }
  memset(ns, 0, sizeof(*ns));
  if(opts->defidx && opts->defidx >= itemcount){
    logerror("default index %u too large (%u items)", opts->defidx, itemcount);
    goto freeitems;
  }
  ns->title = opts->title ? strdup(opts->title) : NULL;
  ns->titlecols = opts->title ? ncstrwidth(opts->title, NULL, NULL) : 0;
  ns->secondary = opts->secondary ? strdup(opts->secondary) : NULL;
  ns->secondarycols = opts->secondary ? ncstrwidth(opts->secondary, NULL, NULL) : 0;
  ns->footer = opts->footer ? strdup(opts->footer) : NULL;
  ns->footercols = opts->footer ? ncstrwidth(opts->footer, NULL, NULL) : 0;
  ns->selected = opts->defidx;
  ns->longop = 0;
  if( (ns->maxdisplay = opts->maxdisplay) ){
    if(opts->defidx >= ns->maxdisplay){
      ns->startdisp = opts->defidx - ns->maxdisplay + 1;
    }else{
      ns->startdisp = 0;
    }
  }else{
    ns->startdisp = 0;
  }
  ns->longdesc = 0;
  ns->opchannels = opts->opchannels;
  ns->boxchannels = opts->boxchannels;
  ns->descchannels = opts->descchannels;
  ns->titlechannels = opts->titlechannels;
  ns->footchannels = opts->footchannels;
  ns->boxchannels = opts->boxchannels;
  ns->darrowy = ns->uarrowy = ns->arrowx = -1;
  if(itemcount){
    if(!(ns->items = malloc(sizeof(*ns->items) * itemcount))){
      goto freeitems;
    }
  }else{
    ns->items = NULL;
  }
  for(ns->itemcount = 0 ; ns->itemcount < itemcount ; ++ns->itemcount){
    const struct ncselector_item* src = &opts->items[ns->itemcount];
    int unsafe = ncstrwidth(src->option, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    unsigned cols = unsafe;
    ns->items[ns->itemcount].opcolumns = cols;
    if(cols > ns->longop){
      ns->longop = cols;
    }
    const char *desc = src->desc ? src->desc : "";
    unsafe = ncstrwidth(desc, NULL, NULL);
    if(unsafe < 0){
      goto freeitems;
    }
    cols = unsafe;
    ns->items[ns->itemcount].desccolumns = cols;
    if(cols > ns->longdesc){
      ns->longdesc = cols;
    }
    ns->items[ns->itemcount].option = strdup(src->option);
    ns->items[ns->itemcount].desc = strdup(desc);
    if(!(ns->items[ns->itemcount].desc && ns->items[ns->itemcount].option)){
      free(ns->items[ns->itemcount].option);
      free(ns->items[ns->itemcount].desc);
      goto freeitems;
    }
  }
  unsigned dimy, dimx;
  ns->ncp = n;
  ncselector_dim_yx(ns, &dimy, &dimx);
  if(ncplane_resize_simple(n, dimy, dimx)){
    goto freeitems;
  }
  if(ncplane_set_widget(ns->ncp, ns, (void(*)(void*))ncselector_destroy_internal)){
    goto freeitems;
  }
  ncselector_draw(ns); // deal with error here?
  return ns;
 
freeitems:
  while(ns->itemcount--){
    free(ns->items[ns->itemcount].option);
    free(ns->items[ns->itemcount].desc);
  }
  free(ns->items);
  free(ns->title); free(ns->secondary); free(ns->footer);
  free(ns);
  ncplane_destroy(n);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncselector_delitem()

API int ncselector_delitem	(	struct ncselector *	n,
		const char *	item
	)

Definition at line 427 of file selector.c.

                                                       {
  unsigned origdimy, origdimx;
  ncselector_dim_yx(n, &origdimy, &origdimx);
  bool found = false;
  int maxop = 0, maxdesc = 0;
  for(unsigned idx = 0 ; idx < n->itemcount ; ++idx){
    if(strcmp(n->items[idx].option, item) == 0){ // found it
      free(n->items[idx].option);
      free(n->items[idx].desc);
      if(idx < n->itemcount - 1){
        memmove(n->items + idx, n->items + idx + 1, sizeof(*n->items) * (n->itemcount - idx - 1));
      }else{
        if(idx){
          --n->selected;
        }
      }
      --n->itemcount;
      found = true;
      --idx;
    }else{
      int cols = ncstrwidth(n->items[idx].option, NULL, NULL);
      if(cols > maxop){
        maxop = cols;
      }
      cols = ncstrwidth(n->items[idx].desc, NULL, NULL);
      if(cols > maxdesc){
        maxdesc = cols;
      }
    }
  }
  if(found){
    n->longop = maxop;
    n->longdesc = maxdesc;
    unsigned dimy, dimx;
    ncselector_dim_yx(n, &dimy, &dimx);
    if(origdimx > dimx || origdimy > dimy){ // resize if too big
      ncplane_resize_simple(n->ncp, dimy, dimx);
    }
    return ncselector_draw(n);
  }
  return -1; // wasn't found
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncselector_destroy()

API bool API void ncselector_destroy	(	struct ncselector *	n,
		char **	item
	)

Definition at line 270 of file selector.c.

                                                   {
  if(n){
    if(item){
      *item = n->items[n->selected].option;
      n->items[n->selected].option = NULL;
    }
    ncselector_destroy_internal(n);
  }
}

Here is the caller graph for this function:

◆ ncselector_nextitem()

API const char * ncselector_nextitem ( struct ncselector * n )

Definition at line 500 of file selector.c.

                                              {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return NULL;
  }
  unsigned lastdisp = n->startdisp;
  lastdisp += n->maxdisplay && n->maxdisplay < n->itemcount ? n->maxdisplay : n->itemcount;
  --lastdisp;
  lastdisp %= n->itemcount;
  if(lastdisp == n->selected){
    if(++n->startdisp == n->itemcount){
      n->startdisp = 0;
    }
  }
  ++n->selected;
  if(n->selected == n->itemcount){
    n->selected = 0;
  }
  ret = n->items[n->selected].option;
  ncselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

◆ ncselector_offer_input()

API bool ncselector_offer_input	(	struct ncselector *	n,
		const ncinput *	nc
	)

◆ ncselector_plane()

API struct ncplane * ncselector_plane ( struct ncselector * n )

Definition at line 470 of file selector.c.

                                        {
  return n->ncp;
}

◆ ncselector_previtem()

API const char * ncselector_previtem ( struct ncselector * n )

Definition at line 481 of file selector.c.

                                              {
  const char* ret = NULL;
  if(n->itemcount == 0){
    return ret;
  }
  if(n->selected == n->startdisp){
    if(n->startdisp-- == 0){
      n->startdisp = n->itemcount - 1;
    }
  }
  if(n->selected == 0){
    n->selected = n->itemcount;
  }
  --n->selected;
  ret = n->items[n->selected].option;
  ncselector_draw(n);
  return ret;
}

Here is the caller graph for this function:

◆ ncselector_selected()

API const char * ncselector_selected ( const struct ncselector * n )

◆ ncstrwidth()

API int ncstrwidth	(	const char *	egcs,
		int *	validbytes,
		int *	validwidth
	)

Definition at line 3309 of file notcurses.c.

                                                                  {
  int cols;
  if(validwidth == NULL){
    validwidth = &cols;
  }
  *validwidth = 0;
  int bytes;
  if(validbytes == NULL){
    validbytes = &bytes;
  }
  *validbytes = 0;
  do{
    int thesecols, thesebytes;
    thesebytes = utf8_egc_len(egcs, &thesecols);
    if(thesebytes < 0){
      return -1;
    }
    egcs += thesebytes;
    *validbytes += thesebytes;
    *validwidth += thesecols;
  }while(*egcs);
  return *validwidth;
}

Here is the caller graph for this function:

◆ ncsubproc_createv()

API ALLOC struct ncsubproc * ncsubproc_createv	(	struct ncplane *	n,
		const ncsubproc_options *	opts,
		const char *	bin,
		const char *const	arg[],
		ncfdplane_callback	cbfxn,
		ncfdplane_done_cb	donecbfxn
	)

Definition at line 383 of file fd.c.

                                                                                   {
  return ncexecvpe(n, opts, 0, bin, (char* const *)arg, NULL, cbfxn, donecbfxn);
}

◆ ncsubproc_createvp()

API ALLOC struct ncsubproc * ncsubproc_createvp	(	struct ncplane *	n,
		const ncsubproc_options *	opts,
		const char *	bin,
		const char *const	arg[],
		ncfdplane_callback	cbfxn,
		ncfdplane_done_cb	donecbfxn
	)

Definition at line 389 of file fd.c.

                                                                                    {
  return ncexecvpe(n, opts, 1, bin, (char* const *)arg, NULL, cbfxn, donecbfxn);
}

◆ ncsubproc_createvpe()

API ALLOC struct ncsubproc * ncsubproc_createvpe	(	struct ncplane *	n,
		const ncsubproc_options *	opts,
		const char *	bin,
		const char *const	arg[],
		const char *const	env[],
		ncfdplane_callback	cbfxn,
		ncfdplane_done_cb	donecbfxn
	)

Definition at line 395 of file fd.c.

                                                                             {
  return ncexecvpe(n, opts, 1, bin, (char* const *)arg, (char* const*)env, cbfxn, donecbfxn);
}

◆ ncsubproc_destroy()

API int ncsubproc_destroy ( struct ncsubproc * n )

Definition at line 402 of file fd.c.

                                   {
  int ret = 0;
  if(n){
    void* vret = NULL;
//fprintf(stderr, "pid: %u pidfd: %d waittid: %u\n", n->pid, n->pidfd, n->waittid);
#ifndef __MINGW32__
#ifdef USING_PIDFD
    if(n->pidfd >= 0){
      loginfo("sending SIGKILL to pidfd %d", n->pidfd);
      if(syscall(__NR_pidfd_send_signal, n->pidfd, SIGKILL, NULL, 0)){
        kill(n->pid, SIGKILL);
      }
    }
#else
    pthread_mutex_lock(&n->lock);
    if(!n->waited){
      loginfo("sending SIGKILL to PID %d", n->pid);
      kill(n->pid, SIGKILL);
    }
    pthread_mutex_unlock(&n->lock);
#endif
#endif
    // the thread waits on the subprocess via pidfd (iff pidfd >= 0), and
    // then exits. don't try to cancel the thread in that case; rely instead on
    // killing the subprocess.
    if(n->pidfd < 0){
      pthread_cancel(n->nfp->tid);
      // shouldn't need a cancellation of waittid thanks to SIGKILL
      pthread_join(n->waittid, &vret);
    }
    if(vret == NULL){
      pthread_join(n->nfp->tid, &vret);
    }else{
      pthread_join(n->nfp->tid, NULL);
    }
    pthread_mutex_destroy(&n->lock);
    free(n);
    if(vret == NULL){
      ret = -1;
    }else if(vret != PTHREAD_CANCELED){
      ret = *(int*)vret;
      free(vret);
    }
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncsubproc_plane()

API struct ncplane * ncsubproc_plane ( struct ncsubproc * n )

Definition at line 449 of file fd.c.

                                      {
  return n->nfp->ncp;
}

Here is the caller graph for this function:

◆ nctab_cb()

API tabcb nctab_cb ( struct nctab * t )

Definition at line 124 of file tabbed.c.

                        {
  return t->cb;
}

◆ nctab_move()

API int nctab_move	(	struct nctabbed *	nt,
		struct nctab *	t,
		struct nctab *	after,
		struct nctab *	before
	)

◆ nctab_move_left()

API int API void API void nctab_move_left	(	struct nctabbed *	nt,
		struct nctab *	t
	)

◆ nctab_move_right()

API int API void nctab_move_right	(	struct nctabbed *	nt,
		struct nctab *	t
	)

◆ nctab_name()

API const char * nctab_name ( struct nctab * t )

Definition at line 128 of file tabbed.c.

                                {
  return t->name;
}

◆ nctab_name_width()

API int nctab_name_width ( struct nctab * t )

Definition at line 132 of file tabbed.c.

                              {
  return t->namecols;
}

◆ nctab_next()

API struct nctab * nctab_next ( struct nctab * t )

Definition at line 140 of file tabbed.c.

                           {
  return t->next;
}

◆ nctab_prev()

API struct nctab * nctab_prev ( struct nctab * t )

Definition at line 144 of file tabbed.c.

                           {
  return t->prev;
}

◆ nctab_set_cb()

API tabcb nctab_set_cb	(	struct nctab *	t,
		tabcb	newcb
	)

Definition at line 448 of file tabbed.c.

                                         {
  tabcb prevcb = t->cb;
  t->cb = newcb;
  return prevcb;
}

◆ nctab_set_name()

API int nctab_set_name	(	struct nctab *	t,
		const char *	newname
	)

◆ nctab_set_userptr()

API int API void * nctab_set_userptr	(	struct nctab *	t,
		void *	newopaque
	)

Definition at line 471 of file tabbed.c.

                                                  {
  void* prevcurry = t->curry;
  t->curry = newopaque;
  return prevcurry;
}

◆ nctab_userptr()

API void * nctab_userptr ( struct nctab * t )

Definition at line 136 of file tabbed.c.

                             {
  return t->curry;
}

◆ nctabbed_add()

API ALLOC struct nctab * nctabbed_add	(	struct nctabbed *	nt,
		struct nctab *	after,
		struct nctab *	before,
		tabcb	tcb,
		const char *	name,
		void *	opaque
	)

◆ nctabbed_channels()

API struct nctab API void nctabbed_channels	(	struct nctabbed *	nt,
		uint64_t *RESTRICT	hdrchan,
		uint64_t *RESTRICT	selchan,
		uint64_t *RESTRICT	sepchan
	)

Definition at line 390 of file tabbed.c.

                                                                              {
  if(hdrchan){
    memcpy(hdrchan, &nt->opts.hdrchan, sizeof(*hdrchan));
  }
  if(selchan){
    memcpy(selchan, &nt->opts.selchan, sizeof(*selchan));
  }
  if(sepchan){
    memcpy(sepchan, &nt->opts.sepchan, sizeof(*sepchan));
  }
}

◆ nctabbed_content_plane()

API struct ncplane * nctabbed_content_plane ( struct nctabbed * nt )

Definition at line 120 of file tabbed.c.

                                             {
  return nt->p;
}

◆ nctabbed_create()

API ALLOC struct nctabbed * nctabbed_create	(	struct ncplane *	n,
		const nctabbed_options *	opts
	)

Definition at line 148 of file tabbed.c.

                                                                    {
  nctabbed_options zeroed = {0};
  ncplane_options nopts = {0};
  unsigned nrows, ncols;
  nctabbed* nt = NULL;
  if(!topts){
    topts = &zeroed;
  }
  if(!nctabbed_validate_opts(topts)){
    goto err;
  }
  if((nt = malloc(sizeof(*nt))) == NULL){
    logerror("Couldn't allocate nctabbed");
    goto err;
  }
  nt->ncp = n;
  nt->leftmost = nt->selected = NULL;
  nt->tabcount = 0;
  nt->sepcols = 0;
  nt->opts.separator = NULL;
  nt->opts.selchan = topts->selchan;
  nt->opts.hdrchan = topts->hdrchan;
  nt->opts.sepchan = topts->sepchan;
  nt->opts.flags = topts->flags;
  if(topts->separator){
    if((nt->sepcols = ncstrwidth(topts->separator, NULL, NULL)) < 0){
      logerror("Separator string contains illegal characters");
      goto err;
    }
    if((nt->opts.separator = strdup(topts->separator)) == NULL){
      logerror("Couldn't allocate nctabbed separator");
      goto err;
    }
  }
  ncplane_dim_yx(n, &nrows, &ncols);
  if(topts->flags & NCTABBED_OPTION_BOTTOM){
    nopts.y = nopts.x = 0;
    nopts.cols = ncols;
    nopts.rows = nrows - 1;
    if((nt->p = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab content plane");
      goto err;
    }
    nopts.y = nrows - 2;
    nopts.rows = 1;
    if((nt->hp = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab headers plane");
      ncplane_destroy(nt->p);
      goto err;
    }
  }else{
    nopts.y = nopts.x = 0;
    nopts.cols = ncols;
    nopts.rows = 1;
    if((nt->hp = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab headers plane");
      goto err;
    }
    nopts.y = 1;
    nopts.rows = nrows - 1;
    if((nt->p = ncplane_create(n, &nopts)) == NULL){
      logerror("Couldn't create the tab content plane");
      ncplane_destroy(nt->hp);
      goto err;
    }
  }
  if(ncplane_set_widget(nt->ncp, nt, (void(*)(void*))nctabbed_destroy)){
    ncplane_destroy(nt->hp);
    ncplane_destroy(nt->p);
    goto err;
  }
  nctabbed_redraw(nt);
  return nt;
 
err:
  ncplane_destroy_family(n);
  if(nt){
    free(nt->opts.separator);
    free(nt);
  }
  return NULL;
}

Here is the call graph for this function:

◆ nctabbed_del()

API ALLOC struct nctab API int nctabbed_del	(	struct nctabbed *	nt,
		struct nctab *	t
	)

Definition at line 280 of file tabbed.c.

                                        {
  if(!t){
    logerror("Provided NULL nctab");
    return -1;
  }
  if(nt->tabcount == 1){
    nt->leftmost = nt->selected = NULL;
  }else{
    if(nt->selected == t){
      nt->selected = t->next;
    }
    if(nt->leftmost == t){
      nt->leftmost = t->next;
    }
    t->next->prev = t->prev;
    t->prev->next = t->next;
  }
  free(t->name);
  free(t);
  --nt->tabcount;
  return 0;
}

Here is the call graph for this function:

◆ nctabbed_destroy()

API void nctabbed_destroy ( struct nctabbed * nt )

Definition at line 411 of file tabbed.c.

                                   {
  if(!nt){
    return;
  }
  if(ncplane_set_widget(nt->ncp, NULL, NULL) == 0){
    nctab* t = nt->leftmost;
    nctab* tmp;
    if(t){
      t->prev->next = NULL;
      if(t->next){
        t->next->prev = NULL;
      }
    }
    while(t){
      tmp = t->next;
      free(t->name);
      free(t);
      t = tmp;
    }
    ncplane_destroy_family(nt->ncp);
    free(nt->opts.separator);
    free(nt);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nctabbed_ensure_selected_header_visible()

API void nctabbed_ensure_selected_header_visible ( struct nctabbed * nt )

Definition at line 69 of file tabbed.c.

                                                          {
  nctab* t = nt->leftmost;
  int cols = ncplane_dim_x(nt->hp);
  int takencols = 0;
  if(!t){
    return;
  }
//fprintf(stderr, "ensuring selected header visible\n");
  do{
    if(t == nt->selected){
      break;
    }
    takencols += t->namecols + nt->sepcols;
    if(takencols >= cols){
//fprintf(stderr, "not enough space, rotating\n");
      takencols -= nt->leftmost->namecols + nt->sepcols;
      nctabbed_rotate(nt, -1);
    }
    t = t->next;
//fprintf(stderr, "iteration over: takencols = %d, cols = %d\n", takencols, cols);
  }while(t != nt->leftmost);
//fprintf(stderr, "ensuring done\n");
}

Here is the call graph for this function:

◆ nctabbed_leftmost()

API struct nctab * nctabbed_leftmost ( struct nctabbed * nt )

Definition at line 108 of file tabbed.c.

                                      {
  return nt->leftmost;
}

◆ nctabbed_next()

API struct nctab * nctabbed_next ( struct nctabbed * nt )

Definition at line 368 of file tabbed.c.

                                  {
  if(nt->tabcount == 0){
    return NULL;
  }
  nt->selected = nt->selected->next;
  return nt->selected;
}

◆ nctabbed_plane()

API struct ncplane * nctabbed_plane ( struct nctabbed * nt )

Definition at line 116 of file tabbed.c.

                                     {
  return nt->ncp;
}

◆ nctabbed_prev()

API struct nctab * nctabbed_prev ( struct nctabbed * nt )

Definition at line 376 of file tabbed.c.

                                  {
  if(nt->tabcount == 0){
    return NULL;
  }
  nt->selected = nt->selected->prev;
  return nt->selected;
}

◆ nctabbed_redraw()

API void nctabbed_redraw ( struct nctabbed * nt )

Definition at line 23 of file tabbed.c.

                                  {
  nctab* t;
  unsigned drawn_cols = 0;
  unsigned rows, cols;
  if(nt->tabcount == 0){
    // no tabs = nothing to draw
    ncplane_erase(nt->hp);
    return;
  }
  // update sizes for planes
  ncplane_dim_yx(nt->ncp, &rows, &cols);
  if(nt->opts.flags & NCTABBED_OPTION_BOTTOM){
    ncplane_resize_simple(nt->hp, -1, cols);
    ncplane_resize_simple(nt->p, rows - 1, cols);
    ncplane_move_yx(nt->hp, rows - 2, 0);
  }else{
    ncplane_resize_simple(nt->hp, -1, cols);
    ncplane_resize_simple(nt->p, rows - 1, cols);
  }
  // the callback draws the tab contents
  if(nt->selected->cb){
    nt->selected->cb(nt->selected, nt->p, nt->selected->curry);
  }
  // now we draw the headers
  t = nt->leftmost;
  ncplane_erase(nt->hp);
  ncplane_set_channels(nt->hp, nt->opts.hdrchan);
  do{
    if(t == nt->selected){
      ncplane_set_channels(nt->hp, nt->opts.selchan);
      drawn_cols += ncplane_putstr(nt->hp, t->name);
      ncplane_set_channels(nt->hp, nt->opts.hdrchan);
    }else{
      drawn_cols += ncplane_putstr(nt->hp, t->name);
    }
    // avoid drawing the separator after the last tab, or when we
    // ran out of space, or when it's not set
    if((t->next != nt->leftmost || drawn_cols >= cols) && nt->opts.separator){
      ncplane_set_channels(nt->hp, nt->opts.sepchan);
      drawn_cols += ncplane_putstr(nt->hp, nt->opts.separator);
      ncplane_set_channels(nt->hp, nt->opts.hdrchan);
    }
    t = t->next;
  }while(t != nt->leftmost && drawn_cols < cols);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nctabbed_rotate()

API int API void API void API void nctabbed_rotate	(	struct nctabbed *	nt,
		int	amt
	)

Definition at line 356 of file tabbed.c.

                                           {
  if(amt > 0){
    for(int i = 0 ; i < amt ; ++i){
      nt->leftmost = nt->leftmost->prev;
    }
  }else{
    for(int i = 0 ; i < -amt ; ++i){
      nt->leftmost = nt->leftmost->next;
    }
  }
}

Here is the caller graph for this function:

◆ nctabbed_select()

API struct nctab * nctabbed_select	(	struct nctabbed *	nt,
		struct nctab *	t
	)

◆ nctabbed_selected()

API struct nctab * nctabbed_selected ( struct nctabbed * nt )

Definition at line 104 of file tabbed.c.

                                      {
  return nt->selected;
}

◆ nctabbed_separator()

API const char * nctabbed_separator ( struct nctabbed * nt )

Definition at line 403 of file tabbed.c.

                                            {
  return nt->opts.separator;
}

◆ nctabbed_separator_width()

API int nctabbed_separator_width ( struct nctabbed * nt )

Definition at line 407 of file tabbed.c.

                                          {
  return nt->sepcols;
}

◆ nctabbed_set_hdrchan()

API void nctabbed_set_hdrchan	(	struct nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 436 of file tabbed.c.

                                                      {
  nt->opts.hdrchan = chan;
}

◆ nctabbed_set_selchan()

API void nctabbed_set_selchan	(	struct nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 440 of file tabbed.c.

                                                      {
  nt->opts.selchan = chan;
}

◆ nctabbed_set_separator()

API int nctabbed_set_separator	(	struct nctabbed *	nt,
		const char *	separator
	)

◆ nctabbed_set_sepchan()

API void nctabbed_set_sepchan	(	struct nctabbed *	nt,
		uint64_t	chan
	)

Definition at line 444 of file tabbed.c.

                                                      {
  nt->opts.sepchan = chan;
}

◆ nctabbed_tabcount()

API int nctabbed_tabcount ( struct nctabbed * nt )

Definition at line 112 of file tabbed.c.

                                   {
  return nt->tabcount;
}

◆ nctablet_plane()

API struct ncplane * nctablet_plane ( struct nctablet * t )

Definition at line 799 of file reel.c.

                                    {
  return t->cbp;
}

◆ nctablet_userptr()

API void * nctablet_userptr ( struct nctablet * t )

Definition at line 893 of file reel.c.

                                   {
  return t->curry;
}

Here is the caller graph for this function:

◆ nctree_add()

API int nctree_add	(	struct nctree *	n,
		const unsigned *	spec,
		const struct nctree_item *	add
	)

◆ nctree_create()

API ALLOC struct nctree * nctree_create	(	struct ncplane *	n,
		const nctree_options *	opts
	)

◆ nctree_del()

API int API int nctree_del	(	struct nctree *	n,
		const unsigned *	spec
	)

◆ nctree_destroy()

API int API int API void nctree_destroy ( struct nctree * n )

Definition at line 294 of file tree.c.

                              {
  if(n){
    free_tree_items(&n->items);
    free(n->currentpath);
    free(n);
  }
}

Here is the call graph for this function:

◆ nctree_focused()

API bool API void * nctree_focused ( struct nctree * n )

Definition at line 606 of file tree.c.

                               {
  return n->curitem->curry;
}

◆ nctree_goto()

API void * nctree_goto	(	struct nctree *	n,
		const unsigned *	spec,
		int *	failspec
	)

Definition at line 610 of file tree.c.

                                                                 {
  n->activerow = 0;
  (void)spec;
  (void)failspec;
  // FIXME
  return NULL;
}

◆ nctree_next()

API void * nctree_next ( struct nctree * n )

Definition at line 396 of file tree.c.

                            {
  int rows = 0;
  if(n->curitem->ncp){
    rows = ncplane_dim_y(n->curitem->ncp);
  }
  nctree_int_item* tmp = nctree_next_internal(n, n->currentpath);
  if(tmp != n->curitem){
    n->curitem = tmp;
    n->activerow += rows;
    if(n->activerow >= (int)ncplane_dim_y(n->items.ncp)){
      n->activerow = ncplane_dim_y(n->items.ncp) - 1;
    }
  }
  return n->curitem->curry;
}

Here is the caller graph for this function:

◆ nctree_offer_input()

API bool nctree_offer_input	(	struct nctree *	n,
		const ncinput *	ni
	)

◆ nctree_plane()

API ALLOC struct nctree API struct ncplane * nctree_plane ( struct nctree * n )

Definition at line 303 of file tree.c.

                                {
  return n->items.ncp;
}

◆ nctree_prev()

API void * nctree_prev ( struct nctree * n )

Definition at line 349 of file tree.c.

                            {
  int rows = 0;
  if(n->curitem->ncp){
    rows = ncplane_dim_y(n->curitem->ncp);
  }
  nctree_int_item* tmp = nctree_prev_internal(n, n->currentpath);
  if(tmp != n->curitem){
    n->curitem = tmp;
    n->activerow -= rows;
    if(n->activerow < 0){
      n->activerow = 0;
    }
  }
  return n->curitem->curry;
}

Here is the caller graph for this function:

◆ nctree_redraw()

API int nctree_redraw ( struct nctree * n )

Definition at line 568 of file tree.c.

                            {
  unsigned* tmppath = malloc(sizeof(*tmppath) * (n->maxdepth + 2));
  if(tmppath == NULL){
    return -1;
  }
  memcpy(tmppath, n->currentpath, sizeof(*tmppath) * (n->maxdepth + 1));
  int ret = nctree_inner_redraw(n, tmppath);
  free(tmppath);
  return ret;
}

Here is the call graph for this function:

◆ ncuplot_add_sample()

API int ncuplot_add_sample	(	struct ncuplot *	n,
		uint64_t	x,
		uint64_t	y
	)

Definition at line 666 of file plot.c.

667 {

668 const int64_t diff = ncp->plot.slotx - x; /* amount behind */

◆ ncuplot_create()

API ALLOC struct ncuplot * ncuplot_create	(	struct ncplane *	n,
		const ncplot_options *	opts,
		uint64_t	miny,
		uint64_t	maxy
	)

Definition at line 647 of file plot.c.

                                        {
    return -1;
  }
  return 0;
}
 
/* x must be within n's window at this point */
static void
update_sample_uint64_t(ncuplot* ncp, int64_t x, uint64_t y, bool reset){
  const int64_t diff = ncp->plot.slotx - x; /* amount behind */
  const int idx = (ncp->plot.slotstart + ncp->plot.slotcount - diff) % ncp->plot.slotcount;
  if(reset){
    ncp->slots[idx] = y;
  }else{

Here is the caller graph for this function:

◆ ncuplot_destroy()

API void ncuplot_destroy ( struct ncuplot * n )

Definition at line 681 of file plot.c.

686 { // create_uint64_t() destroys n on error

687 ncuplot_destroy(ret);

ncuplot_destroy

void ncuplot_destroy(ncuplot *n)

Definition plot.c:681

Here is the caller graph for this function:

◆ ncuplot_plane()

API struct ncplane * ncuplot_plane ( struct ncuplot * n )

Definition at line 662 of file plot.c.

◆ ncuplot_sample()

API int ncuplot_sample	(	const struct ncuplot *	n,
		uint64_t	x,
		uint64_t *	y
	)

◆ ncuplot_set_sample()

API int ncuplot_set_sample	(	struct ncuplot *	n,
		uint64_t	x,
		uint64_t	y
	)

Definition at line 670 of file plot.c.

           {
    ncp->slots[idx] = y;
  }else{
    ncp->slots[idx] += y;
  }
}
 
// takes ownership of n on all paths
ncuplot* ncuplot_create(ncplane* n, const ncplot_options* opts, uint64_t miny, uint64_t maxy){
  ncuplot* ret = malloc(sizeof(*ret));

◆ ncvisual_at_yx()

API int ncvisual_at_yx	(	const struct ncvisual *	n,
		unsigned	y,
		unsigned	x,
		uint32_t *	pixel
	)

◆ ncvisual_blit()

API struct ncplane * ncvisual_blit	(	struct notcurses *	nc,
		struct ncvisual *	ncv,
		const struct ncvisual_options *	vopts
	)

Definition at line 1136 of file visual.c.

                                                                                          {
//fprintf(stderr, "%p tacache: %p\n", n, n->tacache);
  struct ncvisual_options fakevopts;
  if(vopts == NULL){
    memset(&fakevopts, 0, sizeof(fakevopts));
    vopts = &fakevopts;
  }
  loginfo("inblit %dx%d %d@%d %dx%d @ %dx%d %p", ncv->pixy, ncv->pixx, vopts->y, vopts->x,
          vopts->leny, vopts->lenx, vopts->begy, vopts->begx, vopts->n);
  ncvgeom geom;
  const struct blitset* bset;
  unsigned disppxy, disppxx, outy, outx;
  int placey, placex;
  if(ncvisual_geom_inner(&nc->tcache, ncv, vopts, &geom, &bset,
                         &disppxy, &disppxx, &outy, &outx,
                         &placey, &placex)){
    // ncvisual_blitset_geom() emits its own diagnostics, no need for an error here
    return NULL;
  }
  ncplane* n = vopts->n;
  uint32_t transcolor = 0;
  if(vopts->flags & NCVISUAL_OPTION_ADDALPHA){
    transcolor = 0x1000000ull | vopts->transcolor;
  }
  ncplane* createdn = NULL; // to destroy on error
  if(n == NULL || (vopts->flags & NCVISUAL_OPTION_CHILDPLANE)){ // create plane
    struct ncplane_options nopts = {
      .y = placey,
      .x = placex,
      .rows = geom.rcelly,
      .cols = geom.rcellx,
      .userptr = NULL,
      .name = geom.blitter == NCBLIT_PIXEL ? "bmap" : "cvis",
      .resizecb = NULL,
      .flags = 0,
    };
    if(vopts->flags & NCVISUAL_OPTION_HORALIGNED){
      nopts.flags |= NCPLANE_OPTION_HORALIGNED;
      nopts.x = vopts->x;
    }
    if(vopts->flags & NCVISUAL_OPTION_VERALIGNED){
      nopts.flags |= NCPLANE_OPTION_VERALIGNED;
      nopts.y = vopts->y;
    }
    loginfo("placing new plane: %d/%d @ %d/%d 0x%016" PRIx64, nopts.rows, nopts.cols, nopts.y, nopts.x, nopts.flags);
    if(n == NULL){
      n = ncpile_create(nc, &nopts);
    }else{
      n = ncplane_create(n, &nopts);
    }
    if((createdn = n) == NULL){
      return NULL;
    }
    placey = 0;
    placex = 0;
  }
  logdebug("blit to plane %p at %d/%d geom %dx%d", n, ncplane_abs_y(n), ncplane_abs_x(n), ncplane_dim_y(n), ncplane_dim_x(n));
  if(geom.blitter != NCBLIT_PIXEL){
    n = ncvisual_render_cells(ncv, bset, placey, placex,
                              &geom, n, vopts->flags, transcolor);
  }else{
    n = ncvisual_render_pixels(nc, ncv, bset, placey, placex,
                               &geom, n,
                               vopts->flags, transcolor,
                               vopts->pxoffy, vopts->pxoffx);
  }
  if(n == NULL){
    ncplane_destroy(createdn);
  }
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_decode()

API int ncvisual_decode ( struct ncvisual * nc )

Definition at line 39 of file visual.c.

                                 {
  if(!visual_implementation->visual_decode){
    return -1;
  }
  return visual_implementation->visual_decode(nc);
}

Here is the caller graph for this function:

◆ ncvisual_decode_loop()

API int ncvisual_decode_loop ( struct ncvisual * nc )

Definition at line 46 of file visual.c.

                                      {
  if(!visual_implementation->visual_decode_loop){
    return -1;
  }
  return visual_implementation->visual_decode_loop(nc);
}

Here is the caller graph for this function:

◆ ncvisual_destroy()

API void ncvisual_destroy ( struct ncvisual * ncv )

Definition at line 1225 of file visual.c.

                                    {
  if(ncv){
    if(visual_implementation->visual_destroy == NULL){
      if(ncv->owndata){
        free(ncv->data);
      }
      free(ncv);
    }else{
      visual_implementation->visual_destroy(ncv);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_from_bgra()

API ALLOC struct ncvisual * ncvisual_from_bgra	(	const void *	bgra,
		int	rows,
		int	rowstride,
		int	cols
	)

Definition at line 891 of file visual.c.

                                                                                 {
  if(rowstride % 4){
    logerror("rowstride %d not a multiple of 4", rowstride);
    return NULL;
  }
  if(rows <= 0 || cols <= 0 || rowstride < cols * 4){
    logerror("illegal bgra geometry");
    return NULL;
  }
  ncvisual* ncv = ncvisual_create();
  if(ncv){
    ncv->rowstride = pad_for_image(rowstride, cols);
    ncv->pixx = cols;
    ncv->pixy = rows;
    uint32_t* data = malloc(ncv->rowstride * ncv->pixy);
    if(data == NULL){
      ncvisual_destroy(ncv);
      return NULL;
    }
    for(int y = 0 ; y < rows ; ++y){
      for(int x = 0 ; x < cols ; ++x){
        uint32_t src;
        memcpy(&src, (const char*)bgra + y * rowstride + x * 4, 4);
        uint32_t* dst = &data[ncv->rowstride * y / 4 + x];
        ncpixel_set_a(dst, ncpixel_a(src));
        ncpixel_set_r(dst, ncpixel_b(src));
        ncpixel_set_g(dst, ncpixel_g(src));
        ncpixel_set_b(dst, ncpixel_r(src));
//fprintf(stderr, "BGRA PIXEL: %02x%02x%02x%02x RGBA result: %02x%02x%02x%02x\n", ((const char*)&src)[0], ((const char*)&src)[1], ((const char*)&src)[2], ((const char*)&src)[3], ((const char*)dst)[0], ((const char*)dst)[1], ((const char*)dst)[2], ((const char*)dst)[3]);
      }
    }
    ncvisual_set_data(ncv, data, true);
    ncvisual_details_seed(ncv);
  }
  return ncv;
}

Here is the call graph for this function:

◆ ncvisual_from_file()

API ALLOC struct ncvisual * ncvisual_from_file ( const char * file )

Definition at line 53 of file visual.c.

                                                  {
  if(!visual_implementation->visual_from_file){
    return NULL;
  }
  ncvisual* n = visual_implementation->visual_from_file(filename);
  if(n == NULL){
    logerror("error loading %s", filename);
  }
  return n;
}

Here is the caller graph for this function:

◆ ncvisual_from_palidx()

API ALLOC struct ncvisual * ncvisual_from_palidx	(	const void *	data,
		int	rows,
		int	rowstride,
		int	cols,
		int	palsize,
		int	pstride,
		const uint32_t *	palette
	)

◆ ncvisual_from_plane()

API ALLOC struct ncvisual API ALLOC struct ncvisual * ncvisual_from_plane	(	const struct ncplane *	n,
		ncblitter_e	blit,
		int	begy,
		int	begx,
		unsigned	leny,
		unsigned	lenx
	)

◆ ncvisual_from_rgb_loose()

API ALLOC struct ncvisual * ncvisual_from_rgb_loose	(	const void *	rgba,
		int	rows,
		int	rowstride,
		int	cols,
		int	alpha
	)

Definition at line 858 of file visual.c.

                                                      {
  if(rowstride % 4){
    logerror("rowstride %d not a multiple of 4", rowstride);
    return NULL;
  }
  if(rows <= 0 || cols <= 0 || rowstride < cols * 4){
    logerror("illegal packed rgb geometry");
    return NULL;
  }
  ncvisual* ncv = ncvisual_create();
  if(ncv){
    ncv->rowstride = pad_for_image(cols * 4, cols);
    ncv->pixx = cols;
    ncv->pixy = rows;
    uint32_t* data = malloc(ncv->rowstride * ncv->pixy);
    if(data == NULL){
      ncvisual_destroy(ncv);
      return NULL;
    }
    for(int y = 0 ; y < rows ; ++y){
//fprintf(stderr, "ROWS: %d STRIDE: %d (%d) COLS: %d %08x\n", ncv->pixy, ncv->rowstride, ncv->rowstride / 4, cols, data[ncv->rowstride * y / 4]);
      memcpy(data + (ncv->rowstride * y) / 4, (const char*)rgba + rowstride * y, rowstride);
      for(int x = 0 ; x < cols ; ++x){
        ncpixel_set_a(&data[y * ncv->rowstride / 4 + x], alpha);
      }
    }
    ncvisual_set_data(ncv, data, true);
    ncvisual_details_seed(ncv);
  }
  return ncv;
}

Here is the call graph for this function:

◆ ncvisual_from_rgb_packed()

API ALLOC struct ncvisual * ncvisual_from_rgb_packed	(	const void *	rgba,
		int	rows,
		int	rowstride,
		int	cols,
		int	alpha
	)

Definition at line 817 of file visual.c.

                                                       {
  if(rowstride % 3){
    logerror("rowstride %d not a multiple of 3", rowstride);
    return NULL;
  }
  if(rows <= 0 || cols <= 0 || rowstride < cols * 3){
    logerror("illegal packed rgb geometry");
    return NULL;
  }
  ncvisual* ncv = ncvisual_create();
  if(ncv){
    ncv->rowstride = pad_for_image(cols * 4, cols);
    ncv->pixx = cols;
    ncv->pixy = rows;
    uint32_t* data = malloc(ncv->rowstride * ncv->pixy);
    if(data == NULL){
      ncvisual_destroy(ncv);
      return NULL;
    }
    const unsigned char* src = rgba;
    for(int y = 0 ; y < rows ; ++y){
//fprintf(stderr, "ROWS: %d STRIDE: %d (%d) COLS: %d %08x\n", ncv->pixy, ncv->rowstride, ncv->rowstride / 4, cols, data[ncv->rowstride * y / 4]);
      for(int x = 0 ; x < cols ; ++x){
        unsigned char r, g, b;
        memcpy(&r, src + rowstride * y + 3 * x, 1);
        memcpy(&g, src + rowstride * y + 3 * x + 1, 1);
        memcpy(&b, src + rowstride * y + 3 * x + 2, 1);
        ncpixel_set_a(&data[y * ncv->rowstride / 4 + x], alpha);
        ncpixel_set_r(&data[y * ncv->rowstride / 4 + x], r);
        ncpixel_set_g(&data[y * ncv->rowstride / 4 + x], g);
        ncpixel_set_b(&data[y * ncv->rowstride / 4 + x], b);
//fprintf(stderr, "RGBA: 0x%02x 0x%02x 0x%02x 0x%02x\n", r, g, b, alpha);
      }
    }
    ncvisual_set_data(ncv, data, true);
    ncvisual_details_seed(ncv);
  }
  return ncv;
}

Here is the call graph for this function:

◆ ncvisual_from_rgba()

API ALLOC struct ncvisual * ncvisual_from_rgba	(	const void *	rgba,
		int	rows,
		int	rowstride,
		int	cols
	)

Definition at line 776 of file visual.c.

                                                                                 {
  if(rowstride % 4){
    logerror("rowstride %d not a multiple of 4", rowstride);
    return NULL;
  }
  if(rowstride * 4 < cols || cols <= 0 || rows <= 0){
    logerror("invalid rowstride or geometry");
    return NULL;
  }
  ncvisual* ncv = ncvisual_create();
  if(ncv){
    // ffmpeg needs inputs with rows aligned on 192-byte boundaries
    ncv->rowstride = pad_for_image(rowstride, cols);
    ncv->pixx = cols;
    ncv->pixy = rows;
    uint32_t* data = malloc(ncv->rowstride * ncv->pixy);
    if(data == NULL){
      ncvisual_destroy(ncv);
      return NULL;
    }
    for(int y = 0 ; y < rows ; ++y){
//fprintf(stderr, "ROWS: %d STRIDE: %d (%d) COLS: %d %08x\n", ncv->pixy, ncv->rowstride, rowstride, cols, data[ncv->rowstride * y / 4]);
      memcpy(data + (ncv->rowstride * y) / 4, (const char*)rgba + rowstride * y, rowstride);
    }
    ncvisual_set_data(ncv, data, true);
    ncvisual_details_seed(ncv);
  }
  return ncv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_from_sixel()

API ALLOC struct ncvisual * ncvisual_from_sixel	(	const char *	s,
		unsigned	leny,
		unsigned	lenx
	)

Definition at line 806 of file visual.c.

                                                                          {
  uint32_t* rgba = ncsixel_as_rgba(s, leny, lenx);
  if(rgba == NULL){
    logerror("failed converting sixel to rgba");
    return NULL;
  }
  ncvisual* ncv = ncvisual_from_rgba(rgba, leny, lenx * sizeof(*rgba), lenx);
  free(rgba);
  return ncv;
}

Here is the call graph for this function:

◆ ncvisual_geom()

API int ncvisual_geom	(	const struct notcurses *	nc,
		const struct ncvisual *	n,
		const struct ncvisual_options *	vopts,
		ncvgeom *	geom
	)

◆ ncvisual_media_defblitter()

API ALLOC struct ncplane API ncblitter_e ncvisual_media_defblitter	(	const struct notcurses *	nc,
		ncscale_e	scale
	)

◆ ncvisual_polyfill_yx()

API int ncvisual_polyfill_yx	(	struct ncvisual *	n,
		unsigned	y,
		unsigned	x,
		uint32_t	rgba
	)

Definition at line 1344 of file visual.c.

                                                                            {
  if(y >= n->pixy){
    logerror("invalid coordinates %u/%u", y, x);
    return -1;
  }
  if(x >= n->pixx){
    logerror("invalid coordinates %u/%u", y, x);
    return -1;
  }
  uint32_t* pixel = &n->data[y * (n->rowstride / 4) + x];
  return ncvisual_polyfill_core(n, y, x, rgba, *pixel);
}

Here is the caller graph for this function:

◆ ncvisual_resize()

API int ncvisual_resize	(	struct ncvisual *	n,
		int	rows,
		int	cols
	)

Definition at line 982 of file visual.c.

                                                    {
  if(!visual_implementation->visual_resize){
    return ncvisual_resize_noninterpolative(n, rows, cols);
  }
  if(visual_implementation->visual_resize(n, rows, cols)){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

◆ ncvisual_resize_noninterpolative()

API int ncvisual_resize_noninterpolative	(	struct ncvisual *	n,
		int	rows,
		int	cols
	)

Definition at line 992 of file visual.c.

                                                                     {
  size_t dstride = pad_for_image(cols * 4, cols);
  uint32_t* r = resize_bitmap(n->data, n->pixy, n->pixx, n->rowstride,
                              rows, cols, dstride);
  if(r == NULL){
    return -1;
  }
  ncvisual_set_data(n, r, true);
  n->rowstride = dstride;
  n->pixy = rows;
  n->pixx = cols;
  ncvisual_details_seed(n);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_rotate()

API int ncvisual_rotate	(	struct ncvisual *	n,
		double	rads
	)

Definition at line 704 of file visual.c.

                                               {
  assert(ncv->rowstride / 4 >= ncv->pixx);
  rads = -rads; // we're a left-handed Cartesian
  int centy, centx;
  ncvisual_center(ncv, &centy, &centx); // pixel center (center of 'data')
  double stheta, ctheta; // sine, cosine
  stheta = sin(rads);
  ctheta = cos(rads);
  // bounding box for real data within the ncvisual. we must only resize to
  // accommodate real data, lest we grow without band as we rotate.
  // see https://github.com/dankamongmen/notcurses/issues/599.
  int bby = ncv->pixy;
  int bbx = ncv->pixx;
  int bboffy = 0;
  int bboffx = 0;
  if(ncvisual_bounding_box(ncv, &bby, &bbx, &bboffy, &bboffx) <= 0){
    logerror("couldn't find a bounding box");
    return -1;
  }
  int bbarea;
  bbarea = rotate_bounding_box(stheta, ctheta, &bby, &bbx, &bboffy, &bboffx);
  if(bbarea <= 0){
    logerror("couldn't rotate the visual (%d, %d, %d, %d)", bby, bbx, bboffy, bboffx);
    return -1;
  }
  int bbcentx = bbx, bbcenty = bby;
  center_box(&bbcenty, &bbcentx);
//fprintf(stderr, "stride: %d height: %d width: %d\n", ncv->rowstride, ncv->pixy, ncv->pixx);
  assert(ncv->rowstride / 4 >= ncv->pixx);
  uint32_t* data = malloc(bbarea * 4);
  if(data == NULL){
    return -1;
  }
  memset(data, 0, bbarea * 4);
//fprintf(stderr, "bbarea: %d bby: %d bbx: %d centy: %d centx: %d bbcenty: %d bbcentx: %d\n", bbarea, bby, bbx, centy, centx, bbcenty, bbcentx);
  for(unsigned y = 0 ; y < ncv->pixy ; ++y){
      for(unsigned x = 0 ; x < ncv->pixx ; ++x){
      int targx = x, targy = y;
      rotate_point(&targy, &targx, stheta, ctheta, centy, centx);
      if(targx > bboffx && targy > bboffy){
        const int deconvx = targx - bboffx;
        const int deconvy = targy - bboffy;
        if(deconvy < bby && deconvx < bbx){
          data[deconvy * bbx + deconvx] = ncv->data[y * (ncv->rowstride / 4) + x];
        }
      }
//fprintf(stderr, "CW: %d/%d (%08x) -> %d/%d (stride: %d)\n", y, x, ncv->data[y * (ncv->rowstride / 4) + x], targy, targx, ncv->rowstride);
//fprintf(stderr, "wrote %08x to %d (%d)\n", data[targy * ncv->pixy + targx], targy * ncv->pixy + targx, (targy * ncv->pixy + targx) * 4);
    }
  }
  ncvisual_set_data(ncv, data, true);
  ncv->pixx = bbx;
  ncv->pixy = bby;
  ncv->rowstride = bbx * 4;
  ncvisual_details_seed(ncv);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_set_yx()

API int API int ncvisual_set_yx	(	const struct ncvisual *	n,
		unsigned	y,
		unsigned	x,
		uint32_t	pixel
	)

Definition at line 1259 of file visual.c.

                                                                                     {
  if(y >= n->pixy){
    logerror("invalid coordinates %u/%u", y, x);
    return -1;
  }
  if(x >= n->pixx){
    logerror("invalid coordinates %u/%u", y, x);
    return -1;
  }
  n->data[y * (n->rowstride / 4) + x] = pixel;
  return 0;
}

Here is the caller graph for this function:

◆ ncvisual_simple_streamer()

API int ncvisual_simple_streamer	(	struct ncvisual *	ncv,
		struct ncvisual_options *	vopts,
		const struct timespec *	tspec,
		void *	curry
	)

Definition at line 1238 of file visual.c.

                                                                       {
  struct ncplane* subtitle = NULL;
  int ret = 0;
  if(curry){
    // FIXME improve this hrmmmmm
    ncplane* subncp = curry;
    if(subncp->blist){
      ncplane_destroy(subncp->blist);
      subncp->blist = NULL;
    }
    subtitle = ncvisual_subtitle_plane(subncp, ncv);
  }
  if(notcurses_render(ncplane_notcurses(vopts->n))){
    return -1;
  }
  clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, tspec, NULL);
  ncplane_destroy(subtitle);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ncvisual_stream()

API int ncvisual_stream	(	struct notcurses *	nc,
		struct ncvisual *	ncv,
		float	timescale,
		ncstreamcb	streamer,
		const struct ncvisual_options *	vopts,
		void *	curry
	)

◆ ncvisual_subtitle_plane()

API ALLOC struct ncplane * ncvisual_subtitle_plane	(	struct ncplane *	parent,
		const struct ncvisual *	ncv
	)

◆ notcurses_accountname()

API ALLOC char * notcurses_accountname ( void )

Definition at line 35 of file util.c.

                                 {
#ifndef __MINGW32__
  const char* un;
  if( (un = getenv("LOGNAME")) ){
    return strdup(un);
  }
  uid_t uid = getuid();
  struct passwd* p = getpwuid(uid);
  if(p == NULL){
    return NULL;
  }
  return strdup(p->pw_name);
#else
  DWORD unlen = UNLEN + 1;
  char* un = malloc(unlen);
  if(un == NULL){
    return NULL;
  }
  if(!GetUserNameExA(NameSamCompatible, un, &unlen)){
    logerror("couldn't get user name");
    free(un);
    return NULL;
  }
  return un;
#endif
}

Here is the call graph for this function:

◆ notcurses_at_yx()

API char * notcurses_at_yx	(	struct notcurses *	nc,
		unsigned	yoff,
		unsigned	xoff,
		uint16_t *	stylemask,
		uint64_t *	channels
	)

Definition at line 1625 of file render.c.

                                                                                                           {
  if(nc->lastframe == NULL){
    logerror("haven't yet rendered");
    return NULL;
  }
  if(yoff >= nc->lfdimy){
    logerror("invalid coordinates: %u/%u", yoff, xoff);
    return NULL;
  }
  if(xoff >= nc->lfdimx){
    logerror("invalid coordinates: %u/%u", yoff, xoff);
    return NULL;
  }
  const nccell* srccell = &nc->lastframe[yoff * nc->lfdimx + xoff];
  if(nccell_wide_right_p(srccell)){
    return notcurses_at_yx(nc, yoff, xoff - 1, stylemask, channels);
  }
  if(stylemask){
    *stylemask = srccell->stylemask;
  }
  if(channels){
    *channels = srccell->channels;
  }
//fprintf(stderr, "COPYING: %d from %p\n", srccell->gcluster, &nc->pool);
  return pool_egc_copy(&nc->pool, srccell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notcurses_canopen_images()

API bool notcurses_canopen_images ( const struct notcurses * nc )

◆ notcurses_canopen_videos()

API bool notcurses_canopen_videos ( const struct notcurses * nc )

◆ notcurses_capabilities()

API const nccapabilities * notcurses_capabilities ( const struct notcurses * n )

◆ notcurses_check_pixel_support()

API ncpixelimpl_e notcurses_check_pixel_support ( const struct notcurses * nc )

◆ notcurses_core_init()

API ALLOC struct notcurses * notcurses_core_init	(	const notcurses_options *	opts,
		FILE *	fp
	)

Definition at line 1242 of file notcurses.c.

                                                                          {
  if(outfp == NULL){
    outfp = stdout;
  }
  unsigned utf8;
  // ret comes out entirely zero-initialized
  notcurses* ret = notcurses_early_init(opts, outfp, &utf8);
  if(ret == NULL){
    return NULL;
  }
  // the fbuf is needed by notcurses_stop_minimal, so this must be done
  // before registering fatal signal handlers.
  if(fbuf_init(&ret->rstate.f)){
    pthread_mutex_destroy(&ret->pilelock);
    pthread_mutex_destroy(&ret->stats.lock);
    free(ret);
    return NULL;
  }
  if(setup_signals(ret, (ret->flags & NCOPTION_NO_QUIT_SIGHANDLERS),
                   (ret->flags & NCOPTION_NO_WINCH_SIGHANDLER),
                   notcurses_stop_minimal)){
    fbuf_free(&ret->rstate.f);
    pthread_mutex_destroy(&ret->pilelock);
    pthread_mutex_destroy(&ret->stats.lock);
    free(ret);
    return NULL;
  }
  // don't set loglevel until we've acquired the signal handler, lest we
  // change the loglevel out from under a running instance
  loglevel = ret->loglevel;
  ret->rstate.logendy = -1;
  ret->rstate.logendx = -1;
  ret->rstate.x = ret->rstate.y = -1;
  int fakecursory = ret->rstate.logendy;
  int fakecursorx = ret->rstate.logendx;
  int* cursory = ret->flags & NCOPTION_PRESERVE_CURSOR ?
                  &ret->rstate.logendy : &fakecursory;
  int* cursorx = ret->flags & NCOPTION_PRESERVE_CURSOR ?
                  &ret->rstate.logendx : &fakecursorx;
  if(interrogate_terminfo(&ret->tcache, ret->ttyfp, utf8,
                          ret->flags & NCOPTION_NO_ALTERNATE_SCREEN, 0,
                          ret->flags & NCOPTION_NO_FONT_CHANGES,
                          cursory, cursorx, &ret->stats,
                          ret->margin_l, ret->margin_t,
                          ret->margin_r, ret->margin_b,
                          ret->flags & NCOPTION_DRAIN_INPUT)){
    void* altstack;
    fbuf_free(&ret->rstate.f);
    pthread_mutex_destroy(&ret->pilelock);
    pthread_mutex_destroy(&ret->stats.lock);
    drop_signals(ret, &altstack);
    free(ret);
    free(altstack);
    return NULL;
  }
  if(ret->tcache.maxpaletteread > -1){
    memcpy(ret->palette.chans, ret->tcache.originalpalette.chans,
           sizeof(*ret->palette.chans) * (ret->tcache.maxpaletteread + 1));
  }
  if((ret->flags & NCOPTION_PRESERVE_CURSOR) ||
      (!(ret->flags & NCOPTION_SUPPRESS_BANNERS))){
    // the u7 led the queries so that we would get a cursor position
    // unaffected by any query spill (unconsumed control sequences). move
    // us back to that location, in case there was any such spillage.
    if(*cursory < 0 || *cursorx < 0){
      unsigned cy, cx;
      if(locate_cursor(&ret->tcache, &cy, &cx)){
        logwarn("couldn't preserve cursor");
      }else{
        *cursory = cy;
        *cursorx = cx;
      }
    }
    if(*cursory >= 0 && *cursorx >= 0){
      if(goto_location(ret, &ret->rstate.f, *cursory, *cursorx, NULL)){
        goto err;
      }
    }
  }
  unsigned dimy, dimx, cgeo, pgeo; // latter two are don't-cares
  if(update_term_dimensions(&dimy, &dimx, &ret->tcache, ret->margin_b, &cgeo, &pgeo)){
    goto err;
  }
  if(ncvisual_init(ret->loglevel)){
    goto err;
  }
  ret->stdplane = NULL;
  if((ret->stdplane = create_initial_ncplane(ret, dimy, dimx)) == NULL){
    logpanic("couldn't create the initial plane (bad margins?)");
    goto err;
  }
  if(ret->flags & NCOPTION_SCROLLING){
    ncplane_set_scrolling(ret->stdplane, true);
  }
  reset_term_attributes(&ret->tcache, &ret->rstate.f);
  const char* cinvis = get_escape(&ret->tcache, ESCAPE_CIVIS);
  if(cinvis && fbuf_emit(&ret->rstate.f, cinvis) < 0){
    free_plane(ret->stdplane);
    goto err;
  }
  const char* pushcolors = get_escape(&ret->tcache, ESCAPE_SAVECOLORS);
  if(pushcolors && fbuf_emit(&ret->rstate.f, pushcolors)){
    free_plane(ret->stdplane);
    goto err;
  }
  init_banner(ret, &ret->rstate.f);
  if(fbuf_flush(&ret->rstate.f, ret->ttyfp) < 0){
    free_plane(ret->stdplane);
    goto err;
  }
  if(ret->rstate.logendy >= 0){ // if either is set, both are
    if(!(ret->flags & NCOPTION_SUPPRESS_BANNERS) && ret->tcache.ttyfd >= 0){
      unsigned uendy, uendx;
      if(locate_cursor(&ret->tcache, &uendy, &uendx)){
        free_plane(ret->stdplane);
        goto err;
      }
      ret->rstate.logendy = uendy;
      ret->rstate.logendx = uendx;
    }
    if(ret->flags & NCOPTION_PRESERVE_CURSOR){
      ncplane_cursor_move_yx(ret->stdplane, ret->rstate.logendy, ret->rstate.logendx);
    }
  }
  if(!(ret->flags & NCOPTION_NO_ALTERNATE_SCREEN)){
    // perform an explicit clear since the alternate screen was requested
    // (smcup *might* clear, but who knows? and it might not have been
    // available in any case).
    if(clear_and_home(ret, &ret->tcache, &ret->rstate.f)){
      goto err;
    }
    // no need to reestablish a preserved cursor -- that only affects the
    // standard plane, not the physical cursor that was just disrupted.
  }
  // the sprite clear ought take place within the alternate screen, if it's
  // being used.
  if(!(ret->flags & NCOPTION_NO_CLEAR_BITMAPS)){
    if(sprite_clear_all(&ret->tcache, &ret->rstate.f)){
      goto err;
    }
  }
  if(ret->rstate.f.used){
    if(fbuf_flush(&ret->rstate.f, ret->ttyfp) < 0){
      goto err;
    }
  }
  return ret;
 
err:{
    void* altstack;
    logpanic("alas, you will not be going to space today.");
    notcurses_stop_minimal(ret, &altstack);
    fbuf_free(&ret->rstate.f);
    if(ret->tcache.ttyfd >= 0 && ret->tcache.tpreserved){
      (void)tcsetattr(ret->tcache.ttyfd, TCSAFLUSH, ret->tcache.tpreserved);
      free(ret->tcache.tpreserved);
    }
    del_curterm(cur_term);
    pthread_mutex_destroy(&ret->stats.lock);
    pthread_mutex_destroy(&ret->pilelock);
    free(ret);
    free(altstack);
    return NULL;
  }
}

Here is the call graph for this function:

◆ notcurses_cursor_disable()

API int notcurses_cursor_disable ( struct notcurses * nc )

Definition at line 1772 of file render.c.

                                           {
  if(nc->cursorx < 0 || nc->cursory < 0){
    logerror("cursor is not enabled");
    return -1;
  }
  const char* cinvis = get_escape(&nc->tcache, ESCAPE_CIVIS);
  if(cinvis){
    if(!tty_emit(cinvis, nc->tcache.ttyfd) && !ncflush(nc->ttyfp)){
      nc->cursory = -1;
      nc->cursorx = -1;
      return 0;
    }
  }
  return -1;
}

Here is the caller graph for this function:

◆ notcurses_cursor_enable()

API int notcurses_cursor_enable	(	struct notcurses *	nc,
		int	y,
		int	x
	)

Definition at line 1738 of file render.c.

                                                        {
  if(y < 0 || x < 0){
    logerror("illegal cursor placement: %d, %d", y, x);
    return -1;
  }
  // if we're already at the demanded location, we must already be visible, and
  // we needn't move the cursor -- return success immediately.
  if(nc->cursory == y && nc->cursorx == x){
    return 0;
  }
  fbuf f = {0};
  if(fbuf_init_small(&f)){
    return -1;
  }
  // updates nc->rstate.cursor{y,x}
  if(goto_location(nc, &f, y + nc->margin_t, x + nc->margin_l, nc->rstate.lastsrcp)){
    fbuf_free(&f);
    return -1;
  }
  if(nc->cursory < 0){ // we weren't visible before, need cnorm
    const char* cnorm = get_escape(&nc->tcache, ESCAPE_CNORM);
    if(!cnorm || fbuf_emit(&f, cnorm)){
      fbuf_free(&f);
      return -1;
    }
  }
  if(fbuf_finalize(&f, nc->ttyfp)){
    return -1;
  }
  nc->cursory = y;
  nc->cursorx = x;
  return 0;
}

Here is the caller graph for this function:

◆ notcurses_cursor_yx()

API int notcurses_cursor_yx	(	const struct notcurses *	nc,
		int *	y,
		int *	x
	)

◆ notcurses_debug()

API void notcurses_debug	(	const struct notcurses *	nc,
		FILE *	debugfp
	)

◆ notcurses_default_background()

API int notcurses_default_background	(	const struct notcurses *	nc,
		uint32_t *	bg
	)

Definition at line 1722 of file render.c.

                                                                          {
  const tinfo* ti = &nc->tcache;
  if(ti->bg_collides_default & 0x80000000){
    logerror("default background could not be determined");
    return -1;
  }
  *bg = ti->bg_collides_default & NC_BG_RGB_MASK;
  return 0;
}

◆ notcurses_default_foreground()

API int notcurses_default_foreground	(	const struct notcurses *	nc,
		uint32_t *	fg
	)

Definition at line 1712 of file render.c.

                                                                          {
  const tinfo* ti = &nc->tcache;
  if(ti->fg_default & 0x80000000){
    logerror("default foreground could not be determined");
    return -1;
  }
  *fg = ti->fg_default & NC_BG_RGB_MASK;
  return 0;
}

◆ notcurses_detected_terminal()

ALLOC API char * notcurses_detected_terminal ( const struct notcurses * nc )

◆ notcurses_drop_planes()

API int API int API void notcurses_drop_planes ( struct notcurses * nc )

Definition at line 1434 of file notcurses.c.

                                         {
  logdebug("we have some planes");
  pthread_mutex_lock(&nc->pilelock);
  ncpile* p = ncplane_pile(nc->stdplane);
  ncpile* p0 = p;
  do{
    ncpile_drop(nc, &p);
  }while(p0 != p);
  pthread_mutex_unlock(&nc->pilelock);
  logdebug("all planes dropped");
}

Here is the caller graph for this function:

◆ notcurses_enter_alternate_screen()

API int notcurses_enter_alternate_screen ( struct notcurses * nc )

Definition at line 31 of file notcurses.c.

                                                   {
  if(nc->tcache.ttyfd < 0){
    return -1;
  }
  if(enter_alternate_screen(nc->tcache.ttyfd, nc->ttyfp, &nc->tcache, nc->flags & NCOPTION_DRAIN_INPUT)){
    return -1;
  }
  ncplane_set_scrolling(notcurses_stdplane(nc), false);
  return 0;
}

Here is the call graph for this function:

◆ notcurses_get()

API uint32_t notcurses_get	(	struct notcurses *	n,
		const struct timespec *	ts,
		ncinput *	ni
	)

Definition at line 2751 of file in.c.

                                                                                {
  uint32_t ret = internal_get(nc->tcache.ictx, absdl, ni);
  return ret;
}

Here is the caller graph for this function:

◆ notcurses_getvec()

API int notcurses_getvec	(	struct notcurses *	n,
		const struct timespec *	ts,
		ncinput *	ni,
		int	vcount
	)

◆ notcurses_hostname()

API ALLOC char * notcurses_hostname ( void )

Definition at line 62 of file util.c.

                              {
#ifndef __MINGW32__
  char hostname[_POSIX_HOST_NAME_MAX + 1];
  if(gethostname(hostname, sizeof(hostname)) == 0){
    char* fqdn = strchr(hostname, '.');
    if(fqdn){
      *fqdn = '\0';
    }
    return strdup(hostname);
  }
#else // windows
  char lp[MAX_COMPUTERNAME_LENGTH + 1];
  DWORD s = sizeof(lp);
  if(GetComputerNameA(lp, &s)){
    return strdup(lp);
  }
#endif
  return NULL;
}

◆ notcurses_init()

API ALLOC struct notcurses * notcurses_init	(	const notcurses_options *	opts,
		FILE *	fp
	)

◆ notcurses_inputready_fd()

API int API int notcurses_inputready_fd ( struct notcurses * n )

Definition at line 3091 of file notcurses.c.

                                         {
  return inputready_fd(n->tcache.ictx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notcurses_leave_alternate_screen()

API int notcurses_leave_alternate_screen ( struct notcurses * nc )

Definition at line 42 of file notcurses.c.

                                                   {
  if(nc->tcache.ttyfd < 0){
    return -1;
  }
  if(leave_alternate_screen(nc->tcache.ttyfd, nc->ttyfp,
                            &nc->tcache, nc->flags & NCOPTION_DRAIN_INPUT)){
    return -1;
  }
  // move to the end of our output
  if(nc->rstate.logendy < 0){
    return 0;
  }
  ncplane_cursor_move_yx(notcurses_stdplane(nc), nc->rstate.logendy, nc->rstate.logendx);
  return 0;
}

Here is the call graph for this function:

◆ notcurses_lex_blitter()

API int notcurses_lex_blitter	(	const char *	op,
		ncblitter_e *	blitter
	)

Definition at line 1378 of file blit.c.

                                                               {
  const struct blitset* bset = notcurses_blitters;
  while(bset->name){
    if(strcasecmp(bset->name, op) == 0){
      *blitfxn = bset->geom;
      return 0;
    }
    ++bset;
  }
  if(strcasecmp("default", op) == 0){
    *blitfxn = NCBLIT_DEFAULT;
    return 0;
  }
  return -1;
}

Here is the caller graph for this function:

◆ notcurses_lex_margins()

API int notcurses_lex_margins	(	const char *	op,
		notcurses_options *	opts
	)

Definition at line 3067 of file notcurses.c.

                                                                  {
  char* eptr;
  if(lex_ulong(op, &opts->margin_t, &eptr)){
    return -1;
  }
  if(!*eptr){ // allow a single value to be specified for all four margins
    opts->margin_r = opts->margin_l = opts->margin_b = opts->margin_t;
    return 0;
  }
  op = ++eptr; // once here, we require four values
  if(lex_ulong(op, &opts->margin_r, &eptr) || !*eptr){
    return -1;
  }
  op = ++eptr;
  if(lex_ulong(op, &opts->margin_b, &eptr) || !*eptr){
    return -1;
  }
  op = ++eptr;
  if(lex_ulong(op, &opts->margin_l, &eptr) || *eptr){ // must end in NUL
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

◆ notcurses_lex_scalemode()

API int notcurses_lex_scalemode	(	const char *	op,
		ncscale_e *	scalemode
	)

Definition at line 3035 of file notcurses.c.

                                                                 {
  if(strcasecmp(op, "stretch") == 0){
    *scalemode = NCSCALE_STRETCH;
  }else if(strcasecmp(op, "scalehi") == 0){
    *scalemode = NCSCALE_SCALE_HIRES;
  }else if(strcasecmp(op, "hires") == 0){
    *scalemode = NCSCALE_NONE_HIRES;
  }else if(strcasecmp(op, "scale") == 0){
    *scalemode = NCSCALE_SCALE;
  }else if(strcasecmp(op, "none") == 0){
    *scalemode = NCSCALE_NONE;
  }else{
    return -1;
  }
  return 0;
}

Here is the caller graph for this function:

◆ notcurses_linesigs_disable()

API int notcurses_linesigs_disable ( struct notcurses * n )

Definition at line 2850 of file in.c.

                                             {
  return linesigs_disable(&nc->tcache);
}

Here is the caller graph for this function:

◆ notcurses_linesigs_enable()

API int notcurses_linesigs_enable ( struct notcurses * n )

Definition at line 2892 of file in.c.

                                           {
  return linesigs_enable(&n->tcache);
}

Here is the caller graph for this function:

◆ notcurses_mice_enable()

API int notcurses_mice_enable	(	struct notcurses *	n,
		unsigned	eventmask
	)

Definition at line 2556 of file notcurses.c.

                                                           {
  if(mouse_setup(&n->tcache, eventmask)){
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notcurses_osversion()

API ALLOC char * notcurses_osversion ( void )

Definition at line 82 of file util.c.

                               {
#ifdef __MINGW32__
  // FIXME get version
  return strdup("Microsoft Windows");
#else
#ifdef __APPLE__
#define PREFIX "macOS "
  char osver[30] = PREFIX; // shrug
  size_t oldlenp = sizeof(osver) - strlen(PREFIX);
  if(sysctlbyname("kern.osproductversion", osver + strlen(PREFIX),
                  &oldlenp, NULL, 0) == 0){
    return strdup(osver);
  }
  return strdup("macOS");
#else
  struct utsname uts;
  if(uname(&uts)){
    logerror("failure invoking uname (%s)", strerror(errno));
    return NULL;
  }
  const size_t nlen = strlen(uts.sysname);
  const size_t rlen = strlen(uts.release);
  size_t tlen = nlen + rlen + 2;
  char* ret = malloc(tlen);
  memcpy(ret, uts.sysname, nlen);
  ret[nlen] = ' ';
  strcpy(ret + nlen + 1, uts.release);
  return ret;
#endif
#undef PREFIX
#endif
}

Here is the caller graph for this function:

◆ notcurses_palette_size()

API unsigned notcurses_palette_size ( const struct notcurses * nc )

◆ notcurses_refresh()

API int notcurses_refresh	(	struct notcurses *	n,
		unsigned *RESTRICT	y,
		unsigned *RESTRICT	x
	)

◆ notcurses_stats()

API void notcurses_stats	(	struct notcurses *	nc,
		ncstats *	stats
	)

◆ notcurses_stats_alloc()

API ALLOC ncstats * notcurses_stats_alloc ( const struct notcurses *nc __attribute__(unused) )

◆ notcurses_stats_reset()

API void API void notcurses_stats_reset	(	struct notcurses *	nc,
		ncstats *	stats
	)

Definition at line 100 of file stats.c.

                                                         {
  pthread_mutex_lock(&nc->stats.lock);
    if(stats){
      memcpy(stats, &nc->stats.s, sizeof(*stats));
    }
    // add the stats to the stashed stats, so that we can show true totals on
    // shutdown in the closing banner
    ncstats* stash = &nc->stashed_stats;
    if(nc->stats.s.render_min_ns < stash->render_min_ns){
      stash->render_min_ns = nc->stats.s.render_min_ns;
    }
    if(nc->stats.s.raster_min_bytes < stash->raster_min_bytes){
      stash->raster_min_bytes = nc->stats.s.raster_min_bytes;
    }
    if(nc->stats.s.raster_min_ns < stash->raster_min_ns){
      stash->raster_min_ns = nc->stats.s.raster_min_ns;
    }
    if(nc->stats.s.writeout_min_ns < stash->writeout_min_ns){
      stash->writeout_min_ns = nc->stats.s.writeout_min_ns;
    }
    if(nc->stats.s.render_max_ns > stash->render_max_ns){
      stash->render_max_ns = nc->stats.s.render_max_ns;
    }
    if(nc->stats.s.raster_max_bytes > stash->raster_max_bytes){
      stash->raster_max_bytes = nc->stats.s.raster_max_bytes;
    }
    if(nc->stats.s.raster_max_ns > stash->raster_max_ns){
      stash->raster_max_ns = nc->stats.s.raster_max_ns;
    }
    if(nc->stats.s.writeout_max_ns > stash->writeout_max_ns){
      stash->writeout_max_ns = nc->stats.s.writeout_max_ns;
    }
    stash->writeout_ns += nc->stats.s.writeout_ns;
    stash->raster_ns += nc->stats.s.raster_ns;
    stash->render_ns += nc->stats.s.render_ns;
    stash->raster_bytes += nc->stats.s.raster_bytes;
    stash->failed_renders += nc->stats.s.failed_renders;
    stash->failed_writeouts += nc->stats.s.failed_writeouts;
    stash->renders += nc->stats.s.renders;
    stash->writeouts += nc->stats.s.writeouts;
    stash->cellelisions += nc->stats.s.cellelisions;
    stash->cellemissions += nc->stats.s.cellemissions;
    stash->fgelisions += nc->stats.s.fgelisions;
    stash->fgemissions += nc->stats.s.fgemissions;
    stash->bgelisions += nc->stats.s.bgelisions;
    stash->bgemissions += nc->stats.s.bgemissions;
    stash->defaultelisions += nc->stats.s.defaultelisions;
    stash->defaultemissions += nc->stats.s.defaultemissions;
    stash->refreshes += nc->stats.s.refreshes;
    stash->sprixelemissions += nc->stats.s.sprixelemissions;
    stash->sprixelelisions += nc->stats.s.sprixelelisions;
    stash->sprixelbytes += nc->stats.s.sprixelbytes;
    stash->appsync_updates += nc->stats.s.appsync_updates;
    stash->input_errors += nc->stats.s.input_errors;
    stash->input_events += nc->stats.s.input_events;
    stash->hpa_gratuitous += nc->stats.s.hpa_gratuitous;
    stash->cell_geo_changes += nc->stats.s.cell_geo_changes;
    stash->pixel_geo_changes += nc->stats.s.pixel_geo_changes;
 
    stash->fbbytes = nc->stats.s.fbbytes;
    stash->planes = nc->stats.s.planes;
    reset_stats(&nc->stats.s);
  pthread_mutex_unlock(&nc->stats.lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notcurses_stdplane()

API struct ncplane * notcurses_stdplane ( struct notcurses * nc )

Definition at line 699 of file notcurses.c.

                                          {
  return nc->stdplane;
}

Here is the caller graph for this function:

◆ notcurses_stdplane_const()

API const struct ncplane * notcurses_stdplane_const ( const struct notcurses * nc )

◆ notcurses_stop()

API int notcurses_stop ( struct notcurses * nc )

Definition at line 1446 of file notcurses.c.

                                 {
  logdebug("stopping notcurses");
//notcurses_debug(nc, stderr);
  int ret = 0;
  if(nc){
    void* altstack;
    ret |= notcurses_stop_minimal(nc, &altstack);
    // if we were not using the alternate screen, our cursor's wherever we last
    // wrote. move it to the furthest place to which it advanced.
    if(!get_escape(&nc->tcache, ESCAPE_SMCUP)){
      fbuf_reset(&nc->rstate.f);
//fprintf(stderr, "CLOSING TO %d/%d\n", nc->rstate.logendy, nc->rstate.logendx);
      goto_location(nc, &nc->rstate.f, nc->rstate.logendy, nc->rstate.logendx, NULL);
//fprintf(stderr, "***"); fflush(stderr);
      fbuf_finalize(&nc->rstate.f, stdout);
    }
    if(nc->stdplane){
      notcurses_drop_planes(nc);
      free_plane(nc->stdplane);
    }
    if(nc->tcache.ttyfd >= 0){
      ret |= close(nc->tcache.ttyfd);
    }
    egcpool_dump(&nc->pool);
    free(nc->lastframe);
    // perhaps surprisingly, this stops the input thread
    free_terminfo_cache(&nc->tcache);
    // get any current stats loaded into stash_stats
    notcurses_stats_reset(nc, NULL);
    if(!(nc->flags & NCOPTION_SUPPRESS_BANNERS)){
      summarize_stats(nc);
    }
#ifndef __MINGW32__
    del_curterm(cur_term);
#endif
    ret |= pthread_mutex_destroy(&nc->stats.lock);
    ret |= pthread_mutex_destroy(&nc->pilelock);
    fbuf_free(&nc->rstate.f);
    free(nc);
    free(altstack);
  }
  return ret;
}

Here is the call graph for this function:

◆ notcurses_str_blitter()

API const char * notcurses_str_blitter ( ncblitter_e blitter )

Definition at line 1394 of file blit.c.

                                                      {
  if(blitfxn == NCBLIT_DEFAULT){
    return "default";
  }
  const struct blitset* bset = notcurses_blitters;
  while(bset->name){
    if(bset->geom == blitfxn){
      return bset->name;
    }
    ++bset;
  }
  return NULL;
}

Here is the caller graph for this function:

◆ notcurses_str_scalemode()

API const char * notcurses_str_scalemode ( ncscale_e scalemode )

Definition at line 3052 of file notcurses.c.

                                                        {
  if(scalemode == NCSCALE_STRETCH){
    return "stretch";
  }else if(scalemode == NCSCALE_SCALE){
    return "scale";
  }else if(scalemode == NCSCALE_NONE){
    return "none";
  }else if(scalemode == NCSCALE_NONE_HIRES){
    return "hires";
  }else if(scalemode == NCSCALE_SCALE_HIRES){
    return "scalehi";
  }
  return NULL;
}

Here is the caller graph for this function:

◆ notcurses_supported_styles()

API uint16_t notcurses_supported_styles ( const struct notcurses * nc )

◆ notcurses_ucs32_to_utf8()

API int notcurses_ucs32_to_utf8	(	const uint32_t *	ucs32,
		unsigned	ucs32count,
		unsigned char *	resultbuf,
		size_t	buflen
	)

◆ notcurses_version()

API const char * notcurses_version ( void )

Definition at line 182 of file notcurses.c.

                                   {
  return NOTCURSES_VERSION;
}

Here is the caller graph for this function:

◆ notcurses_version_components()

API void notcurses_version_components	(	int *	major,
		int *	minor,
		int *	patch,
		int *	tweak
	)

Definition at line 24 of file notcurses.c.

                                                                                 {
  *major = NOTCURSES_VERNUM_MAJOR;
  *minor = NOTCURSES_VERNUM_MINOR;
  *patch = NOTCURSES_VERNUM_PATCH;
  *tweak = atoi(NOTCURSES_VERSION_TWEAK);
}

Here is the caller graph for this function:

Variable Documentation

◆ c

API int const nccell* c

Definition at line 861 of file notcurses.h.

◆ else

else

Initial value:

{

newn = ncpile_create(nc, opts)

ncpile_create

API ALLOC struct ncplane API ALLOC struct ncplane * ncpile_create(struct notcurses *nc, const ncplane_options *nopts) __attribute__((nonnull(1

Definition at line 3491 of file notcurses.h.

◆ len

API int const nccell unsigned len

Initial value:

{

return ncplane_hline_interp(n, c, len, c->channels, c->channels)

ncplane_hline_interp

API int API int ncplane_hline_interp(struct ncplane *n, const nccell *c, unsigned len, uint64_t c1, uint64_t c2) __attribute__((nonnull(1

len

API int API int const nccell unsigned len

Definition notcurses.h:2588

Definition at line 2588 of file notcurses.h.

◆ n

vopts n = newn

Definition at line 3502 of file notcurses.h.

◆ ncplane_resizecb

API int(*)(struct ncplane *) ncplane_resizecb(const struct ncplane *n) ( const struct ncplane * n )

Definition at line 1513 of file notcurses.h.

◆ ncv

const struct ncplane_options struct ncvisual* ncv

Definition at line 3484 of file notcurses.h.

◆ newn

return newn

Definition at line 3508 of file notcurses.h.

◆ opts

const struct ncplane_options* opts

Definition at line 3483 of file notcurses.h.

◆ v

struct ncvisual_options v

Definition at line 3497 of file notcurses.h.

◆ vopts

const struct ncplane_options struct ncvisual struct ncvisual_options* vopts

Initial value:

{

struct ncplane* newn

Definition at line 3484 of file notcurses.h.

◆ x

int int x

Initial value:

{

int oy, ox

Definition at line 1905 of file notcurses.h.

◆ y

int y

Definition at line 1905 of file notcurses.h.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ALLOC

◆ API

◆ NC_BG_ALPHA_MASK

◆ NC_BG_PALETTE

◆ NC_BG_RGB_MASK

◆ NC_BGDEFAULT_MASK

◆ NC_NOBACKGROUND_MASK

◆ NCALIGN_BOTTOM

◆ NCALIGN_TOP

◆ NCALPHA_BLEND

◆ NCALPHA_HIGHCONTRAST

◆ NCALPHA_OPAQUE

◆ NCALPHA_TRANSPARENT

◆ NCBOXCORNER_MASK

◆ NCBOXCORNER_SHIFT

◆ NCBOXGRAD_BOTTOM

◆ NCBOXGRAD_LEFT

◆ NCBOXGRAD_RIGHT

◆ NCBOXGRAD_TOP

◆ NCBOXMASK_BOTTOM

◆ NCBOXMASK_LEFT

◆ NCBOXMASK_RIGHT

◆ NCBOXMASK_TOP

◆ NCBPREFIXCOLUMNS

◆ NCBPREFIXFMT

◆ NCBPREFIXSTRLEN

◆ NCCELL_CHAR_INITIALIZER

◆ NCCELL_INITIALIZER

◆ NCCELL_TRIVIAL_INITIALIZER

◆ NCCHANNEL_INITIALIZER

◆ NCCHANNELS_INITIALIZER

◆ NCINPUT_MAX_EFF_TEXT_CODEPOINTS

◆ NCIPREFIXCOLUMNS

◆ NCIPREFIXFMT

◆ NCIPREFIXSTRLEN

◆ NCMENU_OPTION_BOTTOM

◆ NCMENU_OPTION_HIDING

◆ NCMETRICFWIDTH

◆ NCMICE_ALL_EVENTS

◆ NCMICE_BUTTON_EVENT

◆ NCMICE_DRAG_EVENT

◆ NCMICE_MOVE_EVENT

◆ NCMICE_NO_EVENTS

◆ NCOPTION_CLI_MODE

◆ NCOPTION_DRAIN_INPUT

◆ NCOPTION_INHIBIT_SETLOCALE

◆ NCOPTION_NO_ALTERNATE_SCREEN

◆ NCOPTION_NO_CLEAR_BITMAPS

◆ NCOPTION_NO_FONT_CHANGES

◆ NCOPTION_NO_QUIT_SIGHANDLERS

◆ NCOPTION_NO_WINCH_SIGHANDLER

◆ NCOPTION_PRESERVE_CURSOR

◆ NCOPTION_SCROLLING

◆ NCOPTION_SUPPRESS_BANNERS

◆ NCPALETTESIZE

◆ NCPLANE_OPTION_AUTOGROW

◆ NCPLANE_OPTION_FIXED

◆ NCPLANE_OPTION_HORALIGNED

◆ NCPLANE_OPTION_MARGINALIZED

◆ NCPLANE_OPTION_VERALIGNED

◆ NCPLANE_OPTION_VSCROLL

◆ NCPLOT_OPTION_DETECTMAXONLY

◆ NCPLOT_OPTION_EXPONENTIALD

◆ NCPLOT_OPTION_LABELTICKSD

◆ NCPLOT_OPTION_NODEGRADE

◆ NCPLOT_OPTION_PRINTSAMPLE

◆ NCPLOT_OPTION_VERTICALI

◆ NCPREFIXCOLUMNS

◆ NCPREFIXFMT

◆ NCPREFIXSTRLEN

◆ NCPROGBAR_OPTION_RETROGRADE

◆ NCREADER_OPTION_CURSOR

◆ NCREADER_OPTION_HORSCROLL

◆ attribute() [1/8]

◆ attribute() [2/8]

◆ attribute() [3/8]

◆ attribute() [4/8]

◆ attribute() [5/8]

◆ attribute() [6/8]

◆ attribute() [7/8]

◆ attribute() [8/8]