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