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