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