check curses-libs by configure
[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 #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 */