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