#include <stdio.h>
#include <string.h>
#include <qmessagebox.h>
#include <qpixmap.h>
#ifdef USEQPE
#include <qpe/qcopenvelope_qws.h>
#endif /* USEQPE */
#ifdef LOCALPICTURES
#include <qscrollview.h>
#endif
#ifdef USEQPE
#include <qpe/global.h>
#endif /* USEQPE */
#include <qclipboard.h>
#ifndef USEQPE
#include <qapplication.h>
#else /* USEQPE */
#include <qpe/qpeapplication.h>
#endif /* USEQPE */
#include <qimage.h>

#include "plucker_base.h"
#include "Aportis.h"
#include "hrule.h"
#include "decompress.h"

const UInt8 CPlucker_base::continuation_bit = 1;

CPlucker_base::CPlucker_base() :
#ifdef LOCALPICTURES
  m_viewer(NULL),
  m_picture(NULL),
#endif
  expandedtextbuffer(NULL),
  compressedtextbuffer(NULL),
  bufferrec(-1),
  m_offset(0)
  //,    urls(NULL)
{ /*printf("constructing:%x\n",fin);*/ }


void CPlucker_base::Expand(UInt32 reclen, UInt8 type, UInt8* buffer, UInt32 buffersize)
{
unsuspend();
  if ((type%2 == 0) && (type != 14))
    {
      size_t bytes_read = fread(buffer, reclen, sizeof(char), fin);
      buffer[bytes_read] = '\0';
    }
  else
    {
      UInt8* readbuffer = NULL;
      if (reclen > compressedbuffersize)
	{
	  readbuffer = new UInt8[reclen];
	}
      else
	{
	  readbuffer = compressedtextbuffer;
	}
      if (readbuffer != NULL)
	{
	  fread(readbuffer, reclen, sizeof(char), fin);
	  size_t bytes_read = (*m_decompress)(readbuffer, reclen, buffer, buffersize);
	  buffer[bytes_read] = '\0';
	  if (reclen > compressedbuffersize)
	    {
	      delete [] readbuffer;
	    }
	}
    }
}

void CPlucker_base::sizes(unsigned long& _file, unsigned long& _text)
{
  _file = file_length;
  if (textlength == 0)
    {
      for (int recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
	{
	  gotorecordnumber(recptr);
	  UInt16 thishdr_uid, thishdr_nParagraphs;
	  UInt32 thishdr_size;
	  UInt8 thishdr_type, thishdr_reserved;
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  if (thishdr_type < 2) textlength += thishdr_size;
	}
    }
  _text = textlength;
  //ntohl(hdr0.size);
}

char* CPlucker_base::geturl(UInt16 tgt)
{
  char * pRet = NULL;
  gotorecordnumber(0);
  fread(&hdr0, 1, 6, fin);
  unsigned int nrecs = ntohs(hdr0.nRecords);
  //qDebug("Version %u, no. recs %u", ntohs(hdr0.version), nrecs);
  UInt16 urlid = 0;
  bool urlsfound = false;
  char* urls = NULL;
  size_t urlsize = 0;
  for (unsigned int i = 0; i < nrecs; i++)
    {
      UInt16 id, name;
      fread(&name, 1, sizeof(name), fin);
      fread(&id, 1, sizeof(id), fin);
      //qDebug("N:%d, I:%d", ntohs(name), ntohs(id));
      if (ntohs(name) == 2)
	{
	  urlsfound = true;
	  urlid = id;
	  //qDebug("Found url index:%d", ntohs(urlid));
	}
      //	//qDebug("%x", id);
    }
  if (urlsfound)
    {
      unsigned short recptr = finduid(ntohs(urlid));
      if (recptr != 0)
	{
	  gotorecordnumber(recptr);
	  UInt16 thishdr_uid, thishdr_nParagraphs;
	  UInt32 thishdr_size;
	  UInt8 thishdr_type, thishdr_reserved;
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  UInt16 urlctr = 0;
	  while (1)
	    {
	      UInt16 tctr;
	      fread(&tctr, 1, sizeof(tctr), fin);
	      fread(&urlid, 1, sizeof(urlid), fin);
	      tctr = ntohs(tctr);
	      //qDebug("tgt:%u urlctr:%u tctr:%u", tgt, urlctr, tctr);
	      if (tctr >= tgt)
		{
		  break;
		}
	      urlctr = tctr;
	    }
	  //qDebug("urls are in %d", ntohs(urlid));
	  recptr = finduid(ntohs(urlid));
	  if (recptr != 0)
	    {
	      UInt32 reclen = recordlength(recptr) - HeaderSize();
	      gotorecordnumber(recptr);
	      GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	      //qDebug("Found urls:%x",thishdr_type);
	      urlsize = thishdr_size;
	      urls = new char[urlsize];
	      Expand(reclen, thishdr_type, (UInt8*)urls, urlsize);
	      char* ptr = urls;
	      int rn = urlctr+1;
	      while (ptr - urls < urlsize)
		{
		  if (rn == tgt)
		    {
		      //qDebug("URL:%s", ptr);
		      int len = strlen(ptr)+1;
		      pRet = new char[len];
		      memcpy(pRet, ptr, len);
		      break;
		    }
		  ptr += strlen(ptr)+1;
		  rn++;
		}
	      delete [] urls;
	    }
	}
    }
  else
    {
      pRet = NULL;
    }
  return pRet;
}

CPlucker_base::~CPlucker_base()
{
  if (expandedtextbuffer != NULL) delete [] expandedtextbuffer;
  if (compressedtextbuffer != NULL) delete [] compressedtextbuffer;
#ifdef LOCALPICTURES
  if (m_viewer != NULL) delete m_viewer;
#endif
}

int CPlucker_base::getch() { return getch(false); }

void CPlucker_base::getch(tchar& ch, CStyle& sty, unsigned long& pos)
{
  pos = locate();
  ch = getch(false);
  sty = mystyle;
}

unsigned int CPlucker_base::locate()
{
  return currentpos;
  /*
    UInt16 thisrec = 1;
    unsigned long locpos = 0;
    gotorecordnumber(thisrec);
    UInt16 thishdr_uid, thishdr_nParagraphs;
    UInt32 thishdr_size;
    UInt8 thishdr_type, thishdr_reserved;
    while (thisrec < bufferrec)
    {
    GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
    if (thishdr_type < 2) locpos += thishdr_size;
    thisrec++;
    gotorecordnumber(thisrec);
    }
    return locpos+bufferpos;
  */
}

void CPlucker_base::locate(unsigned int n)
{

  //    clock_t start = clock();
  if (n >= currentpos-bufferpos && n < currentpos - bufferpos + buffercontent)
    {
      currentpos -= bufferpos;
      expand(bufferrec);
      while (currentpos < n && bufferpos < buffercontent) getch_base(true);
      return;
    }
  /*

  UInt32 textlength = currentpos - bufferpos;
  UInt16 recptr = bufferrec;
  if (n < textlength/2)
    {
      textlength = 0;
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size = buffercontent;
      UInt8 thishdr_type, thishdr_reserved;
      for (recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
	{
	  gotorecordnumber(recptr);
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  if (thishdr_type < 2)
	    {
	      textlength += thishdr_size;
	      if (textlength > n)
		{
		  textlength -= thishdr_size;
		  break;
		}
	    }
	}
    }
  else if (n < textlength)
    {
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size;
      UInt8 thishdr_type, thishdr_reserved;
      while (n < textlength && recptr > 1)
	{
	  recptr--;
	  gotorecordnumber(recptr);
	  //qDebug("recptr:%u", recptr);
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  if (thishdr_type < 2)
	    {
	      textlength -= thishdr_size;
	    }
	}
    }
  else
    {
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size = buffercontent;
      UInt8 thishdr_type, thishdr_reserved;
      while (n > textlength + thishdr_size && recptr < ntohs(head.recordList.numRecords)-1)
	{
	  textlength += thishdr_size;
	  recptr++;
	  gotorecordnumber(recptr);
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  if (!(thishdr_type < 2))
	    {
	      thishdr_size = 0;
	    }
	}
    }

  */
  UInt16 thisrec = 0;
  unsigned long locpos = 0;
  unsigned long bs = 0;
  unsigned int np1 = n+1;
  UInt16 thishdr_uid, thishdr_nParagraphs;
  UInt32 thishdr_size;
  UInt8 thishdr_type, thishdr_reserved;
  do
    {
      thisrec++;
      locpos += bs;
      gotorecordnumber(thisrec);
      GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
      if (thishdr_type < 2)
	{
	  bs = thishdr_size;
	}
      else
	{
	  bs = 0;
	}
    } while (locpos + bs < np1);

  //    qDebug("Time(2): %u", clock()-start);
  /*
  if (recptr != thisrec)
    {
      qDebug("Disaster:recptr:%u thisrec:%u", recptr, thisrec);
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size = buffercontent;
      UInt8 thishdr_type, thishdr_reserved;
      for (recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
	{
	  gotorecordnumber(recptr);
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  //	    qDebug("UID:%u Paras:%u Size:%u Type:%u Reserved:%u", thishdr_uid, thishdr_nParagraphs, thishdr_size, (unsigned int)thishdr_type, (unsigned int)thishdr_reserved);
	}
      //	QApplication::exit ( 100 );
    }
  */
  currentpos = locpos;
  expand(thisrec);
  while (currentpos < n && bufferpos < buffercontent) getch_base(true);

  /*  // This is faster but the alignment attribute doesn't get set 8^(
      bufferpos = n-locpos;
      currentpos = n;
      while (bufferpos >= m_nextPara && m_nextPara >= 0)
      {
      UInt16 attr = m_ParaAttrs[m_nextParaIndex];
      m_nextParaIndex++;
      if (m_nextParaIndex == m_nParas)
      {
      m_nextPara = -1;
      }
      else
      {
      m_nextPara += m_ParaOffsets[m_nextParaIndex];
      }
      }
  */
}

bool CPlucker_base::expand(int thisrec)
{
  mystyle.unset();
  if (bufferrec != thisrec)
    {
      size_t reclen = recordlength(thisrec);
      gotorecordnumber(thisrec);
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size;
      UInt8 thishdr_type, thishdr_reserved;
      while (1)
	{
	  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
	  //qDebug("This (%d) type is %d, uid is %u", thisrec, thishdr_type, thishdr_uid);
	  if (thishdr_type < 2) break;
	  //qDebug("Skipping paragraph of type %d", thishdr_type);
	  if (++thisrec >= ntohs(head.recordList.numRecords) - 1) return false;
	  reclen = recordlength(thisrec);
	  gotorecordnumber(thisrec);
	}
      m_nParas = thishdr_nParagraphs;
      m_bufferisreserved = (thishdr_reserved != 0);
      //qDebug("It has %u paragraphs and is %u bytes", thishdr_nParagraphs, thishdr_size);
      uid = thishdr_uid;
      //    gotorecordnumber(thisrec);
      //    fread(expandedtextbuffer,1,10,fin);
      for (int i = 0; i < m_nParas; i++)
	{
	  UInt16 ubytes, attrs;
	  fread(&ubytes, 1, sizeof(ubytes), fin);
	  fread(&attrs, 1, sizeof(attrs), fin);
	  m_ParaOffsets[i] = ntohs(ubytes);
	  m_ParaAttrs[i] = ntohs(attrs);
	  //	//qDebug("Bytes %u, Attr %x", ntohs(ubytes), ntohs(attrs));
	}

      reclen -= HeaderSize()+4*m_nParas;

      buffercontent = thishdr_size;

      if (thishdr_size > buffersize)
	{
	  delete [] expandedtextbuffer;
	  buffersize = thishdr_size;
	  expandedtextbuffer = new UInt8[buffersize];
	}
      Expand(reclen, thishdr_type, expandedtextbuffer, buffercontent);
      bufferrec = thisrec;
    }


  if (m_nParas > 0)
    {
      m_nextPara = m_ParaOffsets[0];
      //qDebug("First offset = %u", m_nextPara);
      m_nextParaIndex = 0;
    }
  else
    {
      m_nextPara = -1;
    }
  bufferpos = 0;
  //qDebug("BC:%u, HS:%u", buffercontent, thishdr_size);
  return true;
}
/*
void CPlucker_base::UnZip(UInt8* compressedbuffer, size_t reclen, UInt8* tgtbuffer, size_t bsize)
{
  z_stream zstream;
  memset(&zstream,sizeof(zstream),0);
  zstream.next_in = compressedbuffer;
  zstream.next_out = tgtbuffer;
  zstream.avail_out = bsize;
  zstream.avail_in = reclen;

  int keylen = 0;

  zstream.zalloc = Z_NULL;
  zstream.zfree = Z_NULL;
  zstream.opaque = Z_NULL;
  
  //  printf("Initialising\n");
  
  inflateInit(&zstream);
  int err = 0;
  do {
    if ( zstream.avail_in == 0 && 0 < keylen ) {
      zstream.next_in   = compressedbuffer + keylen;
      zstream.avail_in  = reclen - keylen;
      keylen      = 0;
    }
    zstream.next_out  = tgtbuffer;
    zstream.avail_out = bsize;

    err = inflate( &zstream, Z_SYNC_FLUSH );

    //	//qDebug("err:%d - %u", err, zstream.avail_in);

  } while ( err == Z_OK );

  inflateEnd(&zstream);
}
*/
size_t CPlucker_base::UnDoc(UInt8* compressedbuffer, size_t reclen, UInt8* tgtbuffer, size_t bsize)
{
  //    UInt16      headerSize;
  UInt16      docSize;
  UInt16      i;
  UInt16      j;
  UInt16      k;

  UInt8 *inBuf = compressedbuffer;
  UInt8 *outBuf = tgtbuffer;

  //    headerSize  = sizeof( Header ) + record->paragraphs * sizeof( Paragraph );
  docSize     = reclen;

  j               = 0;
  k               = 0;
  while ( j < docSize ) {
    i = 0;
    while ( i < bsize && j < docSize ) {
      UInt16 c;

      c = (UInt16) inBuf[ j++ ];
      if ( 0 < c && c < 9 ) {
	while ( 0 < c-- )
	  outBuf[ i++ ] = inBuf[ j++ ];
      }
      else if ( c < 0x80 )
	outBuf[ i++ ] = c;
      else if ( 0xc0 <= c ) {
	outBuf[ i++ ] = ' ';
	outBuf[ i++ ] = c ^ 0x80;
      }
      else {
	Int16 m;
	Int16 n;

	c <<= 8;
	c  += inBuf[ j++ ];

	m   = ( c & 0x3fff ) >> COUNT_BITS;
	n   = c & ( ( 1 << COUNT_BITS ) - 1 );
	n  += 2;

	do {
	  outBuf[ i ] = outBuf[ i - m ];
	  i++;
	} while ( 0 < n-- );
      }
    }
    k += bsize;
  }
  return i;
}

void CPlucker_base::home()
{
  currentpos = 0;
  expand(1);
}

CList<Bkmk>* CPlucker_base::getbkmklist()
{
  /*
    UInt16 thishdr_uid, thishdr_nParagraphs;
    UInt32 thishdr_size;
    UInt8 thishdr_type, thishdr_reserved;

    for (int i = 1; i < ntohs(head.recordList.numRecords); i++)
    {
    gotorecordnumber(i);
    GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
    if (thishdr_type == 8)
    {
    UInt16 n;
    fread(&n, 1, sizeof(n), fin);
    n = ntohs(n);
    //qDebug("Found %u bookmarks", n);
    }
    //qDebug("Found:%d, %u", i , thishdr_type);
    }
  */
  return NULL;
}

#include <qnamespace.h>

QImage* CPlucker_base::expandimg(UInt16 tgt, bool border)
{
  QImage* qimage = getimg(tgt);
  QImage* ret;
  if (qimage == NULL) return NULL;
  if (border)
    {
      QPixmap* image = new QPixmap(0,0);
      image->convertFromImage(*qimage);
      delete qimage;
      QPixmap* pret = new QPixmap(image->width()+4, image->height()+4);
      pret->fill(Qt::red);
      bitBlt(pret, 2, 2, image, 0, 0, -1, -1);//, Qt::RasterOp::CopyROP);
      delete image;
      ret = new QImage(pret->convertToImage());
    }
  else
    {
      ret = qimage;
    }
  return ret;
}

#ifdef _BUFFERPICS
#include <qmap.h>
#endif

QImage* CPlucker_base::getPicture(unsigned long tgt)
{
#ifdef _BUFFERPICS
  static QMap<unsigned long, QPixmap> pix;
  QMap<unsigned long, QPixmap>::Iterator t = pix.find(tgt);
  if (t == pix.end())
    {
      pix[tgt] = *expandimg(tgt);
      return &pix[tgt];
    }
  else
    return &(t.data());
#else
  return expandimg(tgt >> 16);
#endif
}

#ifdef LOCALPICTURES
#include <unistd.h>
#include <qpe/global.h>
void CPlucker_base::showimg(UInt16 tgt)
{
  //qDebug("Crassssssh!");
  QPixmap* qimage = expandimg(tgt);
  m_picture->setFixedSize(qimage->size());
  m_picture->setBackgroundPixmap(*qimage);
  delete qimage;
  m_viewer->show();

  /*
    char tmp[] = "uqtreader.XXXXXX";
    QImage* qimage = getimg(tgt);
    QPixmap* image = new QPixmap(0,0);
    //    //qDebug("New image");
    image->convertFromImage(*qimage);
    delete qimage;
    char tmpfile[sizeof(tmp)+1];
    strcpy(tmpfile,tmp);
    int f = mkstemp(tmpfile);
    close(f);
    //qDebug("TMPFILE:%s", tmpfile);
    if (image->save(tmpfile,"PNG"))
    {
    QCopEnvelope e("QPE/Application/showimg", "setDocument(QString)");
    e << QString(tmpfile);
    }
    Global::statusMessage("Opening image");
    sleep(5);
    delete image;
    unlink(tmpfile);
  */
}

#endif

unsigned short CPlucker_base::finduid(unsigned short urlid)
{
  //    //qDebug("Finding %u", urlid);
  unsigned short jmin = 1, jmax = ntohs(head.recordList.numRecords);
  unsigned short jmid = (jmin+jmax) >> 1;
  while (jmax - jmin > 1)
    {
      gotorecordnumber(jmid);
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size;
      UInt8 thishdr_type, thishdr_reserved;
      GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
      unsigned short luid = thishdr_uid;
      //	//qDebug("%u %u %u : %u", jmin, jmid, jmax, urlid);
      if (luid == urlid)
	{
	  return jmid;
	}
      if (luid < urlid)
	{
	  jmin = jmid;
	}
      else
	{
	  jmax = jmid;
	}
      jmid = (jmin+jmax) >> 1;
    }
  gotorecordnumber(jmin);
  UInt16 thishdr_uid, thishdr_nParagraphs;
  UInt32 thishdr_size;
  UInt8 thishdr_type, thishdr_reserved;
  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
  unsigned short luid = thishdr_uid;
  //qDebug("jmin at end:%u,%u", jmin, luid);
  if (luid == urlid)
    {
      return jmin;
    }
  gotorecordnumber(jmax);
  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
  luid = thishdr_uid;
  //qDebug("jmax at end:%u,%u", jmax, luid);
  if (luid == urlid)
    {
      return jmax;
    }
  //qDebug("Couldn't find %u", urlid);
  return 0; // Not found!
}

#include <qnamespace.h>

void CPlucker_base::setSaveData(unsigned char*& data, unsigned short& len, unsigned char* src, unsigned short srclen)
{
  unsigned short sz = 0;
  for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
    {
      sz++;
    }
  size_t newlen = srclen+sizeof(sz)+sz*sizeof(unsigned long);
  unsigned char* newdata = new unsigned char[newlen];
  unsigned char* pdata = newdata;
  memcpy(newdata, src, srclen);
  newdata += srclen;
  memcpy(newdata, &sz, sizeof(sz));
  newdata += sizeof(sz);
#ifdef _WINDOWS
  for (it = visited.begin(); it != visited.end(); it++)
#else
    for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
#endif
      {
	unsigned long t = *it;
	//	qDebug("[%u]", t);
	memcpy(newdata, &t, sizeof(t));
	newdata += sizeof(t);
      }
  m_nav.setSaveData(data, len, pdata, newlen);
  delete [] pdata;
}

void CPlucker_base::putSaveData(unsigned char*& src, unsigned short& srclen)
{
  unsigned short sz;
  if (srclen >= sizeof(sz))
    {
      memcpy(&sz, src, sizeof(sz));
      src += sizeof(sz);
      srclen -= sizeof(sz);
    }
  for (int i = 0; i < sz; i++)
    {
      unsigned long t;
      if (srclen >= sizeof(t))
	{
	  memcpy(&t, src, sizeof(t));
	  //	    qDebug("[%u]", t);
	  visited.push_front(t);
	  src += sizeof(t);
	  srclen -= sizeof(t);
	}
      else
	{
	  QMessageBox::warning(NULL, PROGNAME, "File data mismatch\nMight fix itself");
	  break;
	}
    }
  m_nav.putSaveData(src, srclen);
}

int CPlucker_base::OpenFile(const char *src)
{
  qDebug("plucker openfile:%s", src);
  m_lastBreak = 0;
  if (!Cpdb::openpdbfile(src))
    {
      return -1;
    }

  if (!CorrectDecoder()) return -1;

  gotorecordnumber(0);
  fread(&hdr0, 1, 6, fin);
  qDebug("Compression type:%u", ntohs(hdr0.version));
 
 
  switch (ntohs(hdr0.version))
    {
    case 2:
      m_decompress = UnZip;
      break;
    case 1:
      m_decompress = UnDoc;
      break;
#ifdef USENEF
    case 3:
      m_decompress = getdecompressor("PluckerDecompress3");
      break;
    case 4:
      m_decompress = getdecompressor("PluckerDecompress4");
      break;
#endif
    default:
      m_decompress = NULL;
    }
  if (m_decompress == NULL) return -1;

  setbuffersize();
  compressedtextbuffer = new UInt8[compressedbuffersize];
  expandedtextbuffer = new UInt8[buffersize];

  unsigned int nrecs = ntohs(hdr0.nRecords);
  qDebug("Version %u, no. reserved recs %u", ntohs(hdr0.version), nrecs);
  textlength = ntohl(head.sortInfoID);
  qDebug("Textlength at startup:%u", textlength);
  UInt16 homerecid = 1;
  for (unsigned int i = 0; i < nrecs; i++)
    {
      UInt16 id, name;
      fread(&name, 1, sizeof(name), fin);
      fread(&id, 1, sizeof(id), fin);
      //qDebug("N:%d, I:%d", ntohs(name), ntohs(id));
      if (ntohs(name) == 0) homerecid = ntohs(id);
    }

  textlength = 0;
  for (int recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
    {
      gotorecordnumber(recptr);
      UInt16 thishdr_uid, thishdr_nParagraphs;
      UInt32 thishdr_size;
      UInt8 thishdr_type, thishdr_reserved;
      GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
      if (thishdr_uid == homerecid)
	{
	  m_homepos = textlength;
	  break;
	}
      if (thishdr_type < 2) textlength += thishdr_size;
    }
  qDebug("Found home");
  textlength = 0;
  home();
  qDebug("Gone home");
#ifdef LOCALPICTURES
  if (m_viewer == NULL)
    {
      m_viewer = new QScrollView(NULL);
      m_picture = new QWidget(m_viewer->viewport());
      m_viewer->addChild(m_picture);
    }
#endif
  return 0;

}

QImage* CPlucker_base::getimg(UInt16 tgt)
{
  size_t reclen;
  UInt16 thisrec = finduid(tgt);
  qDebug("getimg:Found %u from uid:%u", thisrec, tgt);
  reclen = recordlength(thisrec);
  gotorecordnumber(thisrec);
  UInt16 thishdr_uid, thishdr_nParagraphs;
  UInt32 thishdr_size;
  UInt8 thishdr_type, thishdr_reserved;
  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
  if (thishdr_type == 15)
    {
      char *buffer = new char[thishdr_size];
      fread(buffer, thishdr_size, sizeof(char), fin);
      unsigned short tmp;
      memcpy(&tmp, buffer, sizeof(tmp));
      unsigned short cols = ntohs(tmp);
      memcpy(&tmp, buffer+sizeof(tmp), sizeof(tmp));
      unsigned short rows = ntohs(tmp);
      qDebug("Found a picture of type:%u [%u,%u]", thishdr_type, rows, cols);
      QImage*** images;
      images = new QImage**[rows];
#ifdef _WINDOWS
      int i;
      for (i = 0; i < rows; i++)
#else
	for (int i = 0; i < rows; i++)
#endif
	  {
	    images[i] = new QImage*[cols];
	  }
      int height = 0;
      int width = 0;
#ifdef _WINDOWS
      for (i = 0; i < rows; i++)
#else
	for (int i = 0; i < rows; i++)
#endif
	  {
	    width = 0;
	    for (int j = 0; j < cols; j++)
	      {
		memcpy(&tmp, buffer+(i*cols+j+2)*sizeof(tmp), sizeof(tmp));
		unsigned short uid = ntohs(tmp);
		images[i][j] = getimg(uid);
		width += images[i][j]->width();
	      }
	    height += images[i][0]->height();
	  }
      delete [] buffer;
      QPixmap pm(width, height);
      int hoffset = 0;
#ifdef _WINDOWS
      for (i = 0; i < rows; i++)
#else
	for (int i = 0; i < rows; i++)
#endif
	  {
	    int woffset = 0;
	    int delht = images[i][0]->height();
	    for (int j = 0; j < cols; j++)
	      {
		QPixmap pm2;
		pm2.convertFromImage(*(images[i][j]));
		delete images[i][j];
		bitBlt(&pm, woffset, hoffset, &pm2, 0, 0, pm2.width(), pm2.height());
		woffset += pm2.width();
	      }
	    hoffset += delht;
	  }
#ifdef _WINDOWS
      for (i = 0; i < rows; i++)
#else
	for (int i = 0; i < rows; i++)
#endif
	  {
	    delete [] images[i];
	  }
      delete [] images;
      return new QImage(pm.convertToImage());
    }
  else
    {
      qDebug("Found a picture of type:%u", thishdr_type);
      reclen -= HeaderSize();

      UInt32 imgsize = thishdr_size;
      UInt8* imgbuffer = new UInt8[imgsize];
    
      Expand(reclen, thishdr_type, imgbuffer, imgsize);

      return imagefromdata(imgbuffer, imgsize);
    }
}

linkType CPlucker_base::hyperlink(unsigned int n, unsigned int offset, QString& wrd, QString&)
{
  visited.push_front(n);
  UInt16 tuid = (n >> 16);
  n &= 0xffff;
  char *turl = geturl(tuid);
  if (turl != NULL)
    {
      qDebug("URL in PB:%s", turl);
      wrd = turl;
      delete [] turl;
    }
  else
    {
      wrd.truncate(0);
    }
  qDebug("Hyper: UID:%u, Para:%u, Offset:%u", tuid, n, offset);
  UInt16 thisrec = 1;
  currentpos = 0;
  gotorecordnumber(thisrec);
  UInt16 thishdr_uid, thishdr_nParagraphs;
  UInt32 thishdr_size;
  UInt8 thishdr_type, thishdr_reserved;
  while (1)
    {
      GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
      if (tuid == thishdr_uid) break;
      if (thishdr_type < 2) currentpos += thishdr_size;
      //	//qDebug("hyper-cp:%u", currentpos);
      thisrec++;
      if (thisrec >= ntohs(head.recordList.numRecords))
	{
	  if (wrd.isEmpty())
	    {
	      QMessageBox::information(NULL,
				       QString(PROGNAME),
				       QString("Couldn't find link")
				       );
	    }
	  else
	    {
#ifdef USEQPE
	      if (wrd.length() > 10)
		{
		  Global::statusMessage(wrd.left(8) + "..");
		}
	      else
		{
		  Global::statusMessage(wrd);
		}
#else
#endif /* USEQPE */
	      //qDebug("Link:%s", (const char*)wrd);
	      //		setlink(fn, wrd);
	    }
	  return eNone;
	}
      gotorecordnumber(thisrec);
    }
  if (thishdr_type > 1)
    {
      if (thishdr_type == 4)
	{
	  QMessageBox::information(NULL,
				   QString(PROGNAME),
				   QString("Mailto links\nnot yet supported (2)"));
	}
      else
	{
	  if (thishdr_type > 3 && thishdr_type != 15)
	    {
	      QMessageBox::information(NULL,
				       QString(PROGNAME),
				       QString("External links\nnot yet supported (2)")
				       );
	      return eNone;
	    }
	  else
	    {
#ifdef LOCALPICTURES
	      showimg(tuid);
#else
	      return ePicture;
#endif
	    }
	}
      return eNone;
    }
  /*
    if (thishdr_type == 2 || thishdr_type == 3)
    {
    expandimg(thisrec);

    }
  */
  else
    {
      expand(thisrec);
      unsigned int paraoffset = offset;
      //      unsigned int noff = 0;
      if (n != 0) 
	{
	  if (n >= m_nParas)
	    {
	      QMessageBox::information(NULL,
				       QString(PROGNAME),
				       QString("Error in link\nPara # too big")
				       );
	      return eNone;
	    }
	  unsigned int noff = 0;
	  for (unsigned int i = 0; i < n; i++) noff += m_ParaOffsets[i];

	  paraoffset += noff;
	}
      if (paraoffset > thishdr_size)
	{
	  QMessageBox::information(NULL,
				   QString(PROGNAME),
				   QString("Error in link\nOffset too big")
				   );
	  return eNone;
	}
      while (bufferpos < paraoffset && bufferpos < buffercontent) getch_base(true);
      //qDebug("Hyper:<%u,%u,%u>", paraoffset, bufferpos, currentpos);
      /*      // This is faster but the alignment doesn't get set
	      mystyle.unset();
	      bufferpos = n;
	      currentpos += n;
	      while (bufferpos >= m_nextPara && m_nextPara >= 0)
	      {
	      UInt16 attr = m_ParaAttrs[m_nextParaIndex];
	      m_nextParaIndex++;
	      if (m_nextParaIndex == m_nParas)
	      {
	      m_nextPara = -1;
	      }
	      else
	      {
	      m_nextPara += m_ParaOffsets[m_nextParaIndex];
	      }
	      }
      */
    }
  return eLink;
}
QString CPlucker_base::getTableAsHtml(unsigned long tgt)
{
  qDebug("CPlucker_base::getTableAsHtml:%u", tgt);
  size_t reclen;
  UInt16 thisrec = finduid(tgt);
  qDebug("getimg:Found %u from uid:%u", thisrec, tgt);
  reclen = recordlength(thisrec);
  gotorecordnumber(thisrec);
  UInt16 thishdr_uid, thishdr_nParagraphs;
  UInt32 thishdr_size;
  UInt8 thishdr_type, thishdr_reserved;
  GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
  qDebug("Found a table of type:%u", thishdr_type);
  reclen -= HeaderSize();
  UInt32 imgsize = thishdr_size;
  UInt8* imgbuffer = new UInt8[imgsize];
  Expand(reclen, thishdr_type, imgbuffer, imgsize);

  QString ret;

  UInt16 size, columns, rows;
  UInt8 depth, border;
  UInt32 borderColour, linkColour;
  UInt8* dp(imgbuffer);

  memcpy(&size, dp, sizeof(size));
  size = ntohs(size);
  dp += sizeof(size);
  memcpy(&columns, dp, sizeof(columns));
  columns = ntohs(columns);
  dp += sizeof(columns);
  memcpy(&rows, dp, sizeof(rows));
  rows = ntohs(rows);
  dp += sizeof(rows);
  qDebug("Rows:%u Cols:%u", rows, columns);

  memcpy(&depth, dp, sizeof(depth));
  dp += sizeof(depth);
  memcpy(&border, dp, sizeof(border));
  dp += sizeof(border);

  qDebug("Depth:%u, Border:%u", depth, border);

  memcpy(&borderColour, dp, sizeof(borderColour));
  dp += sizeof(borderColour);
  memcpy(&linkColour, dp, sizeof(linkColour));
  dp += sizeof(linkColour);

  qDebug("Colours: border:%x, link:%x", borderColour, linkColour);

  if (border)
    {
      ret = "<table border>";
    }
  else
    {
      ret = "<table>";
    }
  bool firstrow = true;
  bool firstcol = true;
  while (dp < imgbuffer+imgsize)
    {
      UInt8 ch = *dp++;
      if (ch == 0x00)
	{
	  ch = *dp++;
	  if (ch == 0x90)
	    {
	      if (firstrow)
		{
		  ret += "<tr>";
		  firstrow = false;
		  firstcol = true;
		}
	      else
		{
		  ret += "</tr><tr>";
		}
	    }
	  else if (ch == 0x97)
	    {
	      if (firstcol)
		{
		  ret += "<td";
		  firstcol = false;
		}
	      else
		{
		  ret += "</td><td";
		}
	      UInt8 align;
	      UInt16 imgid;
	      UInt8 cols, rows;
	      UInt16 len;
	      memcpy(&align, dp, sizeof(align));
	      dp += sizeof(align);
	      memcpy(&imgid, dp, sizeof(imgid));
	      dp += sizeof(imgid);
	      imgid = ntohs(imgid);
	      memcpy(&cols, dp, sizeof(cols));
	      dp += sizeof(cols);
	      memcpy(&rows, dp, sizeof(rows));
	      dp += sizeof(rows);
	      memcpy(&len, dp, sizeof(len));
	      dp += sizeof(len);
	      len = ntohs(len);
	      switch (align)
		{
		case 1:
		  ret += " align=right";
		  break;
		case 2:
		  ret += " align=center";
		  break;
		case 3:
		  ret += " align=justify";
		  break;
		case 0:
		  break;
		default:
		  qDebug("Unknown table cell alignment:%u", align);
		}
	      if (cols != 1)
		{
		  QString num;
		  num.setNum(cols);
		  ret += " colspan=";
		  ret += num;
		}
	      if (rows != 1)
		{
		  QString num;
		  num.setNum(rows);
		  ret += " rowspan=";
		  ret += num;
		}
	      ret += ">";
	    }
	  else
	    {
	      dp += (ch & 7);
	    }
	}
      else
	{
	  ret += QChar(ch);
	}
    }

  ret += "</td></tr></table>";
  delete [] imgbuffer;
  return ret;
}

tchar CPlucker_base::getch_base(bool fast)
{
  mystyle.setTable(0xffffffff);
  int ch = bgetch();
  while (ch == 0)
    {
      ch = bgetch();
      //	//qDebug("Function:%x", ch);
      switch (ch)
	{
	case 0x38:
	  //		//qDebug("Break:%u", locate());
	  if (m_lastBreak == locate())
	    {
	      ch = bgetch();
	    }
	  else
	    {
	      ch = 10;
	    }
	  m_lastBreak = locate();
	  break;
	case 0x0a:
	case 0x0c:
	  {
	    unsigned long ln = 0;
	    int skip = ch & 7;
	    for (int i = 0; i < 2; i++)
	      {
		int ch = bgetch();
		ln = (ln << 8) + ch;
		//		    //qDebug("ch:%d, ln:%u", ch, ln);
	      }
	    if (skip == 2)
	      {
		ln <<= 16;
	      }
	    else
	      {
		for (int i = 0; i < 2; i++)
		  {
		    int ch = bgetch();
		    ln = (ln << 8) + ch;
		    //			//qDebug("ch:%d, ln:%u", ch, ln);
		  }
	      }
	    //		//qDebug("ln:%u", ln);
	    mystyle.setLink(true);
	    mystyle.setData(ln);
	    //		mystyle.setColour(255, 0, 0);
	    bool hasseen = false;
	    for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
	      {
		if (*it == ln)
		  {
		    hasseen = true;
		    break;
		  }
	      }
	    if (hasseen)
	      {
		mystyle.setStrikethru();
	      }
	    mystyle.setOffset(m_offset);
	    m_offset = 0;
	    ch = bgetch();
	  }
	  break;
	case 0x08:
	  ch = bgetch();
	  //		mystyle.setColour(0, 0, 0);
	  mystyle.unsetUnderline();
	  mystyle.unsetStrikethru();
	  mystyle.setLink(false);
	  mystyle.setData(0);
	  break;
	case 0x40:
	  mystyle.setItalic();
	  ch = bgetch();
	  break;
	case 0x48:
	  mystyle.unsetItalic();
	  ch = bgetch();
	  break;
	case 0x11:
	  {
	    ch = bgetch();
	    //		//qDebug("Font:%d",ch);
	    mystyle.setVOffset(0);
	    mystyle.unsetMono();
	    mystyle.unsetBold();
	    switch (ch)
	      {
	      case 0:
		mystyle.setFontSize(0);
		break;
	      case 1:
		mystyle.setFontSize(3);
		mystyle.setBold();
		break;
	      case 2:
		mystyle.setFontSize(2);
		mystyle.setBold();
		break;
	      case 3:
		mystyle.setFontSize(1);
		mystyle.setBold();
		break;
	      case 4:
		mystyle.setFontSize(0);
		mystyle.setBold();
		break;
	      case 5:
		mystyle.setFontSize(0);
		mystyle.setBold();
		break;
	      case 6:
		mystyle.setFontSize(0);
		mystyle.setBold();
		break;
	      case 7:
		mystyle.setFontSize(0);
		mystyle.setBold();
		break;
	      case 8: // should be fixed width
		//qDebug("Trying fixed width");
		mystyle.setFontSize(0);
		mystyle.setMono();
		break;
	      case 9:
		//		mystyle.setFontSize(mystyle.getFontSize());
		mystyle.setFontSize(-1);
		break;
	      case 10:
		mystyle.setFontSize(-2);
		mystyle.setVOffset(1);
		break;
	      case 11:
		mystyle.setFontSize(-2);
		mystyle.setVOffset(-1);
		break;
	      default:
		qDebug("Unrecognised font");
		break;
	      }
	    ch = bgetch();
	  }
	  break;
	case 0x29:
	  ch = bgetch();
	  switch (ch)
	    {
	    case 0:
	      mystyle.setLeftJustify();
	      //			//qDebug("left");
	      break;
	    case 1:
	      mystyle.setRightJustify();
	      //			//qDebug("right");
	      break;
	    case 2:
	      mystyle.setCentreJustify();
	      //			//qDebug("centre");
	      break;
	    case 3:
	      mystyle.setFullJustify();
	      //			//qDebug("full");
	      break;

	    }
	  ch = bgetch();
	  break;
	case 0x53:
	  {
	    int r = bgetch();
	    int g = bgetch();
	    int b = bgetch();
	    mystyle.setColour(r,g,b);
	    ch = bgetch();
	  }
	  break;
	case 0x1a:
	case 0x5c:
	  {
	    bool hasalternate = (ch == 0x5c);
	    UInt16 ir = bgetch();
	    ir = (ir << 8) + bgetch();
	    if (hasalternate)
	      {
		//qDebug("Alternate image:%x", ir);
		UInt16 ir2 = bgetch();
		ir2 = (ir2 << 8) + bgetch();
		if (!fast) mystyle.setPicture(true, expandimg(ir2, true), true, ir << 16);
#ifdef LOCALPICTURES
		UInt32 ln = ir;
		ln <<= 16;
		mystyle.setLink(true);
		mystyle.setData(ln);
#endif
	      }
	    else
	      {
		if (!fast) mystyle.setPicture(true, expandimg(ir));
	      }
	    //		if (mystyle.getLink()) qDebug("Picture link!");
	    ch = '#';
	  }
	  //	    ch = bgetch();
	  break;
	case 0x33:
	  {
	    UInt8 h = bgetch();
	    UInt8 wc = bgetch();
	    UInt8 pc = bgetch();
	    UInt16 w = wc;
	    //		//qDebug("h,w,pc [%u, %u, %u]", h, w, pc);
	    if (w == 0)
	      {
		w = (m_scrWidth*(unsigned long)pc)/100;
	      }
	    if (w == 0) w = m_scrWidth;
	    mystyle.setPicture(false, hRule(w,h,mystyle.Red(),mystyle.Green(),mystyle.Blue()));
	    //		if (mystyle.getLink()) //qDebug("hRule link!");
	    ch = '#';
	  }
	  break;
	case 0x60:
	  mystyle.setUnderline();
	  ch = bgetch();
	  break;
	case 0x68:
	  mystyle.unsetUnderline();
	  ch = bgetch();
	  break;
	case 0x22:
	  ch = bgetch();
	  mystyle.setLeftMargin(ch);
	  //		//qDebug("Left margin:%d", ch);
	  ch = bgetch();
	  mystyle.setRightMargin(ch);
	  //		//qDebug("Right margin:%d", ch);
	  ch = bgetch();
	  break;
	case 0x70:
	  mystyle.setStrikethru();
	  ch = bgetch();
	  break;
	case 0x78:
	  mystyle.unsetStrikethru();
	  ch = bgetch();
	  break;
	case 0x83:
	  {
	    int tlen = bgetch();
	    ch = bgetch();
	    ch <<= 8;
	    ch |= (tchar)bgetch();
	    for (int i = 0; i < tlen; i++) bgetch();
	    //qDebug("Function 83");
	  }
	  break;
	case 0x9a:
	  {
	    m_offset = 255*bgetch();
	    m_offset += bgetch();
	    qDebug("Found offset:%u", m_offset);
	    ch = bgetch();
	  }
	  break;
	case 0x92:
	  {
	    ch = bgetch();
	    ch <<= 8;
	    ch |= (tchar)bgetch();
	    mystyle.setTable(ch);
	    ch = 0x16e5;
	  }
	  break;
	case 0x85:
	default:
	  qDebug("Function:%x NOT IMPLEMENTED", ch);
	  {
	    int skip = ch & 7;
	    for (int i = 0; i < skip; i++)
	      {
		ch = bgetch();
		//qDebug("Arg %d, %d", i, ch);
	      }
	    ch = bgetch();
	  }
	}
    }

  if (m_lastIsBreak && !mystyle.isMono())
    {
      while (ch == ' ')
	{
	  ch = getch(false);
	}
    }

  m_lastIsBreak = (ch == 10);

  return (ch == EOF) ? UEOF : ch;
}

QString CPlucker_base::about()
{
  QString abt = "Plucker base codec (c) Tim Wentford";
  if (m_decompress != UnDoc && m_decompress != UnZip)
    {
      abt += "\nSpecial decompression (c) Tim Wentford (ppmd by Dmitry Shkarin";
    }
  return abt;
}