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