src/input.c

   1 /* Copyright (c) 2008, 2009
   2  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   3  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   4  *      Micah Cowan (micah@cowan.name)
   5  *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
   6  * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
   7  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   8  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   9  * Copyright (c) 1987 Oliver Laumann
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 3, or (at your option)
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program (see the file COPYING); if not, see
  23  * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
  24  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  *
  26  ****************************************************************
  27  */
  28
  29 #include <sys/types.h>
  30 #include "config.h"
  31 #include "screen.h"
  32 #include "extern.h"
  33
  34 #define INPUTLINE (flayer->l_height - 1)
  35
  36 static void InpProcess __P((char **, int *));
  37 static void InpAbort __P((void));
  38 static void InpRedisplayLine __P((int, int, int, int));
  39
  40 extern struct layer *flayer;
  41 extern struct display *display;
  42 extern struct mchar mchar_blank, mchar_so;
  43
  44 struct inpline
  45 {
  46   char  buf[101];       /* text buffer */
  47   int  len;             /* length of the editible string */
  48   int  pos;             /* cursor position in editable string */
  49   struct inpline *next, *prev;
  50 };
  51
  52 /* 'inphist' is used to store the current input when scrolling through history.
  53  * inpline->prev == history-prev
  54  * inpline->next == history-next
  55  */
  56 static struct inpline inphist;
  57
  58 struct inpdata
  59 {
  60   struct inpline inp;
  61   int  inpmaxlen;       /* 100, or less, if caller has shorter buffer */
  62   char *inpstring;      /* the prompt */
  63   int  inpstringlen;    /* length of the prompt */
  64   int  inpmode;         /* INP_NOECHO, INP_RAW, INP_EVERY */
  65   void (*inpfinfunc) __P((char *buf, int len, char *priv));
  66   char  *priv;          /* private data for finfunc */
  67   int  privdata;        /* private data space */
  68 };
  69
  70 static struct LayFuncs InpLf =
  71 {
  72   InpProcess,
  73   InpAbort,
  74   InpRedisplayLine,
  75   DefClearLine,
  76   DefRewrite,
  77   DefResize,
  78   DefRestore
  79 };
  80
  81 /*
  82 **   Here is the input routine
  83 */
  84
  85 /* called once, after InitOverlayPage in Input() or Isearch() */
  86 void
  87 inp_setprompt(p, s)
  88 char *p, *s;
  89 {
  90   struct inpdata *inpdata;
  91
  92   inpdata = (struct inpdata *)flayer->l_data;
  93   if (p)
  94     {
  95       inpdata->inpstringlen = strlen(p);
  96       inpdata->inpstring = p;
  97     }
  98   if (s)
  99     {
 100       if (s != inpdata->inp.buf)
 101         strncpy(inpdata->inp.buf, s, sizeof(inpdata->inp.buf) - 1);
 102       inpdata->inp.buf[sizeof(inpdata->inp.buf) - 1] = 0;
 103       inpdata->inp.pos = inpdata->inp.len = strlen(inpdata->inp.buf);
 104     }
 105   InpRedisplayLine(INPUTLINE, 0, flayer->l_width - 1, 0);
 106   flayer->l_x = inpdata->inpstringlen + (inpdata->inpmode & INP_NOECHO ? 0 : inpdata->inp.pos);
 107   flayer->l_y = INPUTLINE;
 108 }
 109
 110 /*
 111  * We dont use HS status line with Input().
 112  * If we would use it, then we should check e_tgetflag("es") if
 113  * we are allowed to use esc sequences there.
 114  *
 115  * mode is an OR of
 116  * INP_NOECHO == suppress echoing of characters.
 117  * INP_RAW    == raw mode. call finfunc after each character typed.
 118  * INP_EVERY  == digraph mode.
 119  */
 120 void
 121 Input(istr, len, mode, finfunc, priv, data)
 122 char *istr;
 123 int len;
 124 int mode;
 125 void (*finfunc) __P((char *buf, int len, char *priv));
 126 char *priv;
 127 int data;
 128 {
 129   int maxlen;
 130   struct inpdata *inpdata;
 131
 132   if (!flayer)
 133     return;
 134
 135   if (len > 100)
 136     len = 100;
 137   if (!(mode & INP_NOECHO))
 138     {
 139       maxlen = flayer->l_width - 1 - strlen(istr);
 140       if (len > maxlen)
 141         len = maxlen;
 142     }
 143   if (len < 0)
 144     {
 145       LMsg(0, "Width %d chars too small", -len);
 146       return;
 147     }
 148   if (InitOverlayPage(sizeof(*inpdata), &InpLf, 1))
 149     return;
 150   inpdata = (struct inpdata *)flayer->l_data;
 151   inpdata->inpmaxlen = len;
 152   inpdata->inpfinfunc = finfunc;
 153   inpdata->inp.pos = inpdata->inp.len = 0;
 154   inpdata->inp.prev = inphist.prev;
 155   inpdata->inpmode = mode;
 156   inpdata->privdata = data;
 157   if (!priv)
 158     priv = (char*)&inpdata->privdata;
 159   inpdata->priv = priv;
 160   inpdata->inpstringlen = 0;
 161   inpdata->inpstring = NULL;
 162   if (istr)
 163     inp_setprompt(istr, (char *)NULL);
 164 }
 165
 166 static void
 167 erase_chars(inpdata, from, to, x, mv)
 168 struct inpdata *inpdata;
 169 char *from;
 170 char *to;
 171 int x;
 172 int mv;
 173 {
 174   int chng;
 175   ASSERT(from < to);
 176   if (inpdata->inp.len > to - inpdata->inp.buf)
 177     bcopy(to, from, inpdata->inp.len - (to - inpdata->inp.buf));
 178   chng = to - from;
 179   if (mv)
 180     {
 181       x -= chng;
 182       inpdata->inp.pos -= chng;
 183     }
 184   inpdata->inp.len -= chng;
 185   if (!(inpdata->inpmode & INP_NOECHO))
 186     {
 187       struct mchar mc;
 188       char *s = from < to ? from : to;
 189       mc = mchar_so;
 190       while (s < inpdata->inp.buf+inpdata->inp.len)
 191         {
 192           mc.image = *s++;
 193           LPutChar(flayer, &mc, x++, INPUTLINE);
 194         }
 195       while (chng--)
 196         LPutChar(flayer, &mchar_blank, x++, INPUTLINE);
 197       x = inpdata->inpstringlen + inpdata->inp.pos;
 198       LGotoPos(flayer, x, INPUTLINE);
 199     }
 200 }
 201
 202 static void
 203 InpProcess(ppbuf, plen)
 204 char **ppbuf;
 205 int *plen;
 206 {
 207   int len, x;
 208   char *pbuf;
 209   char ch;
 210   struct inpdata *inpdata;
 211   struct display *inpdisplay;
 212   int prev, next;
 213
 214   inpdata = (struct inpdata *)flayer->l_data;
 215   inpdisplay = display;
 216
 217   LGotoPos(flayer, inpdata->inpstringlen + (inpdata->inpmode & INP_NOECHO ? 0 : inpdata->inp.pos), INPUTLINE);
 218   if (ppbuf == 0)
 219     {
 220       InpAbort();
 221       return;
 222     }
 223   x = inpdata->inpstringlen + inpdata->inp.pos;
 224   len = *plen;
 225   pbuf = *ppbuf;
 226   while (len)
 227     {
 228       char *p = inpdata->inp.buf + inpdata->inp.pos;
 229
 230       ch = *pbuf++;
 231       len--;
 232       if (inpdata->inpmode & INP_EVERY)
 233         {
 234           inpdata->inp.buf[inpdata->inp.len] = ch;
 235           if (ch)
 236             {
 237               display = inpdisplay;
 238               (*inpdata->inpfinfunc)(inpdata->inp.buf, inpdata->inp.len, inpdata->priv);
 239               ch = inpdata->inp.buf[inpdata->inp.len];
 240             }
 241         }
 242       else if (inpdata->inpmode & INP_RAW)
 243         {
 244           display = inpdisplay;
 245           (*inpdata->inpfinfunc)(&ch, 1, inpdata->priv);        /* raw */
 246           if (ch)
 247             continue;
 248         }
 249       if (((unsigned char)ch & 0177) >= ' ' && ch != 0177 && inpdata->inp.len < inpdata->inpmaxlen)
 250         {
 251           if (inpdata->inp.len > inpdata->inp.pos)
 252             bcopy(p, p+1, inpdata->inp.len - inpdata->inp.pos);
 253           inpdata->inp.buf[inpdata->inp.pos++] = ch;
 254           inpdata->inp.len++;
 255
 256           if (!(inpdata->inpmode & INP_NOECHO))
 257             {
 258               struct mchar mc;
 259               mc = mchar_so;
 260               mc.image = *p++;
 261               LPutChar(flayer, &mc, x, INPUTLINE);
 262               x++;
 263               if (p < inpdata->inp.buf+inpdata->inp.len)
 264                 {
 265                   while (p < inpdata->inp.buf+inpdata->inp.len)
 266                     {
 267                       mc.image = *p++;
 268                       LPutChar(flayer, &mc, x++, INPUTLINE);
 269                     }
 270                   x = inpdata->inpstringlen + inpdata->inp.pos;
 271                   LGotoPos(flayer, x, INPUTLINE);
 272                 }
 273             }
 274         }
 275       else if ((ch == '\b' || ch == 0177) && inpdata->inp.pos > 0)
 276         {
 277           erase_chars(inpdata, p-1, p, x, 1);
 278         }
 279       else if (ch == '\025')                    /* CTRL-U */
 280         {
 281           x = inpdata->inpstringlen;
 282           if (inpdata->inp.len && !(inpdata->inpmode & INP_NOECHO))
 283             {
 284               LClearArea(flayer, x, INPUTLINE, x + inpdata->inp.len - 1, INPUTLINE, 0, 0);
 285               LGotoPos(flayer, x, INPUTLINE);
 286             }
 287           inpdata->inp.len = inpdata->inp.pos = 0;
 288         }
 289       else if (ch == '\013')                    /* CTRL-K */
 290         {
 291           x = inpdata->inpstringlen + inpdata->inp.pos;
 292           if (inpdata->inp.len > inpdata->inp.pos && !(inpdata->inpmode & INP_NOECHO))
 293             {
 294               LClearArea(flayer, x, INPUTLINE, x + inpdata->inp.len - inpdata->inp.pos - 1, INPUTLINE, 0, 0);
 295               LGotoPos(flayer, x, INPUTLINE);
 296             }
 297           inpdata->inp.len = inpdata->inp.pos;
 298         }
 299       else if (ch == '\027' && inpdata->inp.pos > 0)            /* CTRL-W */
 300         {
 301           char *oldp = p--;
 302           while (p > inpdata->inp.buf && *p == ' ')
 303             p--;
 304           while (p > inpdata->inp.buf && *(p - 1) != ' ')
 305             p--;
 306           erase_chars(inpdata, p, oldp, x, 1);
 307         }
 308       else if (ch == '\004' && inpdata->inp.pos < inpdata->inp.len)     /* CTRL-D */
 309         {
 310           erase_chars(inpdata, p, p+1, x, 0);
 311         }
 312       else if (ch == '\001' || (unsigned char)ch == 0201)       /* CTRL-A */
 313         {
 314           LGotoPos(flayer, x -= inpdata->inp.pos, INPUTLINE);
 315           inpdata->inp.pos = 0;
 316         }
 317       else if ((ch == '\002' || (unsigned char)ch == 0202) && inpdata->inp.pos > 0)     /* CTRL-B */
 318         {
 319           LGotoPos(flayer, --x, INPUTLINE);
 320           inpdata->inp.pos--;
 321         }
 322       else if (ch == '\005' || (unsigned char)ch == 0205)       /* CTRL-E */
 323         {
 324           LGotoPos(flayer, x += inpdata->inp.len - inpdata->inp.pos, INPUTLINE);
 325           inpdata->inp.pos = inpdata->inp.len;
 326         }
 327       else if ((ch == '\006' || (unsigned char)ch == 0206) && inpdata->inp.pos < inpdata->inp.len)      /* CTRL-F */
 328         {
 329           LGotoPos(flayer, ++x, INPUTLINE);
 330           inpdata->inp.pos++;
 331         }
 332       else if ((prev = ((ch == '\020' || (unsigned char)ch == 0220) &&  /* CTRL-P */
 333               inpdata->inp.prev)) ||
 334           (next = ((ch == '\016' || (unsigned char)ch == 0216) &&  /* CTRL-N */
 335                    inpdata->inp.next)))
 336         {
 337           struct mchar mc;
 338           mc = mchar_so;
 339           if (inpdata->inp.len && !(inpdata->inpmode & INP_NOECHO))
 340             LClearArea(flayer, inpdata->inpstringlen, INPUTLINE, inpdata->inpstringlen + inpdata->inp.len - 1, INPUTLINE, 0, 0);
 341
 342           if (prev && !inpdata->inp.next)
 343             inphist = inpdata->inp;
 344           memcpy(&inpdata->inp, prev ? inpdata->inp.prev : inpdata->inp.next, sizeof(struct inpline));
 345           if (inpdata->inp.len > inpdata->inpmaxlen)
 346             inpdata->inp.len = inpdata->inpmaxlen;
 347           if (inpdata->inp.pos > inpdata->inp.len)
 348             inpdata->inp.pos = inpdata->inp.len;
 349
 350           x = inpdata->inpstringlen;
 351           p = inpdata->inp.buf;
 352
 353           if (!(inpdata->inpmode & INP_NOECHO))
 354             {
 355               while (p < inpdata->inp.buf+inpdata->inp.len)
 356                 {
 357                   mc.image = *p++;
 358                   LPutChar(flayer, &mc, x++, INPUTLINE);
 359                 }
 360             }
 361           x = inpdata->inpstringlen + inpdata->inp.pos;
 362           LGotoPos(flayer, x, INPUTLINE);
 363         }
 364
 365       else if (ch == '\003' || ch == '\007' || ch == '\033' ||
 366                ch == '\000' || ch == '\n' || ch == '\r')
 367         {
 368           if (ch != '\n' && ch != '\r')
 369             inpdata->inp.len = 0;
 370           inpdata->inp.buf[inpdata->inp.len] = 0;
 371
 372           if (inpdata->inp.len && !(inpdata->inpmode & (INP_NOECHO | INP_RAW)))
 373             {
 374               struct inpline *store;
 375
 376               /* Look for a duplicate first */
 377               for (store = inphist.prev; store; store = store->prev)
 378                 {
 379                   if (strcmp(store->buf, inpdata->inp.buf) == 0)
 380                     {
 381                       if (store->next)
 382                         store->next->prev = store->prev;
 383                       if (store->prev)
 384                         store->prev->next = store->next;
 385                       store->pos = inpdata->inp.pos;
 386                       break;
 387                     }
 388                 }
 389
 390               if (!store)
 391                 {
 392                   store = malloc(sizeof(struct inpline));
 393                   memcpy(store, &inpdata->inp, sizeof(struct inpline));
 394                 }
 395               store->next = &inphist;
 396               store->prev = inphist.prev;
 397               if (inphist.prev)
 398                 inphist.prev->next = store;
 399               inphist.prev = store;
 400             }
 401
 402           flayer->l_data = 0;   /* so inpdata does not get freed */
 403           InpAbort();           /* redisplays... */
 404           *ppbuf = pbuf;
 405           *plen = len;
 406           display = inpdisplay;
 407           if ((inpdata->inpmode & INP_RAW) == 0)
 408             (*inpdata->inpfinfunc)(inpdata->inp.buf, inpdata->inp.len, inpdata->priv);
 409           else
 410             (*inpdata->inpfinfunc)(pbuf - 1, 0, inpdata->priv);
 411           free((char *)inpdata);
 412           return;
 413         }
 414     }
 415   if (!(inpdata->inpmode & INP_RAW))
 416     {
 417       flayer->l_x = inpdata->inpstringlen + (inpdata->inpmode & INP_NOECHO ? 0 : inpdata->inp.pos);
 418       flayer->l_y = INPUTLINE;
 419     }
 420   *ppbuf = pbuf;
 421   *plen = len;
 422 }
 423
 424 static void
 425 InpAbort()
 426 {
 427   LAY_CALL_UP(LayRedisplayLine(INPUTLINE, 0, flayer->l_width - 1, 0));
 428   ExitOverlayPage();
 429 }
 430
 431 static void
 432 InpRedisplayLine(y, xs, xe, isblank)
 433 int y, xs, xe, isblank;
 434 {
 435   int q, r, s, l, v;
 436   struct inpdata *inpdata;
 437
 438   inpdata = (struct inpdata *)flayer->l_data;
 439   if (y != INPUTLINE)
 440     {
 441       LAY_CALL_UP(LayRedisplayLine(y, xs, xe, isblank));
 442       return;
 443     }
 444   inpdata->inp.buf[inpdata->inp.len] = 0;
 445   q = xs;
 446   v = xe - xs + 1;
 447   s = 0;
 448   r = inpdata->inpstringlen;
 449   if (v > 0 && q < r)
 450     {
 451       l = v;
 452       if (l > r - q)
 453         l = r - q;
 454       LPutStr(flayer, inpdata->inpstring + q - s, l, &mchar_so, q, y);
 455       q += l;
 456       v -= l;
 457     }
 458   s = r;
 459   r += inpdata->inp.len;
 460   if (!(inpdata->inpmode & INP_NOECHO) && v > 0 && q < r)
 461     {
 462       l = v;
 463       if (l > r - q)
 464         l = r - q;
 465       LPutStr(flayer, inpdata->inp.buf + q - s, l, &mchar_so, q, y);
 466       q += l;
 467       v -= l;
 468     }
 469   s = r;
 470   r = flayer->l_width;
 471   if (!isblank && v > 0 && q < r)
 472     {
 473       l = v;
 474       if (l > r - q)
 475         l = r - q;
 476       LClearArea(flayer, q, y, q + l - 1, y, 0, 0);
 477       q += l;
 478     }
 479 }
 480
 481 int
 482 InInput()
 483 {
 484   if (flayer && flayer->l_layfn == &InpLf)
 485     return 1;
 486   return 0;
 487 }
 488