irix compile fixes
[openafs.git] / src / gtx / frame.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 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #ifdef AFS_HPUX_ENV
15 #include <sys/types.h>
16 #endif
17 #include <lwp.h>
18
19 #include <string.h>
20 #include <stdlib.h>
21 #ifdef HAVE_STDINT_H
22 #include <stdint.h>
23 #endif
24 #include "gtxobjects.h"
25 #include "gtxwindows.h"
26 #include "gtxcurseswin.h"
27 #include "gtxinput.h"
28 #include "gtxkeymap.h"
29 #include "gtxframe.h"
30
31 static struct keymap_map *recursiveMap = 0;
32 static char menubuffer[1024];   /*Buffer for menu selections */
33 int gtxframe_exitValue = 0;     /*Program exit value */
34
35 int
36 gtxframe_CtrlUCmd(void *aparam, void *arock)
37 {
38     struct gwin *awindow = (struct gwin *) aparam;
39     struct gtx_frame *tframe;
40
41     tframe = awindow->w_frame;
42     if (!tframe->defaultLine)
43         return -1;
44     *(tframe->defaultLine) = 0;
45     return 0;
46 }
47
48 int
49 gtxframe_CtrlHCmd(void *aparam, void *arock)
50 {
51     struct gwin *awindow = (struct gwin *) aparam;
52     
53     register struct gtx_frame *tframe;
54     register char *tp;
55     register int pos;
56
57     tframe = awindow->w_frame;
58     if (!(tp = tframe->defaultLine))
59         return -1;
60     pos = strlen(tp);
61     if (pos == 0)
62         return 0;               /* rubout at the end of the line */
63     tp[pos - 1] = 0;
64     return 0;
65 }
66
67 int
68 gtxframe_RecursiveEndCmd(void *aparam, void *arock)
69 {
70     struct gwin *awindow = (struct gwin *) aparam;
71     
72     register struct gtx_frame *tframe;
73
74     tframe = awindow->w_frame;
75     tframe->flags |= GTXFRAME_RECURSIVEEND;
76     tframe->flags &= ~GTXFRAME_RECURSIVEERR;
77     return 0;
78 }
79
80 int
81 gtxframe_RecursiveErrCmd(void *aparam, void *arock)
82 {
83     struct gwin *awindow = (struct gwin *) aparam;
84     
85     register struct gtx_frame *tframe;
86
87     tframe = awindow->w_frame;
88     tframe->flags |= GTXFRAME_RECURSIVEEND;
89     tframe->flags |= GTXFRAME_RECURSIVEERR;
90     return 0;
91 }
92
93 int
94 gtxframe_SelfInsertCmd(void *aparam, void *rockparam)
95 {
96     struct gwin *awindow = (struct gwin *) aparam;
97     
98     int arock = (intptr_t)rockparam;
99     
100     register struct gtx_frame *tframe;
101     register int pos;
102     register char *tp;
103
104     tframe = awindow->w_frame;
105     if (!(tp = tframe->defaultLine))
106         return -1;
107     pos = strlen(tp);
108     tp[pos] = arock;            /* arock has char to insert */
109     tp[pos + 1] = 0;            /* null-terminate it, too */
110     return 0;
111 }
112
113 /* save map, setup recursive map and install it */
114 static int
115 SaveMap(struct gtx_frame *aframe)
116 {
117     char tstring[2];
118     register int i;
119
120     if (!recursiveMap) {
121         /* setup recursive edit map if not previously done */
122         recursiveMap = keymap_Create();
123         keymap_BindToString(recursiveMap, "\010", gtxframe_CtrlHCmd, NULL,
124                             NULL);
125         keymap_BindToString(recursiveMap, "\177", gtxframe_CtrlHCmd, NULL,
126                             NULL);
127         keymap_BindToString(recursiveMap, "\025", gtxframe_CtrlUCmd, NULL,
128                             NULL);
129         keymap_BindToString(recursiveMap, "\033", gtxframe_RecursiveEndCmd,
130                             NULL, NULL);
131         keymap_BindToString(recursiveMap, "\015", gtxframe_RecursiveEndCmd,
132                             NULL, NULL);
133         keymap_BindToString(recursiveMap, "\012", gtxframe_RecursiveEndCmd,
134                             NULL, NULL);
135         keymap_BindToString(recursiveMap, "\003", gtxframe_RecursiveErrCmd,
136                             NULL, NULL);
137         keymap_BindToString(recursiveMap, "\007", gtxframe_RecursiveErrCmd,
138                             NULL, NULL);
139
140         for (i = 040; i < 0177; i++) {
141             tstring[0] = i;
142             tstring[1] = 0;
143             keymap_BindToString(recursiveMap, tstring, gtxframe_SelfInsertCmd,
144                                 NULL, (void *)(intptr_t)i);
145         }
146     }
147     aframe->savemap = aframe->keymap;
148     aframe->keymap = recursiveMap;
149     keymap_InitState(aframe->keystate, aframe->keymap);
150     return 0;
151 }
152
153 /* Restore map to previous value */
154 static int
155 RestoreMap(struct gtx_frame *aframe)
156 {
157     aframe->keymap = aframe->savemap;
158     aframe->savemap = (struct keymap_map *)0;
159     keymap_InitState(aframe->keystate, aframe->keymap);
160     return 0;
161 }
162
163 int
164 gtxframe_SetFrame(struct gwin *awin, struct gtx_frame *aframe)
165 {
166     if (awin->w_frame) {
167         /* Unthread this frame */
168         awin->w_frame->window = NULL;
169     }
170     awin->w_frame = aframe;
171     aframe->window = awin;      /* Set frame's window ptr */
172     return 0;
173 }
174
175 struct gtx_frame *
176 gtxframe_GetFrame(struct gwin *awin)
177 {
178     return awin->w_frame;
179 }
180
181 /* Add a menu string to display list */
182 int
183 gtxframe_AddMenu(struct gtx_frame *aframe, char *alabel, char *astring)
184 {
185     register struct gtxframe_menu *tmenu;
186
187     if (aframe->menus)
188         for (tmenu = aframe->menus; tmenu; tmenu = tmenu->next) {
189             if (strcmp(alabel, tmenu->name) == 0)
190                 break;
191     } else
192         tmenu = (struct gtxframe_menu *)0;
193     if (!tmenu) {
194         /* Handle everything but the command string, which is handled by the
195          * common-case code below */
196         tmenu = (struct gtxframe_menu *)malloc(sizeof(*tmenu));
197         if (tmenu == (struct gtxframe_menu *)0)
198             return (-1);
199         memset(tmenu, 0, sizeof(*tmenu));
200         tmenu->next = aframe->menus;
201         aframe->menus = tmenu;
202         tmenu->name = gtx_CopyString(alabel);
203     }
204
205     /*
206      * Common case: redo the string labels.  Note: at this point, tmenu
207      * points to a valid menu.
208      */
209     if (tmenu->cmdString)
210         free(tmenu->cmdString);
211     tmenu->cmdString = gtx_CopyString(astring);
212     return 0;
213 }
214
215 /* Delete a given menu from a frame*/
216 int
217 gtxframe_DeleteMenu(struct gtx_frame *aframe, char *alabel)
218 {
219     register struct gtxframe_menu *tm, **lm;
220
221     for (lm = &aframe->menus, tm = *lm; tm; lm = &tm->next, tm = *lm) {
222         if (strcmp(alabel, tm->name) == 0) {
223             /* found it, remove and return success */
224             *lm = tm->next;     /* unthread from list */
225             free(tm->name);
226             free(tm->cmdString);
227             free(tm);
228             return (0);
229         }
230     }
231     return (-1);                /* failed to find entry to delete */
232 }
233
234 /* Function to remove all known menus */
235 int
236 gtxframe_ClearMenus(struct gtx_frame *aframe)
237 {
238
239     register struct gtxframe_menu *tm, *nm;
240
241     if (aframe->menus != (struct gtxframe_menu *)0) {
242         for (tm = aframe->menus; tm; tm = nm) {
243             nm = tm->next;
244             free(tm->name);
245             free(tm->cmdString);
246             free(tm);
247         }
248     }
249
250     aframe->menus = (struct gtxframe_menu *)0;
251     return 0;
252 }
253
254 int
255 gtxframe_AskForString(struct gtx_frame *aframe, char *aprompt, 
256                       char *adefault, char *aresult, int aresultSize)
257 {
258     register int code;
259     register char *tp;
260
261     /* Ensure recursive-edit map is initialized */
262     SaveMap(aframe);
263
264     /* Set up display */
265     if (aframe->promptLine)
266         free(aframe->promptLine);
267     if (aframe->defaultLine)
268         free(aframe->defaultLine);
269     aframe->promptLine = gtx_CopyString(aprompt);
270     tp = aframe->defaultLine = (char *)malloc(1024);
271     if (tp == NULL)
272         return (-1);
273     if (adefault)
274         strcpy(tp, adefault);
275     else
276         *tp = 0;
277
278     /* Do recursive edit */
279     gtx_InputServer(aframe->window);
280     tp = aframe->defaultLine;   /* In case command reallocated it */
281
282     /* Back from recursive edit, check out what's happened */
283     if (aframe->flags & GTXFRAME_RECURSIVEERR) {
284         code = -1;
285         goto done;
286     }
287     code = strlen(tp);
288     if (code + 1 > aresultSize) {
289         code = -2;
290         goto done;
291     }
292     strcpy(aresult, tp);
293     code = 0;
294
295     /* Fall through to cleanup and return code */
296   done:
297     RestoreMap(aframe);
298     if (aframe->promptLine)
299         free(aframe->promptLine);
300     if (aframe->defaultLine)
301         free(aframe->defaultLine);
302     aframe->defaultLine = aframe->promptLine = NULL;
303     if (code)
304         gtxframe_DisplayString(aframe, "[Aborted]");
305     return (code);
306 }
307
308 int
309 gtxframe_DisplayString(struct gtx_frame *aframe, char *amsgLine)
310 {
311     if (aframe->messageLine)
312         free(aframe->messageLine);
313     aframe->messageLine = gtx_CopyString(amsgLine);
314     return 0;
315 }
316
317 /* Called by input processor to try to clear the dude */
318 int
319 gtxframe_ClearMessageLine(struct gtx_frame *aframe)
320 {
321     /* If we haven't shown message long enough yet, just return */
322     if (aframe->flags & GTXFRAME_NEWDISPLAY)
323         return (0);
324     if (aframe->messageLine)
325         free(aframe->messageLine);
326     aframe->messageLine = NULL;
327     return (0);
328 }
329
330 static int
331 ShowMessageLine(struct gtx_frame *aframe)
332 {
333     struct gwin_strparams strparms;
334     struct gwin_sizeparams sizeparms;
335     register char *tp;
336
337     if (!aframe->window)
338         return -1;
339
340     /* First, find window size */
341     WOP_GETDIMENSIONS(aframe->window, &sizeparms);
342
343     if (aframe->promptLine) {
344         memset(&strparms, 0, sizeof(strparms));
345         strparms.x = 0;
346         strparms.y = sizeparms.maxy - 1;
347         strparms.highlight = 1;
348         tp = strparms.s = (char *)malloc(1024);
349         strcpy(tp, aframe->promptLine);
350         strcat(tp, aframe->defaultLine);
351         WOP_DRAWSTRING(aframe->window, &strparms);
352         aframe->flags |= GTXFRAME_NEWDISPLAY;
353     } else if (aframe->messageLine) {
354         /* Otherwise we're visible, print the message at the bottom */
355         memset(&strparms, 0, sizeof(strparms));
356         strparms.highlight = 1;
357         strparms.x = 0;
358         strparms.y = sizeparms.maxy - 1;
359         strparms.s = aframe->messageLine;
360         WOP_DRAWSTRING(aframe->window, &strparms);
361         aframe->flags |= GTXFRAME_NEWDISPLAY;
362     }
363     return (0);
364 }
365
366 /* Exit function, returning whatever has been put in its argument */
367 int
368 gtxframe_ExitCmd(void *a_exitValuep, void *arock)
369 {                               /*gtxframe_ExitCmd */
370
371     int exitval;                /*Value we've been asked to exit with */
372
373     /* This next call should be type independent! */
374     gator_cursesgwin_cleanup(&gator_basegwin);
375
376     exitval = *((int *)(a_exitValuep));
377     exit(exitval);
378
379 }                               /*gtxframe_ExitCmd */
380
381 struct gtx_frame *
382 gtxframe_Create(void)
383 {
384     struct gtx_frame *tframe;
385     struct keymap_map *newkeymap;
386     struct keymap_state *newkeystate;
387
388     /*
389      * Allocate all the pieces first: frame, keymap, and key state.
390      */
391     tframe = (struct gtx_frame *)malloc(sizeof(struct gtx_frame));
392     if (tframe == (struct gtx_frame *)0) {
393         return ((struct gtx_frame *)0);
394     }
395
396     newkeymap = keymap_Create();
397     if (newkeymap == (struct keymap_map *)0) {
398         /*
399          * Get rid of the frame before exiting.
400          */
401         free(tframe);
402         return ((struct gtx_frame *)0);
403     }
404
405     newkeystate = (struct keymap_state *)
406         malloc(sizeof(struct keymap_state));
407     if (newkeystate == (struct keymap_state *)0) {
408         /*
409          * Get rid of the frame AND the keymap before exiting.
410          */
411         free(tframe);
412         free(newkeymap);
413         return ((struct gtx_frame *)0);
414     }
415
416     /*
417      * Now that all the pieces exist, fill them in and stick them in
418      * the right places.
419      */
420     memset(tframe, 0, sizeof(struct gtx_frame));
421     tframe->keymap = newkeymap;
422     tframe->keystate = newkeystate;
423     keymap_InitState(tframe->keystate, tframe->keymap);
424     keymap_BindToString(tframe->keymap, "\003", gtxframe_ExitCmd, "ExitCmd",
425                         (char *)(&gtxframe_exitValue));
426
427     /*
428      * At this point, we return successfully.
429      */
430     return (tframe);
431 }
432
433 int
434 gtxframe_Delete(struct gtx_frame *aframe)
435 {
436     keymap_Delete(aframe->keymap);
437     free(aframe->keystate);
438     if (aframe->messageLine)
439         free(aframe->messageLine);
440     free(aframe);
441     return 0;
442 }
443
444 int
445 gtxframe_Display(struct gtx_frame *aframe, struct gwin *awm)
446 {
447     register struct gtxframe_dlist *tlist;
448     register struct gtxframe_menu *tm;
449     struct gwin_strparams strparms;
450
451     /* Run through the menus, displaying them on the top line */
452     *menubuffer = 0;
453     for (tm = aframe->menus; tm; tm = tm->next) {
454         strcat(menubuffer, tm->name);
455         strcat(menubuffer, ":");
456         strcat(menubuffer, tm->cmdString);
457         strcat(menubuffer, " ");
458     }
459     if (menubuffer[0] != 0) {
460         memset(&strparms, 0, sizeof(strparms));
461         strparms.x = 0;
462         strparms.y = 0;
463         strparms.s = menubuffer;
464         strparms.highlight = 1;
465         WOP_DRAWSTRING(awm, &strparms);
466     }
467
468     /* Run through the display list, displaying all objects */
469     for (tlist = aframe->display; tlist; tlist = tlist->next) {
470         OOP_DISPLAY(((struct onode *)(tlist->data)));
471     }
472
473     /* Finally, show the message line */
474     ShowMessageLine(awm->w_frame);
475     return (0);
476 }
477
478 /* Add an object to a window's display list */
479 int
480 gtxframe_AddToList(struct gtx_frame *aframe, struct onode *aobj)
481 {
482     register struct gtxframe_dlist *tlist;
483
484     for (tlist = aframe->display; tlist; tlist = tlist->next) {
485         if (tlist->data == (char *)aobj) {
486             /*
487              * Don't add the same thing twice.
488              */
489             return (-1);
490         }
491     }
492
493     /*
494      * OK, it's not alreadyt there.  Create a new list object, fill it
495      * in, and splice it on.
496      */
497     tlist = (struct gtxframe_dlist *)malloc(sizeof(struct gtxframe_dlist));
498     if (tlist == (struct gtxframe_dlist *)0)
499         return (-1);
500     tlist->data = (char *)aobj;
501     tlist->next = aframe->display;
502     aframe->display = tlist;
503     return (0);
504 }
505
506 /* Remove an object from a display list, if it is already there */
507 int
508 gtxframe_RemoveFromList(struct gtx_frame *aframe, struct onode *aobj)
509 {
510     register struct gtxframe_dlist *tlist, **plist;
511
512     plist = &aframe->display;
513     for (tlist = *plist; tlist; plist = &tlist->next, tlist = *plist) {
514         if (tlist->data == (char *)aobj) {
515             *plist = tlist->next;
516             free(tlist);
517             return 0;
518         }
519     }
520     return (-1);                /* Item not found */
521 }
522
523 /* Clear out everything on the display list for the given frame*/
524 int
525 gtxframe_ClearList(struct gtx_frame *aframe)
526 {
527     register struct gtxframe_dlist *tlist, *nlist;
528
529     if (aframe->display != (struct gtxframe_dlist *)0) {
530         /*
531          * Throw away each display list structure (we have at least
532          * one).
533          */
534         for (tlist = aframe->display; tlist; tlist = nlist) {
535             nlist = tlist->next;
536             free(tlist);
537         }
538     }
539
540     aframe->display = (struct gtxframe_dlist *)0;
541     return 0;
542 }