src/input.c

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