src/kmscon_terminal.c

   1 /*
   2  * kmscon - Terminal
   3  *
   4  * Copyright (c) 2011-2012 David Herrmann <dh.herrmann@googlemail.com>
   5  * Copyright (c) 2011 University of Tuebingen
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining
   8  * a copy of this software and associated documentation files
   9  * (the "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  22  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /*
  28  * Terminal
  29  * A terminal gets assigned an input stream and several output objects and then
  30  * runs a fully functional terminal emulation on it.
  31  */
  32
  33 #include <errno.h>
  34 #include <inttypes.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include "conf.h"
  38 #include "eloop.h"
  39 #include "kmscon_conf.h"
  40 #include "kmscon_seat.h"
  41 #include "kmscon_terminal.h"
  42 #include "pty.h"
  43 #include "shl_dlist.h"
  44 #include "shl_log.h"
  45 #include "text.h"
  46 #include "tsm_screen.h"
  47 #include "tsm_vte.h"
  48 #include "uterm_input.h"
  49 #include "uterm_video.h"
  50
  51 #define LOG_SUBSYSTEM "terminal"
  52
  53 struct screen {
  54         struct shl_dlist list;
  55         struct kmscon_terminal *term;
  56         struct uterm_display *disp;
  57         struct kmscon_text *txt;
  58
  59         bool swapping;
  60         bool pending;
  61 };
  62
  63 struct kmscon_terminal {
  64         unsigned long ref;
  65         struct ev_eloop *eloop;
  66         struct uterm_input *input;
  67         bool opened;
  68         bool awake;
  69
  70         struct conf_ctx *conf_ctx;
  71         struct kmscon_conf_t *conf;
  72         struct kmscon_session *session;
  73
  74         struct shl_dlist screens;
  75         unsigned int min_cols;
  76         unsigned int min_rows;
  77
  78         struct tsm_screen *console;
  79         struct tsm_vte *vte;
  80         struct kmscon_pty *pty;
  81         struct ev_fd *ptyfd;
  82
  83         struct kmscon_font_attr font_attr;
  84         struct kmscon_font *font;
  85         struct kmscon_font *bold_font;
  86 };
  87
  88 static void do_clear_margins(struct screen *scr)
  89 {
  90         unsigned int w, h, sw, sh;
  91         struct uterm_mode *mode;
  92         int dw, dh;
  93
  94         mode = uterm_display_get_current(scr->disp);
  95         if (!mode)
  96                 return;
  97
  98         sw = uterm_mode_get_width(mode);
  99         sh = uterm_mode_get_height(mode);
 100         w = scr->txt->font->attr.width * scr->txt->cols;
 101         h = scr->txt->font->attr.height * scr->txt->rows;
 102         dw = sw - w;
 103         dh = sh - h;
 104
 105         if (dw > 0)
 106                 uterm_display_fill(scr->disp, 0, 0, 0,
 107                                    w, 0,
 108                                    dw, h);
 109         if (dh > 0)
 110                 uterm_display_fill(scr->disp, 0, 0, 0,
 111                                    0, h,
 112                                    sw, dh);
 113 }
 114
 115 static void do_redraw_screen(struct screen *scr)
 116 {
 117         int ret;
 118
 119         if (!scr->term->awake)
 120                 return;
 121
 122         scr->pending = false;
 123         do_clear_margins(scr);
 124         tsm_screen_draw(scr->term->console, kmscon_text_prepare_cb,
 125                         kmscon_text_draw_cb, kmscon_text_render_cb, scr->txt);
 126         ret = uterm_display_swap(scr->disp, false);
 127         if (ret) {
 128                 log_warning("cannot swap display %p", scr->disp);
 129                 return;
 130         }
 131
 132         scr->swapping = true;
 133 }
 134
 135 static void redraw_screen(struct screen *scr)
 136 {
 137         if (!scr->term->awake)
 138                 return;
 139
 140         if (scr->swapping)
 141                 scr->pending = true;
 142         else
 143                 do_redraw_screen(scr);
 144 }
 145
 146 static void redraw_all(struct kmscon_terminal *term)
 147 {
 148         struct shl_dlist *iter;
 149         struct screen *scr;
 150
 151         if (!term->awake)
 152                 return;
 153
 154         shl_dlist_for_each(iter, &term->screens) {
 155                 scr = shl_dlist_entry(iter, struct screen, list);
 156                 redraw_screen(scr);
 157         }
 158 }
 159
 160 static void redraw_all_test(struct kmscon_terminal *term)
 161 {
 162         struct shl_dlist *iter;
 163         struct screen *scr;
 164
 165         if (!term->awake)
 166                 return;
 167
 168         shl_dlist_for_each(iter, &term->screens) {
 169                 scr = shl_dlist_entry(iter, struct screen, list);
 170                 if (uterm_display_is_swapping(scr->disp))
 171                         scr->swapping = true;
 172                 redraw_screen(scr);
 173         }
 174 }
 175
 176 static void display_event(struct uterm_display *disp,
 177                           struct uterm_display_event *ev, void *data)
 178 {
 179         struct screen *scr = data;
 180
 181         if (ev->action != UTERM_PAGE_FLIP)
 182                 return;
 183
 184         scr->swapping = false;
 185         if (scr->pending)
 186                 do_redraw_screen(scr);
 187 }
 188
 189 /*
 190  * Resize terminal
 191  * We support multiple monitors per terminal. As some software-rendering
 192  * backends to not support scaling, we always use the smallest cols/rows that are
 193  * provided so wider displays will have black margins.
 194  * This can be extended to support scaling but that would mean we need to check
 195  * whether the text-renderer backend supports that, first (TODO).
 196  *
 197  * If @force is true, then the console/pty are notified even though the size did
 198  * not changed. If @notify is false, then console/pty are not notified even
 199  * though the size might have changed. force = true and notify = false doesn't
 200  * make any sense, though.
 201  */
 202 static void terminal_resize(struct kmscon_terminal *term,
 203                             unsigned int cols, unsigned int rows,
 204                             bool force, bool notify)
 205 {
 206         bool resize = false;
 207
 208         if (!term->min_cols || (cols > 0 && cols < term->min_cols)) {
 209                 term->min_cols = cols;
 210                 resize = true;
 211         }
 212         if (!term->min_rows || (rows > 0 && rows < term->min_rows)) {
 213                 term->min_rows = rows;
 214                 resize = true;
 215         }
 216
 217         if (!notify || (!resize && !force))
 218                 return;
 219         if (!term->min_cols || !term->min_rows)
 220                 return;
 221
 222         tsm_screen_resize(term->console, term->min_cols, term->min_rows);
 223         kmscon_pty_resize(term->pty, term->min_cols, term->min_rows);
 224         redraw_all(term);
 225 }
 226
 227 static int font_set(struct kmscon_terminal *term)
 228 {
 229         int ret;
 230         struct kmscon_font *font, *bold_font;
 231         struct shl_dlist *iter;
 232         struct screen *ent;
 233
 234         term->font_attr.bold = false;
 235         ret = kmscon_font_find(&font, &term->font_attr,
 236                                term->conf->font_engine);
 237         if (ret)
 238                 return ret;
 239
 240         term->font_attr.bold = true;
 241         ret = kmscon_font_find(&bold_font, &term->font_attr,
 242                                term->conf->font_engine);
 243         if (ret) {
 244                 log_warning("cannot create bold font: %d", ret);
 245                 bold_font = font;
 246                 kmscon_font_ref(bold_font);
 247         }
 248
 249         kmscon_font_unref(term->bold_font);
 250         kmscon_font_unref(term->font);
 251         term->font = font;
 252         term->bold_font = bold_font;
 253
 254         term->min_cols = 0;
 255         term->min_rows = 0;
 256         shl_dlist_for_each(iter, &term->screens) {
 257                 ent = shl_dlist_entry(iter, struct screen, list);
 258
 259                 ret = kmscon_text_set(ent->txt, font, bold_font, ent->disp);
 260                 if (ret)
 261                         log_warning("cannot change text-renderer font: %d",
 262                                     ret);
 263
 264                 terminal_resize(term,
 265                                 kmscon_text_get_cols(ent->txt),
 266                                 kmscon_text_get_rows(ent->txt),
 267                                 false, false);
 268         }
 269
 270         terminal_resize(term, 0, 0, true, true);
 271         return 0;
 272 }
 273
 274 static int add_display(struct kmscon_terminal *term, struct uterm_display *disp)
 275 {
 276         struct shl_dlist *iter;
 277         struct screen *scr;
 278         int ret;
 279         const char *be;
 280         bool opengl;
 281
 282         shl_dlist_for_each(iter, &term->screens) {
 283                 scr = shl_dlist_entry(iter, struct screen, list);
 284                 if (scr->disp == disp)
 285                         return 0;
 286         }
 287
 288         scr = malloc(sizeof(*scr));
 289         if (!scr) {
 290                 log_error("cannot allocate memory for display %p", disp);
 291                 return -ENOMEM;
 292         }
 293         memset(scr, 0, sizeof(*scr));
 294         scr->term = term;
 295         scr->disp = disp;
 296
 297         ret = uterm_display_register_cb(scr->disp, display_event, scr);
 298         if (ret) {
 299                 log_error("cannot register display callback: %d", ret);
 300                 goto err_free;
 301         }
 302
 303         ret = uterm_display_use(scr->disp, &opengl);
 304         if (term->conf->render_engine)
 305                 be = term->conf->render_engine;
 306         else if (ret >= 0 && opengl)
 307                 be = "gltex";
 308         else
 309                 be = "bbulk";
 310
 311         ret = kmscon_text_new(&scr->txt, be);
 312         if (ret) {
 313                 log_error("cannot create text-renderer");
 314                 goto err_cb;
 315         }
 316
 317         ret = kmscon_text_set(scr->txt, term->font, term->bold_font,
 318                               scr->disp);
 319         if (ret) {
 320                 log_error("cannot set text-renderer parameters");
 321                 goto err_text;
 322         }
 323
 324         terminal_resize(term,
 325                         kmscon_text_get_cols(scr->txt),
 326                         kmscon_text_get_rows(scr->txt),
 327                         false, true);
 328
 329         shl_dlist_link(&term->screens, &scr->list);
 330
 331         log_debug("added display %p to terminal %p", disp, term);
 332         redraw_screen(scr);
 333         uterm_display_ref(scr->disp);
 334         return 0;
 335
 336 err_text:
 337         kmscon_text_unref(scr->txt);
 338 err_cb:
 339         uterm_display_unregister_cb(scr->disp, display_event, scr);
 340 err_free:
 341         free(scr);
 342         return ret;
 343 }
 344
 345 static void free_screen(struct screen *scr, bool update)
 346 {
 347         struct shl_dlist *iter;
 348         struct screen *ent;
 349         struct kmscon_terminal *term = scr->term;
 350
 351         log_debug("destroying terminal screen %p", scr);
 352         shl_dlist_unlink(&scr->list);
 353         kmscon_text_unref(scr->txt);
 354         uterm_display_unregister_cb(scr->disp, display_event, scr);
 355         uterm_display_unref(scr->disp);
 356         free(scr);
 357
 358         if (!update)
 359                 return;
 360
 361         term->min_cols = 0;
 362         term->min_rows = 0;
 363         shl_dlist_for_each(iter, &term->screens) {
 364                 ent = shl_dlist_entry(iter, struct screen, list);
 365                 terminal_resize(term,
 366                                 kmscon_text_get_cols(ent->txt),
 367                                 kmscon_text_get_rows(ent->txt),
 368                                 false, false);
 369         }
 370
 371         terminal_resize(term, 0, 0, true, true);
 372 }
 373
 374 static void rm_display(struct kmscon_terminal *term, struct uterm_display *disp)
 375 {
 376         struct shl_dlist *iter;
 377         struct screen *scr;
 378
 379         shl_dlist_for_each(iter, &term->screens) {
 380                 scr = shl_dlist_entry(iter, struct screen, list);
 381                 if (scr->disp == disp)
 382                         break;
 383         }
 384
 385         if (iter == &term->screens)
 386                 return;
 387
 388         log_debug("removed display %p from terminal %p", disp, term);
 389         free_screen(scr, true);
 390 }
 391
 392 static void input_event(struct uterm_input *input,
 393                         struct uterm_input_event *ev,
 394                         void *data)
 395 {
 396         struct kmscon_terminal *term = data;
 397
 398         if (!term->opened || !term->awake || ev->handled)
 399                 return;
 400
 401         if (conf_grab_matches(term->conf->grab_scroll_up,
 402                               ev->mods, ev->num_syms, ev->keysyms)) {
 403                 tsm_screen_sb_up(term->console, 1);
 404                 redraw_all(term);
 405                 ev->handled = true;
 406                 return;
 407         }
 408         if (conf_grab_matches(term->conf->grab_scroll_down,
 409                               ev->mods, ev->num_syms, ev->keysyms)) {
 410                 tsm_screen_sb_down(term->console, 1);
 411                 redraw_all(term);
 412                 ev->handled = true;
 413                 return;
 414         }
 415         if (conf_grab_matches(term->conf->grab_page_up,
 416                               ev->mods, ev->num_syms, ev->keysyms)) {
 417                 tsm_screen_sb_page_up(term->console, 1);
 418                 redraw_all(term);
 419                 ev->handled = true;
 420                 return;
 421         }
 422         if (conf_grab_matches(term->conf->grab_page_down,
 423                               ev->mods, ev->num_syms, ev->keysyms)) {
 424                 tsm_screen_sb_page_down(term->console, 1);
 425                 redraw_all(term);
 426                 ev->handled = true;
 427                 return;
 428         }
 429         if (conf_grab_matches(term->conf->grab_zoom_in,
 430                               ev->mods, ev->num_syms, ev->keysyms)) {
 431                 ev->handled = true;
 432                 if (term->font_attr.points + 1 < term->font_attr.points)
 433                         return;
 434
 435                 ++term->font_attr.points;
 436                 if (font_set(term))
 437                         --term->font_attr.points;
 438                 return;
 439         }
 440         if (conf_grab_matches(term->conf->grab_zoom_out,
 441                               ev->mods, ev->num_syms, ev->keysyms)) {
 442                 ev->handled = true;
 443                 if (term->font_attr.points <= 1)
 444                         return;
 445
 446                 --term->font_attr.points;
 447                 if (font_set(term))
 448                         ++term->font_attr.points;
 449                 return;
 450         }
 451
 452         /* TODO: xkbcommon supports multiple keysyms, but it is currently
 453          * unclear how this feature will be used. There is no keymap, which
 454          * uses this, yet. */
 455         if (ev->num_syms > 1)
 456                 return;
 457
 458         if (tsm_vte_handle_keyboard(term->vte, ev->keysyms[0], ev->ascii,
 459                                     ev->mods, ev->codepoints[0])) {
 460                 tsm_screen_sb_reset(term->console);
 461                 redraw_all(term);
 462                 ev->handled = true;
 463         }
 464 }
 465
 466 static void rm_all_screens(struct kmscon_terminal *term)
 467 {
 468         struct shl_dlist *iter;
 469         struct screen *scr;
 470
 471         while ((iter = term->screens.next) != &term->screens) {
 472                 scr = shl_dlist_entry(iter, struct screen, list);
 473                 free_screen(scr, false);
 474         }
 475
 476         term->min_cols = 0;
 477         term->min_rows = 0;
 478 }
 479
 480 static int terminal_open(struct kmscon_terminal *term)
 481 {
 482         int ret;
 483         unsigned short width, height;
 484
 485         if (term->opened)
 486                 return -EALREADY;
 487
 488         tsm_vte_hard_reset(term->vte);
 489         width = tsm_screen_get_width(term->console);
 490         height = tsm_screen_get_height(term->console);
 491         ret = kmscon_pty_open(term->pty, width, height);
 492         if (ret)
 493                 return ret;
 494
 495         term->opened = true;
 496         redraw_all(term);
 497         return 0;
 498 }
 499
 500 static void terminal_close(struct kmscon_terminal *term)
 501 {
 502         kmscon_pty_close(term->pty);
 503         term->opened = false;
 504 }
 505
 506 static void terminal_destroy(struct kmscon_terminal *term)
 507 {
 508         log_debug("free terminal object %p", term);
 509
 510         terminal_close(term);
 511         rm_all_screens(term);
 512         uterm_input_unregister_cb(term->input, input_event, term);
 513         ev_eloop_rm_fd(term->ptyfd);
 514         kmscon_pty_unref(term->pty);
 515         kmscon_font_unref(term->bold_font);
 516         kmscon_font_unref(term->font);
 517         tsm_vte_unref(term->vte);
 518         tsm_screen_unref(term->console);
 519         uterm_input_unref(term->input);
 520         ev_eloop_unref(term->eloop);
 521         free(term);
 522 }
 523
 524 static int session_event(struct kmscon_session *session,
 525                          struct kmscon_session_event *ev, void *data)
 526 {
 527         struct kmscon_terminal *term = data;
 528
 529         switch (ev->type) {
 530         case KMSCON_SESSION_DISPLAY_NEW:
 531                 add_display(term, ev->disp);
 532                 break;
 533         case KMSCON_SESSION_DISPLAY_GONE:
 534                 rm_display(term, ev->disp);
 535                 break;
 536         case KMSCON_SESSION_ACTIVATE:
 537                 term->awake = true;
 538                 if (!term->opened)
 539                         terminal_open(term);
 540                 redraw_all_test(term);
 541                 break;
 542         case KMSCON_SESSION_DEACTIVATE:
 543                 term->awake = false;
 544                 break;
 545         case KMSCON_SESSION_UNREGISTER:
 546                 terminal_destroy(term);
 547                 break;
 548         }
 549
 550         return 0;
 551 }
 552
 553 static void pty_input(struct kmscon_pty *pty, const char *u8, size_t len,
 554                                                                 void *data)
 555 {
 556         struct kmscon_terminal *term = data;
 557
 558         if (!len) {
 559                 terminal_close(term);
 560                 terminal_open(term);
 561         } else {
 562                 tsm_vte_input(term->vte, u8, len);
 563                 redraw_all(term);
 564         }
 565 }
 566
 567 static void pty_event(struct ev_fd *fd, int mask, void *data)
 568 {
 569         struct kmscon_terminal *term = data;
 570
 571         kmscon_pty_dispatch(term->pty);
 572 }
 573
 574 static void write_event(struct tsm_vte *vte, const char *u8, size_t len,
 575                         void *data)
 576 {
 577         struct kmscon_terminal *term = data;
 578
 579         kmscon_pty_write(term->pty, u8, len);
 580 }
 581
 582 int kmscon_terminal_register(struct kmscon_session **out,
 583                              struct kmscon_seat *seat)
 584 {
 585         struct kmscon_terminal *term;
 586         int ret;
 587
 588         if (!out || !seat)
 589                 return -EINVAL;
 590
 591         term = malloc(sizeof(*term));
 592         if (!term)
 593                 return -ENOMEM;
 594
 595         memset(term, 0, sizeof(*term));
 596         term->ref = 1;
 597         term->eloop = kmscon_seat_get_eloop(seat);
 598         term->input = kmscon_seat_get_input(seat);
 599         shl_dlist_init(&term->screens);
 600
 601         term->conf_ctx = kmscon_seat_get_conf(seat);
 602         term->conf = conf_ctx_get_mem(term->conf_ctx);
 603
 604         strncpy(term->font_attr.name, term->conf->font_name,
 605                 KMSCON_FONT_MAX_NAME - 1);
 606         term->font_attr.ppi = term->conf->font_ppi;
 607         term->font_attr.points = term->conf->font_size;
 608
 609         ret = tsm_screen_new(&term->console, log_llog, NULL);
 610         if (ret)
 611                 goto err_free;
 612         tsm_screen_set_max_sb(term->console, term->conf->sb_size);
 613         if (term->conf->render_timing)
 614                 tsm_screen_set_opts(term->console,
 615                                     TSM_SCREEN_OPT_RENDER_TIMING);
 616
 617         ret = tsm_vte_new(&term->vte, term->console, write_event, term,
 618                           log_llog, NULL);
 619         if (ret)
 620                 goto err_con;
 621         tsm_vte_set_palette(term->vte, term->conf->palette);
 622
 623         ret = font_set(term);
 624         if (ret)
 625                 goto err_vte;
 626
 627         ret = kmscon_pty_new(&term->pty, pty_input, term);
 628         if (ret)
 629                 goto err_font;
 630
 631         kmscon_pty_set_env_reset(term->pty, term->conf->reset_env);
 632
 633         ret = kmscon_pty_set_term(term->pty, term->conf->term);
 634         if (ret)
 635                 goto err_pty;
 636
 637         ret = kmscon_pty_set_colorterm(term->pty, "kmscon");
 638         if (ret)
 639                 goto err_pty;
 640
 641         ret = kmscon_pty_set_argv(term->pty, term->conf->argv);
 642         if (ret)
 643                 goto err_pty;
 644
 645         ret = kmscon_pty_set_seat(term->pty, kmscon_seat_get_name(seat));
 646         if (ret)
 647                 goto err_pty;
 648
 649         ret = ev_eloop_new_fd(term->eloop, &term->ptyfd,
 650                               kmscon_pty_get_fd(term->pty),
 651                               EV_READABLE, pty_event, term);
 652         if (ret)
 653                 goto err_pty;
 654
 655         ret = uterm_input_register_cb(term->input, input_event, term);
 656         if (ret)
 657                 goto err_ptyfd;
 658
 659         ret = kmscon_seat_register_session(seat, &term->session, session_event,
 660                                            term);
 661         if (ret) {
 662                 log_error("cannot register session for terminal: %d", ret);
 663                 goto err_input;
 664         }
 665
 666         ev_eloop_ref(term->eloop);
 667         uterm_input_ref(term->input);
 668         *out = term->session;
 669         log_debug("new terminal object %p", term);
 670         return 0;
 671
 672 err_input:
 673         uterm_input_unregister_cb(term->input, input_event, term);
 674 err_ptyfd:
 675         ev_eloop_rm_fd(term->ptyfd);
 676 err_pty:
 677         kmscon_pty_unref(term->pty);
 678 err_font:
 679         kmscon_font_unref(term->bold_font);
 680         kmscon_font_unref(term->font);
 681 err_vte:
 682         tsm_vte_unref(term->vte);
 683 err_con:
 684         tsm_screen_unref(term->console);
 685 err_free:
 686         free(term);
 687         return ret;
 688 }