#include <stdlib.h>
#include <xvt.h>

#if XVT_OS==XVT_OS_SCOUNIX
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#else
#include <stdio.h>
#endif

#define STYLE_NUM 4

#include <mask.h>
#include <utility.h>
#include <viswin.h>
#include <extcdecl.h>
#include <applicat.h>

#include <printer.h>
#include <execp.h>
#include <bagn001a.h>
#include <strstream.h>

struct PrDesc
{
  TTextfile *_txt;
  PRINT_RCD *_prcd;
  bool _graphics;
  int _formlen;
  int _charsize;
  int _lines_per_inch;
}
PrintWhat;

#define LINES_PER_INCH (6.0)

#if XVT_OS == XVT_OS_WIN

#include <windows.h>

void TPrinter::_get_windows_printer_names (TToken_string & t)
{
  char *buf = new char[4096];   // ammazzao'

  GetProfileString ("devices", NULL, "", buf, 4096);

  for (int i = 0; i < 4095; i++)
  {
    if (buf[i] == '\0' && buf[i + 1] == '\0')
      break;
    if (buf[i] == '\0' && buf[i + 1] != '\0')
      buf[i] = '|';
  }
  t = buf;
  delete buf;
}

BOOLEAN TPrinter::start_winprint (long data)
{
  PrDesc *pd = (PrDesc *) data;
  TTextfile & txt = *(pd->_txt);
  TPrintwin pw (pd->_prcd, txt, pd->_charsize);
  pw.print_background (pd->_graphics);
  pw.do_print ();
  return pw.aborted ();
}
#endif

// utils del caz
HIDDEN void read_int (const char *s, int &n, int &cnt)
{
  static char nbuf[10];
  int j = 0;
  while (!isdigit (s[cnt]))
    cnt++;
  while (isdigit (s[cnt]))
    nbuf[j++] = s[cnt++];
  nbuf[j] = '\0';
  n = atoi (nbuf);
}

#if XVT_OS == XVT_OS_WIN
void TPrinter::set_win_formlen ()
{
  long pw, ph, phr, pvr;
  xvt_escape (XVT_ESC_GET_PRINTER_INFO, _print_rcd, &ph, &pw, &pvr, &phr);
  if (pvr != 0)
  {
    _formlen = (int) ((ph / pvr) * _lines_per_inch);
    _dots_per_line = (int) (pvr / _lines_per_inch);
    _vert_offset = (int) (ph % (long) (_formlen * _dots_per_line));
    _horz_offset = 0;         // not implemented (font dependent)    

  }
  else
    warning_box ("Il driver di stampante non e' valido.\n"
                 "Non stampare prima di averlo reinstallato");
}
#endif

void TPrinter::_parse_background ()
{
  char op;
  int x1, x2, y1, y2;
  TToken_string tt (20);
  TString txt (80);
  TArray pix;
  char ch;
  int cnt = 0;

  while ((ch = _bg_desc[cnt++]) != '\0')
  {
    op = ch;
    tt = "";
    char bf[2];
    bf[1] = '\0';
    switch (op)
    {
    case ' ':               // ignore whitespace

    case '\t':
    case '\n':
      continue;
      break;
    case 'l':               // line

    case 'b':               // box

    case 'r':               // round box

      cnt++;
      read_int (_bg_desc, x1, cnt);
      read_int (_bg_desc, y1, cnt);
      read_int (_bg_desc, x2, cnt);
      read_int (_bg_desc, y2, cnt);
      cnt++;
      tt << op;
      tt.add (x1 - 1);
      tt.add (y1 - 1);
      tt.add (x2 - 1);
      tt.add (y2 - 1);
      break;
    case 't':               // text

      cnt++;
      read_int (_bg_desc, x1, cnt);
      read_int (_bg_desc, y1, cnt);
      cnt++;
      txt = "";
      while ((ch = _bg_desc[cnt++]) != '}')
        txt << ch;
      tt << op;
      tt.add (x1 - 1);
      tt.add (y1 - 1);
      tt.add (txt);
      break;
    case 'P':               // set pen style

    case 'B':           // set brush

    case 'W':           // set line width 

    case 'C':           // set pen color

      tt << op;
      bf[0] = _bg_desc[cnt++];
      tt.add (bf);
      break;
    default:
      yesnofatal_box ("Unknown background opcode: %c", op);
      break;
    }
    pix.add (tt);
  }

  // now build row descriptions

  // colors are listed in printapp:

  char curcol = 'n';
  char curpen = 'n';
  char curpat = 'n';
  char curwid = '1';

  for (int l = 0; l < _formlen; l++)
  {

    TString *rwd = (TString *) _background.objptr (l);
    if (rwd == NULL)
    {
      _background.add (rwd = new TString, l);
      if (curcol != 'n')
        (*rwd) << 'C' << curcol;
      if (curpat != 'n')
        (*rwd) << 'B' << curpat;
      if (curwid != '1')
        (*rwd) << 'W' << curwid;
      if (curpen != 'n')
        (*rwd) << 'P' << curcol;
    }
    for (int j = 0; j < pix.items (); j++)
    {
      TToken_string & tt = (TToken_string &) pix[j];
      tt.restart ();

      // la stringa contiene l'opcode piu' i parametri in binario, 
      // incrementati di 1 per evitare lo 0

      switch (*(tt.get (0)))
      {
      case 'b':
        x1 = tt.get_int (1) + 1;
        y1 = tt.get_int (2) + 1;
        x2 = tt.get_int (3) + 1;
        y2 = tt.get_int (4) + 1;
        if (y1 == l + 1)        // at ze biginnin

        {
          (*rwd) << 'u' << char (x1);
          (*rwd) << 'r' << char (x1) << char (x2);
          (*rwd) << 'u' << char (x2);
        }
        else if (y2 == l + 1)   // at ze end

        {
          (*rwd) << 'o' << char (x1);
          (*rwd) << 'r' << char (x1) << char (x2);
          (*rwd) << 'o' << char (x2);
        }
        else if (y1 < l + 1 && y2 > l + 1)      // in ze middol

        {
          (*rwd) << 'v' << char (x1);
          (*rwd) << 'v' << char (x2);
        }
        break;
      case 'l':
        x1 = tt.get_int (1) + 1;
        y1 = tt.get_int (2) + 1;
        x2 = tt.get_int (3) + 1;
        y2 = tt.get_int (4) + 1;
        if (y1 == y2 && y1 == l + 1)    // orizzontale 

        {
          (*rwd) << 'h' << char (x1) << char (x2);
        }
        else if (y1 <= l + 1 && y2 >= l + 1)    // verticale  

        {
          (*rwd) << 'v' << char (x1);
        }
        break;
      case 't':
        x1 = tt.get_int (1) + 1;
        y1 = tt.get_int (2) + 1;        // al gh'e'

        if (y1 == l + 1)
        {
        }
        break;
      case 'W':
        curwid = *(tt.get (1));
        (*rwd) << 'W' << curwid;
        break;
      case 'P':
        curpen = *(tt.get (1));
        (*rwd) << 'P' << curpen;
        break;
      case 'B':
        curpat = *(tt.get (1));
        (*rwd) << 'B' << curpat;
        break;
      case 'C':
        curcol = *(tt.get (1));
        (*rwd) << 'C' << curcol;
        break;
      }
    }
  }
}

void TPrinter::setbackground (const char *b)
{
  _background.destroy ();
  _bg_desc = b;
  if (b != NULL)
    _parse_background ();
}

bool printers_on_key (TMask_field & f, KEY key);

// fv support structs for config

bool PrinterDef::read (const char *name, FILE * fd)
{
  _printername = name;
  _printername.trim ();

  TToken_string tmp (64, '=');
  TString l (48);
  TString r (16);

  while (TRUE)
  {
    const long p = ftell (fd);  // Memorizza inizio paragrafo

    if (fgets (__tmp_string, 256, fd) == NULL)
      return FALSE;
    tmp = __tmp_string;
    tmp.trim ();

    if (tmp == "[End of File]")
      return FALSE;

    if (tmp[0] == '[')
    {
      fseek (fd, p, SEEK_SET);  // Ritorna ad inizio paragrafo

      break;
    }

    l = tmp.get ();
    l.trim ();
    r = tmp.get ();
    r.trim ();

    if (l == "Device name")
    {
      _devicename = r;
    }
    else if (l == "Filter name")
    {
      _filtername = r;
    }
    else if (l == "Printer type")
    {
      _printertype = r;
    }
    else if (l == "Normal")
    {
      strcpy (_atstr[normalstyle], r);
    }
    else if (l == "Bold")
    {
      strcpy (_atstr[boldstyle], r);
    }
    else if (l == "Italic")
    {
      strcpy (_atstr[italicstyle], r);
    }
    else if (l == "Underlined")
    {
      strcpy (_atstr[underlinedstyle], r);
    }
    else if (l == "Code")
    {
      TToken_string code (r);
      _names.add (TString (code.get ()));
      _codes.add (TString (code.get ()));
    }
    else if (l == "Form feed")
    {
      _ffcode = r;
    }
    else if (l == "Newline")
    {
      _nlcode = r;
    }
    else
      return error_box ("Riga di configurazione stampante errata:\n%s", (const char *) l);
  }
  return TRUE;
}

bool PrinterDef::isdefault ()
{
  return strcmp(_printername, "Default") == 0;
}

////////// TPRINTROW //////////

TPrintrow ::TPrintrow ()
{
  reset ();
}

TPrintrow ::TPrintrow (const TPrintrow & pr)
{
  _row = pr.row ();
  memcpy (_attr, pr._attr, MAXSTR);
  memcpy (_cols, pr._cols, MAXSTR);
  _currentcolor = 'w';
  _currentcolor <<= 8;
  _currentcolor += 'n';
  _currentstyle = pr._currentstyle;
  for (int i = 0; i < MAXSTR; i++)
    _cols[i] = _currentcolor;
  _lastpos = pr._lastpos;
}

TObject *TPrintrow::dup () const
{
  return new TPrintrow (*this);
}

const char *TPrintrow ::class_name () const
{
  return "Printrow";
}

word TPrintrow ::class_id ()
  const
{
  return CLASS_PRINTROW;
}

TPrintrow & TPrintrow ::
reset ()
{
  _row.spaces (sizeof (_attr));
  _currentcolor = 'w';
  _currentcolor <<= 8;
  _currentcolor += 'n';
  memset (_attr, normalstyle, sizeof (_attr));
  for (int i = 0; i < MAXSTR; i++)
    _cols[i] = _currentcolor;
  _lastpos = 0;
  _currentstyle = normalstyle;
  return *this;
}

const char *TPrintrow::row_codified ()
{
  // returns the row with @-codes for font style and color
  char last_attr = -1;
  int last_color = -1;
  int k = 0;
  _row.rtrim ();
  for (int i = 0; i < _row.len (); i++)
  {
    if (_attr[i] != last_attr)
    {
      __tmp_string[k++] = '@';
      switch (_attr[i])
      {
      case normalstyle:
        __tmp_string[k++] = 'r';
        break;
      case boldstyle:
        __tmp_string[k++] = 'b';
        break;
      case italicstyle:
        __tmp_string[k++] = 'i';
        break;
      case underlinedstyle:
        __tmp_string[k++] = 'u';
        break;
      }
      last_attr = _attr[i];
    }
    if (_cols[i] != last_color)
    {
      __tmp_string[k++] = '$';
      __tmp_string[k++] = '[';
      __tmp_string[k++] = (char) (_cols[i] & 0x00ff);
      __tmp_string[k++] = ',';
      __tmp_string[k++] = (char) (_cols[i] >> 8);
      __tmp_string[k++] = ']';
      last_color = _cols[i];
    }
    __tmp_string[k++] = _row[i];
  }
  // k = k > 255 ? 255 : k;
  __tmp_string[k] = '\0';
  return __tmp_string;
}

TPrintrow & TPrintrow::put(const char *str, int position, int len)
{
  if (len < 1)
    len = strlen (str);

  if (position < 0)
    position = _lastpos;

  char bg = 'w', fg = 'n';
  for (int i = 0; i < len; i++)
  {
    char c = str[i];
    if (c == '$' && str[i + 1] == '[')
    {
      ++i;
      fg = str[++i];
      c = str[++i];
      if (c == ']')
        bg = _currentcolor >> 8;
      else if (c == ',')
      {
        bg = str[++i];
        i++;
      }
      else
      {
        CHECK (0, "Error in color specification");
      }
      _currentcolor = (bg << 8) + fg;
    }
    else if (c == '@')
    {
      c = str[++i];
      switch (toupper (c))
      {
      case '#':
      case '<':
      case '>':
        // printer MUST handle them
      {
        const int n = (c == '#') ? 5 : ((c == '>') ? 10 : 8);
        _row[position] = '@';
        _attr[position++] = _currentstyle;
        for (int j = 1; j < n; j++)
        {
          _row[position] = c;
          _attr[position++] = _currentstyle;
        }
      }
      break;
    case 'B':
      _currentstyle = boldstyle;
      break;
    case 'I':
      _currentstyle = italicstyle;
      break;
    case 'U':
      _currentstyle = underlinedstyle;
      break;
    case 'R':
      _currentstyle = normalstyle;
      break;
    default:
      // should be number followed by skip or jump
      if (isdigit (c))
      {
        // read number
        char digbuf[8];
        int cnt = 0;
        digbuf[cnt++] = c;
        while (isdigit (c = str[++i]))
          digbuf[cnt++] = c;
        digbuf[cnt] = '\0';
        int pp = atoi (digbuf);
        if (toupper (c) == 'G')
        {
          if (pp >= MAXSTR)
            fatal_box ("printrow reaches position %d", pp);
          if (pp > position)
            for (int k = position; k < pp; k++)
            {
              _attr[k] = _currentstyle;
              _cols[k] = _currentcolor;
            }
          position = pp;
        }
        else if (toupper (c) == 'J')
        {
          if (pp + position >= MAXSTR)
            fatal_box ("printrow reaches position %d", pp + position);
          for (int k = 0; k < pp; k++)
          {
            _attr[k + position] = _currentstyle;
            _cols[k + position] = _currentcolor;
          }
          position += pp;
        }
      }
      else
      {
        _row[position] = c;
        _attr[position++] = _currentstyle;
        _cols[position++] = _currentcolor;
      }
    }                   // switch

    }
    else
    {
      _row[position] = c;
      _attr[position] = _currentstyle;
      _cols[position++] = _currentcolor;
    }
  }                             // for

  _lastpos = position;
  return *this;
}

////////// TPRINTER //////////

bool printers_on_key (TMask_field & f, KEY key)
{
  if (key == K_SPACE)
  {
    TToken_string pn1 (10), pn2 (20);

    const PrinterDef & def = MainApp()->printer().get_description(atoi(f.get ()));
    const char *s;
    int j = 0;
    while ((s = def.get_codenames (j)) != NULL)
    {
      pn1.add (format ("%02d", j));
      pn2.add (s);
      j++;
    }
    ((TList_field &) f.mask ().field (MSK_1_CODES)).replace_items (pn1, pn2);
  }
  return TRUE;
}

#if XVT_OS == XVT_OS_WIN

bool set_windows_print_device (TMask_field & f, KEY key)
{
  static char szDevice[80];
  if (key == K_SPACE)
  {
    if (MainApp()->printer().get_printrcd() != NULL)
      free_print_rcd (MainApp ()->printer().get_printrcd ());
    TToken_string & pn = MainApp()->printer().getprinternames ();
    TString pdev (pn.get (atoi (f.get ())));
    GetProfileString ("devices", pdev, "", szDevice, sizeof (szDevice));
    pdev << "," << szDevice;
    //              WriteProfileString("windows","device", pdev);
    // madonna bona         
    MainApp()->printer().set_printrcd(get_print_rcd (&(MainApp ()->printer ().get_printrcdsize ())));
    MainApp()->printer().set_win_formlen();
  }
  return TRUE;
}

#endif

TPrinter::TPrinter()
: _date (TODAY), _multiple_link (FALSE), _frozen (FALSE), _isgraphics (TRUE),
  _lines_per_inch (6), _ch_size (12), _ncopies(1)

{
  _footerhandler = _headerhandler = NULL;
  _linkhandler = NULL;
  _config = "printer.ini";
  _curprn = 0;                  // first in list if no default is specified

  _curcode = 0;                 // first in list if no default is specified

  _formlen = 66;
  _frompage = 0;
  _topage = 0xffff;
  _hwformfeed = FALSE;
  _currentpage = 1;
  _currentrow = 1;
  _fp = NULL;
  _headersize = 0;
  _footersize = 0;
  _isopen = FALSE;
  _multiple_copies = MainApp()->class_id() == CLASS_PRINT_APPLICATION;
  
  // read configuration file
  read_configuration (_config);
#if XVT_OS == XVT_OS_WIN
  print_begin ();
  _print_rcd = get_print_rcd (&_print_rcd_size);
  set_win_formlen ();

  static char defPrinter[80];
  static char szDevice[50];

  // get default printer driver
  GetProfileString ("windows", "device", ",,,", defPrinter, sizeof(defPrinter));
  TString pdev (defPrinter);
  GetProfileString ("devices", pdev, "", szDevice, sizeof(szDevice));
  pdev << "," << szDevice;
  TToken_string dio (pdev, ',');
  TToken_string pn2(1024);
  
  // get printer names
  _get_windows_printer_names (pn2);

  // determine index of current default printer
  for (int i = 0; i < pn2.items (); i++)
  {
    if (TString(dio.get(0)) == TString(pn2.get (i)))
    {
      _curprn = i;
      break;
    }
  }

#else
  _isgraphics = FALSE;
#endif
}

TToken_string& TPrinter::getprinternames ()
{
  // per ora va solo in windows
#if XVT_OS == XVT_OS_WIN
  _get_windows_printer_names (_printer_names);
#endif
  return _printer_names;
}

void TPrinter::read_configuration (const char *conf)
{

  FILE *cnfp = fopen (conf, "r");
  if (cnfp == NULL)
    fatal_box ("Impossibile aprire il file %s", (const char *) _config);

  for (int i = 0; !feof (cnfp); i++)
  {
    if (fgets (__tmp_string, 256, cnfp) == NULL)
      return;
    // else
    if (strncmp (__tmp_string, "[Default]", 9) != 0)
      // fgets(__tmp_string,256,cnfp);
      // else
    {
      if (*__tmp_string == '[')
      {
        // fatal_box("[ expected in file of printer configuration");

        char *u = strchr (__tmp_string, ']');
        if (u)
          *u = '\0';
        u = __tmp_string + 1;

        PrinterDef *pp = new PrinterDef;
        _printers.add (pp);
        if (pp->read (u, cnfp) == FALSE)
          break;
      }
    }
  }
  fclose (cnfp);

  TString s ("printer.def");
#if XVT_OS == XVT_OS_SCOUNIX
  s << format (".%d", getuid ());
#endif
  if (fexist (s))
  {
    TScanner sc (s);
    TToken_string t (sc.line ());
    int where_print = t.get_int (1);
    t = sc.line ();
    _curprn = t.get_int(1);
    t = sc.line ();
    _printerfile = t.get (1);
    t = sc.line ();
    _curcode = t.get_int (1);
#if XVT_OS != XVT_OS_WIN
    PrinterDef & def = (PrinterDef &) get_description (_curprn);
#endif
    switch (where_print)
    {
    case 0:             // stampante     
#if XVT_OS == XVT_OS_WIN
      _printertype = winprinter;
#else
      switch (atoi (def._printertype))
      {
      case 0:
        _printertype = normprinter;
        break;
      case 1:
        _printertype = localprinter;
        break;
      case 2:
        _printertype = spoolprinter;
        break;
      }
#endif
      break;
    case 1:             // file

      _printertype = fileprinter;
      break;
    case 2:             // video

      _printertype = screenvis;
      _curcode = 0;
      break;
    }
  }
}

TPrinter::~TPrinter ()
{
#if XVT_OS == XVT_OS_WIN
  print_end ();
#endif
}

const char* TPrinter::class_name () const
{
  return "Printer";
}

word TPrinter::class_id () const
{
  return CLASS_PRINTER;
}

TPrintrow *TPrinter::getheaderline (int linetoget)
{
  return ((TPrintrow *) _header.objptr (linetoget));
}

TPrintrow *TPrinter::getfooterline (int linetoget)
{
  return ((TPrintrow *) _footer.objptr (linetoget));
}

void TPrinter::setheaderline (int linetoset, TPrintrow * line)
{
  _header.add (line, linetoset);
  if (linetoset >= _headersize)
    _headersize = linetoset + 1;
}

void TPrinter::setheaderline (int linetoset, const TPrintrow & line)
{
  TPrintrow *p = new TPrintrow (line);
  setheaderline (linetoset, p);
}

void TPrinter::setfooterline (int linetoset, TPrintrow* line)
{
  _footer.add (line, linetoset);
  // if (linetoset >= _footersize) _footersize = linetoset+1;
}

void TPrinter::setfooterline (int linetoset, const TPrintrow& line)
{
  TPrintrow *p = new TPrintrow (line);
  setfooterline (linetoset, p);
}

void TPrinter::resetheader ()
{
  _header.destroy ();
  _headersize = 0;
}

void TPrinter::resetfooter ()
{
  _footer.destroy ();
  // _footersize = 0;
}

bool TPrinter::printrow (TPrintrow * rowtoprint)
{
  if (!isopen ())
    return FALSE;

  if (_currentpage < _frompage || _currentpage > _topage)
    return TRUE;

  TString rw (rowtoprint == NULL ? "" : (_printertype == screenvis || _printertype == winprinter ?
                                         rowtoprint->row_codified () :
                                         rowtoprint->row ()));
  rw.rtrim ();

  int lun = rw.len ();
  int idx;

  for (idx = 0; idx < lun; idx++)
  {
    if (rw[idx] == '@') // gestione data e n. di pagina

    {
      switch (rw[idx + 1])
      {
      case '#':
        rw.overwrite (format ("%-5u", _currentpage), idx++);
        break;
      case '>':
        rw.overwrite (_date.string (4), idx++);
        break;
      case '<':
        rw.overwrite (_date.string (2), idx++);
        break;
      default:
        break;
      }
    }
  }

  if (_printertype == screenvis)
  {
    if (!_vf->frozen ())
      _vf->add_line (rw);
    else
      _frozen = TRUE;
    return TRUE;
  }

  if (_printertype == winprinter)
  {
    // add line to txt 
    if (!_frozen)
      _txt.append (rw);
    return TRUE;
  }

  const PrinterDef & pd = get_description (_curprn);
  int prvstl = -1;
  for (idx = 0; idx < lun; idx++)
  {
    int cst = rowtoprint->get_style (idx);
    if (cst != prvstl)
    {
      fprintf (_fp, "%s", pd._atstr[normalstyle]);
      if (cst != normalstyle)
        fprintf (_fp, "%s", pd._atstr[cst]);
    }
    prvstl = cst;
    putc (rw[idx], _fp);
  }
  if (newline ())
    putc (newline (), _fp);

  return TRUE;
}

word TPrinter::rows_left () const
{
  word left = _formlen - _currentrow - _footersize + 1;
  if (_currentrow < 2)
    left -= _headersize;
  return left;
}

bool TPrinter ::print (TPrintrow & rowtoprint)
{
  bool ok = TRUE;

  if (_currentrow > _formlen - _footersize)
    ok = printfooter ();

  //              if (ok && _currentrow <= _headersize)
  if (ok && _currentrow == 1)
    ok = printheader ();

  if (ok)
  {
    ok = printrow (&rowtoprint);
    _currentrow++;
  }

  return ok;
}

bool TPrinter::printheader ()
{
  if (_headerhandler)
    _headerhandler (*this);

  bool ok = TRUE;
  for (int i = 0; i < _headersize && ok; i++)
    ok = printrow (getheaderline (i));

  _currentrow = _headersize + 1;
  return ok;
}

bool TPrinter::printfooter ()
{
  if (_footerhandler)
    _footerhandler (*this);

  bool ok = TRUE;
  for (int i = 0; i < _footersize && ok; i++)
    ok = printrow (getfooterline (i));

#if XVT_OS != XVT_OS_WIN
  if (ok)
    printformfeed ();
#endif

  _currentrow = 1;
  _currentpage++;

  return ok;
}

bool TPrinter::skip (int linestoskip)
{
  int jumpline;

  CHECK (linestoskip >= 0, "Linestoskip can't be negative");
  jumpline = _currentrow + linestoskip;
  return jump (jumpline);
}

bool TPrinter::jump (int jumpline)
{
  int i = 0;
  bool ok = TRUE;

  CHECK (jumpline >= 0, "Jumpline can't be negative");
  if (jumpline > _formlen - _footersize)
    ok = formfeed ();
  else
    for (i = _currentrow; i < jumpline; i++)
      if (!printrow ())
        ok = FALSE;
  if (jumpline > _formlen - _footersize)
    ok = FALSE;
  return ok;
}

bool TPrinter::formfeed ()
{
  const int lastrow = _formlen - _footersize;
  for (; _currentrow <= lastrow; _currentrow++)
    printrow ();
  return printfooter ();
}

void TPrinter::reset ()
{
  resetheader ();
  resetfooter ();
  _currentpage = 1;
  _currentrow = 1;
}

bool TPrinter::printformfeed ()
{
#if XVT_OS != XVT_OS_WIN
  const PrinterDef & pd = get_description (_curprn);

  if (_printertype != screenvis && _hwformfeed)
    fprintf (_fp, "%s", (const char *) pd._ffcode);
#endif
  return TRUE;
}

bool TPrinter::open ()
{
  // qui
#if  XVT_OS==XVT_OS_SCOUNIX
  if (_printertype == spoolprinter)
  {
    const PrinterDef & def = get_description (_curprn);
    int pfd[2];

    if (pipe (pfd) == -1)
      return error_box ("Impossibile creare processo di stampa " "(pipe)");

    int ret = fork ();
    if (ret == -1)
      return error_box ("Impossibile creare processo di stampa " "(fork)");

    if (ret == 0)
    {
      if (( :: close (0) != -1) && ( ::dup (pfd[0]) == 0) &&
          ( :: close (pfd[0]) == 0) && ( ::close (pfd[1]) != -1))
      {
        char s0[80];

        sprintf (s0, "-d%s", (const char *) def._devicename);
        if ((def._filtername).not_empty ())
        {
          char s1[80];
          sprintf (s1, "-o %s", (const char *) def._filtername);
          char *ws[5] =
          {"lpr", "-s", s0, s1, NULL};
          execvp (ws[0], ws);
        }
        else
        {
          char *ws[4] =
          {"lpr", "-s", s0, NULL};
          execvp (ws[0], ws);
        }
        exit (-1);
      }
    }
    if (( ::close (pfd[0]) == -1) || ((_fp = fdopen (pfd[1], "w")) == NULL))
      return error_box ("Impossibile creare processo di stampa" "(close)");
  }
  else
#endif
    if (_printertype == screenvis)
    {
      _vf = new TViswin (NULL, "Anteprima di stampa", TRUE, TRUE,
                         _linksdescr.items () > 0);
      _vf->open_modal ();
    }
    else if (_printertype == winprinter)
    {
      // prepare text object for new text
      _txt.destroy ();
    }
    else
    {
      const PrinterDef & def = get_description (_curprn);
      TFilename fname (_printerfile);

      if (_printertype == normprinter)
        fname = def._devicename;
      _fp = fopen (fname, "w");

      if (_fp == NULL)
        return error_box ("Errore di apertura file stampa: '%s'",
                          (const char *) fname);

      TString code (def.get_codes (_curcode));
      if (code.not_empty ())
      {
        const char *s = code;
        fputs (esc ((char *) s), _fp);
      }
    }

  _currentrow = 1;
  _currentpage = 1;

  return _isopen = TRUE;
}

void TPrinter::set()
{
  TMask mask ("bagn001a");
  TToken_string pn1 (50), pn2 (100);
  int i;

  MainApp()->disable_menu_item (M_FILE_PG_SETUP);

#if XVT_OS != XVT_OS_WIN
  
  for (i = 0; i < _printers.items (); i++)
  {
    pn1.add (i);
    pn2.add (((PrinterDef &) _printers[i])._printername);
  }                      
  
  ((TList_field &) (mask.field (MSK_1_PRINTERS))).replace_items (pn1, pn2);
  mask.hide(MSK_1_SETUP);
  mask.hide(MSK_1_SIZE);
  mask.hide(MSK_1_LINES);  
  if (!_multiple_copies) mask.hide(MSK_1_NPAGES);

  pn1 = "";
  pn2 = "";

  for (i = 0; i < ((PrinterDef &)_printers[_curprn])._names.items (); i++)
  {
    pn1.add (format ("%d", i));
    pn2.add ((TString &)((PrinterDef &) _printers[_curprn])._names[i]);
  }

  ((TList_field &) (mask.field (MSK_1_CODES))).replace_items (pn1, pn2);
  mask.set_handler (MSK_1_PRINTERS, printers_on_key);
  if (_printertype == fileprinter)
    mask.set (MSK_1_TYPE, "1");
  else if (_printertype == screenvis)
    mask.set (MSK_1_TYPE, "2");
  else
    mask.set (MSK_1_TYPE, "0");

  mask.set (MSK_1_PRINTERS, format ("%d", _curprn));
  mask.set (MSK_1_CODES, format ("%d", _curcode));
  mask.set (MSK_1_FILENAME, _printerfile);
  mask.set(MSK_1_NPAGES, _ncopies);

  mask.reset (MSK_1_SAVE);

  if (mask.run () == K_ESC)
    return;

  if (mask.get (MSK_1_SAVE).not_empty ())
  {
    TString s ("printer.def");
#if XVT_OS == XVT_OS_SCOUNIX
    s << format (".%d", getuid ());
#endif
    mask.set_workfile (s);
    mask.save ();
  }

  // get user choices

  _curprn = atoi(mask.get(MSK_1_PRINTERS));
  _ncopies = atoi(mask.get(MSK_1_NPAGES));
  
  PrinterDef& def = (PrinterDef &) get_description (_curprn);
  switch (atoi(mask.get (MSK_1_TYPE)))
  {
  case 0:                       // stampante

    _printertype = normprinter;
    _curcode = atoi (mask.get (MSK_1_CODES));
    switch (atoi (def._printertype))
    {
    case 0:
      _printertype = normprinter;
      break;
    case 1:
      _printertype = localprinter;
      break;
    case 2:
      _printertype = spoolprinter;
      break;
    }
    break;
  case 1:                       // file

    _printertype = fileprinter;
    _printerfile = mask.get (MSK_1_FILENAME);
    _curcode = atoi (mask.get (MSK_1_CODES));
    break;
  case 2:                       // video

    _printertype = screenvis;
    _curcode = 0;
    break;
  }

#else

  _get_windows_printer_names (pn2);

  for (i = 0; i < pn2.items (); i++)
    pn1.add(i);

  ((TList_field &) (mask.field (MSK_1_PRINTERS))).replace_items(pn1, pn2);
  mask.set(MSK_1_PRINTERS, pn1.get(_curprn));

  mask.hide(MSK_1_CODES);
  if (!_multiple_copies) mask.hide(MSK_1_NPAGES);

  mask.set(MSK_1_ISGRAPHICS, _isgraphics ? "X" : "");
  mask.set(MSK_1_SIZE, _ch_size);
  mask.set(MSK_1_LINES, _lines_per_inch);
  
  mask.set(MSK_1_NPAGES, _ncopies);

  if (_printertype == fileprinter)
    mask.set (MSK_1_TYPE, "1");
  else if (_printertype == screenvis)
    mask.set (MSK_1_TYPE, "2");
  else
    mask.set (MSK_1_TYPE, "0");

  mask.set_handler (MSK_1_PRINTERS, set_windows_print_device);
  mask.reset (MSK_1_SAVE);

  KEY k;                                           
  int oldprn = _curprn;
  
  while ((k = mask.run ()) != K_ESC && k != K_ENTER)
  {
    if (k == MSK_1_SETUP)
    {
      if (_print_rcd != NULL)
      {
        if (page_setup_dlg (_print_rcd))
        {
          // see if user has changed printer
          // determine index of currently selected printer 
          // ACTHUNG! Deep hacking of XVT internals! NON PORTABLE!
          for (i = 0; i < pn2.items (); i++)
            if (strcmp((const char *)(_print_rcd + 4), pn2.get (i)) == 0)
            {
              _curprn = i;
              break;
            }
          mask.set (MSK_1_PRINTERS, pn1.get(_curprn));
          set_win_formlen ();
        }
        mask.set_focus ();
      }
      else
        beep ();
    }
  }
  if (k == K_ESC)
  {
    // rimetti come prima  
    // WriteProfileString("windows","device", pdev);
    if (_print_rcd != NULL)
      free_print_rcd (_print_rcd);
    _curprn = oldprn;
    _print_rcd = get_print_rcd(&_print_rcd_size);
    set_win_formlen ();
    MainApp()->enable_menu_item(M_FILE_PG_SETUP);
    return;
  }

  _curprn = atoi(mask.get(MSK_1_PRINTERS));

  if (mask.get (MSK_1_SAVE).not_empty ())
  {
    TString s ("printer.def");
    mask.set_workfile (s);
    mask.save ();
  }                            
  
  _ncopies = atoi (mask.get (MSK_1_NPAGES));
  
  switch (atoi (mask.get (MSK_1_TYPE)))
  {
  case 0:                       // stampante

    _printertype = winprinter;
    break;
  case 1:                       // file

    _printertype = fileprinter;
    _printerfile = mask.get (MSK_1_FILENAME);
    _curcode = atoi (mask.get (MSK_1_CODES));
    break;
  case 2:                       // video

    _printertype = screenvis;
    _curcode = 0;
    break;
  }

  _isgraphics = mask.get_bool (MSK_1_ISGRAPHICS);
  _ch_size = atoi (mask.get (MSK_1_SIZE));
  _lines_per_inch = atoi (mask.get (MSK_1_LINES));
  set_win_formlen ();

#endif

  MainApp ()->enable_menu_item (M_FILE_PG_SETUP);
}

void TPrinter::close ()
{
  if (isopen () && _currentrow > 1 &&
      (_footersize || (_printertype != screenvis && _printertype != winprinter)))
    formfeed ();

  if (_fp)
  {
    fclose (_fp);
    _fp = NULL;
  }

  if (_printertype == screenvis)
  {
    CHECK (_vf, "VF!");
    _vf->close_print ();
    _vf->run ();
    if (_vf->is_open ())
      _vf->close_modal ();
    delete _vf;
    freeze (FALSE);
    _vf = NULL;
  }
#if XVT_OS == XVT_OS_WIN
else if (_printertype == winprinter)
{
  PrintWhat._prcd = _print_rcd;
  PrintWhat._txt = &_txt;
  PrintWhat._graphics = _isgraphics;
  PrintWhat._charsize = _ch_size;
  start_print_thread (start_winprint, (long) (&PrintWhat));
}
#endif
else if (_printertype == localprinter)
{
#if XVT_OS == XVT_OS_SCOUNIX
  TFilename s1 = tmpnam (NULL);
  switch (fork ())
  {
  case -1:
    break;
  case 0:
    execlp ("localprint", "localprint", (const char *) s1, NULL);
  default:
    wait ((int *) NULL);
  }
  remove (s1);
#endif
}
_isopen = FALSE;
}

//  
// TFile_printer
// 

#include <bagn004.h>

#if XVT_OS == XVT_OS_DOS
#define FORMAT_COMMAND "FORMAT"
#else
#define FORMAT_COMMAND "dosformat -fq"
#endif

const long disk_sizes[] =
{360000, 1200000, 720000, 1400000, 2880000};

TFile_printer ::TFile_printer (const char *ffile, const char *label, int len_rec, int num_rec_inizio, int num_rec_fine, int tipo_disco)
{
  set_printtype (fileprinter);

  _num_rec_testa_coda = num_rec_inizio + num_rec_fine;
  _file = ffile;
  _label = label;
  _len_rec = len_rec;
  _volume = 1;
  _size = disk_sizes[tipo_disco];
  _num_rec_volume = int ((_size / len_rec) - _num_rec_testa_coda);
  _nome_file_fissato = TRUE;
  _formatta = FALSE;
  _label_fissata = TRUE;

}

void TFile_printer::open()
{
}

void TFile_printer ::
close ()
{
}

bool TFile_printer ::
genera_dischetti ()
{
  int r;

  warning_box ("Questa procedura richiede %2d dischetti",
               _volume);

  for (int i = 0; i < _tmp_files.items (); i++)
  {
    // Avvisa l'utente di inserire un dischetto
    r = yesno_box ("Inserire il dischetto n. %2d di %2d nel drive %2s",
                   i + 1, _volume, _drive);
    if (!r)
      return error_box ("Procedura interrotta!");

    // e eventualmente lo formatta 
    if (_formatta)
    {
      TString dep (30);
      if (_label != NULL)
        dep << FORMAT_COMMAND << " " << "/v:" << _label << " " << _drive;
      else
        dep << FORMAT_COMMAND << " " << _drive;

      TExternal_app sys (dep);
      sys.run ();
    }

    // copia il file sul dischetto
    fcopy ((const char *) &_tmp_files[i], (const char *) _drive);

  }
  return TRUE;
}

TFile_printer::~TFile_printer ()
{
}

void TFile_printer::set ()
{
  TMask m ("bagn004");
  KEY tasto;
  int f;

  //
  // 
  // --------------------------------------------------------------------
  // Qui bisogna inserire la lista dei drive disponibili nella maschera
  // Per ora tale lista e' fissa e contiene solo A: e B:
  // --------------------------------------------------------------------
  // 
  // 

  m.set (F_FILE_DESTINAZIONE, _file);
  m.set (F_LABEL, _label);

  if (_nome_file_fissato)
    m.disable (F_FILE_DESTINAZIONE);

  if (_label_fissata)
    m.disable (F_LABEL);

  tasto = m.run ();

  if (tasto == K_ENTER)
  {
    f = atoi (m.get (F_FORMATO_DISCO));
    _drive = m.get (F_DRIVE);
    _file = m.get (F_FILE_DESTINAZIONE);
    _label = m.get (F_LABEL);
    _formatta = (bool) (m.get (F_FORMATTA) == "X");
    _size = disk_sizes[f];
    _num_rec_volume = int ((_size / _len_rec) - _num_rec_testa_coda);
  }
}

//
// TFile printer fine
//