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