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