libvterm/src/screen.c

32 /* Internal representation of a screen cell */
39 static int vterm_screen_set_cell(VTermScreen *screen, VTermPos pos, const VTermScreenCell *cell);
65   /* buffer for a single screen row used in scrollback storage callbacks */
71 static inline ScreenCell *getcell(const VTermScreen *screen, int row, int col)
73   if(row < 0 || row >= screen->rows)
75   if(col < 0 || col >= screen->cols)
77   return screen->buffer + (screen->cols * row) + col;
80 static ScreenCell *realloc_buffer(VTermScreen *screen, ScreenCell *buffer, int new_rows, int new_cols)
82   ScreenCell *new_buffer = vterm_allocator_malloc(screen->vt, sizeof(ScreenCell) * new_rows * new_cols);
89       if(buffer && row < screen->rows && col < screen->cols)
90         *new_cell = buffer[row * screen->cols + col];
93         new_cell->pen = screen->pen;
99     vterm_allocator_free(screen->vt, buffer);
104 static void damagerect(VTermScreen *screen, VTermRect rect)
108   switch(screen->damage_merge) {
119       vterm_screen_flush_damage(screen);
122     else if(screen->damaged.start_row == -1) {
124       screen->damaged = rect;
127     else if(rect.start_row == screen->damaged.start_row) {
129       if(screen->damaged.start_col > rect.start_col)
130         screen->damaged.start_col = rect.start_col;
131       if(screen->damaged.end_col < rect.end_col)
132         screen->damaged.end_col = rect.end_col;
137       emit = screen->damaged;
138       screen->damaged = rect;
145     if(screen->damaged.start_row == -1)
146       screen->damaged = rect;
148       rect_expand(&screen->damaged, &rect);
153     fprintf(stderr, "TODO: Maybe merge damage for level %d\n", screen->damage_merge);
157   if(screen->callbacks && screen->callbacks->damage)
158     (*screen->callbacks->damage)(emit, screen->cbdata);
161 static void damagescreen(VTermScreen *screen)
165     .end_row   = screen->rows,
167     .end_col   = screen->cols,
170   damagerect(screen, rect);
175   VTermScreen *screen = user;
176   ScreenCell *cell = getcell(screen, pos.row, pos.col);
185     cell->pen = screen->pen;
191     getcell(screen, pos.row, pos.col + col)->chars[0] = (uint32_t)-1;
202   damagerect(screen, rect);
209   VTermScreen *screen = user;
213   if(screen->callbacks && screen->callbacks->sb_pushline &&
215      dest.end_col == screen->cols &&                // full width
216      screen->buffer == screen->buffers[0]) {        // not altscreen
219       for(pos.col = 0; pos.col < screen->cols; pos.col++)
220         vterm_screen_get_cell(screen, pos, screen->sb_buffer + pos.col);
222       (screen->callbacks->sb_pushline)(screen->cols, screen->sb_buffer, screen->cbdata);
241     memmove(getcell(screen, row, dest.start_col),
242             getcell(screen, row + downward, src.start_col),
250   VTermScreen *screen = user;
252   if(screen->callbacks && screen->callbacks->moverect) {
253     if(screen->damage_merge != VTERM_DAMAGE_SCROLL)
255       vterm_screen_flush_damage(screen);
257     if((*screen->callbacks->moverect)(dest, src, screen->cbdata))
261   damagerect(screen, dest);
268   VTermScreen *screen = user;
272     const VTermLineInfo *info = vterm_state_get_lineinfo(screen->state, row);
275       ScreenCell *cell = getcell(screen, row, col);
281       cell->pen = screen->pen;
292   VTermScreen *screen = user;
294   damagerect(screen, rect);
307   VTermScreen *screen = user;
310       moverect_internal, erase_internal, screen);
312   if(screen->damage_merge != VTERM_DAMAGE_SCROLL) {
313     vterm_screen_flush_damage(screen);
316         moverect_user, erase_user, screen);
321   if(screen->damaged.start_row != -1 &&
322      !rect_intersects(&rect, &screen->damaged)) {
323     vterm_screen_flush_damage(screen);
326   if(screen->pending_scrollrect.start_row == -1) {
327     screen->pending_scrollrect = rect;
328     screen->pending_scroll_downward  = downward;
329     screen->pending_scroll_rightward = rightward;
331   else if(rect_equal(&screen->pending_scrollrect, &rect) &&
332      ((screen->pending_scroll_downward  == 0 && downward  == 0) ||
333       (screen->pending_scroll_rightward == 0 && rightward == 0))) {
334     screen->pending_scroll_downward  += downward;
335     screen->pending_scroll_rightward += rightward;
338     vterm_screen_flush_damage(screen);
340     screen->pending_scrollrect = rect;
341     screen->pending_scroll_downward  = downward;
342     screen->pending_scroll_rightward = rightward;
345   if(screen->damaged.start_row == -1)
348   if(rect_contains(&rect, &screen->damaged)) {
349     vterm_rect_move(&screen->damaged, -downward, -rightward);
350     rect_clip(&screen->damaged, &rect);
357   else if(rect.start_col <= screen->damaged.start_col &&
358           rect.end_col   >= screen->damaged.end_col &&
360     if(screen->damaged.start_row >= rect.start_row &&
361        screen->damaged.start_row  < rect.end_row) {
362       screen->damaged.start_row -= downward;
363       if(screen->damaged.start_row < rect.start_row)
364         screen->damaged.start_row = rect.start_row;
365       if(screen->damaged.start_row > rect.end_row)
366         screen->damaged.start_row = rect.end_row;
368     if(screen->damaged.end_row >= rect.start_row &&
369        screen->damaged.end_row  < rect.end_row) {
370       screen->damaged.end_row -= downward;
371       if(screen->damaged.end_row < rect.start_row)
372         screen->damaged.end_row = rect.start_row;
373       if(screen->damaged.end_row > rect.end_row)
374         screen->damaged.end_row = rect.end_row;
379         ARGSrect(screen->damaged), ARGSrect(rect));
387   VTermScreen *screen = user;
389   if(screen->callbacks && screen->callbacks->movecursor)
390     return (*screen->callbacks->movecursor)(pos, oldpos, visible, screen->cbdata);
397   VTermScreen *screen = user;
401     screen->pen.bold = val->boolean;
404     screen->pen.underline = val->number;
407     screen->pen.italic = val->boolean;
410     screen->pen.blink = val->boolean;
413     screen->pen.reverse = val->boolean;
416     screen->pen.strike = val->boolean;
419     screen->pen.font = val->number;
422     screen->pen.fg = val->color;
425     screen->pen.bg = val->color;
434   VTermScreen *screen = user;
438     if(val->boolean && !screen->buffers[1])
441     screen->buffer = val->boolean ? screen->buffers[1] : screen->buffers[0];
446       damagescreen(screen);
449     screen->global_reverse = val->boolean;
450     damagescreen(screen);
456   if(screen->callbacks && screen->callbacks->settermprop)
457     return (*screen->callbacks->settermprop)(prop, val, screen->cbdata);
464   VTermScreen *screen = user;
466   if(screen->callbacks && screen->callbacks->setmousefunc)
467     return (*screen->callbacks->setmousefunc)(func, data, screen->cbdata);
474   VTermScreen *screen = user;
476   if(screen->callbacks && screen->callbacks->bell)
477     return (*screen->callbacks->bell)(screen->cbdata);
484   VTermScreen *screen = user;
486   int is_altscreen = (screen->buffers[1] && screen->buffer == screen->buffers[1]);
488   int old_rows = screen->rows;
489   int old_cols = screen->cols;
498       if(!vterm_screen_is_eol(screen, pos))
510       vterm_screen_flush_damage(screen);
516   screen->buffers[0] = realloc_buffer(screen, screen->buffers[0], new_rows, new_cols);
517   if(screen->buffers[1])
518     screen->buffers[1] = realloc_buffer(screen, screen->buffers[1], new_rows, new_cols);
520   screen->buffer = is_altscreen ? screen->buffers[1] : screen->buffers[0];
522   screen->rows = new_rows;
523   screen->cols = new_cols;
525   if(screen->sb_buffer)
526     vterm_allocator_free(screen->vt, screen->sb_buffer);
528   screen->sb_buffer = vterm_allocator_malloc(screen->vt, sizeof(VTermScreenCell) * new_cols);
537     damagerect(screen, rect);
541     if(!is_altscreen && screen->callbacks && screen->callbacks->sb_popline) {
546           .end_row   = screen->rows,
548           .end_col   = screen->cols,
552         if(!(screen->callbacks->sb_popline(screen->cols, screen->sb_buffer, screen->cbdata)))
557         for(pos.col = 0; pos.col < screen->cols; pos.col += screen->sb_buffer[pos.col].width)
558           vterm_screen_set_cell(screen, pos, screen->sb_buffer + pos.col);
561         damagerect(screen, rect);
563         vterm_screen_flush_damage(screen);
574     damagerect(screen, rect);
577   if(screen->callbacks && screen->callbacks->resize)
578     return (*screen->callbacks->resize)(new_rows, new_cols, screen->cbdata);
585   VTermScreen *screen = user;
591     for(col = 0; col < screen->cols; col++) {
592       ScreenCell *cell = getcell(screen, row, col);
600     rect.end_col   = newinfo->doublewidth ? screen->cols / 2 : screen->cols;
601     damagerect(screen, rect);
604       rect.start_col = screen->cols / 2;
605       rect.end_col   = screen->cols;
631   VTermScreen *screen;
636   screen = vterm_allocator_malloc(vt, sizeof(VTermScreen));
640   screen->vt = vt;
641   screen->state = state;
643   screen->damage_merge = VTERM_DAMAGE_CELL;
644   screen->damaged.start_row = -1;
645   screen->pending_scrollrect.start_row = -1;
647   screen->rows = rows;
648   screen->cols = cols;
650   screen->buffers[0] = realloc_buffer(screen, NULL, rows, cols);
652   screen->buffer = screen->buffers[0];
654   screen->sb_buffer = vterm_allocator_malloc(screen->vt, sizeof(VTermScreenCell) * cols);
656   vterm_state_set_callbacks(screen->state, &state_cbs, screen);
658   return screen;
661 INTERNAL void vterm_screen_free(VTermScreen *screen)
663   vterm_allocator_free(screen->vt, screen->buffers[0]);
664   if(screen->buffers[1])
665     vterm_allocator_free(screen->vt, screen->buffers[1]);
667   vterm_allocator_free(screen->vt, screen->sb_buffer);
669   vterm_allocator_free(screen->vt, screen);
672 void vterm_screen_reset(VTermScreen *screen, int hard)
674   screen->damaged.start_row = -1;
675   screen->pending_scrollrect.start_row = -1;
676   vterm_state_reset(screen->state, hard);
677   vterm_screen_flush_damage(screen);
680 static size_t _get_chars(const VTermScreen *screen, const int utf8, void *buffer, size_t len, const VTermRect rect)
703       ScreenCell *cell = getcell(screen, row, col);
732 size_t vterm_screen_get_chars(const VTermScreen *screen, uint32_t *chars, size_t len, const VTermRect rect)
734   return _get_chars(screen, 0, chars, len, rect);
737 size_t vterm_screen_get_text(const VTermScreen *screen, char *str, size_t len, const VTermRect rect)
739   return _get_chars(screen, 1, str, len, rect);
742 /* Copy internal to external representation of a screen cell */
743 int vterm_screen_get_cell(const VTermScreen *screen, VTermPos pos, VTermScreenCell *cell)
745   ScreenCell *intcell = getcell(screen, pos.row, pos.col);
760   cell->attrs.reverse   = intcell->pen.reverse ^ screen->global_reverse;
770   if(pos.col < (screen->cols - 1) &&
771      getcell(screen, pos.row, pos.col + 1)->chars[0] == (uint32_t)-1)
779 /* Copy external to internal representation of a screen cell */
781 static int vterm_screen_set_cell(VTermScreen *screen, VTermPos pos, const VTermScreenCell *cell)
783   ScreenCell *intcell = getcell(screen, pos.row, pos.col);
799   intcell->pen.reverse   = cell->attrs.reverse ^ screen->global_reverse;
807     getcell(screen, pos.row, pos.col + 1)->chars[0] = (uint32_t)-1;
812 int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos)
815   for(; pos.col < screen->cols; pos.col++) {
816     ScreenCell *cell = getcell(screen, pos.row, pos.col);
826   VTermScreen *screen;
827   if(vt->screen)
828     return vt->screen;
830   screen = screen_new(vt);
831   vt->screen = screen;
833   return screen;
836 void vterm_screen_enable_altscreen(VTermScreen *screen, int altscreen)
839   if(!screen->buffers[1] && altscreen) {
841     vterm_get_size(screen->vt, &rows, &cols);
843     screen->buffers[1] = realloc_buffer(screen, NULL, rows, cols);
847 void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user)
849   screen->callbacks = callbacks;
850   screen->cbdata = user;
853 void vterm_screen_flush_damage(VTermScreen *screen)
855   if(screen->pending_scrollrect.start_row != -1) {
856     vterm_scroll_rect(screen->pending_scrollrect, screen->pending_scroll_downward, screen->pending_scroll_rightward,
857         moverect_user, erase_user, screen);
859     screen->pending_scrollrect.start_row = -1;
862   if(screen->damaged.start_row != -1) {
863     if(screen->callbacks && screen->callbacks->damage)
864       (*screen->callbacks->damage)(screen->damaged, screen->cbdata);
866     screen->damaged.start_row = -1;
870 void vterm_screen_set_damage_merge(VTermScreen *screen, VTermDamageSize size)
872   vterm_screen_flush_damage(screen);
873   screen->damage_merge = size;
900 int vterm_screen_get_attrs_extent(const VTermScreen *screen, VTermRect *extent, VTermPos pos, VTermAttrMask attrs)
902   ScreenCell *target = getcell(screen, pos.row, pos.col);
913     extent->end_col = screen->cols;
916     if(attrs_differ(attrs, target, getcell(screen, pos.row, col)))
921     if(attrs_differ(attrs, target, getcell(screen, pos.row, col)))