path: root/dviware/dvgtk/screenio.c

/* screenio.c - display functions
   $Id: screenio.c,v 0.2 1997/03/28 03:17:23 tjchol01 Exp $
   Authors: Andrew Trevorrow, Ian Dall, Geoffrey Tobin, Tomasz J. Cholewo
 */

#include "dvgt.h"
#include "screenio.h"
#include "unixio.h"
#include "vdu.h"

/* Variables Exported, via "screenio.h" */

char TeXtoASCII[XXX];


/* IMPORT InitVDU, ClearScreen, StartText, ClearScreen, ResetVDU.
   To handle ^Z suspension properly, ScreenIO needs to use some VDU routines.
 */

/* SYSDEP: We need to use the Unix write routine.
   In particular, using Pascal's write/writeln has some nasty side-effect
   that prevents BusyRead from working!
 */

int textlinewidth;		/* text characters (columns) per line */
int textcolumn = 0;		/* column number in current text line */

/*--------------------------------------------------------------------*/

int 
MesgChar (int ch)
{
  int status;
  /* maxcol <= both size of a string, and width of a line */
  int maxcol = (maxstring < textlinewidth ? maxstring : textlinewidth);

  /* Keep messages within maxcol columns */
  if (textcolumn >= maxcol)
    status = EOF;
  else
    {
      status = putchar (ch);
      ++textcolumn;
    }
  return status;
}
/* MesgChar */

/*--------------------------------------------------------------------*/

int 
MesgString (const char *s)
{
  int status;
  String message;
  /* maxcol <= both size of a string, and width of a line */
  int maxcol = (maxstring < textlinewidth ? maxstring : textlinewidth);

  /* Keep messages within maxcol columns */
  if (textcolumn < 0 || textcolumn >= maxcol)
    {
      strcpy (message, "");
    }
  else
    {
      strncpy (message, s, maxcol - textcolumn);
      message[maxcol - textcolumn] = '\0';
    }

  status = fputs (message, stdout);
  textcolumn += strlen (message);
  return status;
}
/* MesgString */

/*--------------------------------------------------------------------*/

int 
MesgFlush ()
{
  int status = fflush (stdout);
  textcolumn = 0;
  return status;
}
/* MesgFlush */

/*--------------------------------------------------------------------*/

void 
MesgLine ()
{
  save_temp_tty ();
  rawoutoff ();			/* Enable NL to CR+LF mapping */
  /*!!!    putchar (CR); *//* SYSDEP:  Really an NL */
  putchar ('\r');		/* SYSDEP:  Really an NL */
  putchar ('\n');		/* SYSDEP:  Really an NL */
  MesgFlush ();			/* MesgLine also updates terminal */
  restore_temp_tty ();
}
/* MesgLine */

/*--------------------------------------------------------------------*/

static int 
MesgCard (int c)
{
  /* Since the vast majority of given values will be small numbers, we avoid
     recursion until c >= 100.
   */

  int len = 0;
  if (c < 10)
    {
      MesgChar (c + '0');
      ++len;
    }
  else if (c < 100)
    {
      MesgChar (c / 10 + '0');
      MesgChar (c % 10 + '0');
      len += 2;
    }
  else
    {				/* c >= 100 */
      len += MesgCard (c / 100);	/* recursive if c >= 100 */
      c %= 100;
      MesgChar (c / 10 + '0');
      MesgChar (c % 10 + '0');
      len += 2;
    }
  return (len);
}
/* MesgCard */

/*--------------------------------------------------------------------*/

int 
MesgInt (int i)
{
  int len = 0;
  if (i < 0)
    {
      MesgChar ('-');
      ++len;
      i = abs (i);
    }
  len += MesgCard (i);
  return (len);
}
/* MesgInt */

/*--------------------------------------------------------------------*/

void 
WriteLine ()
{
  WriteChar (CR);
  WriteFlush ();		/* WriteLine also updates terminal */
}
/* WriteLine */

/*--------------------------------------------------------------------*/

static void 
WriteCard (int c)
{
  /* Since the vast majority of given values will be small numbers, we avoid
     recursion until c >= 100.
   */

  if (c < 10)
    {
      WriteChar (c + '0');
      return;
    }
  if (c < 100)
    {
      WriteChar (c / 10 + '0');
      WriteChar (c % 10 + '0');
      return;
    }
  else
    {
      WriteCard (c / 100);	/* recursive if c >= 100 */
      c %= 100;
      WriteChar (c / 10 + '0');
      WriteChar (c % 10 + '0');
    }
}
/* WriteCard */

/*--------------------------------------------------------------------*/

void 
WriteInt (int i)
{
  if (i < 0)
    {
      WriteChar ('-');
      i = abs (i);
    }
  WriteCard (i);
}
/* WriteInt */

/*--------------------------------------------------------------------*/

static void 
Restore_Temp_Terminal ()
{
  /* Restore_Temp_Terminal is for screenio.c only. */

  MesgFlush ();			/* make sure terminal is up-to-date */
  restore_temp_tty ();		/* restore terminal characteristics saved below */
}

/* Restore_Temp_Terminal */

/*--------------------------------------------------------------------*/

void 
RestoreTerminal ()
{
  /* RestoreTerminal restores the initial terminal setting. */
  /* It should be called before any client module terminates. */
  MesgFlush ();			/* make sure terminal is up-to-date */
  restore_init_tty ();		/* restore terminal characteristics saved below */
}

/* RestoreTerminal */

/*--------------------------------------------------------------------*/

void 
ReadChar (char *ch)
{
  /* gt - if cbreak's off, turn it on */
  singlecharon ();
  /* gt - if echo's on, turn it off */
  echooff ();

  /* gt - at this point, we need singlechar (cbreak) on and echo off. */
  /* gt - BUT WHY? */

  /* check for CTRL-C or CTRL-Z */

  /* Interrupted by user?  (CTRL-C) */
  if (sig_flags.intr)
    {				/* echo ch since echooff has been called */
      /* interrupt */
      sig_flags.intr = 0;	/* reset intr flag */
      *ch = CR;			/* return to "Command: " prompt level */
    }
  else if (sig_flags.tstop)
    {				/* Suspended by user? (CTRL-Z) */
      /* suspend */
      sig_flags.tstop = 0;	/* reset tstop flag */

      StartText ();
      ClearScreen ();
      MesgLine ();
      ResetVDU ();
      Restore_Temp_Terminal ();

      suspend ();
      save_temp_tty ();

      singlecharon ();
      rawouton ();
      echooff ();

      InitVDU ();
      StartText ();
      ClearScreen ();

      *ch = CR;			/* return to Command: level */
    }
  else
    {
      putchar (*ch = getchar ());
    }
}
/* ReadChar */

/*--------------------------------------------------------------------*/

void 
ReadString (char *s)
{
  /* Read a string of characters.
     The routine is terminated upon carriage return.
   */

  char ch;
  int i;

  singlecharoff ();		/* read string in cooked mode */
  rawoutoff ();
  echoon ();			/* echo characters */

  for (i = 0; true; i++)
    {
      if (sig_flags.intr)
	{
	  /* interrupt */
	  sig_flags.intr = 0;	/* reset intr flag */
	  s[0] = '\0';
	  break;
	}
      if (sig_flags.tstop)
	{
	  /* suspend */
	  sig_flags.tstop = 0;	/* reset tstop flag */

	  StartText ();
	  ClearScreen ();
	  MesgLine ();
	  ResetVDU ();
	  Restore_Temp_Terminal ();

	  suspend ();
	  save_temp_tty ();
	  /* singlecharon and echooff are called below */

	  InitVDU ();
	  StartText ();
	  ClearScreen ();

	  s[0] = '\0';
	  break;
	}
      ch = getchar ();
      if (ch == CR)
	{
	  s[i] = '\0';
	  break;
	}
      s[i] = ch;
      if (i == maxstring)
	{
	  s[i] = '\0';
	  break;
	}
    }
  singlecharon ();		/* return to cbreak mode */
  rawouton ();
  echooff ();			/* and no echo */
}
/* ReadString */

/*--------------------------------------------------------------------*/

boolean 
BusyRead (char *ch)
{
  /* Return TRUE if ch is waiting in input buffer or if a ^C or ^Z has been
     typed.  Set ch to CR or the character read (no echo).
     If nothing in input buffer, then ch is undefined and we return FALSE.
   */

  if (sig_flags.intr)
    {
      /* interrupt */
      sig_flags.intr = 0;
      *ch = CR;			/* main module will return to Command: level */
      return true;
    }
  if (sig_flags.tstop)
    {
      /* suspend */
      sig_flags.tstop = 0;

      StartText ();
      ClearScreen ();
      MesgLine ();
      ResetVDU ();
      Restore_Temp_Terminal ();

      suspend ();
      save_temp_tty ();
      /* singlecharon and echooff are called below */

      InitVDU ();
      StartText ();
      ClearScreen ();

      *ch = CR;			/* after suspend, return to Command: level */
      return true;
    }
  /* SYSDEP: buffercount assumes singlecharon and echooff have been called */

  /* gt - check whether singlecharon and echooff have been called */

  if (cmode_flags.cbreak == 0)
    singlecharon ();

  if (cmode_flags.echo == 1)
    echooff ();

  if (buffercount () == 0)
    return false;
  else
    {
      *ch = getchar ();
      return true;
    }
}
/* BusyRead */

/*--------------------------------------------------------------------*/

static void 
InitTeXtoASCII ()
{
  /* Initialize TeXtoASCII array used in specific ShowChar/Rectangle routines
     to map a given TeX char into a similar, displayable ASCII char.
   */

  int i;

  for (i = 0; i <= 0xa; i++)	/* Greek letters */
    TeXtoASCII[i] = '?';
  for (i = 0xb; i <= 0xf; i++)	/* ligatures */
    TeXtoASCII[i] = '?';
  TeXtoASCII[0x10] = 'i';	/* dotless i */
  TeXtoASCII[0x11] = 'j';	/* dotless j */
  TeXtoASCII[0x12] = '`';	/* grave accent */
  TeXtoASCII[0x13] = '\'';	/* acute accent */
  for (i = 0x14; i <= 0x17; i++)	/* high accents */
    TeXtoASCII[i] = '~';
  TeXtoASCII[0x18] = ',';	/* cedilla */
  for (i = 0x19; i <= 0x20; i++)	/* foreigns */
    TeXtoASCII[i] = '?';
  for (i = 0x21; i <= 0x5b; i++)	/* same */
    TeXtoASCII[i] = i;
  TeXtoASCII[0x5c] = '"';	/* open dble quote */
  TeXtoASCII[0x5d] = ']';	/* same */
  for (i = 0x5e; i <= 0x5f; i++)	/* more accents */
    TeXtoASCII[i] = '^';
  for (i = 0x60; i <= 0x7a; i++)	/* same */
    TeXtoASCII[i] = i;
  for (i = 0x7b; i <= 0x7c; i++)	/* en & em dash */
    TeXtoASCII[i] = '-';
  for (i = 0x7d; i <= 0x7f; i++)	/* more accents */
    TeXtoASCII[i] = '~';
  for (i = 0x80; i <= 0xff; i++)	/* non-ASCII, but 8-bit: 128 to 255 */
    TeXtoASCII[i] = '?';
}
/* InitTeXtoASCII */

/*--------------------------------------------------------------------*/

void 
InitScreenIO ()
{
  InitTeXtoASCII ();
  /* We first save the current terminal characteristics.
     save_init_tty also calls save_temp_tty, which
     sets up ^C/^Z interrupt handlers; see unixio.c.
   */
  save_init_tty ();
  atexit (RestoreTerminal);

  singlecharon ();		/* cbreak mode for ReadChar and BusyRead */
  echooff ();			/* no echo for BusyRead */
  rawouton ();
  /* was _IOFBF */
#ifdef SETVBUF_REVERSED
  if (setvbuf (stdout, _IONBF, NULL, BUFSIZ / 4) != 0)
    {
#else
  if (setvbuf (stdout, NULL, _IONBF, BUFSIZ / 4) != 0)
    {
#endif
      MesgString ("screenio.c: InitScreenIO: setvbuf failed!");
      MesgLine ();
    }
}
/* InitScreenIO */

/*--------------------------------------------------------------------*/

/* end screenio.c */