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