src/gtx/curseswindows.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * gator_curseswindows.c
  12  *
  13  * Description:
  14  *      Implementation of the gator curses window facility.
  15  *
  16  *------------------------------------------------------------------------*/
  17
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21
  22
  23 #include <sys/types.h>
  24 #include <sys/file.h>
  25 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD80_ENV)
  26 #include <sgtty.h>
  27 #endif
  28 #include <stdio.h>
  29 #include <sys/time.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33
  34 #include <lwp.h>
  35
  36 #include "gtxcurseswin.h"       /*Interface definition */
  37 #include "gtxobjects.h"
  38 #include "gtxframe.h"
  39
  40
  41
  42 int curses_debug;               /*Is debugging turned on? */
  43 static char mn[] = "gator_curseswindows";       /*Module name */
  44
  45 /*
  46  * Version of standard operations for a curses window.
  47  */
  48 struct gwinops curses_gwinops = {
  49     gator_cursesgwin_box,
  50     gator_cursesgwin_clear,
  51     gator_cursesgwin_destroy,
  52     gator_cursesgwin_display,
  53     gator_cursesgwin_drawline,
  54     gator_cursesgwin_drawrectangle,
  55     gator_cursesgwin_drawchar,
  56     gator_cursesgwin_drawstring,
  57     gator_cursesgwin_invert,
  58     gator_cursesgwin_getchar,
  59     gator_cursesgwin_getdimensions,
  60     gator_cursesgwin_wait,
  61 };
  62
  63 struct gwinbaseops gator_curses_gwinbops = {
  64     gator_cursesgwin_create,
  65     gator_cursesgwin_cleanup,
  66 };
  67
  68
  69 /*
  70  * Macros to map pixel positions to row & column positions.
  71  * (Note: for now, they are the identity function!!)
  72  */
  73 #define GATOR_MAP_X_TO_COL(w, x)    (x)
  74 #define GATOR_MAP_Y_TO_LINE(w, y)   (y)
  75
  76 /*------------------------------------------------------------------------
  77  * gator_cursesgwin_init
  78  *
  79  * Description:
  80  *      Initialize the curses window package.
  81  *
  82  * Arguments:
  83  *      int adebug: Is debugging turned on?
  84  *
  85  * Returns:
  86  *      0 on success,
  87  *      Error value otherwise.
  88  *
  89  * Environment:
  90  *      Nothing interesting.
  91  *
  92  * Side Effects:
  93  *      As advertised.
  94  *------------------------------------------------------------------------*/
  95
  96 int
  97 gator_cursesgwin_init(int adebug)
  98 {                               /*gator_cursesgwin_init */
  99
 100     static char rn[] = "gator_cursesgwin_init"; /*Routine name */
 101     struct gator_cursesgwin *c_data;    /*Ptr to curses-specific data */
 102
 103     /*
 104      * Remember if we'll be doing debugging, then init the curses package.
 105      */
 106     curses_debug = adebug;
 107
 108     if (curses_debug)
 109         fprintf(stderr, "[%s:%s] Calling initscr()\n", mn, rn);
 110     initscr();
 111
 112     /*
 113      * Fill out the base window structure for curses.
 114      */
 115     if (curses_debug)
 116         fprintf(stderr,
 117                 "[%s:%s] Allocating %" AFS_SIZET_FMT " bytes for curses window private space in base window\n",
 118                 mn, rn, sizeof(struct gator_cursesgwin));
 119     c_data =
 120         (struct gator_cursesgwin *)malloc(sizeof(struct gator_cursesgwin));
 121     if (c_data == (struct gator_cursesgwin *)0) {
 122         fprintf(stderr,
 123                 "[%s:%s] Can't allocate %" AFS_SIZET_FMT " bytes for curses window private space in base window\n",
 124                 mn, rn, sizeof(struct gator_cursesgwin));
 125         return (-1);
 126     }
 127
 128     /*
 129      * Fill in the curses-specific base window info.  We assume that chars are 8x13.
 130      */
 131     c_data->wp = stdscr;
 132     c_data->charwidth = 8;
 133     c_data->charheight = 13;
 134     c_data->box_vertchar = '|';
 135     c_data->box_horizchar = '-';
 136
 137     /*
 138      * Fill in the generic base window info.
 139      */
 140     gator_basegwin.w_type = GATOR_WIN_CURSES;
 141     gator_basegwin.w_x = 0;
 142     gator_basegwin.w_y = 0;
 143     gator_basegwin.w_width = c_data->charwidth * COLS;
 144     gator_basegwin.w_height = c_data->charheight * LINES;
 145     gator_basegwin.w_changed = 0;
 146     gator_basegwin.w_op = &curses_gwinops;
 147     gator_basegwin.w_parent = NULL;
 148
 149     /*
 150      * Plug the private data into the generic part of the base window.
 151      */
 152     gator_basegwin.w_data = (int *)c_data;
 153
 154     /*
 155      * Now, set the terminal into the right mode for handling input
 156      */
 157     raw();                      /* curses raw mode */
 158
 159     /* init the frame */
 160     gator_basegwin.w_frame = gtxframe_Create();
 161
 162     /*
 163      * Clear out the screen and return the good news.
 164      */
 165     wclear(((struct gator_cursesgwin *)(gator_basegwin.w_data))->wp);
 166     return (0);
 167
 168 }                               /*gator_cursesgwin_init */
 169
 170 /*------------------------------------------------------------------------
 171  * gator_cursesgwin_create
 172  *
 173  * Description:
 174  *      Create a curses window (incorrectly).
 175  *
 176  * Arguments:
 177  *      struct gator_cursesgwin_params *params : Ptr to creation parameters.
 178  *
 179  * Returns:
 180  *      Ptr to the created curses window if successful,
 181  *      Null ptr otherwise.
 182  *
 183  * Environment:
 184  *      Nothing interesting.
 185  *
 186  * Side Effects:
 187  *      As advertised.
 188  *------------------------------------------------------------------------*/
 189
 190 struct gwin *
 191 gator_cursesgwin_create(void * rock)
 192 {
 193     static char rn[] = "gator_cursesgwin_create";       /*Routine name */
 194     struct gator_cursesgwin_params *params = (struct gator_cursesgwin_params *)rock;
 195     struct gwin *newgwin;       /*Ptr to new curses window */
 196     struct gator_cursesgwin *c_data;    /*Ptr to curses-specific data */
 197     WINDOW *newcursgwin;        /*Ptr to new curses window */
 198
 199     if (curses_debug)
 200         fprintf(stderr,
 201                 "[%s:%s] Allocating %" AFS_SIZET_FMT " bytes for new gwin structure\n", mn,
 202                 rn, sizeof(struct gwin));
 203     newgwin = (struct gwin *)malloc(sizeof(struct gwin));
 204     if (newgwin == NULL) {
 205         fprintf(stderr,
 206                 "[%s:%s] Can't malloc() %" AFS_SIZET_FMT " bytes for new gwin structure: Errno is %d\n",
 207                 mn, rn, sizeof(struct gwin), errno);
 208         return (NULL);
 209     }
 210
 211     newgwin->w_type = GATOR_WIN_CURSES;
 212     newgwin->w_x = params->gwin_params.cr_x;
 213     newgwin->w_y = params->gwin_params.cr_y;
 214     newgwin->w_width = params->gwin_params.cr_width;
 215     newgwin->w_height = params->gwin_params.cr_height;
 216     newgwin->w_changed = 1;
 217     newgwin->w_op = &curses_gwinops;
 218     newgwin->w_parent = params->gwin_params.cr_parentwin;
 219
 220     if (curses_debug)
 221         fprintf(stderr,
 222                 "[%s:%s] Allocating %" AFS_SIZET_FMT " bytes for curses window private space\n",
 223                 mn, rn, sizeof(struct gator_cursesgwin));
 224     c_data =
 225         (struct gator_cursesgwin *)malloc(sizeof(struct gator_cursesgwin));
 226     if (c_data == (struct gator_cursesgwin *)0) {
 227         fprintf(stderr,
 228                 "[%s:%s] Can't allocate %" AFS_SIZET_FMT " bytes for curses window private space\n",
 229                 mn, rn, sizeof(struct gator_cursesgwin));
 230         free(newgwin);
 231         return (NULL);
 232     }
 233
 234     newcursgwin = newwin(newgwin->w_height,     /*Number of lines */
 235                          newgwin->w_width,      /*Number of columns */
 236                          newgwin->w_y,  /*Beginning y value */
 237                          newgwin->w_x); /*Beginning x value */
 238     if (newcursgwin == (WINDOW *) 0) {
 239         fprintf(stderr,
 240                 "[%s:%s] Failed to create curses window via newwin()\n", mn,
 241                 rn);
 242         free(newgwin);
 243         free(c_data);
 244         return (NULL);
 245     }
 246
 247     /*
 248      * Now, fill in the curses-specific window info.
 249      */
 250     c_data->wp = newcursgwin;
 251     c_data->charwidth = params->charwidth;
 252     c_data->charheight = params->charheight;
 253     c_data->box_vertchar = params->box_vertchar;
 254     c_data->box_horizchar = params->box_horizchar;
 255
 256     /*
 257      * Plug in a frame at the top-level.
 258      */
 259     newgwin->w_frame = gtxframe_Create();
 260
 261     /*
 262      * Plug the curses private data into the generic window object, then
 263      * return the new window's info.
 264      */
 265     newgwin->w_data = (int *)c_data;
 266     return (newgwin);
 267
 268 }                               /*gator_cursesgwin_create */
 269
 270 /*------------------------------------------------------------------------
 271  * gator_cursesgwin_cleanup
 272  *
 273  * Description:
 274  *      Clean up, probably right before the caller exits.
 275  *
 276  * Arguments:
 277  *      struct gwin *gwp : Ptr to base window.
 278  *
 279  * Returns:
 280  *      0 on success,
 281  *      Error value otherwise.
 282  *
 283  * Environment:
 284  *      Nothing interesting.
 285  *
 286  * Side Effects:
 287  *      As advertised.
 288  *------------------------------------------------------------------------*/
 289
 290 int
 291 gator_cursesgwin_cleanup(struct gwin *gwp)
 292 {                               /*gator_cursesgwin_cleanup */
 293
 294     static char rn[] = "gator_cursesgwin_cleanup";      /*Routine name */
 295     struct gator_cursesgwin *cwp;       /*Curses private area ptr */
 296
 297     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 298
 299     /*
 300      * Cleaning up in curses is extremely easy - one simple call.  We also
 301      * want to clear the screen before we go.
 302      */
 303     if (curses_debug)
 304         fprintf(stderr, "[%s:%s] Calling wclear() on window at %p\n", mn,
 305                 rn, cwp->wp);
 306     wclear(cwp->wp);
 307     wrefresh(cwp->wp);
 308
 309     /*
 310      * Now, set the terminal back into normal mode.
 311      */
 312     noraw();
 313
 314     if (curses_debug)
 315         fprintf(stderr, "[%s:%s] Calling endwin()\n", mn, rn);
 316     endwin();
 317
 318     return (0);
 319
 320 }                               /*gator_cursesgwin_cleanup */
 321
 322 /*------------------------------------------------------------------------
 323  * gator_cursesgwin_box
 324  *
 325  * Description:
 326  *      Draw a box around the given curses window.
 327  *
 328  * Arguments:
 329  *      struct gwin *gwp : Ptr to the curses window to draw
 330  *                         a box around.
 331  *
 332  * Returns:
 333  *      0 on success,
 334  *      Error value otherwise.
 335  *
 336  * Environment:
 337  *      Nothing interesting.
 338  *
 339  * Side Effects:
 340  *      As advertised.
 341  *------------------------------------------------------------------------*/
 342
 343 int
 344 gator_cursesgwin_box(struct gwin *gwp)
 345 {                               /*gator_cursesgwin_box */
 346
 347     static char rn[] = "gator_cursesgwin_box";  /*Routine name */
 348     struct gator_cursesgwin *cwp;       /*Ptr to curses private area */
 349
 350     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 351     if (curses_debug)
 352         fprintf(stderr, "[%s:%s] Calling box() on window at %p\n", mn, rn,
 353                 cwp->wp);
 354     box(cwp->wp, cwp->box_vertchar, cwp->box_horizchar);
 355
 356     return (0);
 357
 358 }                               /*gator_cursesgwin_box */
 359
 360 /*------------------------------------------------------------------------
 361  * gator_cursesgwin_clear
 362  *
 363  * Description:
 364  *      Clear out the given curses window.
 365  *
 366  * Arguments:
 367  *      struct gwin *gwp : Ptr to the curses window to clear out.
 368  *
 369  * Returns:
 370  *      0 on success,
 371  *      Error value otherwise.
 372  *
 373  * Environment:
 374  *      Nothing interesting.
 375  *
 376  * Side Effects:
 377  *      As advertised.
 378  *------------------------------------------------------------------------*/
 379
 380 int
 381 gator_cursesgwin_clear(struct gwin *gwp)
 382 {                               /*gator_cursesgwin_clear */
 383
 384     static char rn[] = "gator_cursesgwin_clear";        /*Routine name */
 385     struct gator_cursesgwin *cwp;       /*Ptr to curses private area */
 386
 387     /*
 388      * Clearing windows is very easy in curses; just one call will do it.
 389      */
 390     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 391     if (curses_debug)
 392         fprintf(stderr, "[%s:%s] Calling wclear() on window at %p\n", mn,
 393                 rn, cwp->wp);
 394     wclear(cwp->wp);
 395
 396     return (0);
 397
 398 }                               /*gator_cursesgwin_clear */
 399
 400 /*------------------------------------------------------------------------
 401  * gator_cursesgwin_destroy
 402  *
 403  * Description:
 404  *      Destroy the given curses window.
 405  *
 406  * Arguments:
 407  *      struct gwin *gwp : Ptr to the curses window to destroy.
 408  *
 409  * Returns:
 410  *      0 on success,
 411  *      Error value otherwise.
 412  *
 413  * Environment:
 414  *      Nothing interesting.
 415  *
 416  * Side Effects:
 417  *      As advertised.
 418  *------------------------------------------------------------------------*/
 419
 420 int
 421 gator_cursesgwin_destroy(struct gwin *gwp)
 422 {                               /*gator_cursesgwin_destroy */
 423
 424     static char rn[] = "gator_cursesgwin_destroy";      /*Routine name */
 425     struct gator_cursesgwin *cwp;       /*Ptr to curses private area */
 426
 427     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 428     if (curses_debug)
 429         fprintf(stderr, "[%s:%s] Calling delwin() on window at %p\n", mn,
 430                 rn, cwp->wp);
 431     delwin(cwp->wp);
 432
 433     return (0);
 434
 435 }                               /*gator_cursesgwin_destroy */
 436
 437 /*------------------------------------------------------------------------
 438  * gator_cursesgwin_display
 439  *
 440  * Description:
 441  *      Display/redraw the given curses window.
 442  *
 443  * Arguments:
 444  *      struct gwin *gwp : Ptr to the curses window to draw.
 445  *
 446  * Returns:
 447  *      0 on success,
 448  *      Error value otherwise.
 449  *
 450  * Environment:
 451  *      Nothing interesting.
 452  *
 453  * Side Effects:
 454  *      As advertised.
 455  *------------------------------------------------------------------------*/
 456
 457 int
 458 gator_cursesgwin_display(struct gwin *gwp)
 459 {                               /*gator_cursesgwin_display */
 460
 461     struct gator_cursesgwin *cwp;       /*Curses private area ptr */
 462
 463     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 464
 465     wclear(cwp->wp);            /* clear screen */
 466     gtxframe_Display(gwp->w_frame, gwp);        /* display the frame */
 467     wrefresh(cwp->wp);          /* redraw the guy */
 468     return (0);
 469
 470 }                               /*gator_cursesgwin_display */
 471
 472 /*------------------------------------------------------------------------
 473  * gator_cursesgwin_drawline
 474  *
 475  * Description:
 476  *      Draw a line between two points in the given curses
 477  *      window.
 478  *
 479  * Arguments:
 480  *      struct gwin *gwp : Ptr to the curses window in which
 481  *                                 the line is to be drawn.
 482  *      struct gwin_lineparams *params : Ptr to other params.
 483  *
 484  * Returns:
 485  *      0 on success,
 486  *      Error value otherwise.
 487  *
 488  * Environment:
 489  *      Nothing interesting.
 490  *
 491  * Side Effects:
 492  *      As advertised.
 493  *------------------------------------------------------------------------*/
 494
 495 int
 496 gator_cursesgwin_drawline(struct gwin *gwp, struct gwin_lineparams *params)
 497 {                               /*gator_cursesgwin_drawline */
 498
 499     static char rn[] = "gator_cursesgwin_drawline";     /*Routine name */
 500
 501     if (curses_debug)
 502         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 503                 rn);
 504
 505     return (0);
 506
 507 }                               /*gator_cursesgwin_drawline */
 508
 509 /*------------------------------------------------------------------------
 510  * gator_cursesgwin_drawrectangle
 511  *
 512  * Description:
 513  *      Draw a rectangle in the given curses window.
 514  *
 515  * Arguments:
 516  *      struct gwin *gwp : Ptr to the curses window in which
 517  *                                 the rectangle is to be drawn.
 518  *      struct gwin_rectparams *params : Ptr to other params.
 519  *
 520  * Returns:
 521  *      0 on success,
 522  *      Error value otherwise.
 523  *
 524  * Environment:
 525  *      Nothing interesting.
 526  *
 527  * Side Effects:
 528  *      As advertised.
 529  *------------------------------------------------------------------------*/
 530
 531 int
 532 gator_cursesgwin_drawrectangle(struct gwin *gwp, struct gwin_rectparams *params)
 533 {                               /*gator_cursesgwin_drawrectangle */
 534
 535     static char rn[] = "gator_cursesgwin_drawrectangle";        /*Routine name */
 536
 537     if (curses_debug)
 538         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 539                 rn);
 540
 541     return (0);
 542
 543 }                               /*gator_cursesgwin_drawrectangle */
 544
 545 /*------------------------------------------------------------------------
 546  * gator_cursesgwin_drawchar
 547  *
 548  * Description:
 549  *      Draw a character in the given curses window.
 550  *
 551  * Arguments:
 552  *      struct gwin *gwp : Ptr to the curses window in which
 553  *                                 the character is to be drawn.
 554  *      struct gwin_charparams *params : Ptr to other params.
 555  *
 556  * Returns:
 557  *      0 on success,
 558  *      Error value otherwise.
 559  *
 560  * Environment:
 561  *      Nothing interesting.
 562  *
 563  * Side Effects:
 564  *      As advertised.
 565  *------------------------------------------------------------------------*/
 566
 567 int
 568 gator_cursesgwin_drawchar(struct gwin *gwp, struct gwin_charparams *params)
 569 {                               /*gator_cursesgwin_drawchar */
 570
 571     static char rn[] = "gator_cursesgwin_drawchar";     /*Routine name */
 572     struct gator_cursesgwin *cwp;       /*Ptr to curses private area */
 573     int curses_x, curses_y;     /*Mapped x,y positions */
 574     int code=0;
 575
 576     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 577     curses_x = GATOR_MAP_X_TO_COL(cwp, params->x);
 578     curses_y = GATOR_MAP_Y_TO_LINE(cwp, params->y);
 579     if (curses_debug)
 580         fprintf(stderr,
 581                 "[%s:%s] Drawing char '%c' on window at %p at (%d, %d) [line %d, column %d]%s\n",
 582                 mn, rn, params->c, cwp->wp, params->x, params->y, curses_y,
 583                 curses_x, (params->highlight ? ", using standout mode" : ""));
 584     wmove(cwp->wp, curses_y, curses_x);
 585     if (params->highlight)
 586         code=wstandout(cwp->wp);
 587         if (code)
 588             return (code);
 589     waddch(cwp->wp, params->c);
 590     if (params->highlight)
 591         code=wstandend(cwp->wp);
 592         if (code)
 593             return (code);
 594
 595     return (0);
 596
 597 }                               /*gator_cursesgwin_drawchar */
 598
 599 /*------------------------------------------------------------------------
 600  * gator_cursesgwin_drawstring
 601  *
 602  * Description:
 603  *      Draw a string in the given curses window.
 604  *
 605  * Arguments:
 606  *      struct gwin *gwp : Ptr to the curses window in which
 607  *                                 the string is to be drawn.
 608  *      struct gwin_strparams *params : Ptr to other params.
 609  *
 610  * Returns:
 611  *      0 on success,
 612  *      Error value otherwise.
 613  *
 614  * Environment:
 615  *      Nothing interesting.
 616  *
 617  * Side Effects:
 618  *      As advertised.
 619  *------------------------------------------------------------------------*/
 620
 621 int
 622 gator_cursesgwin_drawstring(struct gwin *gwp, struct gwin_strparams *params)
 623 {                               /*gator_cursesgwin_drawstring */
 624
 625     static char rn[] = "gator_cursesgwin_drawstring";   /*Routine name */
 626     struct gator_cursesgwin *cwp;       /*Ptr to curses private area */
 627     int curses_x, curses_y;     /*Mapped x,y positions */
 628     int code=0;
 629
 630     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 631     curses_x = GATOR_MAP_X_TO_COL(cwp, params->x);
 632     curses_y = GATOR_MAP_Y_TO_LINE(cwp, params->y);
 633     if (curses_debug)
 634         fprintf(stderr,
 635                 "[%s:%s] Drawing string '%s' on window at %p at (%d, %d) [line %d, column %d]%s\n",
 636                 mn, rn, params->s, cwp->wp, params->x, params->y, curses_y,
 637                 curses_x, (params->highlight ? ", using standout mode" : ""));
 638     wmove(cwp->wp, curses_y, curses_x);
 639     if (params->highlight)
 640         code=wstandout(cwp->wp);
 641         if (code)
 642             return (code);
 643     waddstr(cwp->wp, params->s);
 644     if (params->highlight)
 645         code=wstandend(cwp->wp);
 646         if (code)
 647             return (code);
 648
 649     return (code);
 650
 651 }                               /*gator_cursesgwin_drawstring */
 652
 653 /*------------------------------------------------------------------------
 654  * gator_cursesgwin_invert
 655  *
 656  * Description:
 657  *      Invert a region in the given curses window.
 658  *
 659  * Arguments:
 660  *      struct gwin *gwp : Ptr to the curses window in which
 661  *                                 the inverted region lies.
 662  *      struct gwin_invparams *params : Ptr to other params.
 663  *
 664  * Returns:
 665  *      0 on success,
 666  *      Error value otherwise.
 667  *
 668  * Environment:
 669  *      Nothing interesting.
 670  *
 671  * Side Effects:
 672  *      As advertised.
 673  *------------------------------------------------------------------------*/
 674
 675 int
 676 gator_cursesgwin_invert(struct gwin *gwp, struct gwin_invparams *params)
 677 {                               /*gator_cursesgwin_invert */
 678
 679     static char rn[] = "gator_cursesgwin_invert";       /*Routine name */
 680
 681     if (curses_debug)
 682         fprintf(stderr, "[%s:%s] This routine is currently a no-op\n", mn,
 683                 rn);
 684
 685     return (0);
 686
 687 }                               /*gator_cursesgwin_invert */
 688
 689 /*------------------------------------------------------------------------
 690  * gator_cursesgwin_getchar
 691  *
 692  * Description:
 693  *      Pick up a character from the given window.
 694  *
 695  * Arguments:
 696  *      struct gwin *gwp : Ptr to the curses window to listen to.
 697  *
 698  * Returns:
 699  *      Value of the character read,
 700  *      -1 otherwise.
 701  *
 702  * Environment:
 703  *      Nothing interesting.
 704  *
 705  * Side Effects:
 706  *      As advertised.
 707  *------------------------------------------------------------------------*/
 708
 709 int
 710 gator_cursesgwin_getchar(struct gwin *gwp)
 711 {                               /*gator_cursesgwin_getchar */
 712
 713     return (getc(stdin));
 714
 715 }                               /*gator_cursesgwin_getchar */
 716
 717 /*------------------------------------------------------------------------
 718  * gator_cursesgwin_wait
 719  *
 720  * Description:
 721  *      Wait until input is available.
 722  *
 723  * Arguments:
 724  *      struct gwin *gwp : Ptr to the curses window to wait on.
 725  *
 726  * Returns:
 727  *      0 on success,
 728  *      Error value otherwise.
 729  *
 730  * Environment:
 731  *      Nothing interesting.
 732  *
 733  * Side Effects:
 734  *      As advertised.
 735  *------------------------------------------------------------------------*/
 736
 737 int
 738 gator_cursesgwin_wait(struct gwin *gwp)
 739 {                               /*gator_cursesgwin_wait */
 740
 741     while (!LWP_WaitForKeystroke(-1));
 742
 743     return (0);
 744
 745 }                               /*gator_cursesgwin_wait */
 746
 747 /*------------------------------------------------------------------------
 748  * gator_cursesgwin_getdimensions
 749  *
 750  * Description:
 751  *      Get the window's X,Y dimensions.
 752  *
 753  * Arguments:
 754  *      struct gwin *gwp               : Ptr to the curses window to examine.
 755  *      struct gwin_sizeparams *params : Ptr to the size params to set.
 756  *
 757  * Returns:
 758  *      0 on success,
 759  *      Error value otherwise.
 760  *
 761  * Environment:
 762  *      Nothing interesting.
 763  *
 764  * Side Effects:
 765  *      As advertised.
 766  *------------------------------------------------------------------------*/
 767
 768 int
 769 gator_cursesgwin_getdimensions(struct gwin *gwp, struct gwin_sizeparams *aparms)
 770 {                               /*gator_cursesgwin_getdimensions */
 771
 772     struct gator_cursesgwin *cwp;       /*Curses-specific data */
 773
 774     cwp = (struct gator_cursesgwin *)(gwp->w_data);
 775 #if defined(AFS_NBSD_ENV) || defined(AFS_DARWIN100_ENV)
 776     aparms->maxx = getmaxx(cwp->wp);
 777     aparms->maxy = getmaxy(cwp->wp);
 778 #else
 779     aparms->maxx = cwp->wp->_maxx;
 780     aparms->maxy = cwp->wp->_maxy;
 781 #endif
 782
 783     return (0);
 784
 785 }                               /*gator_cursesgwin_getdimensions */