fbpad.c

   1 /*
   2  * fbpad - a small linux framebuffer virtual terminal
   3  *
   4  * Copyright (C) 2009-2011 Ali Gholami Rudi <ali at rudi dot ir>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License, as published by the
   8  * Free Software Foundation.
   9  */
  10 #include <ctype.h>
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <poll.h>
  14 #include <signal.h>
  15 #include <string.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/wait.h>
  18 #include <termios.h>
  19 #include <unistd.h>
  20 #include <linux/vt.h>
  21 #include "config.h"
  22 #include "pad.h"
  23 #include "term.h"
  24 #include "util.h"
  25
  26 #define CTRLKEY(x)      ((x) - 96)
  27 #define BADPOLLFLAGS    (POLLHUP | POLLERR | POLLNVAL)
  28 #define NTAGS           sizeof(tags)
  29 #define NTERMS          (NTAGS * 2)
  30
  31 static char tags[] = TAGS;
  32 static struct term terms[NTERMS];
  33 static int tops[NTAGS]; /* top terms of tags */
  34 static int ctag;        /* current tag */
  35 static int ltag;        /* the last tag */
  36 static int exitit;
  37 static int hidden;
  38
  39 static int readchar(void)
  40 {
  41         char b;
  42         if (read(STDIN_FILENO, &b, 1) > 0)
  43                 return (int) b;
  44         return -1;
  45 }
  46
  47 static int cterm(void)
  48 {
  49         return tops[ctag] * NTAGS + ctag;
  50 }
  51
  52 static void showterm(int n)
  53 {
  54         if (cterm() == n)
  55                 return;
  56         if (ctag != n % NTAGS)
  57                 ltag = ctag;
  58         term_save(&terms[cterm()]);
  59         ctag = n % NTAGS;
  60         tops[ctag] = n / NTAGS;
  61         term_load(&terms[n], hidden ? TERM_HIDDEN : TERM_REDRAW);
  62 }
  63
  64 static void showtag(int n)
  65 {
  66         showterm(tops[n] * NTAGS + n);
  67 }
  68
  69 static struct term *mainterm(void)
  70 {
  71         if (terms[cterm()].fd)
  72                 return &terms[cterm()];
  73         return NULL;
  74 }
  75
  76 static void exec_cmd(char *file)
  77 {
  78         if (!mainterm())
  79                 term_exec(file);
  80 }
  81
  82 static int altterm(int n)
  83 {
  84         return n < NTAGS ? n + NTAGS : n - NTAGS;
  85 }
  86
  87 static void nextterm(void)
  88 {
  89         int n = (cterm() + 1) % NTERMS;
  90         while (n != cterm()) {
  91                 if (terms[n].fd) {
  92                         showterm(n);
  93                         break;
  94                 }
  95                 n = (n + 1) % NTERMS;
  96         }
  97 }
  98
  99 static void showtags(void)
 100 {
 101         int colors[] = {15, 4, 2};
 102         int c = 0;
 103         int r = pad_rows() - 1;
 104         int i;
 105         pad_put('T', r, c++, FGCOLOR, BGCOLOR);
 106         pad_put('A', r, c++, FGCOLOR, BGCOLOR);
 107         pad_put('G', r, c++, FGCOLOR, BGCOLOR);
 108         pad_put('S', r, c++, FGCOLOR, BGCOLOR);
 109         pad_put(':', r, c++, FGCOLOR, BGCOLOR);
 110         pad_put(' ', r, c++, FGCOLOR, BGCOLOR);
 111         for (i = 0; i < NTAGS; i++) {
 112                 int nt = 0;
 113                 if (terms[i].fd)
 114                         nt++;
 115                 if (terms[altterm(i)].fd)
 116                         nt++;
 117                 pad_put(i == ctag ? '(' : ' ', r, c++, FGCOLOR, BGCOLOR);
 118                 pad_put(tags[i], r, c++, colors[nt], 7);
 119                 pad_put(i == ctag ? ')' : ' ', r, c++, FGCOLOR, BGCOLOR);
 120         }
 121 }
 122
 123 static void directkey(void)
 124 {
 125         int c = readchar();
 126         if (c == ESC) {
 127                 switch ((c = readchar())) {
 128                 case 'c':
 129                         exec_cmd(SHELL);
 130                         return;
 131                 case 'm':
 132                         exec_cmd(MAIL);
 133                         return;
 134                 case 'e':
 135                         exec_cmd(EDITOR);
 136                         return;
 137                 case 'j':
 138                 case 'k':
 139                         showterm(altterm(cterm()));
 140                         return;
 141                 case 'o':
 142                         showtag(ltag);
 143                         return;
 144                 case 'p':
 145                         showtags();
 146                         return;
 147                 case '\t':
 148                         nextterm();
 149                         return;
 150                 case CTRLKEY('q'):
 151                         exitit = 1;
 152                         return;
 153                 case 's':
 154                         term_screenshot();
 155                         return;
 156                 default:
 157                         if (strchr(tags, c)) {
 158                                 showtag(strchr(tags, c) - tags);
 159                                 return;
 160                         }
 161                         if (mainterm())
 162                                 term_send(ESC);
 163                 }
 164         }
 165         if (c != -1 && mainterm())
 166                 term_send(c);
 167 }
 168
 169 static void temp_switch(int termid)
 170 {
 171         if (termid != cterm()) {
 172                 term_save(&terms[cterm()]);
 173                 term_load(&terms[termid], TERM_HIDDEN);
 174         }
 175 }
 176
 177 static void switch_back(int termid)
 178 {
 179         if (termid != cterm()) {
 180                 term_save(&terms[termid]);
 181                 term_load(&terms[cterm()], hidden ? TERM_HIDDEN : TERM_VISIBLE);
 182         }
 183 }
 184
 185 static int poll_all(void)
 186 {
 187         struct pollfd ufds[NTERMS + 1];
 188         int term_idx[NTERMS + 1];
 189         int i;
 190         int n = 1;
 191         ufds[0].fd = STDIN_FILENO;
 192         ufds[0].events = POLLIN;
 193         for (i = 0; i < NTERMS; i++) {
 194                 if (terms[i].fd) {
 195                         ufds[n].fd = terms[i].fd;
 196                         ufds[n].events = POLLIN;
 197                         term_idx[n++] = i;
 198                 }
 199         }
 200         if (poll(ufds, n, 1000) < 1)
 201                 return 0;
 202         if (ufds[0].revents & BADPOLLFLAGS)
 203                 return 1;
 204         if (ufds[0].revents & POLLIN)
 205                 directkey();
 206         for (i = 1; i < n; i++) {
 207                 temp_switch(term_idx[i]);
 208                 if (ufds[i].revents & POLLIN)
 209                         term_read();
 210                 if (ufds[i].revents & BADPOLLFLAGS)
 211                         term_end();
 212                 switch_back(term_idx[i]);
 213         }
 214         return 0;
 215 }
 216
 217 static void mainloop(void)
 218 {
 219         struct termios oldtermios, termios;
 220         tcgetattr(STDIN_FILENO, &termios);
 221         oldtermios = termios;
 222         cfmakeraw(&termios);
 223         tcsetattr(STDIN_FILENO, TCSAFLUSH, &termios);
 224         term_load(&terms[cterm()], TERM_REDRAW);
 225         while (!exitit)
 226                 if (poll_all())
 227                         break;
 228         tcsetattr(STDIN_FILENO, 0, &oldtermios);
 229 }
 230
 231 static void signalreceived(int n)
 232 {
 233         if (exitit)
 234                 return;
 235         switch (n) {
 236         case SIGUSR1:
 237                 hidden = 1;
 238                 term_save(&terms[cterm()]);
 239                 term_load(&terms[cterm()], TERM_HIDDEN);
 240                 ioctl(STDIN_FILENO, VT_RELDISP, 1);
 241                 break;
 242         case SIGUSR2:
 243                 hidden = 0;
 244                 pad_shown();
 245                 term_save(&terms[cterm()]);
 246                 term_load(&terms[cterm()], TERM_REDRAW);
 247                 break;
 248         case SIGCHLD:
 249                 while (waitpid(-1, NULL, WNOHANG) > 0)
 250                         ;
 251                 break;
 252         }
 253 }
 254
 255 static void setupsignals(void)
 256 {
 257         struct vt_mode vtm;
 258         vtm.mode = VT_PROCESS;
 259         vtm.waitv = 0;
 260         vtm.relsig = SIGUSR1;
 261         vtm.acqsig = SIGUSR2;
 262         vtm.frsig = 0;
 263         ioctl(STDIN_FILENO, VT_SETMODE, &vtm);
 264
 265         signal(SIGUSR1, signalreceived);
 266         signal(SIGUSR2, signalreceived);
 267         signal(SIGCHLD, signalreceived);
 268 }
 269
 270 int main(void)
 271 {
 272         char *hide = "\x1b[?25l";
 273         char *clear = "\x1b[2J\x1b[H";
 274         char *show = "\x1b[?25h";
 275         write(STDOUT_FILENO, clear, strlen(clear));
 276         write(STDIN_FILENO, hide, strlen(hide));
 277         pad_init();
 278         setupsignals();
 279         fcntl(STDIN_FILENO, F_SETFL,
 280                 fcntl(STDIN_FILENO, F_GETFL) | O_NONBLOCK);
 281         mainloop();
 282         pad_free();
 283         write(STDIN_FILENO, show, strlen(show));
 284         return 0;
 285 }