1 /* 2 * NOTE: This is a MODIFIED version of libvterm, see the README file. 3 */ 4 #ifndef __VTERM_H__ 5 #define __VTERM_H__ 6 7 #ifdef __cplusplus 8 extern "C" { 9 #endif 10 11 #include <stdlib.h> 12 13 #include "vterm_keycodes.h" 14 15 #define TRUE 1 16 #define FALSE 0 17 18 // from stdint.h 19 typedef unsigned char uint8_t; 20 typedef unsigned int uint32_t; 21 22 #define VTERM_VERSION_MAJOR 0 23 #define VTERM_VERSION_MINOR 1 24 25 #define VTERM_CHECK_VERSION \ 26 vterm_check_version(VTERM_VERSION_MAJOR, VTERM_VERSION_MINOR) 27 28 typedef struct VTerm VTerm; 29 typedef struct VTermState VTermState; 30 typedef struct VTermScreen VTermScreen; 31 32 // Specifies a screen point. 33 typedef struct { 34 int row; 35 int col; 36 } VTermPos; 37 38 /* 39 * Some small utility functions; we can just keep these static here. 40 */ 41 42 /* 43 * Order points by on-screen flow order: 44 * Return < 0 if "a" is before "b" 45 * Return 0 if "a" and "b" are equal 46 * Return > 0 if "a" is after "b". 47 */ 48 int vterm_pos_cmp(VTermPos a, VTermPos b); 49 50 #if defined(DEFINE_INLINES) || USE_INLINE 51 INLINE int vterm_pos_cmp(VTermPos a, VTermPos b) 52 { 53 return (a.row == b.row) ? a.col - b.col : a.row - b.row; 54 } 55 #endif 56 57 // Specifies a rectangular screen area. 58 typedef struct { 59 int start_row; 60 int end_row; 61 int start_col; 62 int end_col; 63 } VTermRect; 64 65 // Return true if the rect "r" contains the point "p". 66 int vterm_rect_contains(VTermRect r, VTermPos p); 67 68 #if defined(DEFINE_INLINES) || USE_INLINE 69 INLINE int vterm_rect_contains(VTermRect r, VTermPos p) 70 { 71 return p.row >= r.start_row && p.row < r.end_row && 72 p.col >= r.start_col && p.col < r.end_col; 73 } 74 #endif 75 76 // Move "rect" "row_delta" down and "col_delta" right. 77 // Does not check boundaries. 78 void vterm_rect_move(VTermRect *rect, int row_delta, int col_delta); 79 80 #if defined(DEFINE_INLINES) || USE_INLINE 81 INLINE void vterm_rect_move(VTermRect *rect, int row_delta, int col_delta) 82 { 83 rect->start_row += row_delta; rect->end_row += row_delta; 84 rect->start_col += col_delta; rect->end_col += col_delta; 85 } 86 #endif 87 88 // The ansi_index is used for the lower 16 colors, which can be set to any 89 // color. 90 #define VTERM_ANSI_INDEX_DEFAULT 0 // color cleared 91 #define VTERM_ANSI_INDEX_MIN 1 92 #define VTERM_ANSI_INDEX_MAX 16 93 #define VTERM_ANSI_INDEX_NONE 255 // non-ANSI color, use red/green/blue 94 95 typedef struct { 96 uint8_t red, green, blue; 97 uint8_t ansi_index; 98 } VTermColor; 99 100 typedef enum { 101 // VTERM_VALUETYPE_NONE = 0 102 VTERM_VALUETYPE_BOOL = 1, 103 VTERM_VALUETYPE_INT, 104 VTERM_VALUETYPE_STRING, 105 VTERM_VALUETYPE_COLOR, 106 107 VTERM_N_VALUETYPES 108 } VTermValueType; 109 110 typedef struct { 111 const char *str; 112 size_t len : 30; 113 unsigned int initial : 1; 114 unsigned int final : 1; 115 } VTermStringFragment; 116 117 typedef union { 118 int boolean; 119 int number; 120 VTermStringFragment string; 121 VTermColor color; 122 } VTermValue; 123 124 typedef enum { 125 // VTERM_ATTR_NONE = 0 126 VTERM_ATTR_BOLD = 1, // bool: 1, 22 127 VTERM_ATTR_UNDERLINE, // number: 4, 21, 24 128 VTERM_ATTR_ITALIC, // bool: 3, 23 129 VTERM_ATTR_BLINK, // bool: 5, 25 130 VTERM_ATTR_REVERSE, // bool: 7, 27 131 VTERM_ATTR_STRIKE, // bool: 9, 29 132 VTERM_ATTR_FONT, // number: 10-19 133 VTERM_ATTR_FOREGROUND, // color: 30-39 90-97 134 VTERM_ATTR_BACKGROUND, // color: 40-49 100-107 135 136 VTERM_N_ATTRS 137 } VTermAttr; 138 139 typedef enum { 140 // VTERM_PROP_NONE = 0 141 VTERM_PROP_CURSORVISIBLE = 1, // bool 142 VTERM_PROP_CURSORBLINK, // bool 143 VTERM_PROP_ALTSCREEN, // bool 144 VTERM_PROP_TITLE, // string 145 VTERM_PROP_ICONNAME, // string 146 VTERM_PROP_REVERSE, // bool 147 VTERM_PROP_CURSORSHAPE, // number 148 VTERM_PROP_MOUSE, // number 149 VTERM_PROP_CURSORCOLOR, // string 150 151 VTERM_N_PROPS 152 } VTermProp; 153 154 enum { 155 VTERM_PROP_CURSORSHAPE_BLOCK = 1, 156 VTERM_PROP_CURSORSHAPE_UNDERLINE, 157 VTERM_PROP_CURSORSHAPE_BAR_LEFT, 158 159 VTERM_N_PROP_CURSORSHAPES 160 }; 161 162 enum { 163 VTERM_PROP_MOUSE_NONE = 0, 164 VTERM_PROP_MOUSE_CLICK, 165 VTERM_PROP_MOUSE_DRAG, 166 VTERM_PROP_MOUSE_MOVE, 167 168 VTERM_N_PROP_MOUSES 169 }; 170 171 typedef struct { 172 const uint32_t *chars; 173 int width; 174 unsigned int protected_cell:1; // DECSCA-protected against DECSEL/DECSED 175 unsigned int dwl:1; // DECDWL or DECDHL double-width line 176 unsigned int dhl:2; // DECDHL double-height line (1=top 2=bottom) 177 } VTermGlyphInfo; 178 179 typedef struct { 180 unsigned int doublewidth:1; /* DECDWL or DECDHL line */ 181 unsigned int doubleheight:2; /* DECDHL line (1=top 2=bottom) */ 182 unsigned int continuation:1; /* Line is a flow continuation of the previous */ 183 } VTermLineInfo; 184 185 typedef struct { 186 // libvterm relies on the allocated memory to be zeroed out before it is 187 // returned by the allocator. 188 void *(*malloc)(size_t size, void *allocdata); 189 void (*free)(void *ptr, void *allocdata); 190 } VTermAllocatorFunctions; 191 192 void vterm_check_version(int major, int minor); 193 194 // Allocate and initialize a new terminal with default allocators. 195 VTerm *vterm_new(int rows, int cols); 196 197 // Allocate and initialize a new terminal with specified allocators. 198 VTerm *vterm_new_with_allocator(int rows, int cols, VTermAllocatorFunctions *funcs, void *allocdata); 199 200 // Free and cleanup a terminal and all its data. 201 void vterm_free(VTerm* vt); 202 203 // Get the current size of the terminal and store in "rowsp" and "colsp". 204 void vterm_get_size(const VTerm *vt, int *rowsp, int *colsp); 205 206 void vterm_set_size(VTerm *vt, int rows, int cols); 207 208 int vterm_get_utf8(const VTerm *vt); 209 void vterm_set_utf8(VTerm *vt, int is_utf8); 210 211 size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len); 212 213 /* Setting output callback will override the buffer logic */ 214 typedef void VTermOutputCallback(const char *s, size_t len, void *user); 215 void vterm_output_set_callback(VTerm *vt, VTermOutputCallback *func, void *user); 216 217 /* These buffer functions only work if output callback is NOT set 218 * These are deprecated and will be removed in a later version */ 219 size_t vterm_output_get_buffer_size(const VTerm *vt); 220 size_t vterm_output_get_buffer_current(const VTerm *vt); 221 size_t vterm_output_get_buffer_remaining(const VTerm *vt); 222 223 /* This too */ 224 size_t vterm_output_read(VTerm *vt, char *buffer, size_t len); 225 226 int vterm_is_modify_other_keys(VTerm *vt); 227 void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod); 228 void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod); 229 230 void vterm_keyboard_start_paste(VTerm *vt); 231 void vterm_keyboard_end_paste(VTerm *vt); 232 233 void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod); 234 // "button" is 1 for left, 2 for middle, 3 for right. 235 // Button 4 is scroll wheel down, button 5 is scroll wheel up. 236 void vterm_mouse_button(VTerm *vt, int button, int pressed, VTermModifier mod); 237 238 // ------------ 239 // Parser layer 240 // ------------ 241 242 // Flag to indicate non-final subparameters in a single CSI parameter. 243 // Consider 244 // CSI 1;2:3:4;5a 245 // 1 4 and 5 are final. 246 // 2 and 3 are non-final and will have this bit set 247 // 248 // Don't confuse this with the final byte of the CSI escape; 'a' in this case. 249 #define CSI_ARG_FLAG_MORE (1U<<31) 250 #define CSI_ARG_MASK (~(1U<<31)) 251 252 #define CSI_ARG_HAS_MORE(a) ((a) & CSI_ARG_FLAG_MORE) 253 #define CSI_ARG(a) ((a) & CSI_ARG_MASK) 254 255 // Can't use -1 to indicate a missing argument; use this instead 256 #define CSI_ARG_MISSING ((1<<30)-1) 257 258 #define CSI_ARG_IS_MISSING(a) (CSI_ARG(a) == CSI_ARG_MISSING) 259 #define CSI_ARG_OR(a,def) (CSI_ARG(a) == CSI_ARG_MISSING ? (def) : CSI_ARG(a)) 260 #define CSI_ARG_COUNT(a) (CSI_ARG(a) == CSI_ARG_MISSING || CSI_ARG(a) == 0 ? 1 : CSI_ARG(a)) 261 262 typedef struct { 263 int (*text)(const char *bytes, size_t len, void *user); 264 int (*control)(unsigned char control, void *user); 265 int (*escape)(const char *bytes, size_t len, void *user); 266 int (*csi)(const char *leader, const long args[], int argcount, const char *intermed, char command, void *user); 267 int (*osc)(int command, VTermStringFragment frag, void *user); 268 int (*dcs)(const char *command, size_t commandlen, VTermStringFragment frag, void *user); 269 int (*resize)(int rows, int cols, void *user); 270 } VTermParserCallbacks; 271 272 void vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user); 273 void *vterm_parser_get_cbdata(VTerm *vt); 274 275 // ----------- 276 // State layer 277 // ----------- 278 279 /* Copies of VTermState fields that the 'resize' callback might have reason to 280 * edit. 'resize' callback gets total control of these fields and may 281 * free-and-reallocate them if required. They will be copied back from the 282 * struct after the callback has returned. 283 */ 284 typedef struct { 285 VTermPos pos; /* current cursor position */ 286 } VTermStateFields; 287 288 typedef struct { 289 int (*putglyph)(VTermGlyphInfo *info, VTermPos pos, void *user); 290 int (*movecursor)(VTermPos pos, VTermPos oldpos, int visible, void *user); 291 int (*scrollrect)(VTermRect rect, int downward, int rightward, void *user); 292 int (*moverect)(VTermRect dest, VTermRect src, void *user); 293 int (*erase)(VTermRect rect, int selective, void *user); 294 int (*initpen)(void *user); 295 int (*setpenattr)(VTermAttr attr, VTermValue *val, void *user); 296 // Callback for setting various properties. Must return 1 if the property 297 // was accepted, 0 otherwise. 298 int (*settermprop)(VTermProp prop, VTermValue *val, void *user); 299 int (*bell)(void *user); 300 int (*resize)(int rows, int cols, VTermStateFields *fields, void *user); 301 int (*setlineinfo)(int row, const VTermLineInfo *newinfo, const VTermLineInfo *oldinfo, void *user); 302 } VTermStateCallbacks; 303 304 typedef struct { 305 VTermPos pos; 306 int buttons; 307 #define MOUSE_BUTTON_LEFT 0x01 308 #define MOUSE_BUTTON_MIDDLE 0x02 309 #define MOUSE_BUTTON_RIGHT 0x04 310 int flags; 311 #define MOUSE_WANT_CLICK 0x01 312 #define MOUSE_WANT_DRAG 0x02 313 #define MOUSE_WANT_MOVE 0x04 314 // useful to add protocol? 315 } VTermMouseState; 316 317 VTermState *vterm_obtain_state(VTerm *vt); 318 319 void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user); 320 void *vterm_state_get_cbdata(VTermState *state); 321 322 // Only invokes control, csi, osc, dcs 323 void vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermParserCallbacks *fallbacks, void *user); 324 void *vterm_state_get_unrecognised_fbdata(VTermState *state); 325 326 // Initialize the state. 327 void vterm_state_reset(VTermState *state, int hard); 328 329 void vterm_state_get_cursorpos(const VTermState *state, VTermPos *cursorpos); 330 void vterm_state_get_mousestate(const VTermState *state, VTermMouseState *mousestate); 331 void vterm_state_get_default_colors(const VTermState *state, VTermColor *default_fg, VTermColor *default_bg); 332 void vterm_state_get_palette_color(const VTermState *state, int index, VTermColor *col); 333 void vterm_state_set_default_colors(VTermState *state, const VTermColor *default_fg, const VTermColor *default_bg); 334 void vterm_state_set_palette_color(VTermState *state, int index, const VTermColor *col); 335 void vterm_state_set_bold_highbright(VTermState *state, int bold_is_highbright); 336 int vterm_state_get_penattr(const VTermState *state, VTermAttr attr, VTermValue *val); 337 int vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val); 338 void vterm_state_focus_in(VTermState *state); 339 void vterm_state_focus_out(VTermState *state); 340 const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row); 341 342 // ------------ 343 // Screen layer 344 // ------------ 345 346 typedef struct { 347 unsigned int bold : 1; 348 unsigned int underline : 2; 349 unsigned int italic : 1; 350 unsigned int blink : 1; 351 unsigned int reverse : 1; 352 unsigned int strike : 1; 353 unsigned int font : 4; // 0 to 9 354 unsigned int dwl : 1; // On a DECDWL or DECDHL line 355 unsigned int dhl : 2; // On a DECDHL line (1=top 2=bottom) 356 } VTermScreenCellAttrs; 357 358 enum { 359 VTERM_UNDERLINE_OFF, 360 VTERM_UNDERLINE_SINGLE, 361 VTERM_UNDERLINE_DOUBLE, 362 VTERM_UNDERLINE_CURLY, 363 }; 364 365 typedef struct { 366 #define VTERM_MAX_CHARS_PER_CELL 6 367 uint32_t chars[VTERM_MAX_CHARS_PER_CELL]; 368 char width; 369 VTermScreenCellAttrs attrs; 370 VTermColor fg, bg; 371 } VTermScreenCell; 372 373 // All fields are optional, NULL when not used. 374 typedef struct { 375 int (*damage)(VTermRect rect, void *user); 376 int (*moverect)(VTermRect dest, VTermRect src, void *user); 377 int (*movecursor)(VTermPos pos, VTermPos oldpos, int visible, void *user); 378 int (*settermprop)(VTermProp prop, VTermValue *val, void *user); 379 int (*bell)(void *user); 380 int (*resize)(int rows, int cols, void *user); 381 // A line was pushed off the top of the window. 382 // "cells[cols]" contains the cells of that line. 383 // Return value is unused. 384 int (*sb_pushline)(int cols, const VTermScreenCell *cells, void *user); 385 int (*sb_popline)(int cols, VTermScreenCell *cells, void *user); 386 } VTermScreenCallbacks; 387 388 // Return the screen of the vterm. 389 VTermScreen *vterm_obtain_screen(VTerm *vt); 390 391 /* 392 * Install screen callbacks. These are invoked when the screen contents is 393 * changed. "user" is passed into to the callback. 394 */ 395 void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user); 396 void *vterm_screen_get_cbdata(VTermScreen *screen); 397 398 // Only invokes control, csi, osc, dcs 399 void vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen, const VTermParserCallbacks *fallbacks, void *user); 400 void *vterm_screen_get_unrecognised_fbdata(VTermScreen *screen); 401 402 // Enable support for using the alternate screen if "altscreen" is non-zero. 403 // Before that switching to the alternate screen won't work. 404 // Calling with "altscreen" zero has no effect. 405 void vterm_screen_enable_altscreen(VTermScreen *screen, int altscreen); 406 407 typedef enum { 408 VTERM_DAMAGE_CELL, // every cell 409 VTERM_DAMAGE_ROW, // entire rows 410 VTERM_DAMAGE_SCREEN, // entire screen 411 VTERM_DAMAGE_SCROLL, // entire screen + scrollrect 412 413 VTERM_N_DAMAGES 414 } VTermDamageSize; 415 416 // Invoke the relevant callbacks to update the screen. 417 void vterm_screen_flush_damage(VTermScreen *screen); 418 419 void vterm_screen_set_damage_merge(VTermScreen *screen, VTermDamageSize size); 420 421 /* 422 * Reset the screen. Also invokes vterm_state_reset(). 423 * Must be called before the terminal can be used. 424 */ 425 void vterm_screen_reset(VTermScreen *screen, int hard); 426 427 // Neither of these functions NUL-terminate the buffer 428 size_t vterm_screen_get_chars(const VTermScreen *screen, uint32_t *chars, size_t len, const VTermRect rect); 429 size_t vterm_screen_get_text(const VTermScreen *screen, char *str, size_t len, const VTermRect rect); 430 431 typedef enum { 432 VTERM_ATTR_BOLD_MASK = 1 << 0, 433 VTERM_ATTR_UNDERLINE_MASK = 1 << 1, 434 VTERM_ATTR_ITALIC_MASK = 1 << 2, 435 VTERM_ATTR_BLINK_MASK = 1 << 3, 436 VTERM_ATTR_REVERSE_MASK = 1 << 4, 437 VTERM_ATTR_STRIKE_MASK = 1 << 5, 438 VTERM_ATTR_FONT_MASK = 1 << 6, 439 VTERM_ATTR_FOREGROUND_MASK = 1 << 7, 440 VTERM_ATTR_BACKGROUND_MASK = 1 << 8, 441 442 VTERM_ALL_ATTRS_MASK = (1 << 9) - 1 443 } VTermAttrMask; 444 445 int vterm_screen_get_attrs_extent(const VTermScreen *screen, VTermRect *extent, VTermPos pos, VTermAttrMask attrs); 446 447 int vterm_screen_get_cell(const VTermScreen *screen, VTermPos pos, VTermScreenCell *cell); 448 449 int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos); 450 451 // --------- 452 // Utilities 453 // --------- 454 455 VTermValueType vterm_get_attr_type(VTermAttr attr); 456 VTermValueType vterm_get_prop_type(VTermProp prop); 457 458 void vterm_scroll_rect(VTermRect rect, 459 int downward, 460 int rightward, 461 int (*moverect)(VTermRect src, VTermRect dest, void *user), 462 int (*eraserect)(VTermRect rect, int selective, void *user), 463 void *user); 464 465 void vterm_copy_cells(VTermRect dest, 466 VTermRect src, 467 void (*copycell)(VTermPos dest, VTermPos src, void *user), 468 void *user); 469 470 #ifdef __cplusplus 471 } 472 #endif 473 474 #endif 475