ansi.c

   1 #include <stdio.h>
   2 #include <sys/types.h>
   3 #include <string.h>
   4 #include <cbuf.h>
   5 #include <ncurses.h>
   6 #include <stdlib.h>
   7
   8 #include <color.h>
   9
  10
  11 static void
  12 proc_color(char *buf, attr_t *attrs, short *pair)
  13 {
  14         int c = atoi(buf);
  15
  16         if (c < 0)
  17                 return;
  18
  19         if (c == 0) {
  20                 *attrs &= ~(A_BOLD | A_UNDERLINE | A_BLINK);
  21                 *pair = BG(C_BLACK)|C_WHITE;
  22                 return;
  23         }
  24
  25         if (c == 1) {
  26                 *attrs |= A_BOLD;
  27                 return;
  28         }
  29
  30         if (c >= 30 && c <= 37) {
  31                 c-=30;
  32                 *pair &= (short)~7;
  33                 *pair |= (short)(c);
  34                 return;
  35         }
  36
  37         if (c >= 40 && c <= 47) {
  38                 c-=40;
  39                 *pair &= (short)~(BG(7));
  40                 *pair |= (short)(BG(c));
  41         }
  42
  43 }
  44
  45
  46 static void
  47 process_color(WINDOW *win, char *buffer, size_t len)
  48 {
  49         char *curr, *next = NULL;
  50         attr_t attrs;
  51         short pair;
  52
  53         /* Get current attrs */
  54         wattr_get(win, &attrs, &pair, NULL);
  55
  56         while((curr = strtok_r(next?NULL:buffer, ";", &next))) {
  57                 proc_color(curr, &attrs, &pair);
  58         }
  59
  60         wattr_set(win, attrs, pair, NULL);
  61 }
  62
  63
  64 static void
  65 process_clear(WINDOW *win, char *buffer, size_t len)
  66 {
  67         switch (*buffer) {
  68         case 0:
  69         case '0':
  70                 /* NOT IMPLEMENTED */
  71                 break;
  72         case '1':
  73                 wclrtoeol(win);
  74                 break;
  75         case '2':
  76                 wclear(win);
  77                 break;
  78         }
  79
  80         //wcolor_set(win, BG(C_BLACK)|C_RED, NULL);
  81         //wprintw(win,"Cleared.\n");
  82 }
  83
  84 static void
  85 process_cursor(WINDOW *win, char *buffer, size_t len)
  86 {
  87         char *next = NULL;
  88         int y = 1, x = 1;
  89
  90         if (strlen(buffer)) {
  91                 next = strchr(buffer, ';');
  92                 if (next) {
  93                         *next = 0;
  94                         ++next;
  95                         x = atoi(next);
  96                 }
  97
  98                 y = atoi(buffer);
  99         }
 100
 101         x--; y--;
 102
 103         if (y < 0)
 104                 y = 0;
 105         if (x < 0)
 106                 x = 0;
 107
 108         wmove(win, y, x);
 109 }
 110
 111 static void
 112 process_buf(WINDOW *win, char *buffer, size_t len, char code)
 113 {
 114         switch(code) {
 115         case 'm':
 116                 process_color(win, buffer, len);
 117                 break;
 118         case 'H':
 119                 process_cursor(win, buffer, len);
 120                 break;
 121         case 'J':
 122                 process_clear(win, buffer, len);
 123                 break;
 124         }
 125 }
 126
 127
 128 int
 129 ansi_strip(char *circbuf, const char *buffer, size_t len)
 130 {
 131         int x, ret = 0;
 132         int in_escape_code = 0;
 133         char c;
 134
 135         for (x = 0; x < len; x++) {
 136
 137                 c = buffer[x];
 138
 139                 switch(buffer[x]) {
 140                 case '\r':
 141                         break;
 142                 case 0:
 143                         c = ' ';
 144                         cb_append(circbuf, &c, 1);
 145                         ++ret;
 146                         break;
 147                 case 27:
 148                         in_escape_code = 1;
 149                         break;
 150                 case '[':
 151                         if (in_escape_code == 1) {
 152                                 in_escape_code = 2;
 153                         } else if (in_escape_code == 0) {
 154                                 cb_append(circbuf, &c, 1);
 155                                 ++ret;
 156                         }
 157                         break;
 158                 /* most of these are not and will not be handled */
 159                 case 'A':
 160                 case 'B':
 161                 case 'C':
 162                 case 'D':
 163                 case 'E':
 164                 case 'F':
 165                 case 'G':
 166                 case 'H':
 167                 case 'J':
 168                 case 'K':
 169                 case 'S':
 170                 case 'T':
 171                 case 'f':
 172                 case 'm':
 173                 case 's':
 174                 case 'u':
 175                         if (in_escape_code == 2) {
 176                                 in_escape_code = 0;
 177                                 continue;
 178                         }
 179                 default:
 180                         if (in_escape_code == 2)
 181                                 continue;
 182                         cb_append(circbuf, &c, 1);
 183                         ++ret;
 184                         break;
 185                 }
 186         }
 187
 188         return ret;
 189 }
 190
 191
 192 size_t
 193 ansi_waddnstr(WINDOW *win, const char *buffer, size_t len)
 194 {
 195         int x;
 196         int in_escape_code = 0;
 197         char *presumed_start = NULL;
 198         char buf[80];
 199         size_t ret = 0;
 200
 201         for (x = 0; x < len; x++) {
 202
 203                 switch(buffer[x]) {
 204
 205                 case '\r':
 206                         ++ret;
 207                         break;
 208                 case 0:
 209                         waddch(win, ' ');
 210                         ++ret;
 211                         break;
 212                 case 27:
 213                         in_escape_code = 1;
 214                         presumed_start = (char *)&buffer[x];
 215                         break;
 216                 case '[':
 217                         if (in_escape_code == 1) {
 218                                 in_escape_code = 2;
 219                         } else if (in_escape_code == 0) {
 220                                 waddch(win, buffer[x]);
 221                                 ++ret;
 222                                 //printf("%c\n", buffer[x]);
 223                         }
 224                         break;
 225                 /* most of these are not and will not be handled */
 226                 case 'A':
 227                 case 'B':
 228                 case 'C':
 229                 case 'D':
 230                 case 'E':
 231                 case 'F':
 232                 case 'G':
 233                 case 'H':
 234                 case 'J':
 235                 case 'K':
 236                 case 'S':
 237                 case 'T':
 238                 case 'f':
 239                 case 'm':
 240                 case 's':
 241                 case 'u':
 242                         if (in_escape_code == 2) {
 243                                 in_escape_code = 0;
 244                                 presumed_start += 2;
 245                                 if (&buffer[x] - presumed_start <= sizeof(buf)) {
 246                                         memcpy(buf, presumed_start, &buffer[x] - presumed_start);
 247                                         buf[&buffer[x] - presumed_start] = 0;
 248                                         process_buf(win, buf, strlen(buf), buffer[x]);
 249                                         ret += (&buffer[x] - presumed_start)+3;
 250                                 }
 251                                 continue;
 252                         }
 253                 default:
 254                         if (in_escape_code)
 255                                 continue;
 256                         ++ret;
 257                         waddch(win, buffer[x]);
 258                         break;
 259                 }
 260         }
 261
 262         return ret;
 263 }