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