fbpad.c

   1 /*
   2  * FBPAD FRAMEBUFFER VIRTUAL TERMINAL
   3  *
   4  * Copyright (C) 2009-2024 Ali Gholami Rudi <ali at rudi dot ir>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <ctype.h>
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <poll.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <signal.h>
  25 #include <string.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/wait.h>
  28 #include <termios.h>
  29 #include <unistd.h>
  30 #include <linux/vt.h>
  31 #include "conf.h"
  32 #include "fbpad.h"
  33 #include "draw.h"
  34
  35 #define CTRLKEY(x)      ((x) - 96)
  36 #define POLLFLAGS       (POLLIN | POLLHUP | POLLERR | POLLNVAL)
  37 #define NTAGS           (sizeof(tags) - 1)
  38 #define NTERMS          (NTAGS * 2)
  39 #define TERMOPEN(i)     (term_fd(terms[i]))
  40 #define TERMSNAP(i)     (strchr(TAGS_SAVED, tags[(i) % NTAGS]))
  41
  42 static char tags[] = TAGS;
  43 static struct term *terms[NTERMS];
  44 static int tops[NTAGS];         /* top terms of tags */
  45 static int split[NTAGS];        /* terms are shown together */
  46 static int ctag;                /* current tag */
  47 static int ltag;                /* the last tag */
  48 static int exitit;
  49 static int hidden;              /* do not touch the framebuffer */
  50 static int locked;
  51 static int taglock;             /* disable tag switching */
  52 static char pass[1024];
  53 static int passlen;
  54 static int cmdmode;             /* execute a command and exit */
  55
  56 static int readchar(void)
  57 {
  58         char b;
  59         if (read(0, &b, 1) > 0)
  60                 return (unsigned char) b;
  61         return -1;
  62 }
  63
  64 /* the current terminal */
  65 static int cterm(void)
  66 {
  67         return tops[ctag] * NTAGS + ctag;
  68 }
  69
  70 /* tag's active terminal */
  71 static int tterm(int n)
  72 {
  73         return tops[n] * NTAGS + n;
  74 }
  75
  76 /* the other terminal in the same tag */
  77 static int aterm(int n)
  78 {
  79         return n < NTAGS ? n + NTAGS : n - NTAGS;
  80 }
  81
  82 /* the next terminal */
  83 static int nterm(void)
  84 {
  85         int n = (cterm() + 1) % NTERMS;
  86         while (n != cterm()) {
  87                 if (TERMOPEN(n))
  88                         break;
  89                 n = (n + 1) % NTERMS;
  90         }
  91         return n;
  92 }
  93
  94 /* term struct of cterm() */
  95 static struct term *tmain(void)
  96 {
  97         return TERMOPEN(cterm()) ? terms[cterm()] : NULL;
  98 }
  99
 100 #define BRWID           2
 101 #define BRCLR           0xff0000
 102
 103 static void t_conf(int idx)
 104 {
 105         int h1 = fb_rows() / 2 / pad_crows() * pad_crows();
 106         int h2 = fb_rows() - h1 - 4 * BRWID;
 107         int w1 = fb_cols() / 2 / pad_ccols() * pad_ccols();
 108         int w2 = fb_cols() - w1 - 4 * BRWID;
 109         int tag = idx % NTAGS;
 110         int top = idx < NTAGS;
 111         if (split[tag] == 0)
 112                 pad_conf(0, 0, fb_rows(), fb_cols());
 113         if (split[tag] == 1)
 114                 pad_conf(top ? BRWID : h1 + 3 * BRWID, BRWID,
 115                         top ? h1 : h2, fb_cols() - 2 * BRWID);
 116         if (split[tag] == 2)
 117                 pad_conf(BRWID, top ? BRWID : w1 + 3 * BRWID,
 118                         fb_rows() - 2 * BRWID, top ? w1 : w2);
 119 }
 120
 121 static void t_hide(int idx, int save)
 122 {
 123         if (save && TERMOPEN(idx))
 124                 term_hide(terms[idx]);
 125         if (save && TERMOPEN(idx) && TERMSNAP(idx))
 126                 scr_snap(idx);
 127         term_save(terms[idx]);
 128 }
 129
 130 /* show=0 (hidden), show=1 (visible), show=2 (load), show=3 (redraw) */
 131 static int t_show(int idx, int show)
 132 {
 133         t_conf(idx);
 134         term_load(terms[idx], show > 0);
 135         if (show == 2)  /* redraw if scr_load() fails */
 136                 show += !TERMOPEN(idx) || !TERMSNAP(idx) || scr_load(idx);
 137         if (show > 0)
 138                 term_redraw(show == 3);
 139         if ((show == 2 || show == 3) && TERMOPEN(idx))
 140                 term_show(terms[idx]);
 141         return show;
 142 }
 143
 144 /* switch active terminal; hide oidx and show nidx */
 145 static int t_hideshow(int oidx, int save, int nidx, int show)
 146 {
 147         int otag = oidx % NTAGS;
 148         int ntag = nidx % NTAGS;
 149         int ret;
 150         t_hide(oidx, save);
 151         if (show && split[otag] && otag == ntag)
 152                 pad_border(0, BRWID);
 153         ret = t_show(nidx, show);
 154         if (show && split[ntag])
 155                 pad_border(BRCLR, BRWID);
 156         return ret;
 157 }
 158
 159 /* set cterm() */
 160 static void t_set(int n)
 161 {
 162         if (cterm() == n || cmdmode)
 163                 return;
 164         if (taglock && ctag != n % NTAGS)
 165                 return;
 166         if (ctag != n % NTAGS)
 167                 ltag = ctag;
 168         if (ctag == n % NTAGS) {
 169                 if (split[n % NTAGS])
 170                         t_hideshow(cterm(), 0, n, 1);
 171                 else
 172                         t_hideshow(cterm(), 1, n, 2);
 173         } else {
 174                 int draw = t_hideshow(cterm(), 1, n, 2);
 175                 if (split[n % NTAGS]) {
 176                         t_hideshow(n, 0, aterm(n), draw == 2 ? 1 : 2);
 177                         t_hideshow(aterm(n), 0, n, 1);
 178                 }
 179         }
 180         ctag = n % NTAGS;
 181         tops[ctag] = n / NTAGS;
 182 }
 183
 184 static void t_split(int n)
 185 {
 186         split[ctag] = n;
 187         t_hideshow(cterm(), 0, aterm(cterm()), 3);
 188         t_hideshow(aterm(cterm()), 1, cterm(), 3);
 189 }
 190
 191 static void t_exec(char **args, int swsig)
 192 {
 193         if (!tmain())
 194                 term_exec(args, swsig);
 195 }
 196
 197 static void listtags(void)
 198 {
 199         /* colors for tags based on their number of terminals */
 200         int fg = 0x96cb5c, bg = 0x516f7b;
 201         int colors[] = {0x173f4f, fg, 0x68cbc0 | FN_B};
 202         int c = 0;
 203         int r = pad_rows() - 1;
 204         int i;
 205         pad_put('T', r, c++, fg | FN_B, bg);
 206         pad_put('A', r, c++, fg | FN_B, bg);
 207         pad_put('G', r, c++, fg | FN_B, bg);
 208         pad_put('S', r, c++, fg | FN_B, bg);
 209         pad_put(':', r, c++, fg | FN_B, bg);
 210         pad_put(' ', r, c++, fg | FN_B, bg);
 211         for (i = 0; i < NTAGS && c + 2 < pad_cols(); i++) {
 212                 int nt = 0;
 213                 if (TERMOPEN(i))
 214                         nt++;
 215                 if (TERMOPEN(aterm(i)))
 216                         nt++;
 217                 pad_put(i == ctag ? '(' : ' ', r, c++, fg, bg);
 218                 if (TERMSNAP(i))
 219                         pad_put(tags[i], r, c++, !nt ? bg : colors[nt], colors[0]);
 220                 else
 221                         pad_put(tags[i], r, c++, colors[nt], bg);
 222                 pad_put(i == ctag ? ')' : ' ', r, c++, fg, bg);
 223         }
 224         for (; c < pad_cols(); c++)
 225                 pad_put(' ', r, c, fg, bg);
 226 }
 227
 228 static void directkey(void)
 229 {
 230         char *shell[32] = SHELL;
 231         char *mail[32] = MAIL;
 232         char *editor[32] = EDITOR;
 233         int c = readchar();
 234         if (PASS && locked) {
 235                 if (c == '\r') {
 236                         pass[passlen] = '\0';
 237                         if (!strcmp(PASS, pass))
 238                                 locked = 0;
 239                         passlen = 0;
 240                         return;
 241                 }
 242                 if (isprint(c) && passlen + 1 < sizeof(pass))
 243                         pass[passlen++] = c;
 244                 return;
 245         }
 246         if (c == ESC) {
 247                 switch ((c = readchar())) {
 248                 case 'c':
 249                         t_exec(shell, 0);
 250                         return;
 251                 case ';':
 252                         t_exec(shell, 1);
 253                         return;
 254                 case 'm':
 255                         t_exec(mail, 0);
 256                         return;
 257                 case 'e':
 258                         t_exec(editor, 0);
 259                         return;
 260                 case 'j':
 261                 case 'k':
 262                         t_set(aterm(cterm()));
 263                         return;
 264                 case 'o':
 265                         t_set(tterm(ltag));
 266                         return;
 267                 case 'p':
 268                         listtags();
 269                         return;
 270                 case '\t':
 271                         if (nterm() != cterm())
 272                                 t_set(nterm());
 273                         return;
 274                 case CTRLKEY('q'):
 275                         exitit = 1;
 276                         return;
 277                 case 's':
 278                         term_screenshot(SCRSHOT);
 279                         return;
 280                 case 'y':
 281                         term_redraw(1);
 282                         return;
 283                 case CTRLKEY('e'):
 284                         if (!term_colors(CLRFILE))
 285                                 term_redraw(1);
 286                         return;
 287                 case CTRLKEY('l'):
 288                         locked = 1;
 289                         passlen = 0;
 290                         return;
 291                 case CTRLKEY('o'):
 292                         taglock = 1 - taglock;
 293                         return;
 294                 case ',':
 295                         term_scrl(pad_rows() / 2);
 296                         return;
 297                 case '.':
 298                         term_scrl(-pad_rows() / 2);
 299                         return;
 300                 case '=':
 301                         t_split(split[ctag] == 1 ? 2 : 1);
 302                         return;
 303                 case '-':
 304                         t_split(0);
 305                         return;
 306                 default:
 307                         if (strchr(tags, c)) {
 308                                 t_set(tterm(strchr(tags, c) - tags));
 309                                 return;
 310                         }
 311                         if (tmain())
 312                                 term_send(ESC);
 313                 }
 314         }
 315         if (c != -1 && tmain())
 316                 term_send(c);
 317 }
 318
 319 static void peepterm(int termid)
 320 {
 321         int visible = !hidden && ctag == (termid % NTAGS) && split[ctag];
 322         if (termid != cterm())
 323                 t_hideshow(cterm(), 0, termid, visible);
 324 }
 325
 326 static void peepback(int termid)
 327 {
 328         if (termid != cterm())
 329                 t_hideshow(termid, 0, cterm(), !hidden);
 330 }
 331
 332 static int pollterms(void)
 333 {
 334         struct pollfd ufds[NTERMS + 1];
 335         int term_idx[NTERMS + 1];
 336         int i;
 337         int n = 1;
 338         ufds[0].fd = 0;
 339         ufds[0].events = POLLIN;
 340         for (i = 0; i < NTERMS; i++) {
 341                 if (TERMOPEN(i)) {
 342                         ufds[n].fd = term_fd(terms[i]);
 343                         ufds[n].events = POLLIN;
 344                         term_idx[n++] = i;
 345                 }
 346         }
 347         if (poll(ufds, n, 1000) < 1)
 348                 return 0;
 349         if (ufds[0].revents & (POLLFLAGS & ~POLLIN))
 350                 return 1;
 351         if (ufds[0].revents & POLLIN)
 352                 directkey();
 353         for (i = 1; i < n; i++) {
 354                 if (!(ufds[i].revents & POLLFLAGS))
 355                         continue;
 356                 peepterm(term_idx[i]);
 357                 if (ufds[i].revents & POLLIN) {
 358                         term_read();
 359                 } else {
 360                         scr_free(term_idx[i]);
 361                         term_end();
 362                         if (cmdmode)
 363                                 exitit = 1;
 364                 }
 365                 peepback(term_idx[i]);
 366         }
 367         return 0;
 368 }
 369
 370 static void mainloop(char **args)
 371 {
 372         struct termios oldtermios, termios;
 373         tcgetattr(0, &termios);
 374         oldtermios = termios;
 375         cfmakeraw(&termios);
 376         tcsetattr(0, TCSAFLUSH, &termios);
 377         term_load(terms[cterm()], 1);
 378         term_redraw(1);
 379         if (args) {
 380                 cmdmode = 1;
 381                 t_exec(args, 0);
 382         }
 383         while (!exitit)
 384                 if (pollterms())
 385                         break;
 386         tcsetattr(0, 0, &oldtermios);
 387 }
 388
 389 static void signalreceived(int n)
 390 {
 391         if (exitit)
 392                 return;
 393         switch (n) {
 394         case SIGUSR1:
 395                 hidden = 1;
 396                 t_hide(cterm(), 1);
 397                 ioctl(0, VT_RELDISP, 1);
 398                 break;
 399         case SIGUSR2:
 400                 hidden = 0;
 401                 fb_cmap();
 402                 if (t_show(cterm(), 2) == 3 && split[ctag]) {
 403                         t_hideshow(cterm(), 0, aterm(cterm()), 3);
 404                         t_hideshow(aterm(cterm()), 0, cterm(), 1);
 405                 }
 406                 break;
 407         case SIGCHLD:
 408                 while (waitpid(-1, NULL, WNOHANG) > 0)
 409                         ;
 410                 break;
 411         }
 412 }
 413
 414 static void signalsetup(void)
 415 {
 416         struct vt_mode vtm;
 417         vtm.mode = VT_PROCESS;
 418         vtm.waitv = 0;
 419         vtm.relsig = SIGUSR1;
 420         vtm.acqsig = SIGUSR2;
 421         vtm.frsig = 0;
 422         signal(SIGUSR1, signalreceived);
 423         signal(SIGUSR2, signalreceived);
 424         signal(SIGCHLD, signalreceived);
 425         ioctl(0, VT_SETMODE, &vtm);
 426 }
 427
 428 int main(int argc, char **argv)
 429 {
 430         char *hide = "\x1b[2J\x1b[H\x1b[?25l";
 431         char *show = "\x1b[?25h";
 432         char **args = argv + 1;
 433         int i;
 434         if (fb_init(getenv("FBDEV"))) {
 435                 fprintf(stderr, "fbpad: failed to initialize the framebuffer\n");
 436                 return 1;
 437         }
 438         if (pad_init()) {
 439                 fprintf(stderr, "fbpad: cannot find fonts\n");
 440                 return 1;
 441         }
 442         for (i = 0; i < NTERMS; i++)
 443                 terms[i] = term_make();
 444         write(1, hide, strlen(hide));
 445         signalsetup();
 446         fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 447         while (args[0] && args[0][0] == '-')
 448                 args++;
 449         mainloop(args[0] ? args : NULL);
 450         write(1, show, strlen(show));
 451         for (i = 0; i < NTERMS; i++)
 452                 term_free(terms[i]);
 453         pad_free();
 454         scr_done();
 455         fb_free();
 456         return 0;
 457 }