apps/irssi/src/fe-text/term-terminfo.c

   1 /*
   2  term-terminfo.c : irssi
   3
   4     Copyright (C) 2001 Timo Sirainen
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "module.h"
  22 #include "signals.h"
  23 #include "term.h"
  24 #include "terminfo-core.h"
  25 #include "utf8.h"
  26
  27 #include <signal.h>
  28
  29 /* returns number of characters in the beginning of the buffer being a
  30    a single character, or -1 if more input is needed. The character will be
  31    saved in result */
  32 typedef int (*TERM_INPUT_FUNC)(const unsigned char *buffer, int size,
  33                                unichar *result);
  34
  35 struct _TERM_WINDOW {
  36         /* Terminal to use for window */
  37         TERM_REC *term;
  38
  39         /* Area for window in terminal */
  40         int x, y;
  41         int width, height;
  42 };
  43
  44 TERM_WINDOW *root_window;
  45
  46 static char *term_lines_empty; /* 1 if line is entirely empty */
  47 static int vcmove, vcx, vcy, curs_visible;
  48 static int crealx, crealy, cforcemove;
  49 static int curs_x, curs_y;
  50 static int auto_detach;
  51
  52 static int last_fg, last_bg, last_attrs;
  53
  54 static int redraw_needed, redraw_tag;
  55 static int freeze_counter;
  56
  57 static TERM_INPUT_FUNC input_func;
  58 static unsigned char term_inbuf[256];
  59 static int term_inbuf_pos;
  60
  61 /* SIGCONT handler */
  62 static void sig_cont(int p)
  63 {
  64         redraw_needed = TRUE;
  65         terminfo_cont(current_term);
  66 }
  67
  68 static int redraw_timeout(void)
  69 {
  70         if (redraw_needed) {
  71                 irssi_redraw();
  72                 redraw_needed = FALSE;
  73         }
  74
  75         return 1;
  76 }
  77
  78 int term_init(void)
  79 {
  80         struct sigaction act;
  81         int width, height;
  82
  83         last_fg = last_bg = -1;
  84         last_attrs = 0;
  85         vcx = vcy = 0; crealx = crealy = -1;
  86         vcmove = FALSE; cforcemove = TRUE;
  87         curs_visible = TRUE;
  88
  89         current_term = terminfo_core_init(stdin, stdout);
  90         if (current_term == NULL)
  91                 return FALSE;
  92
  93         if (term_get_size(&width, &height)) {
  94                 current_term->width = width;
  95                 current_term->height = height;
  96         }
  97
  98         /* grab CONT signal */
  99         sigemptyset(&act.sa_mask);
 100         act.sa_flags = 0;
 101         act.sa_handler = sig_cont;
 102         sigaction(SIGCONT, &act, NULL);
 103         redraw_tag = g_timeout_add(500, (GSourceFunc) redraw_timeout, NULL);
 104
 105         curs_x = curs_y = 0;
 106         term_width = current_term->width;
 107         term_height = current_term->height;
 108         root_window = term_window_create(0, 0, term_width, term_height);
 109         term_detached = FALSE;
 110
 111         term_lines_empty = g_new0(char, term_height);
 112
 113         term_set_input_type(TERM_TYPE_8BIT);
 114         term_common_init();
 115         g_atexit(term_deinit);
 116         return TRUE;
 117 }
 118
 119 void term_deinit(void)
 120 {
 121         if (current_term != NULL) {
 122                 signal(SIGCONT, SIG_DFL);
 123                 g_source_remove(redraw_tag);
 124
 125                 term_common_deinit();
 126                 terminfo_core_deinit(current_term);
 127                 current_term = NULL;
 128         }
 129 }
 130
 131 static void term_move_real(void)
 132 {
 133         if (term_detached) return;
 134
 135         if (vcx != crealx || vcy != crealy || cforcemove) {
 136                 if (curs_visible) {
 137                         terminfo_set_cursor_visible(FALSE);
 138                         curs_visible = FALSE;
 139                 }
 140
 141                 if (cforcemove) {
 142                         crealx = crealy = -1;
 143                         cforcemove = FALSE;
 144                 }
 145                 terminfo_move_relative(crealx, crealy, vcx, vcy);
 146                 crealx = vcx; crealy = vcy;
 147         }
 148
 149         vcmove = FALSE;
 150 }
 151
 152 /* Cursor position is unknown - move it immediately to known position */
 153 static void term_move_reset(int x, int y)
 154 {
 155         if (x >= term_width) x = term_width-1;
 156         if (y >= term_height) y = term_height-1;
 157
 158         vcx = x; vcy = y;
 159         cforcemove = TRUE;
 160         term_move_real();
 161 }
 162
 163 /* Resize terminal - if width or height is negative,
 164    the new size is unknown and should be figured out somehow */
 165 void term_resize(int width, int height)
 166 {
 167         if (width < 0 || height < 0) {
 168                 terminfo_resize(current_term);
 169                 width = current_term->width;
 170                 height = current_term->height;
 171         }
 172
 173         if (term_width != width || term_height != height) {
 174                 term_width = current_term->width = width;
 175                 term_height = current_term->height = height;
 176                 term_window_move(root_window, 0, 0, term_width, term_height);
 177
 178                 g_free(term_lines_empty);
 179                 term_lines_empty = g_new0(char, term_height);
 180         }
 181
 182         term_move_reset(0, 0);
 183 }
 184
 185 void term_resize_final(int width, int height)
 186 {
 187 }
 188
 189 /* Returns TRUE if terminal has colors */
 190 int term_has_colors(void)
 191 {
 192         return current_term->has_colors;
 193 }
 194
 195 /* Force the colors on any way you can */
 196 void term_force_colors(int set)
 197 {
 198         if (term_detached) return;
 199
 200         terminfo_setup_colors(current_term, set);
 201 }
 202
 203 /* Clear screen */
 204 void term_clear(void)
 205 {
 206         if (term_detached) return;
 207
 208         term_set_color(root_window, ATTR_RESET);
 209         terminfo_clear();
 210         term_move_reset(0, 0);
 211
 212         memset(term_lines_empty, 1, term_height);
 213 }
 214
 215 /* Beep */
 216 void term_beep(void)
 217 {
 218         if (term_detached) return;
 219
 220         terminfo_beep(current_term);
 221 }
 222
 223 /* Create a new window in terminal */
 224 TERM_WINDOW *term_window_create(int x, int y, int width, int height)
 225 {
 226         TERM_WINDOW *window;
 227
 228         window = g_new0(TERM_WINDOW, 1);
 229         window->term = current_term;
 230         window->x = x; window->y = y;
 231         window->width = width; window->height = height;
 232         return window;
 233 }
 234
 235 /* Destroy a terminal window */
 236 void term_window_destroy(TERM_WINDOW *window)
 237 {
 238         g_free(window);
 239 }
 240
 241 /* Move/resize a window */
 242 void term_window_move(TERM_WINDOW *window, int x, int y,
 243                       int width, int height)
 244 {
 245         window->x = x;
 246         window->y = y;
 247         window->width = width;
 248         window->height = height;
 249 }
 250
 251 /* Clear window */
 252 void term_window_clear(TERM_WINDOW *window)
 253 {
 254         int y;
 255
 256         if (term_detached) return;
 257
 258         terminfo_set_normal();
 259         if (window->y == 0 && window->height == term_height) {
 260                 term_clear();
 261         } else {
 262                 for (y = 0; y < window->height; y++) {
 263                         term_move(window, 0, y);
 264                         term_clrtoeol(window);
 265                 }
 266         }
 267 }
 268
 269 /* Scroll window up/down */
 270 void term_window_scroll(TERM_WINDOW *window, int count)
 271 {
 272         int y;
 273
 274         if (term_detached) return;
 275
 276         terminfo_scroll(window->y, window->y+window->height-1, count);
 277         term_move_reset(vcx, vcy);
 278
 279         /* set the newly scrolled area dirty */
 280         for (y = 0; y < window->height; y++)
 281                 term_lines_empty[window->y+y] = FALSE;
 282 }
 283
 284 /* Change active color */
 285 void term_set_color(TERM_WINDOW *window, int col)
 286 {
 287         int set_normal;
 288
 289         if (term_detached) return;
 290
 291         set_normal = ((col & ATTR_RESETFG) && last_fg != -1) ||
 292                 ((col & ATTR_RESETBG) && last_bg != -1);
 293         if (((last_attrs & ATTR_BOLD) && (col & ATTR_BOLD) == 0) ||
 294             ((last_attrs & ATTR_BLINK) && (col & ATTR_BLINK) == 0)) {
 295                 /* we'll need to get rid of bold/blink - this can only be
 296                    done with setting the default color */
 297                 set_normal = TRUE;
 298         }
 299
 300         if (set_normal) {
 301                 last_fg = last_bg = -1;
 302                 last_attrs = 0;
 303                 terminfo_set_normal();
 304         }
 305
 306         if (!term_use_colors && (col & 0xf0) != 0)
 307                 col |= ATTR_REVERSE;
 308
 309         /* reversed text (use standout) */
 310         if (col & ATTR_REVERSE) {
 311                 if ((last_attrs & ATTR_REVERSE) == 0)
 312                         terminfo_set_standout(TRUE);
 313         } else if (last_attrs & ATTR_REVERSE)
 314                 terminfo_set_standout(FALSE);
 315
 316         /* set foreground color */
 317         if ((col & 0x0f) != last_fg &&
 318             ((col & 0x0f) != 0 || (col & ATTR_RESETFG) == 0)) {
 319                 if (term_use_colors) {
 320                         last_fg = col & 0x0f;
 321                         terminfo_set_fg(last_fg);
 322                 }
 323         }
 324
 325         /* set background color */
 326         if (col & ATTR_BLINK)
 327                 col |= 0x80;
 328         else if (col & 0x80)
 329                 col |= ATTR_BLINK;
 330
 331         if ((col & 0xf0) >> 4 != last_bg &&
 332             ((col & 0xf0) != 0 || (col & ATTR_RESETBG) == 0)) {
 333                 if (term_use_colors) {
 334                         last_bg = (col & 0xf0) >> 4;
 335                         terminfo_set_bg(last_bg);
 336                 }
 337         }
 338
 339         /* bold */
 340         if (col & 0x08)
 341                 col |= ATTR_BOLD;
 342         else if (col & ATTR_BOLD)
 343                 terminfo_set_bold();
 344
 345         /* underline */
 346         if (col & ATTR_UNDERLINE) {
 347                 if ((last_attrs & ATTR_UNDERLINE) == 0)
 348                         terminfo_set_uline(TRUE);
 349         } else if (last_attrs & ATTR_UNDERLINE)
 350                 terminfo_set_uline(FALSE);
 351
 352         last_attrs = col & ~0xff;
 353 }
 354
 355 void term_move(TERM_WINDOW *window, int x, int y)
 356 {
 357         vcmove = TRUE;
 358         vcx = x+window->x;
 359         vcy = y+window->y;
 360
 361         if (vcx >= term_width)
 362                 vcx = term_width-1;
 363         if (vcy >= term_height)
 364                 vcy = term_height-1;
 365 }
 366
 367 static void term_printed_text(int count)
 368 {
 369         term_lines_empty[vcy] = FALSE;
 370
 371         /* if we continued writing past the line, wrap to next line.
 372            However, next term_move() really shouldn't try to cache
 373            the move, otherwise terminals would try to combine the
 374            last word in upper line with first word in lower line. */
 375         vcx += count;
 376         while (vcx >= term_width) {
 377                 vcx -= term_width;
 378                 if (vcy < term_height-1) vcy++;
 379                 if (vcx > 0) term_lines_empty[vcy] = FALSE;
 380         }
 381
 382         crealx += count;
 383         if (crealx >= term_width)
 384                 cforcemove = TRUE;
 385 }
 386
 387 void term_addch(TERM_WINDOW *window, int chr)
 388 {
 389         if (term_detached) return;
 390
 391         if (vcmove) term_move_real();
 392
 393         if (vcy < term_height-1 || vcx < term_width-1) {
 394                 /* With UTF-8, move cursor only if this char is either
 395                    single-byte (8. bit off) or beginning of multibyte
 396                    (7. bit off) */
 397                 if (term_type != TERM_TYPE_UTF8 ||
 398                     (chr & 0x80) == 0 || (chr & 0x40) == 0) {
 399                         term_printed_text(1);
 400                 }
 401
 402                 putc(chr, window->term->out);
 403         }
 404 }
 405
 406 static void term_addch_utf8(TERM_WINDOW *window, unichar chr)
 407 {
 408         char buf[10];
 409         int i, len;
 410
 411         len = utf16_char_to_utf8(chr, buf);
 412         for (i = 0;  i < len; i++)
 413                 putc(buf[i], window->term->out);
 414 }
 415
 416 void term_add_unichar(TERM_WINDOW *window, unichar chr)
 417 {
 418         if (term_detached) return;
 419
 420         if (vcmove) term_move_real();
 421         if (vcy == term_height-1 && vcx == term_width-1)
 422                 return; /* last char in screen */
 423
 424         term_printed_text(1);
 425         switch (term_type) {
 426         case TERM_TYPE_UTF8:
 427                 term_addch_utf8(window, chr);
 428                 break;
 429         case TERM_TYPE_BIG5:
 430                 putc((chr >> 8) & 0xff, window->term->out);
 431                 putc((chr & 0xff), window->term->out);
 432                 break;
 433         default:
 434                 putc(chr, window->term->out);
 435                 break;
 436         }
 437 }
 438
 439 void term_addstr(TERM_WINDOW *window, const char *str)
 440 {
 441         int len;
 442
 443         if (term_detached) return;
 444
 445         if (vcmove) term_move_real();
 446         len = strlen(str);
 447         term_printed_text(len);
 448
 449         if (vcy != term_height || vcx != 0)
 450                 fputs(str, window->term->out);
 451         else
 452                 fwrite(str, 1, len-1, window->term->out);
 453 }
 454
 455 void term_clrtoeol(TERM_WINDOW *window)
 456 {
 457         if (term_detached) return;
 458
 459         /* clrtoeol() doesn't necessarily understand colors */
 460         if (last_fg == -1 && last_bg == -1 &&
 461             (last_attrs & (ATTR_UNDERLINE|ATTR_REVERSE)) == 0) {
 462                 if (!term_lines_empty[vcy]) {
 463                         if (vcmove) term_move_real();
 464                         terminfo_clrtoeol();
 465                         if (vcx == 0) term_lines_empty[vcy] = TRUE;
 466                 }
 467         } else if (vcx < term_width) {
 468                 /* we'll need to fill the line ourself. */
 469                 if (vcmove) term_move_real();
 470                 terminfo_repeat(' ', term_width-vcx);
 471                 terminfo_move(vcx, vcy);
 472                 term_lines_empty[vcy] = FALSE;
 473         }
 474 }
 475
 476 void term_move_cursor(int x, int y)
 477 {
 478         curs_x = x;
 479         curs_y = y;
 480 }
 481
 482 void term_refresh(TERM_WINDOW *window)
 483 {
 484         if (term_detached || freeze_counter > 0)
 485                 return;
 486
 487         term_move(root_window, curs_x, curs_y);
 488         term_move_real();
 489
 490         if (!curs_visible) {
 491                 terminfo_set_cursor_visible(TRUE);
 492                 curs_visible = TRUE;
 493         }
 494
 495         term_set_color(window, ATTR_RESET);
 496         fflush(window != NULL ? window->term->out : current_term->out);
 497 }
 498
 499 void term_refresh_freeze(void)
 500 {
 501         freeze_counter++;
 502 }
 503
 504 void term_refresh_thaw(void)
 505 {
 506         if (--freeze_counter == 0)
 507                 term_refresh(NULL);
 508 }
 509
 510 void term_auto_detach(int set)
 511 {
 512         auto_detach = set;
 513 }
 514
 515 void term_detach(void)
 516 {
 517         terminfo_stop(current_term);
 518
 519         fclose(current_term->in);
 520         fclose(current_term->out);
 521
 522         current_term->in = NULL;
 523         current_term->out = NULL;
 524         term_detached = TRUE;
 525 }
 526
 527 void term_attach(FILE *in, FILE *out)
 528 {
 529         current_term->in = in;
 530         current_term->out = out;
 531         term_detached = FALSE;
 532
 533         terminfo_cont(current_term);
 534         irssi_redraw();
 535 }
 536
 537 void term_stop(void)
 538 {
 539         if (term_detached) {
 540                 kill(getpid(), SIGSTOP);
 541         } else {
 542                 terminfo_stop(current_term);
 543                 kill(getpid(), SIGSTOP);
 544                 terminfo_cont(current_term);
 545                 irssi_redraw();
 546         }
 547 }
 548
 549 static int input_utf8(const unsigned char *buffer, int size, unichar *result)
 550 {
 551         const unsigned char *end = buffer;
 552
 553         *result = get_utf8_char(&end, size);
 554         switch (*result) {
 555         case (unichar) -2:
 556                 /* not UTF8 - fallback to 8bit ascii */
 557                 *result = *buffer;
 558                 return 1;
 559         case (unichar) -1:
 560                 /* need more data */
 561                 return -1;
 562         default:
 563                 return (int) (end-buffer)+1;
 564         }
 565 }
 566
 567 /* XXX I didn't check the encoding range of big5+. This is standard big5. */
 568 #define is_big5_los(lo) (0x40 <= (lo) && (lo) <= 0x7E) /* standard */
 569 #define is_big5_lox(lo) (0x80 <= (lo) && (lo) <= 0xFE) /* extended */
 570 #define is_big5_hi(hi)  (0x81 <= (hi) && (hi) <= 0xFE)
 571 #define is_big5(hi,lo) (is_big5_hi(hi) && (is_big5_los(lo) || is_big5_lox(lo)))
 572
 573 static int input_big5(const unsigned char *buffer, int size, unichar *result)
 574 {
 575         if (is_big5_hi(*buffer)) {
 576                 /* could be */
 577                 if (size == 1)
 578                         return -1;
 579
 580                 if (is_big5_los(buffer[1]) || is_big5_lox(buffer[1])) {
 581                         *result = buffer[1] + ((int) *buffer << 8);
 582                         return 2;
 583                 }
 584         }
 585
 586         *result = *buffer;
 587         return 1;
 588 }
 589
 590 static int input_8bit(const unsigned char *buffer, int size, unichar *result)
 591 {
 592         *result = *buffer;
 593         return 1;
 594 }
 595
 596 void term_set_input_type(int type)
 597 {
 598         switch (type) {
 599         case TERM_TYPE_UTF8:
 600                 input_func = input_utf8;
 601                 break;
 602         case TERM_TYPE_BIG5:
 603                 input_func = input_big5;
 604                 break;
 605         default:
 606                 input_func = input_8bit;
 607         }
 608 }
 609
 610 int term_gets(unichar *buffer, int size)
 611 {
 612         int ret, i, char_len;
 613
 614         if (term_detached)
 615                 return 0;
 616
 617         /* fread() doesn't work */
 618         if (size > sizeof(term_inbuf)-term_inbuf_pos)
 619                 size = sizeof(term_inbuf)-term_inbuf_pos;
 620
 621         ret = read(fileno(current_term->in),
 622                    term_inbuf + term_inbuf_pos, size);
 623         if (ret == 0) {
 624                 /* EOF - terminal got lost */
 625                 if (auto_detach)
 626                         term_detach();
 627                 ret = -1;
 628         } else if (ret == -1 && (errno == EINTR || errno == EAGAIN))
 629                 ret = 0;
 630
 631         if (ret > 0) {
 632                 /* convert input to unichars. */
 633                 term_inbuf_pos += ret;
 634                 ret = 0;
 635                 for (i = 0; i < term_inbuf_pos; ) {
 636                         char_len = input_func(term_inbuf+i, term_inbuf_pos-i,
 637                                               buffer);
 638                         if (char_len < 0)
 639                                 break;
 640
 641                         i += char_len;
 642                         buffer++;
 643                         ret++;
 644                 }
 645
 646                 if (i >= term_inbuf_pos)
 647                         term_inbuf_pos = 0;
 648                 else if (i > 0) {
 649                         memmove(term_inbuf+i, term_inbuf, term_inbuf_pos-i);
 650                         term_inbuf_pos -= i;
 651                 }
 652         }
 653
 654         return ret;
 655 }