lib/curses/curses.c

   1 /*
   2 lightOS libunix
   3 Copyright (C) 2007-2009 Jörg Pfähler
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 */
  19 #include <stdio.h>
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <curses.h>
  24 #include <libOS/LIBUNIX_glue.h>
  25 #include <libOS/LIBC_glue.h>
  26
  27 // TODO
  28 #include <libserver/console.h>
  29 #include <libOS/lightOS/internal/curses.h>
  30
  31 // TODO: curses mode can be paused through endwin() and started again through a refresh
  32
  33 #define MAKE_COLOR_PAIR(foreground, background)  (((background) << 4) | (foreground))
  34
  35 // Define the SCREEN modes
  36 #define SCREEN_MODE_ECHO                         0x01
  37 #define SCREEN_MODE_CBREAK                       0x02
  38 #define SCREEN_MODE_KEYPAD                       0x04
  39 #define SCREEN_MODE_NEWLINE_TRANSLATION          0x08
  40
  41 // Define the WINDOW modes
  42 #define WINDOW_MODE_NO_DELAY                     0x01
  43
  44 struct _LIBUNIX_WINDOW
  45 {
  46   size_t x;
  47   size_t y;
  48   size_t width;
  49   size_t height;
  50   size_t cursor;
  51   size_t color;
  52   size_t mode;
  53   _LIBOS_WINDOW osdep;
  54   struct _LIBUNIX_WINDOW *parent;
  55   struct _LIBUNIX_SCREEN *screen;
  56 };
  57
  58 struct _LIBUNIX_SCREEN
  59 {
  60   size_t width;
  61   size_t height;
  62   FILE *infile;
  63   FILE *outfile;
  64   WINDOW *curscr;
  65   WINDOW *stdscr;
  66   size_t mode;
  67 };
  68
  69 // Global variables
  70 int COLS = 0;
  71 int LINES = 0;
  72 WINDOW *curscr = NULL;
  73 WINDOW *stdscr = NULL;
  74
  75 // File-local variables
  76 static SCREEN *_LIBUNIX_cur_screen = NULL;
  77
  78
  79 //
  80 // File-local functions
  81 //
  82
  83 static int _LIBUNIX_move_cursor(int x, int y)
  84 {
  85   assert(_LIBUNIX_cur_screen != NULL);
  86
  87   // Set the 'hardware' cursor
  88   _LIBSERVER_CONSOLE_SET_CURSOR(_LIBUNIX_cur_screen->outfile, x, y);
  89   return OK;
  90 }
  91
  92
  93 //
  94 // Initialization functions
  95 //
  96
  97 SCREEN *newterm(char *type,
  98                 FILE *outfile,
  99                 FILE *infile)
 100 {
 101   // NOTE: type is ignored
 102   assert(outfile != NULL);
 103   assert(infile != NULL);
 104
 105   // Allocate memory for the SCREEN
 106   SCREEN *Screen = malloc(sizeof(SCREEN));
 107   if (Screen == NULL)
 108     return NULL;
 109
 110   // Initialize the SCREEN
 111   Screen->width = 80;
 112   Screen->height = 25;
 113   Screen->infile = infile;
 114   Screen->outfile = outfile;
 115   Screen->mode = SCREEN_MODE_ECHO | SCREEN_MODE_NEWLINE_TRANSLATION;
 116
 117   // Allocate memory for stdscr
 118   Screen->stdscr = malloc(sizeof(WINDOW));
 119   if (Screen->stdscr == NULL)
 120     goto error_stdscr;
 121   if (_LIBOS_init_window(&Screen->stdscr->osdep,
 122                          Screen->width,
 123                          Screen->height,
 124                          FALSE) == FALSE)
 125     goto error_stdscr_init;
 126
 127   // Initialize the stdscr
 128   Screen->stdscr->x = 0;
 129   Screen->stdscr->y = 0;
 130   Screen->stdscr->width = Screen->width;
 131   Screen->stdscr->height = Screen->height;
 132   Screen->stdscr->cursor = 0;
 133   Screen->stdscr->color = MAKE_COLOR_PAIR(COLOR_WHITE, COLOR_BLACK);
 134   Screen->stdscr->mode = 0;
 135   Screen->stdscr->parent = NULL;
 136   Screen->stdscr->screen = Screen;
 137
 138   // Allocate memory for curscr
 139   Screen->curscr = malloc(sizeof(WINDOW));
 140   if (Screen->curscr == NULL)goto error_curscr;
 141   if (_LIBOS_init_window(&Screen->curscr->osdep,
 142                          Screen->width,
 143                          Screen->height,
 144                          TRUE) == FALSE)
 145     goto error_curscr_init;
 146
 147   // Initialize the curscr
 148   Screen->curscr->x = 0;
 149   Screen->curscr->y = 0;
 150   Screen->curscr->width = Screen->width;
 151   Screen->curscr->height = Screen->height;
 152   Screen->curscr->cursor = 0;
 153   Screen->curscr->color = MAKE_COLOR_PAIR(COLOR_WHITE, COLOR_BLACK);
 154   Screen->curscr->mode = 0;
 155   Screen->curscr->parent = NULL;
 156   Screen->curscr->screen = Screen;
 157
 158   // Disable 'hardware' echoing
 159   // TODO: libOS
 160   _LIBSERVER_CONSOLE_HW_ECHO(Screen->outfile, false);
 161
 162   // Clear the screen
 163   // TODO: libOS
 164   _LIBSERVER_CONSOLE_CLEAR(Screen->outfile);
 165
 166   // Set current SCREEN, stdscr & curscr
 167   if (_LIBUNIX_cur_screen == NULL)
 168     set_term(Screen);
 169
 170   return Screen;
 171
 172   error_curscr_init:
 173     free(Screen->curscr);
 174   error_curscr:
 175     _LIBOS_deinit_window(&Screen->stdscr->osdep);
 176   error_stdscr_init:
 177     free(Screen->stdscr);
 178   error_stdscr:
 179     free(Screen);
 180   return NULL;
 181 }
 182
 183 SCREEN *set_term(SCREEN *newterm)
 184 {
 185   curscr = newterm->curscr;
 186   stdscr = newterm->stdscr;
 187   COLS = newterm->width;
 188   LINES = newterm->height;
 189
 190   SCREEN *tmp = _LIBUNIX_cur_screen;
 191   _LIBUNIX_cur_screen = newterm;
 192   return tmp;
 193 }
 194
 195 WINDOW *initscr()
 196 {
 197   if (newterm(NULL, stdout, stdin) == NULL)
 198   {
 199     // TODO: What should we do here?
 200     _LIBOS_WARNING("libunix", "failed");
 201     abort();
 202   }
 203   return stdscr;
 204 }
 205
 206 void _LIBUNIX_getyx(const WINDOW *win, int *y, int *x)
 207 {
 208   *y = (win->cursor / 2) / win->width;
 209   *x = (win->cursor / 2) % win->width;
 210 }
 211
 212 void _LIBUNIX_getbegyx(const WINDOW *win, int *y, int *x)
 213 {
 214   *y = win->y;
 215   *x = win->x;
 216 }
 217
 218 void _LIBUNIX_getmaxyx(const WINDOW *win, int *y, int *x)
 219 {
 220   *y = win->height;
 221   *x = win->width;
 222 }
 223
 224
 225 //
 226 // Control the modes
 227 //
 228
 229 // TODO: libOS?
 230 int echo()
 231 {
 232   assert(_LIBUNIX_cur_screen != NULL);
 233   _LIBUNIX_cur_screen->mode |= SCREEN_MODE_ECHO;
 234   return OK;
 235 }
 236
 237 int noecho()
 238 {
 239   assert(_LIBUNIX_cur_screen != NULL);
 240   _LIBUNIX_cur_screen->mode &= ~SCREEN_MODE_ECHO;
 241   return OK;
 242 }
 243
 244 int cbreak()
 245 {
 246   assert(_LIBUNIX_cur_screen != NULL);
 247   _LIBUNIX_cur_screen->mode |= SCREEN_MODE_CBREAK;
 248   fflush(_LIBUNIX_cur_screen->outfile);
 249   fprintf(_LIBUNIX_cur_screen->outfile, "\x1B]B");
 250   fflush(_LIBUNIX_cur_screen->outfile);
 251   return OK;
 252 }
 253
 254 int nocbreak()
 255 {
 256   assert(_LIBUNIX_cur_screen != NULL);
 257   _LIBUNIX_cur_screen->mode &= ~SCREEN_MODE_CBREAK;
 258   fflush(_LIBUNIX_cur_screen->outfile);
 259   fprintf(_LIBUNIX_cur_screen->outfile, "\x1B[B");
 260   fflush(_LIBUNIX_cur_screen->outfile);
 261   return OK;
 262 }
 263
 264 int raw()
 265 {
 266   _LIBOS_WARNING("libunix", "not implemented");
 267   // TODO
 268 }
 269
 270 int noraw()
 271 {
 272   _LIBOS_WARNING("libunix", "not implemented");
 273   // TODO
 274 }
 275
 276 int nl()
 277 {
 278   assert(_LIBUNIX_cur_screen != NULL);
 279   _LIBUNIX_cur_screen->mode |= SCREEN_MODE_NEWLINE_TRANSLATION;
 280   return OK;
 281 }
 282
 283 int nonl()
 284 {
 285   assert(_LIBUNIX_cur_screen != NULL);
 286   _LIBUNIX_cur_screen->mode &= ~SCREEN_MODE_NEWLINE_TRANSLATION;
 287   return OK;
 288 }
 289
 290 int keypad(WINDOW *win, bool bf)
 291 {
 292   assert(win != NULL);
 293   if (bf == true)win->mode |= SCREEN_MODE_KEYPAD;
 294   else win->mode &= ~SCREEN_MODE_KEYPAD;
 295   return OK;
 296 }
 297
 298 int nodelay(WINDOW *win, bool bf)
 299 {
 300   assert(win != NULL);
 301
 302   if (bf != FALSE)
 303     win->mode |= WINDOW_MODE_NO_DELAY;
 304   else
 305     win->mode &= ~WINDOW_MODE_NO_DELAY;
 306
 307   return OK;
 308 }
 309
 310
 311 //
 312 // Control the cursor modes
 313 //
 314
 315 int curs_set(int visibility)
 316 {
 317   assert(_LIBUNIX_cur_screen != NULL);
 318
 319   fflush(_LIBUNIX_cur_screen->outfile);
 320   const char *string = NULL;
 321   if (visibility == 0)
 322     string = "\x1B[V0";
 323   else
 324     string = "\x1B[V1";
 325   fprintf(_LIBUNIX_cur_screen->outfile, string);
 326   fflush(_LIBUNIX_cur_screen->outfile);
 327   return OK;
 328 }
 329
 330
 331 //
 332 // Window management
 333 //
 334
 335 WINDOW *newwin(int nlines, int ncols, int begin_y, int begin_x)
 336 {
 337   assert(_LIBUNIX_cur_screen != NULL);
 338
 339   if (ncols == 0)
 340     ncols = COLS - begin_x;
 341   if (nlines == 0)
 342     nlines = LINES - begin_y;
 343
 344   // Allocate memory for the window
 345   WINDOW *window = malloc(sizeof(WINDOW));
 346   if (window == NULL)
 347     return NULL;
 348   if (_LIBOS_init_window(&window->osdep, nlines, ncols, FALSE) == FALSE)
 349   {
 350     free(window);
 351     return NULL;
 352   }
 353
 354   // Initialize the window
 355   window->x = begin_x;
 356   window->y = begin_y;
 357   window->width = ncols;
 358   window->height = nlines;
 359   window->cursor = 0;
 360   window->color = MAKE_COLOR_PAIR(COLOR_WHITE, COLOR_BLACK);
 361   window->mode = 0;
 362   window->parent = stdscr;
 363   window->screen = _LIBUNIX_cur_screen;
 364
 365   return window;
 366 }
 367
 368 int endwin()
 369 {
 370   assert(_LIBUNIX_cur_screen != NULL);
 371
 372   // Restore the cursor
 373   if (curs_set(1) == ERR)return ERR;
 374
 375   // Enable 'hardware' echoing
 376   // TODO: libOS
 377   fflush(_LIBUNIX_cur_screen->outfile);
 378   fprintf(_LIBUNIX_cur_screen->outfile, "\x1B[E");
 379   fflush(_LIBUNIX_cur_screen->outfile);
 380
 381   // Clear the screen
 382   // TODO: libOS
 383   fprintf(_LIBUNIX_cur_screen->outfile, "\x1B[C");
 384   fflush(_LIBUNIX_cur_screen->outfile);
 385
 386   // Deallocate memory for the SCREEN, curscr & stdscr
 387   // TODO: delscreen()
 388   // free(_cur_screen->stdscr);
 389   // free(_cur_screen->curscr);
 390   // free(_cur_screen);
 391
 392   // Reset current SCREEN, stdscr & curscr
 393   // _cur_screen = NULL;
 394   // stdscr = NULL;
 395   // curscr = NULL;
 396   // COLS = 0;
 397   // LINES = 0;
 398
 399   return OK;
 400 }
 401
 402 int wclear(WINDOW *win)
 403 {
 404   assert(win != NULL);
 405
 406   // Clear the screen
 407   win->cursor = 0;
 408   memset(_LIBOS_window_data(&win->osdep),
 409          0,
 410          win->width * win->height * 2);
 411
 412   return OK;
 413 }
 414
 415 int werase(WINDOW *win)
 416 {
 417   return wclear(win);
 418 }
 419
 420 int wmove(WINDOW *win, int y, int x)
 421 {
 422   assert(win != NULL);
 423   assert(x < win->width);
 424   assert(y < win->height);
 425
 426   win->cursor = (win->width * y + x) * 2;
 427   return OK;
 428 }
 429
 430 int waddch(WINDOW *win, const chtype ch)
 431 {
 432   assert(win != NULL);
 433
 434   // Get a pointer to the memory
 435   char *Data = _LIBOS_window_data(&win->osdep);
 436
 437   // Write the character to the memory
 438   if (ch == '\n')
 439   {
 440     // NOTE: to static terminal size
 441     win->cursor -= win->cursor % 160;
 442     win->cursor += 160;
 443   }
 444   else
 445   {
 446     Data[win->cursor] = (char)ch;
 447     Data[win->cursor + 1] = win->color;
 448   }
 449
 450   // Move the cursor
 451   win->cursor += 2;
 452
 453   // TODO: replace spaces with the background character (should be \0)
 454   // TODO: Attributes
 455   // TODO: Wrapping
 456   // TODO: Special character processing
 457   return OK;
 458 }
 459
 460 int mvwaddch(WINDOW *win, int y, int x, const chtype ch)
 461 {
 462   assert(win != NULL);
 463
 464   // Move the cursor
 465   if (wmove(win, y, x) != OK)return ERR;
 466
 467   // Add the character
 468   return waddch(win, ch);
 469 }
 470
 471 int waddstr(WINDOW *win, const char *str)
 472 {
 473   return waddnstr(win, str, -1);
 474 }
 475
 476 int waddnstr(WINDOW *win, const char *str, int n)
 477 {
 478   assert(win != NULL);
 479
 480   if (n == -1)n = strlen(str);
 481
 482   for (int i = 0;i < n;i++)
 483   {
 484     if (str[i] == '\0')break;
 485     waddch(win, str[i]);
 486   }
 487
 488   return OK;
 489 }
 490
 491 int mvwaddstr(WINDOW *win, int y, int x, const char *str)
 492 {
 493   return mvwaddnstr(win, y, x, str, -1);
 494 }
 495
 496 int mvwaddnstr(WINDOW *win, int y, int x, const char *str, int n)
 497 {
 498   assert(win != NULL);
 499
 500   // Move the cursor
 501   if (wmove(win, y, x) != OK)return ERR;
 502
 503   // Add the string
 504   return waddnstr(win, str, n);
 505 }
 506
 507 static int var_wprintw(WINDOW *win, const char *fmt, va_list args)
 508 {
 509   va_list argcopy;
 510   va_copy(argcopy, args);
 511   int result = vsnprintf(0, 0, fmt, argcopy);
 512   va_end(argcopy);
 513   if (result < 0)return ERR;
 514   char *array = malloc(result + 1);
 515   result = vsnprintf(array, result + 1, fmt, args);
 516   if (result < 0)
 517   {
 518     free(array);
 519     return ERR;
 520   }
 521   waddstr(win, array);
 522   free(array);
 523   return result;
 524 }
 525
 526 int printw(const char *fmt, ...)
 527 {
 528   va_list args;
 529   va_start(args, fmt);
 530   int result = var_wprintw(stdscr, fmt, args);
 531   va_end(args);
 532   return result;
 533 }
 534
 535 int wprintw(WINDOW *win, const char *fmt, ...)
 536 {
 537   va_list args;
 538   va_start(args, fmt);
 539   int result = var_wprintw(win, fmt, args);
 540   va_end(args);
 541   return result;
 542 }
 543
 544 static int var_mvwprintw(WINDOW *win, int y, int x, const char *fmt, va_list args)
 545 {
 546   va_list argcopy;
 547   va_copy(argcopy, args);
 548   int result = vsnprintf(0, 0, fmt, argcopy);
 549   va_end(argcopy);
 550   if (result < 0)return ERR;
 551   char *array = malloc(result + 1);
 552   result = vsnprintf(array, result + 1, fmt, args);
 553   if (result < 0)
 554   {
 555     free(array);
 556     return ERR;
 557   }
 558   mvwaddstr(win, y, x, array);
 559   free(array);
 560   return result;
 561 }
 562
 563 int mvprintw(int y, int x, const char *fmt, ...)
 564 {
 565   va_list args;
 566   va_start(args, fmt);
 567   int result = var_mvwprintw(stdscr, y, x, fmt, args);
 568   va_end(args);
 569   return result;
 570 }
 571
 572 int mvwprintw(WINDOW *win, int y, int x, const char *fmt, ...)
 573 {
 574   va_list args;
 575   va_start(args, fmt);
 576   int result = var_mvwprintw(win, y, x, fmt, args);
 577   va_end(args);
 578   return result;
 579 }
 580
 581
 582
 583
 584
 585 int wattroff(WINDOW *win, int attrs)
 586 {
 587   assert(win != NULL);
 588
 589   if ((attrs & A_REVERSE) != 0)
 590   {
 591     win->color = MAKE_COLOR_PAIR(COLOR_WHITE, COLOR_BLACK);
 592   }
 593
 594   if ((attrs & (~(A_REVERSE))) != 0)
 595   {
 596     _LIBOS_WARNING("libunix", "unimplemented attribute");
 597     abort();
 598   }
 599
 600   return OK;
 601 }
 602 int wattron(WINDOW *win, int attrs)
 603 {
 604   assert(win != NULL);
 605
 606   if ((attrs & A_REVERSE) != 0)
 607   {
 608     win->color = MAKE_COLOR_PAIR(COLOR_BLACK, COLOR_WHITE);
 609   }
 610
 611   if ((attrs & (~(A_REVERSE))) != 0)
 612   {
 613     _LIBOS_WARNING("libunix", "unimplemented attribute");
 614     abort();
 615   }
 616
 617   return OK;
 618 }
 619
 620
 621 int mvwgetch(WINDOW *win, int y, int x)
 622 {
 623   assert(win != NULL);
 624
 625   // Move the cursor
 626   if (wmove(win, y, x) != OK)return ERR;
 627
 628   return wgetch(win);
 629 }
 630 int wgetch(WINDOW *win)
 631 {
 632   assert(win != NULL);
 633
 634   // TODO: Is window a Pad?
 635   wrefresh(win);
 636
 637   // TODO FIXME HACK
 638   if ((win->mode & WINDOW_MODE_NO_DELAY) != 0)
 639     return ERR;
 640
 641   _LIBSERVER_key_t Key;
 642   int result;
 643   char tmp[10];
 644   size_t length = 0;
 645   do
 646   {
 647     int character = fgetc(win->screen->infile);
 648     if (character == EOF)
 649       return ERR;
 650
 651     tmp[length++] = (char)character;
 652
 653     if ((win->mode & SCREEN_MODE_KEYPAD) == SCREEN_MODE_KEYPAD)
 654     {
 655       result = _LIBSERVER_convert_from_ecma48(tmp, length, &Key);
 656       assert(result != _LIBSERVER_CONVERT_FAILED);
 657     }
 658     else
 659     {
 660       Key.character = tmp[0];
 661       Key.code      = _LIBSERVER_KEYCODE_NONE;
 662       result        = _LIBSERVER_CONVERT_OK;
 663     }
 664
 665     if (result == _LIBSERVER_CONVERT_FAILED)
 666       return ERR;
 667   } while (result == _LIBSERVER_CONVERT_NEED_INPUT);
 668
 669   int retval = Key.character;
 670   if (Key.character == L'\0')
 671     retval = _LIBOS_KEYCODE_TO_LIBUNIX(Key.code);
 672
 673   // Newline translation disabled?
 674   if ((win->mode & SCREEN_MODE_NEWLINE_TRANSLATION) == 0 && retval == '\n')
 675     retval = KEY_ENTER;
 676
 677   // Print the character
 678   if ((_LIBUNIX_cur_screen->mode & SCREEN_MODE_ECHO) != 0)
 679     if (retval < 256)
 680       if (waddch(win, (chtype)retval) == ERR)
 681         return ERR;
 682
 683   return retval;
 684 }
 685
 686
 687 int wrefresh(WINDOW *win)
 688 {
 689   assert(win != NULL);
 690
 691   if (wnoutrefresh(win) == ERR)return ERR;
 692   return doupdate();
 693 }
 694
 695 int wnoutrefresh(WINDOW *win)
 696 {
 697   assert(win != NULL);
 698
 699   // Copy window data to curscr
 700   size_t offsrc = 0;
 701   size_t offdest = (win->y * curscr->width + win->x) * 2;
 702   size_t cpywidth = win->width;
 703   if ((win->width + win->x) > curscr->width)
 704     cpywidth = curscr->width - win->x;
 705   size_t cpyheight = win->height;
 706   if ((win->height + win->y) > curscr->height)
 707     cpyheight = curscr->height - win->y;
 708   for (size_t i = 0;i < cpyheight;i++)
 709   {
 710     memcpy(_LIBOS_window_data(&curscr->osdep) + offdest,
 711            _LIBOS_window_data(&win->osdep) + offsrc,
 712            cpywidth * 2);
 713     offdest += curscr->width * 2;
 714     offsrc += win->width * 2;
 715   }
 716
 717   size_t curx = ((win->cursor / 2) % win->width) + win->x;
 718   size_t cury = ((win->cursor / 2) / win->width) + win->y;
 719   curscr->cursor = ((cury * curscr->width) + curx) * 2;
 720
 721   return OK;
 722 }
 723
 724 int doupdate()
 725 {
 726   _LIBOS_screen_update(&curscr->osdep, _LIBUNIX_cur_screen->outfile);
 727
 728   // Set the cursor
 729   _LIBUNIX_move_cursor((curscr->cursor / 2) % curscr->width,
 730                        (curscr->cursor / 2) / curscr->width);
 731   return OK;
 732 }
 733
 734 int beep()
 735 {
 736   _LIBOS_WARNING("libunix", "not implemented");
 737   abort();
 738   return 0;
 739 }
 740 int delwin(WINDOW *win)
 741 {
 742   _LIBOS_WARNING("libunix", "not implemented");
 743   abort();
 744   return 0;
 745 }
 746 int scrollok(WINDOW *win, bool bf)
 747 {
 748   _LIBOS_WARNING("libunix", "not implemented");
 749   abort();
 750   return 0;
 751 }
 752 int wscrl(WINDOW *win, int n)
 753 {
 754   _LIBOS_WARNING("libunix", "not implemented");
 755   abort();
 756   return 0;
 757 }
 758 bool isendwin(void)
 759 {
 760   _LIBOS_WARNING("libunix", "not implemented");
 761   //abort();
 762   return FALSE;
 763 }