FWD » Core Development » User Interface

/* Copyright (c) 2008, 2009

 *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)

 *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)

 *      Micah Cowan (micah@cowan.name)

 *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)

 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007

 *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)

 *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)

 * Copyright (c) 1987 Oliver Laumann

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3, or (at your option)

 * any later version.

 *  

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program (see the file COPYING); if not, see

 * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 *

 ****************************************************************

 */

#include <sys/types.h>

#include <fcntl.h>

#ifndef sun        /* we want to know about TIOCPKT. */

# include <sys/ioctl.h>

#endif

#include "config.h"

#include "screen.h"

#include "braille.h"

#include "extern.h"

#include "logfile.h"

extern struct display *display, *displays;

extern struct win *fore;        /* for 83 escape */

extern struct layer *flayer;        /* for 83 escape */

extern struct NewWindow nwin_default;        /* for ResetWindow() */

extern int  nversion;                /* numerical version of screen */

extern int  log_flush, logtstamp_on, logtstamp_after;

extern char *logtstamp_string;

extern char *captionstring;

extern char *hstatusstring;

extern char *wliststr;

#ifdef COPY_PASTE

extern int compacthist;

#endif

#ifdef MULTIUSER

extern struct acluser *EffectiveAclUser;

#endif

int Z0width, Z1width;                /* widths for Z0/Z1 switching */

/* globals set in WriteString */

static struct win *curr;        /* window we are working on */

static int rows, cols;                /* window size of the curr window */

int visual_bell = 0;

int use_hardstatus = 1;                /* display status line in hs */

char *printcmd = 0;

int use_altscreen = 0;                /* enable alternate screen support? */

unsigned char *blank;                /* line filled with spaces */

unsigned char *null;                /* line filled with '\0' */

struct mline mline_old;

struct mline mline_blank;

struct mline mline_null;

struct mchar mchar_null;

struct mchar mchar_blank = {' ' /* , 0, 0, ... */};

struct mchar mchar_so    = {' ', A_SO /* , 0, 0, ... */};

int renditions[NUM_RENDS] = {65529 /* =ub */, 65531 /* =b */, 65533 /* =u */ };

/* keep string_t and string_t_string in sync! */

static char *string_t_string[] =

{

  "NONE",

  "DCS",                        /* Device control string */

  "OSC",                        /* Operating system command */

  "APC",                        /* Application program command */

                                /*  - used for status change */

  "PM",                                /* Privacy message */

  "AKA",                        /* title for current screen */

  "GM",                                /* Global message to every display */

  "STATUS"                        /* User hardstatus line */

};

/* keep state_t and state_t_string in sync! */

static char *state_t_string[] =

{

  "LIT",                        /* Literal input */

  "ESC",                        /* Start of escape sequence */

  "ASTR",                        /* Start of control string */

  "STRESC",                        /* ESC seen in control string */

  "CSI",                        /* Reading arguments in "CSI Pn ;...*/

  "PRIN",                        /* Printer mode */

  "PRINESC",                        /* ESC seen in printer mode */

  "PRINCSI",                        /* CSI seen in printer mode */

  "PRIN4"                        /* CSI 4 seen in printer mode */

};

static int  Special __P((int));

static void DoESC __P((int, int));

static void DoCSI __P((int, int));

static void StringStart __P((enum string_t));

static void StringChar __P((int));

static int  StringEnd __P((void));

static void PrintStart __P((void));

static void PrintChar __P((int));

static void PrintFlush __P((void));

#ifdef FONT

static void DesignateCharset __P((int, int));

static void MapCharset __P((int));

static void MapCharsetR __P((int));

#endif

static void SaveCursor __P((struct cursor *));

static void RestoreCursor __P((struct cursor *));

static void BackSpace __P((void));

static void Return __P((void));

static void LineFeed __P((int));

static void ReverseLineFeed __P((void));

static void InsertChar __P((int));

static void DeleteChar __P((int));

static void DeleteLine __P((int));

static void InsertLine __P((int));

static void Scroll __P((char *, int, int, char *));

static void ForwardTab __P((void));

static void BackwardTab __P((void));

static void ClearScreen __P((void));

static void ClearFromBOS __P((void));

static void ClearToEOS __P((void));

static void ClearLineRegion __P((int, int));

static void CursorRight __P((int));

static void CursorUp __P((int));

static void CursorDown __P((int));

static void CursorLeft __P((int));

static void ASetMode __P((int));

static void SelectRendition __P((void));

static void RestorePosRendition __P((void));

static void FillWithEs __P((void));

static void FindAKA __P((void));

static void Report __P((char *, int, int));

static void ScrollRegion __P((int));

#ifdef COPY_PASTE

static void WAddLineToHist __P((struct win *, struct mline *));

#endif

static void WLogString __P((struct win *, char *, int));

static void WReverseVideo __P((struct win *, int));

static int  WindowChangedCheck __P((char *, int, int *));

static void MFixLine __P((struct win *, int, struct mchar *));

static void MScrollH __P((struct win *, int, int, int, int, int));

static void MScrollV __P((struct win *, int, int, int, int));

static void MClearArea __P((struct win *, int, int, int, int, int));

static void MInsChar __P((struct win *, struct mchar *, int, int));

static void MPutChar __P((struct win *, struct mchar *, int, int));

static void MPutStr __P((struct win *, char *, int, struct mchar *, int, int));

static void MWrapChar __P((struct win *, struct mchar *, int, int, int, int));

#ifdef COLOR

static void MBceLine __P((struct win *, int, int, int, int));

#endif

#ifdef COLOR

# define CURR_BCE (curr->w_bce ? rend_getbg(&curr->w_rend) : 0)

#else

# define CURR_BCE 0

#endif

void

ResetAnsiState(p)

struct win *p;

{

  p->w_state = LIT;

  p->w_StringType = NONE;

}

void

ResetWindow(p)

register struct win *p;

{

  register int i;

  p->w_wrap = nwin_default.wrap;

  p->w_origin = 0;

  p->w_insert = 0;

  p->w_revvid = 0;

  p->w_mouse = 0;

  p->w_curinv = 0;

  p->w_curvvis = 0;

  p->w_autolf = 0;

  p->w_keypad = 0;

  p->w_cursorkeys = 0;

  p->w_top = 0;

  p->w_bot = p->w_height - 1;

  p->w_saved.on = 0;

  p->w_x = p->w_y = 0;

  p->w_state = LIT;

  p->w_StringType = NONE;

  bzero(p->w_tabs, p->w_width);

  for (i = 8; i < p->w_width; i += 8)

    p->w_tabs[i] = 1;

  p->w_rend = mchar_null;

#ifdef FONT

  ResetCharsets(p);

#endif

#ifdef COLOR

  p->w_bce = nwin_default.bce;

#endif

}

/* adds max 22 bytes */

int

GetAnsiStatus(w, buf)

struct win *w;

char *buf;

{

  char *p = buf;

  if (w->w_state == LIT)

    return 0;

  strcpy(p, state_t_string[w->w_state]);

  p += strlen(p);

  if (w->w_intermediate)

    {

      *p++ = '-';

      if (w->w_intermediate > 0xff)

        p += AddXChar(p, w->w_intermediate >> 8);

      p += AddXChar(p, w->w_intermediate & 0xff);

      *p = 0;

    }

  if (w->w_state == ASTR || w->w_state == STRESC)

    sprintf(p, "-%s", string_t_string[w->w_StringType]);

  p += strlen(p);

  return p - buf;

}

#ifdef FONT

void

ResetCharsets(p)

struct win *p;

{

  p->w_gr = nwin_default.gr;

  p->w_c1 = nwin_default.c1;

  SetCharsets(p, "BBBB02");

  if (nwin_default.charset)

    SetCharsets(p, nwin_default.charset);

#ifdef ENCODINGS

  ResetEncoding(p);

#endif

}

void

SetCharsets(p, s)

struct win *p;

char *s;

{

  int i;

  for (i = 0; i < 4 && *s; i++, s++)

    if (*s != '.')

      p->w_charsets[i] = ((*s == 'B') ? ASCII : *s);

  if (*s && *s++ != '.')

    p->w_Charset = s[-1] - '0';

  if (*s && *s != '.')

    p->w_CharsetR = *s - '0';

  p->w_ss = 0;

  p->w_FontL = p->w_charsets[p->w_Charset];

  p->w_FontR = p->w_charsets[p->w_CharsetR];

}

#endif        /* FONT */

/*****************************************************************/

/*

 *  Here comes the vt100 emulator

 *  - writes logfiles,

 *  - sets timestamp and flags activity in window.

 *  - record program output in window scrollback

 *  - translate program output for the display and put it into the obuf.

 *

 */

void

WriteString(wp, buf, len)

struct win *wp;

register char *buf;

register int len;

{

  register int c;

#ifdef FONT

  register int font;

#endif

  struct canvas *cv;

  if (!len)

    return;

  if (wp->w_log)

    WLogString(wp, buf, len);

  /* set global variables (yuck!) */

  curr = wp;

  cols = curr->w_width;

  rows = curr->w_height;

  if (curr->w_silence)

    SetTimeout(&curr->w_silenceev, curr->w_silencewait * 1000);

  if (curr->w_monitor == MON_ON)

    {

      debug2("ACTIVITY %d %d\n", curr->w_monitor, curr->w_bell);

      curr->w_monitor = MON_FOUND;

    }

  if (cols > 0 && rows > 0)

    {

      do

        {

          c = (unsigned char)*buf++;

#ifdef FONT

# ifdef DW_CHARS

          if (!curr->w_mbcs)

# endif

            curr->w_rend.font = curr->w_FontL;        /* Default: GL */

#endif

          /* The next part is only for speedup */

          if (curr->w_state == LIT &&

#ifdef UTF8

              curr->w_encoding != UTF8 &&

#endif

#ifdef DW_CHARS

              !is_dw_font(curr->w_rend.font) &&

# ifdef ENCODINGS

              curr->w_rend.font != KANA && !curr->w_mbcs &&

# endif

#endif

#ifdef FONT

              curr->w_rend.font != '<' &&

#endif

              c >= ' ' && c != 0x7f &&

              ((c & 0x80) == 0 || ((c >= 0xa0 || !curr->w_c1) && !curr->w_gr)) && !curr->w_ss &&

              !curr->w_insert && curr->w_x < cols - 1)

            {

              register int currx = curr->w_x;

              char *imp = buf - 1;

              while (currx < cols - 1)

                {

                  currx++;

                  if (--len == 0)

                    break;

                  c = (unsigned char)*buf++;

                  if (c < ' ' || c == 0x7f || ((c & 0x80) && ((c < 0xa0 && curr->w_c1) || curr->w_gr)))

                    break;

                }

              currx -= curr->w_x;

              if (currx > 0)

                {

                  MPutStr(curr, imp, currx, &curr->w_rend, curr->w_x, curr->w_y);

                  LPutStr(&curr->w_layer, imp, currx, &curr->w_rend, curr->w_x, curr->w_y);

                  curr->w_x += currx;

                }

              if (len == 0)

                break;

            }

          /* end of speedup code */

#ifdef UTF8

          if (curr->w_encoding == UTF8)

            {

              c = FromUtf8(c, &curr->w_decodestate);

              if (c == -1)

                continue;

              if (c == -2)

                {

                  c = UCS_REPL;

                  /* try char again */

                  buf--;

                  len++;

                }

              if (c > 0xff)

                debug1("read UNICODE %04x\n", c);

            }

#endif

        tryagain:

          switch (curr->w_state)

            {

            case PRIN:

              switch (c)

                {

                case '\033':

                  curr->w_state = PRINESC;

                  break;

                default:

                  PrintChar(c);

                }

              break;

            case PRINESC:

              switch (c)

                {

                case '[':

                  curr->w_state = PRINCSI;

                  break;

                default:

                  PrintChar('\033');

                  PrintChar(c);

                  curr->w_state = PRIN;

                }

              break;

            case PRINCSI:

              switch (c)

                {

                case '4':

                  curr->w_state = PRIN4;

                  break;

                default:

                  PrintChar('\033');

                  PrintChar('[');

                  PrintChar(c);

                  curr->w_state = PRIN;

                }

              break;

            case PRIN4:

              switch (c)

                {

                case 'i':

                  curr->w_state = LIT;

                  PrintFlush();

                  if (curr->w_pdisplay && curr->w_pdisplay->d_printfd >= 0)

                    {

                      close(curr->w_pdisplay->d_printfd);

                      curr->w_pdisplay->d_printfd = -1;

                    }

                  curr->w_pdisplay = 0;

                  break;

                default:

                  PrintChar('\033');

                  PrintChar('[');

                  PrintChar('4');

                  PrintChar(c);

                  curr->w_state = PRIN;

                }

              break;

            case ASTR:

              if (c == 0)

                break;

              if (c == '\033')

                {

                  curr->w_state = STRESC;

                  break;

                }

              /* special xterm hack: accept SetStatus sequence. Yucc! */

              /* allow ^E for title escapes */

              if (!(curr->w_StringType == OSC && c < ' ' && c != '\005'))

                if (!curr->w_c1 || c != ('\\' ^ 0xc0))

                  {

                    StringChar(c);

                    break;

                  }

              c = '\\';

              /* FALLTHROUGH */

            case STRESC:

              switch (c)

                {

                case '\\':

                  if (StringEnd() == 0 || len <= 1)

                    break;

                  /* check if somewhere a status is displayed */

                  for (cv = curr->w_layer.l_cvlist; cv; cv = cv->c_lnext)

                    {

                      display = cv->c_display;

                      if (D_status == STATUS_ON_WIN)

                        break;

                    }

                  if (cv)

                    {

                      if (len > IOSIZE + 1)

                        len = IOSIZE + 1;

                      curr->w_outlen = len - 1;

                      bcopy(buf, curr->w_outbuf, len - 1);

                      return;        /* wait till status is gone */

                    }

                  break;

                case '\033':

                  StringChar('\033');

                  break;

                default:

                  curr->w_state = ASTR;

                  StringChar('\033');

                  StringChar(c);

                  break;

                }

              break;

            case ESC:

              switch (c)

                {

                case '[':

                  curr->w_NumArgs = 0;

                  curr->w_intermediate = 0;

                  bzero((char *) curr->w_args, MAXARGS * sizeof(int));

                  curr->w_state = CSI;

                  break;

                case ']':

                  StringStart(OSC);

                  break;

                case '_':

                  StringStart(APC);

                  break;

                case 'P':

                  StringStart(DCS);

                  break;

                case '^':

                  StringStart(PM);

                  break;

                case '!':

                  StringStart(GM);

                  break;

                case '"':

                case 'k':

                  StringStart(AKA);

                  break;

                default:

                  if (Special(c))

                    {

                      curr->w_state = LIT;

                      break;

                    }

                  debug1("not special. c = %x\n", c);

                  if (c >= ' ' && c <= '/')

                    {

                      if (curr->w_intermediate)

                        {

#ifdef DW_CHARS

                          if (curr->w_intermediate == '$')

                            c |= '$' << 8;

                          else

#endif

                          c = -1;

                        }

                      curr->w_intermediate = c;

                    }

                  else if (c >= '0' && c <= '~')

                    {

                      DoESC(c, curr->w_intermediate);

                      curr->w_state = LIT;

                    }

                  else

                    {

                      curr->w_state = LIT;

                      goto tryagain;

                    }

                }

              break;

            case CSI:

              switch (c)

                {

                case '0': case '1': case '2': case '3': case '4':

                case '5': case '6': case '7': case '8': case '9':

                  if (curr->w_NumArgs < MAXARGS)

                    {

                      if (curr->w_args[curr->w_NumArgs] < 100000000)

                        curr->w_args[curr->w_NumArgs] =

                          10 * curr->w_args[curr->w_NumArgs] + (c - '0');

                    }

                  break;

                case ';':

                case ':':

                  if (curr->w_NumArgs < MAXARGS)

                    curr->w_NumArgs++;

                  break;

                default:

                  if (Special(c))

                    break;

                  if (c >= '@' && c <= '~')

                    {

                      if (curr->w_NumArgs < MAXARGS)

                        curr->w_NumArgs++;

                      DoCSI(c, curr->w_intermediate);

                      if (curr->w_state != PRIN)

                        curr->w_state = LIT;

                    }

                  else if ((c >= ' ' && c <= '/') || (c >= '<' && c <= '?'))

                    curr->w_intermediate = curr->w_intermediate ? -1 : c;

                  else

                    {

                      curr->w_state = LIT;

                      goto tryagain;

                    }

                }

              break;

            case LIT:

            default:

#ifdef DW_CHARS

              if (curr->w_mbcs)

                if (c <= ' ' || c == 0x7f || (c >= 0x80 && c < 0xa0 && curr->w_c1))

                  curr->w_mbcs = 0;

#endif

              if (c < ' ')

                {

                  if (c == '\033')

                    {

                      curr->w_intermediate = 0;

                      curr->w_state = ESC;

                      if (curr->w_autoaka < 0)

                        curr->w_autoaka = 0;

                    }

                  else

                    Special(c);

                  break;

                }

              if (c >= 0x80 && c < 0xa0 && curr->w_c1)

#ifdef FONT

                if ((curr->w_FontR & 0xf0) != 0x20

# ifdef UTF8

                       || curr->w_encoding == UTF8

# endif

                   )

#endif

                {

                  switch (c)

                    {

                    case 0xc0 ^ 'D':

                    case 0xc0 ^ 'E':

                    case 0xc0 ^ 'H':

                    case 0xc0 ^ 'M':

                    case 0xc0 ^ 'N':                /* SS2 */

                    case 0xc0 ^ 'O':                /* SS3 */

                      DoESC(c ^ 0xc0, 0);

                      break;

                    case 0xc0 ^ '[':

                      if (curr->w_autoaka < 0)

                        curr->w_autoaka = 0;

                      curr->w_NumArgs = 0;

                      curr->w_intermediate = 0;

                      bzero((char *) curr->w_args, MAXARGS * sizeof(int));

                      curr->w_state = CSI;

                      break;

                    case 0xc0 ^ 'P':

                      StringStart(DCS);

                      break;

                    default:

                      break;

                    }

                  break;

                }

#ifdef FONT

# ifdef DW_CHARS

              if (!curr->w_mbcs)

                {

# endif

                  if (c < 0x80 || curr->w_gr == 0)

                    curr->w_rend.font = curr->w_FontL;

# ifdef ENCODINGS

                  else if (curr->w_gr == 2 && !curr->w_ss)

                    curr->w_rend.font = curr->w_FontE;

# endif

                  else

                    curr->w_rend.font = curr->w_FontR;

# ifdef DW_CHARS

                }

# endif

# ifdef UTF8

              if (curr->w_encoding == UTF8)

                {

                  if (curr->w_rend.font == '0')

                    {

                      struct mchar mc, *mcp;

                      debug1("SPECIAL %x\n", c);

                      mc.image = c;

                      mc.mbcs = 0;

                      mc.font = '0';

                      mc.fontx = 0;

                      mcp = recode_mchar(&mc, 0, UTF8);

                      debug2("%02x %02x\n", mcp->image, mcp->font);

                      c = mcp->image | mcp->font << 8;

                    }

                  curr->w_rend.font = 0;

                }

#  ifdef DW_CHARS

              if (curr->w_encoding == UTF8 && utf8_isdouble(c))

                curr->w_mbcs = 0xff;

#  endif

              if (curr->w_encoding == UTF8 && c >= 0x0300 && utf8_iscomb(c))

                {

                  int ox, oy;

                  struct mchar omc;

                  ox = curr->w_x - 1;

                  oy = curr->w_y;

                  if (ox < 0)

                    {

                      ox = curr->w_width - 1;

                      oy--;

                    }

                  if (oy < 0)

                    oy = 0;

                  copy_mline2mchar(&omc, &curr->w_mlines[oy], ox);

                  if (omc.image == 0xff && omc.font == 0xff && omc.fontx == 0)

                    {

                      ox--;

                      if (ox >= 0)

                        {

                          copy_mline2mchar(&omc, &curr->w_mlines[oy], ox);

                          omc.mbcs = 0xff;

                        }

                    }

                  if (ox >= 0)

                    {

                      utf8_handle_comb(c, &omc);

                      MFixLine(curr, oy, &omc);

                      copy_mchar2mline(&omc, &curr->w_mlines[oy], ox);

                      LPutChar(&curr->w_layer, &omc, ox, oy);

                      LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

                    }

                  break;

                }

              font = curr->w_rend.font;

# endif

# ifdef DW_CHARS

#  ifdef ENCODINGS

              if (font == KANA && curr->w_encoding == SJIS && curr->w_mbcs == 0)

                {

                  /* Lets see if it is the first byte of a kanji */

                  debug1("%x may be first of SJIS\n", c);

                  if ((0x81 <= c && c <= 0x9f) || (0xe0 <= c && c <= 0xef))

                    {

                      debug("YES!\n");

                      curr->w_mbcs = c;

                      break;

                    }

                }

#  endif

              if (font == 031 && c == 0x80 && !curr->w_mbcs)

                font = curr->w_rend.font = 0;

              if (is_dw_font(font) && c == ' ')

                font = curr->w_rend.font = 0;

              if (is_dw_font(font) || curr->w_mbcs)

                {

                  int t = c;

                  if (curr->w_mbcs == 0)

                    {

                      curr->w_mbcs = c;

                      break;

                    }

                  if (curr->w_x == cols - 1)

                    {

                      curr->w_x += curr->w_wrap ? 1 : -1;

                      debug1("Patched w_x to %d\n", curr->w_x);

                    }

#  ifdef UTF8

                  if (curr->w_encoding != UTF8)

#  endif

                    {

                      c = curr->w_mbcs;

#  ifdef ENCODINGS

                      if (font == KANA && curr->w_encoding == SJIS)

                        {

                          debug2("SJIS !! %x %x\n", c, t);

                          /*

                           * SJIS -> EUC mapping:

                           *   First byte:

                           *     81,82...9f -> 21,23...5d

                           *     e0,e1...ef -> 5f,61...7d

                           *   Second byte:

                           *     40-7e -> 21-5f

                           *     80-9e -> 60-7e

                           *     9f-fc -> 21-7e (increment first byte!)

                           */

                          if (0x40 <= t && t <= 0xfc && t != 0x7f)

                            {

                              if (c <= 0x9f) c = (c - 0x81) * 2 + 0x21;

                              else c = (c - 0xc1) * 2 + 0x21;

                              if (t <= 0x7e) t -= 0x1f;

                              else if (t <= 0x9e) t -= 0x20;

                              else t -= 0x7e, c++;

                              curr->w_rend.font = KANJI;

                            }

                          else

                            {

                              /* Incomplete shift-jis - skip first byte */

                              c = t;

                              t = 0;

                            }

                          debug2("SJIS after %x %x\n", c, t);

                        }

#  endif

                      if (t && curr->w_gr && font != 030 && font != 031)

                        {

                          t &= 0x7f;

                          if (t < ' ')

                            goto tryagain;

                        }

                      if (t == '\177')

                        break;

                      curr->w_mbcs = t;

                    }

                }

# endif        /* DW_CHARS */

              if (font == '<' && c >= ' ')

                {

                  font = curr->w_rend.font = 0;

                  c |= 0x80;

                }

# ifdef UTF8

              else if (curr->w_gr && curr->w_encoding != UTF8)

# else

              else if (curr->w_gr)

# endif

                {

#ifdef ENCODINGS

                  if (c == 0x80 && font == 0 && curr->w_encoding == GBK)

                    c = 0xa4;

                  else

                    c &= 0x7f;

                  if (c < ' ' && font != 031)

                    goto tryagain;

#else

                  c &= 0x7f;

                  if (c < ' ')        /* this is ugly but kanji support */

                    goto tryagain;        /* prevents nicer programming */

#endif

                }

#endif /* FONT */

              if (c == '\177')

                break;

              curr->w_rend.image = c;

#ifdef UTF8

              if (curr->w_encoding == UTF8)

                {

                  curr->w_rend.font = c >> 8;

                  curr->w_rend.fontx = c >> 16;

                }

#endif

#ifdef DW_CHARS

              curr->w_rend.mbcs = curr->w_mbcs;

#endif

              if (curr->w_x < cols - 1)

                {

                  if (curr->w_insert)

                    {

                      save_mline(&curr->w_mlines[curr->w_y], cols);

                      MInsChar(curr, &curr->w_rend, curr->w_x, curr->w_y);

                      LInsChar(&curr->w_layer, &curr->w_rend, curr->w_x, curr->w_y, &mline_old);

                      curr->w_x++;

                    }

                  else

                    {

                      MPutChar(curr, &curr->w_rend, curr->w_x, curr->w_y);

                      LPutChar(&curr->w_layer, &curr->w_rend, curr->w_x, curr->w_y);

                      curr->w_x++;

                    }

                }

              else if (curr->w_x == cols - 1)

                {

                  MPutChar(curr, &curr->w_rend, curr->w_x, curr->w_y);

                  LPutChar(&curr->w_layer, &curr->w_rend, curr->w_x, curr->w_y);

                  if (curr->w_wrap)

                    curr->w_x++;

                }

              else

                {

                  MWrapChar(curr, &curr->w_rend, curr->w_y, curr->w_top, curr->w_bot, curr->w_insert);

                  LWrapChar(&curr->w_layer, &curr->w_rend, curr->w_y, curr->w_top, curr->w_bot, curr->w_insert);

                  if (curr->w_y != curr->w_bot && curr->w_y != curr->w_height - 1)

                    curr->w_y++;

                  curr->w_x = 1;

                }

#ifdef FONT

# ifdef DW_CHARS

              if (curr->w_mbcs)

                {

                  curr->w_rend.mbcs = curr->w_mbcs = 0;

                  curr->w_x++;

                }

# endif

              if (curr->w_ss)

                {

                  curr->w_FontL = curr->w_charsets[curr->w_Charset];

                  curr->w_FontR = curr->w_charsets[curr->w_CharsetR];

                  curr->w_rend.font = curr->w_FontL;

                  LSetRendition(&curr->w_layer, &curr->w_rend);

                  curr->w_ss = 0;

                }

#endif /* FONT */

              break;

            }

        }

      while (--len);

    }

  if (!printcmd && curr->w_state == PRIN)

    PrintFlush();

}

static void

WLogString(p, buf, len)

struct win *p;

char *buf;

int len;

{

  if (!p->w_log)

    return;

  if (logtstamp_on && p->w_logsilence >= logtstamp_after * 2)

    {

      char *t = MakeWinMsg(logtstamp_string, p, '%');

      logfwrite(p->w_log, t, strlen(t));        /* long time no write */

    }

  p->w_logsilence = 0;

  if (logfwrite(p->w_log, buf, len) < 1)

    {

      WMsg(p, errno, "Error writing logfile");

      logfclose(p->w_log);

      p->w_log = 0;

    }

  if (!log_flush)

    logfflush(p->w_log);

}

static int

Special(c)

register int c;

{

  switch (c)

    {

    case '\b':

      BackSpace();

      return 1;

    case '\r':

      Return();

      return 1;

    case '\n':

      if (curr->w_autoaka)

        FindAKA();

    case '\013':        /* Vertical tab is the same as Line Feed */

      LineFeed(0);

      return 1;

    case '\007':

      WBell(curr, visual_bell);

      return 1;

    case '\t':

      ForwardTab();

      return 1;

#ifdef FONT

    case '\017':                /* SI */

      MapCharset(G0);

      return 1;

    case '\016':                /* SO */

      MapCharset(G1);

      return 1;

#endif

    }

  return 0;

}

static void

DoESC(c, intermediate)

int c, intermediate;

{

  debug2("DoESC: %x - inter = %x\n", c, intermediate);

  switch (intermediate)

    {

    case 0:

      switch (c)

        {

        case 'E':

          LineFeed(1);

          break;

        case 'D':

          LineFeed(0);

          break;

        case 'M':

          ReverseLineFeed();

          break;

        case 'H':

          curr->w_tabs[curr->w_x] = 1;

          break;

        case 'Z':                /* jph: Identify as VT100 */

          Report("\033[?%d;%dc", 1, 2);

          break;

        case '7':

          SaveCursor(&curr->w_saved);

          break;

        case '8':

          RestoreCursor(&curr->w_saved);

          break;

        case 'c':

          ClearScreen();

          ResetWindow(curr);

          LKeypadMode(&curr->w_layer, 0);

          LCursorkeysMode(&curr->w_layer, 0);

#ifndef TIOCPKT

          WNewAutoFlow(curr, 1);

#endif

          /* XXX

          SetRendition(&mchar_null);

          InsertMode(0);

          ChangeScrollRegion(0, rows - 1);

          */

          LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

          break;

        case '=':

          LKeypadMode(&curr->w_layer, curr->w_keypad = 1);

#ifndef TIOCPKT

          WNewAutoFlow(curr, 0);

#endif /* !TIOCPKT */

          break;

        case '>':

          LKeypadMode(&curr->w_layer, curr->w_keypad = 0);

#ifndef TIOCPKT

          WNewAutoFlow(curr, 1);

#endif /* !TIOCPKT */

          break;

#ifdef FONT

        case 'n':                /* LS2 */

          MapCharset(G2);

          break;

        case 'o':                /* LS3 */

          MapCharset(G3);

          break;

        case '~':

          MapCharsetR(G1);        /* LS1R */

          break;

        /* { */

        case '}':

          MapCharsetR(G2);        /* LS2R */

          break;

        case '|':

          MapCharsetR(G3);        /* LS3R */

          break;

        case 'N':                /* SS2 */

          if (curr->w_charsets[curr->w_Charset] != curr->w_charsets[G2]

              || curr->w_charsets[curr->w_CharsetR] != curr->w_charsets[G2])

            curr->w_FontR = curr->w_FontL = curr->w_charsets[curr->w_ss = G2];

          else

            curr->w_ss = 0;

          break;

        case 'O':                /* SS3 */

          if (curr->w_charsets[curr->w_Charset] != curr->w_charsets[G3]

              || curr->w_charsets[curr->w_CharsetR] != curr->w_charsets[G3])

            curr->w_FontR = curr->w_FontL = curr->w_charsets[curr->w_ss = G3];

          else

            curr->w_ss = 0;

          break;

#endif /* FONT */

        case 'g':                /* VBELL, private screen sequence */

          WBell(curr, 1);

          break;

        }

      break;

    case '#':

      switch (c)

        {

        case '8':

          FillWithEs();

          break;

        }

      break;

#ifdef FONT

    case '(':

      DesignateCharset(c, G0);

      break;

    case ')':

      DesignateCharset(c, G1);

      break;

    case '*':

      DesignateCharset(c, G2);

      break;

    case '+':

      DesignateCharset(c, G3);

      break;

# ifdef DW_CHARS

/*

 * ESC $ ( Fn: invoke multi-byte charset, Fn, to G0

 * ESC $ Fn: same as above.  (old sequence)

 * ESC $ ) Fn: invoke multi-byte charset, Fn, to G1

 * ESC $ * Fn: invoke multi-byte charset, Fn, to G2

 * ESC $ + Fn: invoke multi-byte charset, Fn, to G3

 */

    case '$':

    case '$'<<8 | '(':

      DesignateCharset(c & 037, G0);

      break;

    case '$'<<8 | ')':

      DesignateCharset(c & 037, G1);

      break;

    case '$'<<8 | '*':

      DesignateCharset(c & 037, G2);

      break;

    case '$'<<8 | '+':

      DesignateCharset(c & 037, G3);

      break;

# endif

#endif /* FONT */

    }

}

static void

DoCSI(c, intermediate)

int c, intermediate;

{

  register int i, a1 = curr->w_args[0], a2 = curr->w_args[1];

  if (curr->w_NumArgs > MAXARGS)

    curr->w_NumArgs = MAXARGS;

  switch (intermediate)

    {

    case 0:

      switch (c)

        {

        case 'H':

        case 'f':

          if (a1 < 1)

            a1 = 1;

          if (curr->w_origin)

            a1 += curr->w_top;

          if (a1 > rows)

            a1 = rows;

          if (a2 < 1)

            a2 = 1;

          if (a2 > cols)

            a2 = cols;

          LGotoPos(&curr->w_layer, --a2, --a1);

          curr->w_x = a2;

          curr->w_y = a1;

          if (curr->w_autoaka)

            curr->w_autoaka = a1 + 1;

          break;

        case 'J':

          if (a1 < 0 || a1 > 2)

            a1 = 0;

          switch (a1)

            {

            case 0:

              ClearToEOS();

              break;

            case 1:

              ClearFromBOS();

              break;

            case 2:

              ClearScreen();

              LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

              break;

            }

          break;

        case 'K':

          if (a1 < 0 || a1 > 2)

            a1 %= 3;

          switch (a1)

            {

            case 0:

              ClearLineRegion(curr->w_x, cols - 1);

              break;

            case 1:

              ClearLineRegion(0, curr->w_x);

              break;

            case 2:

              ClearLineRegion(0, cols - 1);

              break;

            }

          break;

        case 'X':

          a1 = curr->w_x + (a1 ? a1 - 1 : 0);

          ClearLineRegion(curr->w_x, a1 < cols ? a1 : cols - 1);

          break;

        case 'A':

          CursorUp(a1 ? a1 : 1);

          break;

        case 'B':

          CursorDown(a1 ? a1 : 1);

          break;

        case 'C':

          CursorRight(a1 ? a1 : 1);

          break;

        case 'D':

          CursorLeft(a1 ? a1 : 1);

          break;

        case 'E':

          curr->w_x = 0;

          CursorDown(a1 ? a1 : 1);        /* positions cursor */

          break;

        case 'F':

          curr->w_x = 0;

          CursorUp(a1 ? a1 : 1);        /* positions cursor */

          break;

        case 'G':

        case '`':                        /* HPA */

          curr->w_x = a1 ? a1 - 1 : 0;

          if (curr->w_x >= cols)

            curr->w_x = cols - 1;

          LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

          break;

        case 'd':                        /* VPA */

          curr->w_y = a1 ? a1 - 1 : 0;

          if (curr->w_y >= rows)

            curr->w_y = rows - 1;

          LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

          break;

        case 'm':

          SelectRendition();

          break;

        case 'g':

          if (a1 == 0)

            curr->w_tabs[curr->w_x] = 0;

          else if (a1 == 3)

            bzero(curr->w_tabs, cols);

          break;

        case 'r':

          if (!a1)

            a1 = 1;

          if (!a2)

            a2 = rows;

          if (a1 < 1 || a2 > rows || a1 >= a2)

            break;

          curr->w_top = a1 - 1;

          curr->w_bot = a2 - 1;

          /* ChangeScrollRegion(curr->w_top, curr->w_bot); */

          if (curr->w_origin)

            {

              curr->w_y = curr->w_top;

              curr->w_x = 0;

            }

          else

            curr->w_y = curr->w_x = 0;

          LGotoPos(&curr->w_layer, curr->w_x, curr->w_y);

          break;

        case 's':

          SaveCursor(&curr->w_saved);

          break;

        case 't':

          switch(a1)

            {

            case 11:

              if (curr->w_layer.l_cvlist)

                Report("\033[1t", 0, 0);

              else

                Report("\033[2t", 0, 0);

              break;

            case 7:

              LRefreshAll(&curr->w_layer, 0);

              break;

            case 21:

              a1 = strlen(curr->w_title);

              if ((unsigned)(curr->w_inlen + 5 + a1) <= sizeof(curr->w_inbuf))

                {

                  bcopy("\033]l", curr->w_inbuf + curr->w_inlen, 3);

                  bcopy(curr->w_title, curr->w_inbuf + curr->w_inlen + 3, a1);

                  bcopy("\033\\", curr->w_inbuf + curr->w_inlen + 3 + a1, 2);

                  curr->w_inlen += 5 + a1;

                }

              break;

            case 8:

              a1 = curr->w_args[2];

              if (a1 < 1)

                a1 = curr->w_width;

              if (a2 < 1)

                a2 = curr->w_height;

              if (a1 > 10000 || a2 > 10000)

                break;

              WChangeSize(curr, a1, a2);

              cols = curr->w_width;

              rows = curr->w_height;