test/demo_panels.c

   1 /****************************************************************************
   2  * Copyright (c) 2007-2008,2010 Free Software Foundation, Inc.              *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28 /*
  29  * $Id: demo_panels.c,v 1.34 2010/03/06 18:14:04 tom Exp $
  30  *
  31  * Demonstrate a variety of functions from the panel library.
  32  */
  33
  34 #include <test.priv.h>
  35
  36 #if USE_LIBPANEL
  37
  38 #include <panel.h>
  39
  40 #define LAST_POS '@'
  41 #define TEMP_POS '>'
  42
  43 typedef void (*InitPanel) (void);
  44 typedef void (*FillPanel) (PANEL *);
  45
  46 static bool use_colors = FALSE;
  47 static bool unboxed = FALSE;
  48 static FILE *log_in;
  49 static FILE *log_out;
  50
  51 static void
  52 close_input(void)
  53 {
  54     if (log_in != 0) {
  55         fclose(log_in);
  56         log_in = 0;
  57     }
  58 }
  59
  60 static void
  61 close_output(void)
  62 {
  63     if (log_out != 0) {
  64         fclose(log_out);
  65         log_out = 0;
  66     }
  67 }
  68
  69 static WINDOW *
  70 statusline(void)
  71 {
  72     WINDOW *result = stdscr;
  73
  74     wmove(result, LINES - 1, 0);
  75     wclrtoeol(result);
  76     return result;
  77 }
  78
  79 static void
  80 pflush(void)
  81 {
  82     update_panels();
  83     doupdate();
  84 }
  85
  86 static void
  87 saywhat(NCURSES_CONST char *text)
  88 {
  89     WINDOW *win = statusline();
  90     if (text != 0 && *text != '\0') {
  91         waddstr(win, text);
  92         waddstr(win, "; ");
  93     }
  94     waddstr(win, "press any key to continue");
  95 }
  96
  97 static void
  98 show_position(NCURSES_CONST char *text,
  99               NCURSES_CONST char *also,
 100               int which,
 101               int ypos,
 102               int xpos)
 103 {
 104     WINDOW *win = statusline();
 105
 106     wprintw(win, "%s for panel %d now %d,%d%s", text, which, ypos, xpos, also);
 107     wmove(stdscr, ypos, xpos);
 108 }
 109
 110 static int
 111 get_position(NCURSES_CONST char *text,
 112              NCURSES_CONST char *also,
 113              int which,
 114              int *xpos,
 115              int *ypos)
 116 {
 117     int result = 0;
 118     int x1, y1;
 119     char cmd;
 120     WINDOW *win;
 121
 122     getyx(stdscr, y1, x1);
 123     win = statusline();
 124
 125     show_position(text, also, which, y1, x1);
 126
 127     if (log_in != 0) {
 128         if (fscanf(log_in, "%c%d,%d\n", &cmd, &y1, &x1) == 3) {
 129             switch (cmd) {
 130             case LAST_POS:
 131                 result = 1;
 132                 (void) wgetch(stdscr);
 133                 break;
 134             case TEMP_POS:
 135                 result = 0;
 136                 wrefresh(stdscr);
 137                 napms(100);
 138                 break;
 139             default:
 140                 result = -1;
 141                 break;
 142             }
 143         } else {
 144             result = -1;
 145         }
 146     } else {
 147
 148         switch (wgetch(stdscr)) {
 149         case QUIT:
 150         case ESCAPE:
 151         case ERR:
 152             result = -1;
 153             break;
 154         case ' ':
 155             result = 1;
 156             break;
 157         case KEY_UP:
 158             if (y1 > 0) {
 159                 --y1;
 160             } else {
 161                 beep();
 162             }
 163             break;
 164         case KEY_DOWN:
 165             if (y1 < getmaxy(stdscr)) {
 166                 ++y1;
 167             } else {
 168                 beep();
 169             }
 170             break;
 171         case KEY_LEFT:
 172             if (x1 > 0) {
 173                 --x1;
 174             } else {
 175                 beep();
 176             }
 177             break;
 178         case KEY_RIGHT:
 179             if (x1 < getmaxx(stdscr)) {
 180                 ++x1;
 181             } else {
 182                 beep();
 183             }
 184             break;
 185         }
 186     }
 187
 188     wmove(stdscr, y1, x1);
 189     *ypos = y1;
 190     *xpos = x1;
 191
 192     if (result >= 0) {
 193         if (log_out)
 194             fprintf(log_out, "%c%d,%d\n",
 195                     ((result > 0)
 196                      ? LAST_POS
 197                      : TEMP_POS),
 198                     y1, x1);
 199     }
 200     return result;
 201 }
 202
 203 static PANEL *
 204 mkpanel(short color, int rows, int cols, int tly, int tlx)
 205 {
 206     WINDOW *win;
 207     PANEL *pan = 0;
 208     char *userdata = typeMalloc(char, 3);
 209
 210     if ((win = newwin(rows, cols, tly, tlx)) != 0) {
 211         keypad(win, TRUE);
 212         if ((pan = new_panel(win)) == 0) {
 213             delwin(win);
 214         } else if (use_colors) {
 215             short fg = (short) ((color == COLOR_BLUE)
 216                                 ? COLOR_WHITE
 217                                 : COLOR_BLACK);
 218             short bg = color;
 219
 220             init_pair(color, fg, bg);
 221             wbkgdset(win, (chtype) (COLOR_PAIR(color) | ' '));
 222         } else if (!unboxed) {
 223             wbkgdset(win, A_BOLD | ' ');
 224         }
 225     }
 226     sprintf(userdata, "p%d", color % 8);
 227     set_panel_userptr(pan, (NCURSES_CONST void *) userdata);
 228     return pan;
 229 }
 230
 231 static void
 232 my_remove_panel(PANEL ** pans, int which)
 233 {
 234     if (pans[which] != 0) {
 235         PANEL *pan = pans[which];
 236         WINDOW *win = panel_window(pan);
 237         char *user = (char *) panel_userptr(pan);
 238
 239         free(user);
 240         del_panel(pan);
 241         delwin(win);
 242
 243         pans[which] = 0;
 244     }
 245 }
 246
 247 #undef MIN
 248 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 249 #define ABS(a)   ((a) < 0 ? -(a) : (a))
 250
 251 static void
 252 my_create_panel(PANEL ** pans, int which, FillPanel myFill)
 253 {
 254     PANEL *pan = 0;
 255     int code;
 256     short pair = (short) which;
 257     short fg = (short) ((pair == COLOR_BLUE) ? COLOR_WHITE : COLOR_BLACK);
 258     short bg = pair;
 259     int x0, y0, x1, y1;
 260
 261     init_pair(pair, fg, bg);
 262
 263     /* remove the old panel, if any */
 264     my_remove_panel(pans, which);
 265
 266     /* get the position of one corner */
 267     wmove(stdscr, getmaxy(stdscr) / 2, getmaxx(stdscr) / 2);
 268     getyx(stdscr, y0, x0);
 269     while ((code = get_position("First corner", "", which, &x0, &y0)) == 0) {
 270         ;
 271     }
 272
 273     if (code > 0) {
 274         char also[80];
 275         sprintf(also, " (first %d,%d)", y0, x0);
 276         /* get the position of the opposite corner */
 277         while ((code = get_position("Opposite corner",
 278                                     also, which, &x1, &y1)) == 0) {
 279             ;
 280         }
 281
 282         if (code > 0) {
 283             int tly = MIN(y0, y1);
 284             int tlx = MIN(x0, x1);
 285             pan = mkpanel(pair, ABS(y1 - y0) + 1, ABS(x1 - x0) + 1, tly, tlx);
 286             /* finish */
 287             myFill(pan);
 288             pans[which] = pan;
 289             pflush();
 290             wmove(stdscr, y1, x1);
 291         }
 292     }
 293 }
 294
 295 static void
 296 my_move_panel(PANEL ** pans, int which, bool continuous)
 297 {
 298     if (pans[which] != 0) {
 299         int code;
 300         int y0, x0;
 301         int y1, x1;
 302         WINDOW *win = panel_window(pans[which]);
 303         char also[80];
 304
 305         getbegyx(win, y0, x0);
 306         sprintf(also, " (start %d,%d)", y0, x0);
 307         wmove(stdscr, y0, x0);
 308         while ((code = get_position("Move panel", also, which, &x1, &y1)) == 0) {
 309             if (continuous) {
 310                 move_panel(pans[which], y1, x1);
 311                 pflush();
 312             }
 313         }
 314         if (code > 0) {
 315             move_panel(pans[which], y1, x1);
 316         }
 317     }
 318 }
 319
 320 static void
 321 my_resize_panel(PANEL ** pans, int which, FillPanel myFill)
 322 {
 323     if (pans[which] != 0) {
 324         int code;
 325         int y0, x0;
 326         int y1, x1;
 327         WINDOW *win = panel_window(pans[which]);
 328         char also[80];
 329
 330         getbegyx(win, y0, x0);
 331         sprintf(also, " (start %d,%d)", y0, x0);
 332         wmove(stdscr, y0, x0);
 333         while ((code = get_position("Resize panel",
 334                                     also, which, &x1, &y1)) == 0) {
 335             ;
 336         }
 337         if (code > 0) {
 338             WINDOW *next = newwin(ABS(y1 - y0) + 1,
 339                                   ABS(x1 - x0) + 1,
 340                                   MIN(y0, y1),
 341                                   MIN(x0, x1));
 342             if (next != 0) {
 343                 keypad(next, TRUE);
 344                 if (use_colors) {
 345                     wbkgdset(next, (chtype) (COLOR_PAIR(which) | ' '));
 346                 } else if (!unboxed) {
 347                     wbkgdset(next, A_BOLD | ' ');
 348                 }
 349                 replace_panel(pans[which], next);
 350                 myFill(pans[which]);
 351                 delwin(win);
 352             }
 353         }
 354     }
 355 }
 356
 357 static void
 358 init_panel(void)
 359 {
 360     register int y, x;
 361
 362     for (y = 0; y < LINES - 1; y++) {
 363         for (x = 0; x < COLS; x++)
 364             wprintw(stdscr, "%d", (y + x) % 10);
 365     }
 366 }
 367
 368 static void
 369 fill_panel(PANEL * pan)
 370 {
 371     WINDOW *win = panel_window(pan);
 372     const char *userptr = (const char *) panel_userptr(pan);
 373     int num = (userptr && *userptr) ? userptr[1] : '?';
 374     int y, x;
 375
 376     wmove(win, 1, 1);
 377     wprintw(win, "-pan%c-", num);
 378     wclrtoeol(win);
 379     box(win, 0, 0);
 380     for (y = 2; y < getmaxy(win) - 1; y++) {
 381         for (x = 1; x < getmaxx(win) - 1; x++) {
 382             wmove(win, y, x);
 383             waddch(win, UChar(num));
 384         }
 385     }
 386 }
 387
 388 static void
 389 fill_unboxed(PANEL * pan)
 390 {
 391     WINDOW *win = panel_window(pan);
 392     const char *userptr = (const char *) panel_userptr(pan);
 393     int num = (userptr && *userptr) ? userptr[1] : '?';
 394     int y, x;
 395
 396     for (y = 0; y < getmaxy(win); y++) {
 397         for (x = 0; x < getmaxx(win); x++) {
 398             wmove(win, y, x);
 399             waddch(win, UChar(num));
 400         }
 401     }
 402 }
 403
 404 #if USE_WIDEC_SUPPORT
 405 static void
 406 make_fullwidth_digit(cchar_t *target, int digit)
 407 {
 408     wchar_t source[2];
 409
 410     source[0] = digit + 0xff10;
 411     source[1] = 0;
 412     setcchar(target, source, A_NORMAL, 0, 0);
 413 }
 414
 415 static void
 416 init_wide_panel(void)
 417 {
 418     int digit;
 419     cchar_t temp[10];
 420
 421     for (digit = 0; digit < 10; ++digit)
 422         make_fullwidth_digit(&temp[digit], digit);
 423
 424     do {
 425         int y, x;
 426         getyx(stdscr, y, x);
 427         digit = (y + x / 2) % 10;
 428     } while (add_wch(&temp[digit]) != ERR);
 429 }
 430
 431 static void
 432 fill_wide_panel(PANEL * pan)
 433 {
 434     WINDOW *win = panel_window(pan);
 435     int num = ((const char *) panel_userptr(pan))[1];
 436     int y, x;
 437
 438     wmove(win, 1, 1);
 439     wprintw(win, "-pan%c-", num);
 440     wclrtoeol(win);
 441     box(win, 0, 0);
 442     for (y = 2; y < getmaxy(win) - 1; y++) {
 443         for (x = 1; x < getmaxx(win) - 1; x++) {
 444             wmove(win, y, x);
 445             waddch(win, UChar(num));
 446         }
 447     }
 448 }
 449 #endif
 450
 451 #define MAX_PANELS 5
 452
 453 static int
 454 which_panel(PANEL * px[MAX_PANELS + 1], PANEL * pan)
 455 {
 456     int result = 0;
 457     int j;
 458
 459     for (j = 1; j <= MAX_PANELS; ++j) {
 460         if (px[j] == pan) {
 461             result = j;
 462             break;
 463         }
 464     }
 465     return result;
 466 }
 467
 468 static void
 469 show_panels(PANEL * px[MAX_PANELS + 1])
 470 {
 471     static const char *help[] =
 472     {
 473         "",
 474         "Commands are letter/digit pairs.  Digits are the panel number.",
 475         "",
 476         "  b - put the panel on the bottom of the stack",
 477         "  c - create the panel",
 478         "  d - delete the panel",
 479         "  h - hide the panel",
 480         "  m - move the panel (M for continuous move)",
 481         "  r - resize the panel",
 482         "  s - show the panel",
 483         "  b - put the panel on the top of the stack"
 484     };
 485
 486     struct {
 487         bool valid;
 488         bool hidden;
 489         PANEL *above;
 490         PANEL *below;
 491     } table[MAX_PANELS + 1];
 492
 493     WINDOW *win;
 494     PANEL *pan;
 495     int j;
 496
 497     memset(table, 0, sizeof(table));
 498     for (j = 1; j <= MAX_PANELS; ++j) {
 499         table[j].valid = (px[j] != 0);
 500         if (table[j].valid) {
 501             table[j].hidden = panel_hidden(px[j]);
 502             table[j].above = panel_above(px[j]);
 503             table[j].below = panel_below(px[j]);
 504         }
 505     }
 506
 507     if ((win = newwin(LINES - 1, COLS, 0, 0)) != 0) {
 508         keypad(win, TRUE);
 509         if ((pan = new_panel(win)) != 0) {
 510             werase(win);
 511             mvwprintw(win, 0, 0, "Panels:\n");
 512             for (j = 1; j <= MAX_PANELS; ++j) {
 513                 if (table[j].valid) {
 514                     wprintw(win, " %d:", j);
 515                     if (table[j].hidden) {
 516                         waddstr(win, " hidden");
 517                     } else {
 518                         if (table[j].above) {
 519                             wprintw(win, " above %d",
 520                                     which_panel(px, table[j].above));
 521                         }
 522                         if (table[j].below) {
 523                             wprintw(win, "%s below %d",
 524                                     table[j].above ? "," : "",
 525                                     which_panel(px, table[j].below));
 526                         }
 527                     }
 528                     waddch(win, '\n');
 529                 }
 530             }
 531             for (j = 0; j < (int) SIZEOF(help); ++j) {
 532                 if (wprintw(win, "%s\n", help[j]) == ERR)
 533                     break;
 534             }
 535             wgetch(win);
 536             del_panel(pan);
 537             pflush();
 538         }
 539         delwin(win);
 540     }
 541 }
 542
 543 #define wrapper(func) \
 544 static int my_##func(PANEL *pan) \
 545 { \
 546     int code = ERR; \
 547     if (pan != 0) { \
 548         code = func(pan); \
 549     } \
 550     return code; \
 551 }
 552 /* *INDENT-OFF* */
 553 wrapper(bottom_panel)
 554 wrapper(hide_panel)
 555 wrapper(show_panel)
 556 wrapper(top_panel)
 557 /* *INDENT-ON* */
 558
 559 static void
 560 do_panel(PANEL * px[MAX_PANELS + 1],
 561          NCURSES_CONST char *cmd,
 562          FillPanel myFill)
 563 {
 564     int which = cmd[1] - '0';
 565
 566     if (which < 1 || which > MAX_PANELS) {
 567         beep();
 568         return;
 569     }
 570
 571     if (log_in != 0) {
 572         pflush();
 573     }
 574
 575     saywhat(cmd);
 576     switch (*cmd) {
 577     case 'b':
 578         my_bottom_panel(px[which]);
 579         break;
 580     case 'c':
 581         my_create_panel(px, which, myFill);
 582         break;
 583     case 'd':
 584         my_remove_panel(px, which);
 585         break;
 586     case 'h':
 587         my_hide_panel(px[which]);
 588         break;
 589     case 'm':
 590         my_move_panel(px, which, FALSE);
 591         break;
 592     case 'M':
 593         my_move_panel(px, which, TRUE);
 594         break;
 595     case 'r':
 596         my_resize_panel(px, which, myFill);
 597         break;
 598     case 's':
 599         my_show_panel(px[which]);
 600         break;
 601     case 't':
 602         my_top_panel(px[which]);
 603         break;
 604     }
 605 }
 606
 607 static bool
 608 ok_letter(int ch)
 609 {
 610     return isalpha(UChar(ch)) && strchr("bcdhmMrst", ch) != 0;
 611 }
 612
 613 static bool
 614 ok_digit(int ch)
 615 {
 616     return isdigit(UChar(ch)) && (ch >= '1') && (ch - '0' <= MAX_PANELS);
 617 }
 618
 619 /*
 620  * A command consists of one or more letter/digit pairs separated by a space.
 621  * Digits are limited to 1..MAX_PANELS.
 622  *
 623  * End the command with a newline.  Reject other characters.
 624  */
 625 static bool
 626 get_command(PANEL * px[MAX_PANELS + 1], char *buffer, int limit)
 627 {
 628     int length = 0;
 629     int y0, x0;
 630     int c0, ch;
 631     WINDOW *win;
 632
 633     getyx(stdscr, y0, x0);
 634     win = statusline();
 635     waddstr(win, "Command:");
 636     buffer[length = 0] = '\0';
 637
 638     if (log_in != 0) {
 639         if (fgets(buffer, limit - 3, log_in) != 0) {
 640             length = (int) strlen(buffer);
 641             while (length > 0 && isspace(UChar(buffer[length - 1])))
 642                 buffer[--length] = '\0';
 643             waddstr(win, buffer);
 644         } else {
 645             close_input();
 646         }
 647         (void) wgetch(win);
 648     } else {
 649         c0 = 0;
 650         for (;;) {
 651             ch = wgetch(win);
 652             if (ch == ERR || ch == QUIT || ch == ESCAPE) {
 653                 buffer[0] = '\0';
 654                 break;
 655             } else if (ch == CTRL('L')) {
 656                 wrefresh(curscr);
 657             } else if (ch == '\n' || ch == KEY_ENTER) {
 658                 break;
 659             } else if (ch == '?') {
 660                 show_panels(px);
 661             } else if (length + 3 < limit) {
 662                 if (ch >= KEY_MIN) {
 663                     beep();
 664                 } else if (ok_letter(UChar(ch))) {
 665                     if (isalpha(UChar(c0))) {
 666                         beep();
 667                     } else if (isdigit(UChar(c0))) {
 668                         wprintw(win, " %c", ch);
 669                         buffer[length++] = ' ';
 670                         buffer[length++] = (char) (c0 = ch);
 671                     } else {
 672                         wprintw(win, "%c", ch);
 673                         buffer[length++] = (char) (c0 = ch);
 674                     }
 675                 } else if (ok_digit(ch)) {
 676                     if (isalpha(UChar(c0))) {
 677                         wprintw(win, "%c", ch);
 678                         buffer[length++] = (char) (c0 = ch);
 679                     } else {
 680                         beep();
 681                     }
 682                 } else if (ch == ' ') {
 683                     if (isdigit(UChar(c0))) {
 684                         wprintw(win, "%c", ch);
 685                         buffer[length++] = (char) (c0 = ch);
 686                     } else {
 687                         beep();
 688                     }
 689                 } else {
 690                     beep();
 691                 }
 692             } else {
 693                 beep();
 694             }
 695         }
 696     }
 697
 698     wmove(stdscr, y0, x0);
 699
 700     buffer[length] = '\0';
 701     if (log_out && length) {
 702         fprintf(log_out, "%s\n", buffer);
 703     }
 704     return (length != 0);
 705 }
 706
 707 static void
 708 demo_panels(InitPanel myInit, FillPanel myFill)
 709 {
 710     int itmp;
 711     PANEL *px[MAX_PANELS + 1];
 712     char buffer[BUFSIZ];
 713
 714     scrollok(stdscr, FALSE);    /* we don't want stdscr to scroll! */
 715     refresh();
 716
 717     myInit();
 718     memset(px, 0, sizeof(px));
 719
 720     while (get_command(px, buffer, sizeof(buffer))) {
 721         int limit = (int) strlen(buffer);
 722         for (itmp = 0; itmp < limit; itmp += 3) {
 723             do_panel(px, buffer + itmp, myFill);
 724         }
 725         pflush();
 726     }
 727 #if NO_LEAKS
 728     for (itmp = 1; itmp <= MAX_PANELS; ++itmp) {
 729         my_remove_panel(px, itmp);
 730     }
 731 #endif
 732 }
 733
 734 static void
 735 usage(void)
 736 {
 737     static const char *const tbl[] =
 738     {
 739         "Usage: demo_panels [options]"
 740         ,""
 741         ,"Options:"
 742         ,"  -i file  read commands from file"
 743         ,"  -o file  record commands in file"
 744         ,"  -m       do not use colors"
 745 #if USE_WIDEC_SUPPORT
 746         ,"  -w       use wide-characters in panels and background"
 747 #endif
 748         ,"  -x       do not enclose panels in boxes"
 749     };
 750     size_t n;
 751     for (n = 0; n < SIZEOF(tbl); n++)
 752         fprintf(stderr, "%s\n", tbl[n]);
 753     ExitProgram(EXIT_FAILURE);
 754 }
 755
 756 int
 757 main(int argc, char *argv[])
 758 {
 759     int c;
 760     bool monochrome = FALSE;
 761     InitPanel myInit = init_panel;
 762     FillPanel myFill = fill_panel;
 763
 764     setlocale(LC_ALL, "");
 765
 766     while ((c = getopt(argc, argv, "i:o:mwx")) != -1) {
 767         switch (c) {
 768         case 'i':
 769             log_in = fopen(optarg, "r");
 770             break;
 771         case 'o':
 772             log_out = fopen(optarg, "w");
 773             break;
 774         case 'm':
 775             monochrome = TRUE;
 776             break;
 777 #if USE_WIDEC_SUPPORT
 778         case 'w':
 779             myInit = init_wide_panel;
 780             myFill = fill_wide_panel;
 781             break;
 782 #endif
 783         case 'x':
 784             unboxed = TRUE;
 785             break;
 786         default:
 787             usage();
 788         }
 789     }
 790     if (unboxed)
 791         myFill = fill_unboxed;
 792
 793     initscr();
 794     cbreak();
 795     noecho();
 796     keypad(stdscr, TRUE);
 797
 798     use_colors = monochrome ? FALSE : has_colors();
 799     if (use_colors)
 800         start_color();
 801
 802     demo_panels(myInit, myFill);
 803     endwin();
 804
 805     close_input();
 806     close_output();
 807
 808     ExitProgram(EXIT_SUCCESS);
 809 }
 810 #else
 811 int
 812 main(void)
 813 {
 814     printf("This program requires the curses panel library\n");
 815     ExitProgram(EXIT_FAILURE);
 816 }
 817 #endif