20 files changed, 4221 insertions, 4291 deletions

diff --git a/noncore/apps/opie-reader/Bkmks.cpp b/noncore/apps/opie-reader/Bkmks.cpp
index 889c6d8..16bc1f1 100644
--- a/noncore/apps/opie-reader/Bkmks.cpp
+++ b/noncore/apps/opie-reader/Bkmks.cpp
@@ -1,322 +1,320 @@
 #include <qmessagebox.h>
 
 #include "Bkmks.h"
 
-#include "StyleConsts.h"
-#include "Markups.h"
 #include "my_list.h"
 #include "version.h"
 #include "names.h"
 
 const unsigned long BkmkFile::magic = ((unsigned long)'q' << 24) | ((unsigned long)'t' << 16) | ((unsigned long)'r' << 8) | ((unsigned long)BKMKTYPE);
 
 Bkmk::Bkmk(const unsigned char* _nm, unsigned short _nmlen, const unsigned char* _anno, unsigned short _annolen, unsigned int _p) : m_position(_p)
 {
     init(_nm, _nmlen, _anno, _annolen, _p);
 }
 
 Bkmk::Bkmk(const tchar* _nm, const unsigned char* _anno, unsigned short annolen, unsigned int _p) : m_position(_p)
 {
     init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), _anno, annolen, _p);
 }
 
 Bkmk::Bkmk(const tchar* _nm, const tchar* _anno, unsigned int _p) : m_position(_p)
 {
 
     if (_anno == NULL)
     {
         tchar t = 0;
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), &t, sizeof(t), _p);
     }
     else
     {
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), _anno, sizeof(tchar)*(ustrlen(_anno)+1), _p);
     }
 }
 
 void Bkmk::init(const void* _nm, unsigned short _nmlen, const void* _anno, unsigned short _annolen, unsigned int _p)
 {
     m_namelen = _nmlen;
     if (m_namelen > 0)
     {
         m_name = new unsigned char[m_namelen];
         memcpy(m_name, _nm, m_namelen);
     }
     else
     {
         m_name = NULL;
     }
 
     m_annolen = _annolen;
     if (m_annolen > 0)
     {
         m_anno = new unsigned char[m_annolen];
         memcpy(m_anno, _anno, m_annolen);
     }
     else
     {
         m_anno = NULL;
     }
     m_position = _p;
 }
 
 Bkmk::~Bkmk()
 {
     if (m_name != NULL) delete [] m_name;
     m_name = NULL;
     if (m_anno != NULL) delete [] m_anno;
     m_anno = NULL;
 }
  
 Bkmk& Bkmk::operator=(const Bkmk& rhs)
 {
     if (m_name != NULL)
     {
         delete [] m_name;
         m_name = NULL;
     }
     if (m_anno != NULL)
     {
         delete [] m_anno;
         m_anno = NULL;
     }
     if (rhs.m_name != NULL)
     {
         m_namelen = rhs.m_namelen;
         m_name = new unsigned char[m_namelen];
         memcpy(m_name, rhs.m_name, m_namelen);
     }
     else
         m_name = NULL;
     if (rhs.m_anno != NULL)
     {
         m_annolen = rhs.m_annolen;
         m_anno = new unsigned char[m_annolen];
         memcpy(m_anno, rhs.m_anno, m_annolen);
     }
     else
         m_anno = NULL;
     m_position = rhs.m_position;
     return *this;
 }
 
 bool Bkmk::operator==(const Bkmk& rhs)
 {
     return (m_position == rhs.m_position && (rhs.m_namelen == m_namelen) && memcmp(m_name,rhs.m_name,m_namelen) == 0);
 }
 
 void Bkmk::setAnno(unsigned char* t, unsigned short len)
 {
     if (m_anno != NULL)
     {
         delete [] m_anno;
         m_anno = NULL;
     }
     if (t != NULL)
     {
         m_annolen = len;
         m_anno = new unsigned char[m_annolen];
         memcpy(m_anno, t, m_annolen);
     }
     else
     {
         m_annolen = sizeof(tchar);
         m_anno = new unsigned char[m_annolen];
         *((tchar*)m_anno) = 0;
     }
 }
 
 void Bkmk::setAnno(tchar* t)
 {
     if (m_anno != NULL)
     {
         delete [] m_anno;
         m_anno = NULL;
     }
     if (t != NULL)
     {
         unsigned short len = ustrlen(t)+1;
         m_annolen = sizeof(tchar)*len;
         m_anno = new unsigned char[m_annolen];
         memcpy(m_anno, t, m_annolen);
     }
     else
     {
         m_annolen = sizeof(tchar);
         m_anno = new unsigned char[m_annolen];
         *((tchar*)m_anno) = 0;
     }
 }
 
 BkmkFile::BkmkFile(const char *fnm, bool w)
     :
     wt(w), isUpgraded(false)
 {
     if (w)
     {
         f = fopen(fnm, "wb");
     }
     else
     {
         f = fopen(fnm, "rb");
     }
 }
 
 BkmkFile::~BkmkFile()
 {
     if (f != NULL) fclose(f);
 }
 
 void BkmkFile::write(const Bkmk& b)
 {
     if (f != NULL)
     {
         fwrite(&b.m_namelen, sizeof(b.m_namelen),1,f);
         fwrite(b.m_name,1,b.m_namelen,f);
         fwrite(&b.m_annolen, sizeof(b.m_annolen),1,f);
         fwrite(b.m_anno,1,b.m_annolen,f);
         fwrite(&b.m_position,sizeof(b.m_position),1,f);
     }
 }
 
 void BkmkFile::write(CList<Bkmk>& bl)
 {
     if (f != NULL)
     {
         fwrite(&magic, sizeof(magic), 1, f);
         for (CList<Bkmk>::iterator i = bl.begin(); i != bl.end(); i++)
         {
             write(*i);
         }
     }
 }
 
 CList<Bkmk>* BkmkFile::readall()
 {
     CList<Bkmk>* bl = NULL;
     if (f != NULL)
     {
         unsigned long newmagic;
         fread(&newmagic, sizeof(newmagic), 1, f);
         if ((newmagic & 0xffffff00) != (magic & 0xffffff00))
         {
             if (QMessageBox::warning(NULL, "Old bookmark file!", "Which version of " PROGNAME "\ndid you upgrade from?", "0_4*", "Any other version") == 0)
             {
                 fseek(f,0,SEEK_SET);
                 bl = readall00(&read05);
             }
             else
             {
                 fseek(f,0,SEEK_SET);
                 bl = readall00(&read03);
             }
             isUpgraded = true;
         }
         else
         {
             switch(newmagic & 0xff)
             {
                 case 6:
                     isUpgraded = false;
                     bl = readall00(read06);
         //          qDebug("Correct version!");
                     break;
                 case 5:
                     isUpgraded = true;
                     bl = readall00(read05);
         //          qDebug("Known version!");
                     break;
                 default:
         //          qDebug("Unknown version!");
                     isUpgraded = true;
                     bl = readall00(read05);
             }
         }
     }
     return bl;
 }
 
 CList<Bkmk>* BkmkFile::readall00(Bkmk* (*readfn)(FILE*))
 {
     CList<Bkmk>* bl = new CList<Bkmk>;
     while (1)
     {
         Bkmk* b = (*readfn)(f);
         if (b == NULL) break;
         bl->push_back(*b);
         delete b;
     }
     return bl;
 }
 
 Bkmk* BkmkFile::read03(FILE* f)
 {
     Bkmk* b = NULL;
     if (f != NULL)
     {
         unsigned short ln;
         if (fread(&ln,sizeof(ln),1,f) == 1)
         {
             tchar* name = new tchar[ln+1];
             fread(name,sizeof(tchar),ln,f);
             name[ln] = 0;
 
             ln = 0;
             tchar* anno = new tchar[ln+1];
             anno[ln] = 0;
 
             unsigned int pos;
             fread(&pos,sizeof(pos),1,f);
             b = new Bkmk(name,anno,pos);
         }
     }
     return b;
 }
 
 Bkmk* BkmkFile::read05(FILE* f)
 {
     Bkmk* b = NULL;
     if (f != NULL)
     {
         unsigned short ln;
         if (fread(&ln,sizeof(ln),1,f) == 1)
         {
             tchar* nm = new tchar[ln+1];
             fread(nm,sizeof(tchar),ln,f);
             nm[ln] = 0;
             fread(&ln,sizeof(ln),1,f);
             tchar* anno = new tchar[ln+1];
             if (ln > 0) fread(anno,sizeof(tchar),ln,f);
             anno[ln] = 0;
             unsigned int pos;
             fread(&pos,sizeof(pos),1,f);
             b = new Bkmk(nm,anno,pos);
         }
     }
     return b;
 }
 
 Bkmk* BkmkFile::read06(FILE* f)
 {
     Bkmk* b = NULL;
     if (f != NULL)
     {
         unsigned short ln;
         if (fread(&ln,sizeof(ln),1,f) == 1)
         {
             b = new Bkmk;
             b->m_namelen = ln;
             b->m_name = new unsigned char[b->m_namelen];
             fread(b->m_name,1,b->m_namelen,f);
 
             fread(&(b->m_annolen),sizeof(b->m_annolen),1,f);
             if (b->m_annolen > 0)
             {
                 b->m_anno = new unsigned char[b->m_annolen];
                 fread(b->m_anno,1,b->m_annolen,f);
             }
             fread(&(b->m_position),sizeof(b->m_position),1,f);
         }
     }
     return b;
 }
diff --git a/noncore/apps/opie-reader/BuffDoc.cpp b/noncore/apps/opie-reader/BuffDoc.cpp
index 2402904..4fbab93 100644
--- a/noncore/apps/opie-reader/BuffDoc.cpp
+++ b/noncore/apps/opie-reader/BuffDoc.cpp
@@ -1,394 +1,390 @@
-#include "names.h"
 
 #define NEWLINEBREAK
 
 #include "BuffDoc.h"
 //#include <FL/fl_draw.h>
-#include "config.h"
-#include "CDrawBuffer.h"
 #include "plucker.h"
-#include "usenef.h"
 #ifdef USENEF
 #include "nef.h"
 #include "arrierego.h"
 #endif
 
 linkType BuffDoc::hyperlink(unsigned int n, QString& wrd)
 {
     linkType bRet = eNone;
     if (exp != NULL)
     {
         bRet = exp->hyperlink(n, wrd);
         if (bRet == eLink)
         {
             lastword.empty();
             lastsizes[0] = laststartline = n;
 #ifdef NEWLINEBREAK
             lastispara = true;
 #else
             lastispara = false;
 #endif
             lastsizes[0] = laststartline = exp->locate();
         }
     }
     return bRet;
 }
 
 void BuffDoc::locate(unsigned int n)
 {
   //  //qDebug("BuffDoc:locating:%u",n);
     lastword.empty();
   lastsizes[0] = laststartline = n;
 #ifdef NEWLINEBREAK
     lastispara = true;
 #else
     lastispara = false;
 #endif
   //    tchar linebuf[1024];
   if (exp != NULL) exp->locate(n);
   //  //qDebug("BuffDoc:Located");
 }
 
 #ifdef NEWLINEBREAK
 bool BuffDoc::getline(CDrawBuffer* buff, int wth, unsigned char _border)
 {
     bool moreleft = true;
     bool margindone = false;
     int w = wth-2*_border;
     tchar ch = 32;
     CStyle cs;
     buff->empty();
     if (exp == NULL)
     {
         buff->empty();
         buff->setEof();
         return false;
     }
     int len = 0;
     if (lastword.length() > 0)
     {
         *buff = lastword;
         cs = lastword.laststyle();
         w -= buff->leftMargin() + buff->rightMargin();
         margindone = true;
         len = lastword.length();
     }
     else buff->empty();
     lastword.empty();
     unsigned int slen = buff->width(len);
     if (lastispara) buff->setstartpara();
     while (1)
     {
         lastsizes[len] = exp->locate();
         getch(ch, cs);
         if (ch == 10 && len == 0 && !lastispara)
         {
             lastsizes[len] = exp->locate();
             getch(ch, cs);
         }
         if (ch == UEOF)
         {
             if (len == 0)
             {
                 buff->setEof();
                 moreleft = false;
             }
             laststartline = exp->locate();
             break;
         }
         if (ch == 10)
         {
             buff->setendpara();
             lastispara = true;
             laststartline = exp->locate();
             break;
         }
         lastispara = false;
         buff->addch(ch, cs);
         len++;
         if (!margindone)
         {
             w -= buff->leftMargin() + buff->rightMargin();
             margindone = true;
         }
           if ((slen = buff->width(len)) > w)
         {
             if (ch == ' ' || len == 1)
             {
                 if (ch == ' ') buff->truncate(len-1);
                 laststartline = exp->locate();
                 break;
             }
             else // should do a backward search for spaces, first.
             {
                 for (int i = len-2; i > 0; i--)
                 {
                     if ((*buff)[i] == ' ')
                     {
                         (*buff)[len] = 0;
                         lastword.setright(*buff, i+1);
                         buff->truncate(i);
                         (*buff)[i] = '\0';
                         laststartline = lastsizes[i+1];
                         buff->resize();
                         for (int j = 0; j < lastword.length(); j++)
                         {
                             lastsizes[j] = lastsizes[j+i+1];
                         }
                         return true;
                     }
                     if ((*buff)[i] == '-' && !(((*buff)[i-1] == '-') || ((*buff)[i+1] == '-')))
                     {
                         (*buff)[len] = 0;
                         lastword.setright(*buff, i+1);
                         buff->truncate(i+1);
                         (*buff)[i+1] = '\0';
                         laststartline = lastsizes[i+1];
                         buff->resize();
                         for (int j = 0; j < lastword.length(); j++)
                         {
                             lastsizes[j] = lastsizes[j+i+1];
                         }
                         return true;
                     }
                 }
                 laststartline = lastsizes[len-1];
                 (*buff)[len] = 0;
                 lastword.setright(*buff, len - 1);
                 buff->truncate(len-1);
                 buff->addch('-', cs);
                 for (int j = 0; j < lastword.length(); j++)
                 {
                     lastsizes[j] = lastsizes[j+len];
                 }
                 break;
             }
         }
     }
     (*buff)[len] = '\0';
     buff->resize();
     return moreleft;
 }
 #else
 bool BuffDoc::getline(CDrawBuffer* buff, int wth, unsigned char _border)
 {
     bool margindone = false;
     int w = wth-2*_border;
     tchar ch = 32;
     CStyle cs;
     buff->empty();
     if (exp == NULL)
     {
         //(*buff)[0] = '\0';
         buff->empty();
         return false;
     }
   int len = 0, lastcheck = 0;
   if (lastword.length() > 0)
   {
       *buff = lastword;
       cs = lastword.laststyle();
       w -= buff->leftMargin() + buff->rightMargin();
       margindone = true;
   }
   else buff->empty();
 //  //qDebug("Buff:%s Lastword:%s", (const char*)toQString(buff->data()), (const char*)toQString(lastword.data()));
   lastcheck = len = buff->length();
   unsigned int slen = buff->width(len);
   if (slen > w)
     {
       for ( ; len > 1; len--)
         {
           if (buff->width(len) < w) break;
         }
 //      lastword = buff->data() + len - 1;
       laststartline = lastsizes[len-1];
       for (int i = 0; i < buff->length(); i++) lastsizes[i] = lastsizes[i+len-1];
 //      (*buff)[len-1] = '-';
       if (len > 2)
       {
           lastword.setright(*buff, len - 1);
           buff->truncate(len-1);
           buff->addch('-', cs);
           (*buff)[len] = '\0';
       }
 
       else
       {
           lastword.empty();
           (*buff)[len] = '\0';
       }
       buff->resize();
       return true;
     }
   if (lastispara)
     {
       lastispara = false;
 //      lastword[0] = '\0';
       lastword.empty();
       len = buff->length();
       while (buff->width(len) > w) len--;
 //      (*buff)[len] = '\0';
       buff->truncate(len);
       laststartline = exp->locate();
       buff->resize();
       return true;
     }
   lastispara = false;
   for (int i = 0; i < len; i++) allsizes[i] = lastsizes[i];
   while (slen < w)
   {
       lastcheck = len;
       allsizes[len] = exp->locate();
       getch(ch, cs);
       while (ch != ' ' && ch != '\012' && ch != UEOF && len < 128)
       {
           len++;
           buff->addch(ch,cs);
           allsizes[len] = exp->locate();
           getch(ch, cs);
       }
       (*buff)[len] = 0;
       slen = buff->width(len);
       len++;
       buff->addch(' ', cs);
       if (!margindone)
       {
           w -= buff->leftMargin() + buff->rightMargin();
           margindone = true;
       }
       allsizes[len] = exp->locate();
       if (slen < w && ch != ' ')
       {
           lastcheck = len;
           break;
       }
       lastispara = (ch == '\012');
   }
   (*buff)[len] = '\0';
 //  lastword = buff->data()+lastcheck;
 #ifdef _WINDOWS
   lastword.setright(*buff, (lastcheck > 0) ? lastcheck : 1);
   {
           int i;
   for (i = 0; i < lastword.length(); i++) lastsizes[i] = allsizes[i+lastcheck];
   }
 #else
   lastword.setright(*buff, (lastcheck > 0) ? lastcheck : 1);
   for (int i = 0; i < lastword.length(); i++) lastsizes[i] = allsizes[i+lastcheck];
 #endif
   if (lastcheck > 0)
   {
       laststartline = allsizes[lastcheck];
 //      (*buff)[lastcheck-1] = '\0';
       buff->truncate(lastcheck-1);
   }
   else
   {
       laststartline = (lastcheck == len) ? exp->locate() : allsizes[lastcheck+1];
 //      (*buff)[lastcheck] = '\0';
       buff->truncate(lastcheck);
   }
 //  buff->frig();
   buff->resize();
   if (ch == UEOF && buff->length() == 0)
   {
       buff->setEof();
       return false;
   }
   return true;
 }
 #endif
 
 bool BuffDoc::getline(CDrawBuffer* buff, int wth, int cw, unsigned char _border)
 {
     int w = wth-2*_border;
     buff->empty();
     if (exp == NULL)
     {
         return false;
     }
     tchar ch;
     CStyle cs;
     int i = 1;
     while (i*cw < w-buff->offset(w,0))
     {
         getch(ch, cs);
         if (ch == '\12' || ch == UEOF) break;
         buff->addch(ch,cs);
         i++;
     }
     buff->truncate(i);
     laststartline = exp->locate();
     buff->resize();
     return (ch != UEOF);
 }
 
 int BuffDoc::openfile(QWidget* _parent, const char *src)
 {
     //    //qDebug("BuffDoc:Openfile:%s", src);
     //    //qDebug("Trying aportis %x",exp);
     if (exp != NULL) delete exp;
     lastword.empty();
     lastsizes[0] = laststartline = 0;
 #ifdef NEWLINEBREAK
     lastispara = true;
 #else
     lastispara = false;
 #endif
     /*
       exp = new Text;
       int ret = exp->openfile(src);
     */
 
     exp = new Aportis;
     int ret = exp->openfile(src);
     if (ret == -1)
     {
         delete exp;
         exp = NULL;
         return ret;
     }
     if (ret == -2)
     {
 
         delete exp;
         exp = new ztxt;
         ret = exp->openfile(src);
     }
 #ifdef USENEF
     if (ret != 0)
     {
 
         delete exp;
         exp = new CArriere;
         ret = exp->openfile(src);
     }
     if (ret != 0)
     {
 
         delete exp;
         exp = new CNEF;
         ret = exp->openfile(src);
     }
 #endif
     if (ret != 0)
     {
 
         delete exp;
         exp = new CPlucker;
         ret = exp->openfile(src);
     }
     if (ret != 0)
     {
         delete exp;
         //qDebug("Trying ppms");
         exp = new ppm_expander;
         ret = exp->openfile(src);
     }
     if (ret != 0)
     {
         delete exp;
         exp = new Text;
         //      //qDebug("Trying text");
         ret = exp->openfile(src);
diff --git a/noncore/apps/opie-reader/CDrawBuffer.cpp b/noncore/apps/opie-reader/CDrawBuffer.cpp
index 77b76fb..ec36fb2 100644
--- a/noncore/apps/opie-reader/CDrawBuffer.cpp
+++ b/noncore/apps/opie-reader/CDrawBuffer.cpp
@@ -1,392 +1,388 @@
 #include "CDrawBuffer.h"
 #include "FontControl.h"
-#include <qfontmetrics.h>
 #include <qpainter.h>
-#include <qpixmap.h>
 #include <qimage.h>
-#include "useqpe.h"
-#include "opie.h"
 
 CDrawBuffer::~CDrawBuffer()
 {
     while (!segs.isEmpty()) segs.erase(0);
 }
 
 void CDrawBuffer::setright(CDrawBuffer& rhs, int f)
 {
   int i;
   len = rhs.len;
   fc = rhs.fc;
   m_maxstyle = m_ascent = m_descent = m_lineSpacing = m_lineExtraSpacing = 0;
   while (!segs.isEmpty())
   {
       segs.erase(0);
   }
   for (CList<textsegment>::iterator iter = rhs.segs.begin(); iter != rhs.segs.end(); )
   {
       CList<textsegment>::iterator next = iter;
       iter++;
       if (iter == rhs.segs.end() || iter->start > f)
       {
           int st = next->start-f;
           if (st < 0) st = 0;
 
           CStyle _style = next->style;
 
           segs.push_back(textsegment(st,next->style));
       }
   }
   for (i = f; rhs[i] != '\0'; i++) (*this)[i-f] = rhs[i];
   (*this)[i-f] = '\0';
   len = i;
 }
 
 CDrawBuffer& CDrawBuffer::operator=(CDrawBuffer& rhs)
 {
   int i;
 //  //qDebug("Trying 2");
   len = rhs.len;
   m_maxstyle = rhs.m_maxstyle;
   m_ascent = rhs.m_ascent;
   m_descent = rhs.m_descent;
   m_lineSpacing = rhs.m_lineSpacing;
   m_lineExtraSpacing = rhs.m_lineExtraSpacing;
   while (!segs.isEmpty())
   {
       segs.erase(0);
   }
   for (CList<textsegment>::iterator iter = rhs.segs.begin(); iter != rhs.segs.end(); iter++)
   {
       segs.push_back(*iter);
   }
   for (i = 0; rhs[i] != '\0'; i++) (*this)[i] = rhs[i];
   (*this)[i] = '\0';
   len = i;
 //  //qDebug("Tried 2");
   return *this;
 }
 
 CDrawBuffer& CDrawBuffer::operator=(const tchar*sztmp)
 {
   int i;
   while (!segs.isEmpty())
   {
       segs.erase(0);
   }
   segs.push_back(textsegment(0, CStyle()));
   for (i = 0; sztmp[i] != '\0'; i++) (*this)[i] = sztmp[i];
   (*this)[i] = '\0';
   len = i;
   return *this;
 }
 
 void CDrawBuffer::empty()
 {
     m_bSop = false;
     m_bEop = false;
     len = 0;
     (*this)[0] = 0;
     while (!segs.isEmpty())
     {
         segs.erase(0);
     }
     segs.push_back(textsegment(0,CStyle()));
     m_maxstyle = m_ascent = m_descent = m_lineSpacing = m_lineExtraSpacing = 0;
     m_bEof = false;
 }
 
 void CDrawBuffer::addch(tchar ch, CStyle _style/* = ucFontBase*/)
 {
     if (len == 0)
     {
         segs.first().start = 0;
         segs.first().style = _style;
     }
     else if (_style != segs.last().style)
     {
         segs.push_back(textsegment(len, _style));
     }
     (*this)[len++] = ch;
 }
 
 void CDrawBuffer::truncate(int n)
 {
     len = n;
     (*this)[n] = 0;
 }
 
 int CDrawBuffer::width(int numchars, bool onscreen, int scwidth, unsigned char _border)
 {
     int gzoom = fc->gzoom();
     int currentx = 0, end = 0;
     QString text = (numchars < 0) ? toQString(data()) : toQString(data(), numchars);
     CList<textsegment>::iterator textstart = segs.begin();
     int extraspace = 0;
     bool just = (onscreen && !m_bEop && textstart->style.getJustify() == m_AlignJustify);
     int spaces = 0;
     int spacesofar = 0;
     int spacenumber = 0;
     int nonspace = 0;
     if (just)
     {
         for (int i = 0; i < len; i++)
         {
             if ((*this)[i] != ' ')
             {
                 nonspace = i;
                 break;
             }
         }
 #ifdef _WINDOWS
         for (i = nonspace; i < len; i++)
 #else
         for (int i = nonspace; i < len; i++)
 #endif
         {
             if ((*this)[i] == ' ')
             {
                 spaces++;
             }
         }
         if (spaces == 0)
         {
             just = false;
         }
         else
         {
             extraspace = (scwidth - 2*_border - rightMargin() - leftMargin() - width());
             if (extraspace == 0) just = false;
         }
     }
     CList<textsegment>::iterator textend = textstart;
     do
     {
         textend++;
         end = (textend != segs.end()) ? textend->start : len;
         if (numchars >= 0 && end > numchars)
         {
             end = numchars;
         }
         CStyle currentstyle = textstart->style;
         if (currentstyle.isPicture())
         {
             if (currentstyle.canScale())
             {
                 currentx += (gzoom*currentstyle.getPicture()->width())/100;
             }
             else
             {
                 currentx += currentstyle.getPicture()->width();
             }
         }
         else
         {
             if (currentstyle.isMono() && !fc->hasCourier())
             {
                 int cw = (7*fc->getsize(currentstyle))/10;
                 currentx += cw*(end-textstart->start);
             }
             else
             {
                 QFont f(currentstyle.isMono() ? QString(fc->fixedfontname()) : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
         //    f.setUnderline(currentstyle.isUnderline());
                 QString str = text.mid(textstart->start, end-textstart->start);
                 QFontMetrics fm(f);
                 if (just)
                 {
                     int lastspace = -1;
                     int nsp = 0;
                     int cx = currentx;
                     while ((nsp = str.find(" ", lastspace+1)) >= 0)
                     {
                         if (nsp > nonspace)
                         {
                             spacenumber++;
                             int nexttoadd = (extraspace*spacenumber+spaces/2)/spaces - spacesofar;
                             QString nstr = str.mid(lastspace+1, nsp-lastspace);
                             int lw = fm.width(nstr);
                             cx += lw+nexttoadd;
                             spacesofar += nexttoadd;
                             lastspace = nsp;
                         }
                         else
                         {
                             QString nstr = str.mid(lastspace+1, nsp-lastspace);
         //                  qDebug("str:%s: last:%d new:%d nstr:%s:", (const char*)str, lastspace, nsp, (const char*)nstr);
                             int lw = fm.width(nstr);
                             cx += lw;
                             lastspace = nsp;
                         }
                     }
                     QString nstr = str.right(str.length()-1-lastspace);
                     cx += fm.width(nstr);
                     currentx = cx;
                 }
                 else
                 {
                     currentx += fm.width(str);
                 }
             }
         }
         textstart = textend;
     }
     while (textend != segs.end() && end != numchars && textstart->start < len);
     return currentx;
 }
 
 int CDrawBuffer::leftMargin()
 {
     return (segs.begin()->style.getLeftMargin()*fc->getsize(segs.begin()->style)+3)/6;
 }
 
 int CDrawBuffer::rightMargin()
 {
     return (segs.begin()->style.getRightMargin()*fc->getsize(segs.begin()->style)+3)/6;
 }
 
 int CDrawBuffer::offset(int scwidth, unsigned char _border)
 {
     int currentx = _border;
     switch(segs.begin()->style.getJustify())
     {
         case m_AlignRight:
         {
             currentx = scwidth - _border - rightMargin() - width();
         }
         break;
         case m_AlignCentre:
         {
             currentx = (
                 scwidth +
                 leftMargin() - rightMargin()
                 - width())/2;
         }
         break;
         case m_AlignJustify:
         case m_AlignLeft:
             currentx = _border + leftMargin();
             break;
     }
     return currentx;
 }
 
 void CDrawBuffer::render(QPainter* _p, int _y, bool _bMono, int _charWidth, int scwidth, unsigned char _border)
 {
     int gzoom = fc->gzoom();
     int currentx = offset(scwidth, _border);
     QString text = toQString(data());
     CList<textsegment>::iterator textstart = segs.begin();
     int extraspace = 0;
     bool just = (!m_bEop && textstart->style.getJustify() == m_AlignJustify);
     int spaces = 0;
     int spacesofar = 0;
     int spacenumber = 0;
     int nonspace = 0;
     if (just)
     {
         for (int i = 0; i < len; i++)
         {
             if ((*this)[i] != ' ')
             {
                 nonspace = i;
                 break;
             }
         }
 #ifdef _WINDOWS
         for (i = nonspace; i < len; i++)
 #else
         for (int i = nonspace; i < len; i++)
 #endif
         {
             if ((*this)[i] == ' ')
             {
                 spaces++;
             }
         }
         if (spaces == 0)
         {
             just = false;
         }
         else
         {
             extraspace = (scwidth - 2*_border - rightMargin() - leftMargin() - width());
             if (extraspace == 0) just = false;
         }
     }
     CList<textsegment>::iterator textend = textstart;
     do
     {
         textend++;
         int end = (textend != segs.end()) ? textend->start : len;
         CStyle currentstyle = textstart->style;
         QFont f((currentstyle.isMono() && fc->hasCourier()) ? fc->fixedfontname() : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
         //f.setUnderline(currentstyle.isUnderline());
         //if (currentstyle.isUnderline()) qDebug("UNDERLINE");
         _p->setFont(f);
         QString str = text.mid(textstart->start, end-textstart->start);
 #if defined(OPIE) || !defined(USEQPE)
         _p->setPen(QPen(QColor(currentstyle.Red(), currentstyle.Green(), currentstyle.Blue()), fc->getsize(currentstyle)/100));
 #else
         _p->setPen(QPen(QColor(currentstyle.Red(), currentstyle.Green(), currentstyle.Blue()), fc->getsize(currentstyle)/10));
 #endif
         int voffset = currentstyle.getVOffset()*fc->getsize(currentstyle)/2;
         if (_bMono)
         {
             if (currentstyle.isUnderline())
             {
                 _p->drawLine( currentx, _y+voffset, currentx + str.length()*_charWidth, _y+voffset);
             }
             if (currentstyle.isStrikethru())
             {
                 int ascent = fc->ascent(currentstyle)/3;
                 _p->drawLine( currentx, _y-ascent+voffset, currentx + str.length()*_charWidth, _y-ascent+voffset);
             }
             for (int i = 0; i < str.length(); i++)
             {
                 _p->drawText( currentx + i*_charWidth, _y+voffset, QString(str[i]));
             }
             currentx += str.length()*_charWidth;
         }
         else
         {
             if (currentstyle.isPicture())
             {
                 int ht = (gzoom*currentstyle.getPicture()->height())/100;
                 int wt = (gzoom*currentstyle.getPicture()->width())/100;
                 int ascent = fc->ascent(currentstyle)/2;
                 int yoffset = ht/2 + ascent;
 
                 QPixmap pc;
                 if (gzoom != 100 && currentstyle.canScale())
                 {
                     QImage im = currentstyle.getPicture()->smoothScale(wt,ht);
                     pc.convertFromImage(im);
                 }
                 else
                 {
                     pc.convertFromImage(*currentstyle.getPicture());
                 }
                 _p->drawPixmap( currentx, _y-yoffset, pc );
                 currentx += wt;
             }
             else
             {
                 if (currentstyle.isMono() && !fc->hasCourier())
                 {
                     int cw = (7*fc->getsize(currentstyle))/10;
                     int w = cw*(end-textstart->start);
                     if (currentstyle.isUnderline())
                     {
                         _p->drawLine( currentx, _y+voffset, currentx + w, _y+voffset);
                     }
                     if (currentstyle.isStrikethru())
                     {
                         int ascent = fc->ascent(currentstyle)/3;
                         _p->drawLine( currentx, _y-ascent+voffset, currentx + w, _y-ascent+voffset);
                     }
                     QString str = text.mid(textstart->start, end-textstart->start);
 
                     for (unsigned int i = 0; i < str.length(); i++)
                     {
 #ifdef _WINDOWS
                         _p->drawText( currentx, _y+voffset, QString(str.at(i)));
diff --git a/noncore/apps/opie-reader/CEncoding_tables.cpp b/noncore/apps/opie-reader/CEncoding_tables.cpp
index 667bda0..e335819 100644
--- a/noncore/apps/opie-reader/CEncoding_tables.cpp
+++ b/noncore/apps/opie-reader/CEncoding_tables.cpp
@@ -1,386 +1,385 @@
 #include "CEncoding_tables.h"
-#include "config.h"
 
 static const unicodetable unicodevalues[] = {
     // from RFC 1489, ftp://ftp.isi.edu/in-notes/rfc1489.txt
     { "KOI8-R", "KOI8-R", 2084,
       { 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
         0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
         0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219/**/, 0x221A, 0x2248,
         0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
         0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556,
         0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E,
         0x255F, 0x2560, 0x2561, 0x0401, 0x2562, 0x2563, 0x2564, 0x2565,
         0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x00A9,
         0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
         0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
         0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
         0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
         0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
         0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
         0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
         0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A } },
     // /**/  - The BULLET OPERATOR is confused.  Some people think
     //          it should be 0x2022 (BULLET).
 
     // from RFC 2319, ftp://ftp.isi.edu/in-notes/rfc2319.txt
     { "KOI8-U", "KOI8-U", 2088,
       { 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
         0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
         0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248,
         0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
         0x2550, 0x2551, 0x2552, 0x0451, 0x0454, 0x2554, 0x0456, 0x0457,
         0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x0491, 0x255D, 0x255E,
         0x255F, 0x2560, 0x2561, 0x0401, 0x0404, 0x2563, 0x0406, 0x0407,
         0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x0490, 0x256C, 0x00A9,
         0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
         0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
         0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
         0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
         0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
         0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
         0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
         0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A } },
 
     // next bits generated from tables on the Unicode 2.0 CD.  we can
     // use these tables since this is part of the transition to using
     // unicode everywhere in qt.
 
     // $ for A in 8 9 A B C D E F ; do for B in 0 1 2 3 4 5 6 7 8 9 A B C D E F ; do echo 0x${A}${B} 0xFFFD ; done ; done > /tmp/digits ; for a in 8859-* ; do ( awk '/^0x[89ABCDEF]/{ print $1, $2 }' < $a ; cat /tmp/digits ) | sort | uniq -w4 | cut -c6- | paste '-d ' - - - - - - - - | sed -e 's/ /, /g' -e 's/$/,/' -e '$ s/,$/} },/' -e '1 s/^/{ /' > ~/tmp/$a ; done
 
     // then I inserted the files manually.
     { "ISO-8859-2", "ISO 8859-2", 5,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
               0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
               0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
               0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
               0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
               0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
               0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
               0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
               0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
               0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
               0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
               0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9} },
     { "ISO-8859-3", "ISO 8859-3", 6,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0xFFFD, 0x0124, 0x00A7,
               0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0xFFFD, 0x017B,
               0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
               0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0xFFFD, 0x017C,
               0x00C0, 0x00C1, 0x00C2, 0xFFFD, 0x00C4, 0x010A, 0x0108, 0x00C7,
               0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
               0xFFFD, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7,
               0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
               0x00E0, 0x00E1, 0x00E2, 0xFFFD, 0x00E4, 0x010B, 0x0109, 0x00E7,
               0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
               0xFFFD, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7,
               0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9} },
     { "ISO-8859-4", "ISO 8859-4", 7,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7,
               0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
               0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7,
               0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
               0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
               0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
               0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
               0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
               0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
               0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
               0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
               0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9} },
     { "ISO-8859-5", "ISO 8859-5", 8,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
               0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F,
               0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
               0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
               0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
               0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
               0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
               0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
               0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
               0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
               0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
               0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F} },
     { "ISO-8859-6", "ISO 8859-6", 82,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0xFFFD, 0xFFFD, 0xFFFD, 0x00A4, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x060C, 0x00AD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0x061B, 0xFFFD, 0xFFFD, 0xFFFD, 0x061F,
               0xFFFD, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
               0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
               0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
               0x0638, 0x0639, 0x063A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
               0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
               0x0650, 0x0651, 0x0652, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
     { "ISO-8859-7", "ISO 8859-7", 10,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x2018, 0x2019, 0x00A3, 0xFFFD, 0xFFFD, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0xFFFD, 0x2015,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7,
               0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
               0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
               0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
               0x03A0, 0x03A1, 0xFFFD, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
               0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
               0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
               0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
               0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
               0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0xFFFD} },
     { "ISO-8859-8-I", "ISO 8859-8-I", 85,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x203E,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
               0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2017,
               0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
               0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
               0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
               0x05E8, 0x05E9, 0x05EA, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
     { "ISO-8859-9", "ISO 8859-9", 12,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
               0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
               0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
               0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
               0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
               0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
               0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
               0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
               0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
               0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF} },
     { "ISO-8859-10", "ISO 8859-10", 13,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7,
               0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
               0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7,
               0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B,
               0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
               0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
               0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168,
               0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
               0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
               0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
               0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169,
               0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138} },
     { "ISO-8859-13", "ISO 8859-13", 109,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7,
               0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7,
               0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
               0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
               0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
               0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
               0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
               0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
               0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
               0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
               0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019} },
     { "ISO-8859-14", "ISO 8859-14", 110,
         { 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
               0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
               0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
               0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
               0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7,
               0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178,
               0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56,
               0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61,
               0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
               0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
               0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A,
               0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF,
               0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
               0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
               0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B,
               0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF} },
 
     // next bits generated again from tables on the Unicode 3.0 CD.
 
     // $ for a in CP* ; do ( awk '/^0x[89ABCDEF]/{ print $1, $2 }' < $a ) | sort | sed -e 's/#UNDEF.*$/0xFFFD/' | cut -c6- | paste '-d ' - - - - - - - - | sed -e 's/ /, /g' -e 's/$/,/' -e '$ s/,$/} },/' -e '1 s/^/{ /' > ~/tmp/$a ; done
 
     { "CP 850", "IBM 850", 2009,
         { 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
               0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
               0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
               0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
               0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
               0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
               0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
               0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
               0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
               0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
               0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
               0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
               0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
               0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
               0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
               0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0} },
     { "CP 874", "CP 874", 0, //### what is the mib?
         { 0x20AC, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2026, 0xFFFD, 0xFFFD,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
               0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
               0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
               0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
               0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
               0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
               0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
               0x0E38, 0x0E39, 0x0E3A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0E3F,
               0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
               0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
               0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
               0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
     { "IBM 866", "IBM 866", 2086,
         { 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
           0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
           0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
           0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
           0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
           0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
           0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
           0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
           0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
           0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
           0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
           0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
           0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
           0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
           0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
           0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0} },
 
     { "windows-1250", "CP 1250", 2250,
         { 0x20AC, 0xFFFD, 0x201A, 0xFFFD, 0x201E, 0x2026, 0x2020, 0x2021,
               0xFFFD, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0xFFFD, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
               0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
               0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
               0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
               0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
               0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
               0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
               0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
               0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
               0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
               0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
               0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9} },
     { "windows-1251", "CP 1251", 2251,
         { 0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
               0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
               0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
               0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
               0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
               0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
               0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
               0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
               0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
               0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
               0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
               0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
               0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
               0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
               0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F} },
     { "windows-1252", "CP 1252", 2252,
         { 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
               0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0x017D, 0xFFFD,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0x017E, 0x0178,
               0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
               0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
               0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
               0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
               0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
               0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
               0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
               0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
               0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
               0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF} },
     { "windows-1253", "CP 1253", 2253,
         { 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
               0xFFFD, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
               0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
               0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
               0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
               0x03A0, 0x03A1, 0xFFFD, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
               0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
               0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
               0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
               0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
               0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0xFFFD} },
     { "windows-1254", "CP 1254", 2254,
         { 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
               0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
               0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
               0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
               0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
               0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
               0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
               0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
               0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
               0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
               0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
               0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
               0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
               0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF} },
     { "windows-1255", "CP 1255", 2255,
         { 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
               0x02C6, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
               0x02DC, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
               0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7,
diff --git a/noncore/apps/opie-reader/CFilter.cpp b/noncore/apps/opie-reader/CFilter.cpp
index 73a0872..0422ba6 100644
--- a/noncore/apps/opie-reader/CFilter.cpp
+++ b/noncore/apps/opie-reader/CFilter.cpp
@@ -1,385 +1,384 @@
-#include "CDrawBuffer.h"
 #include "CFilter.h"
 
 unsigned short striphtml::skip_ws()
 {
     tchar ch;
     CStyle sty;
     do
     {
         parent->getch(ch, sty);
     }
     while (ch < 33);
     return ch;
 }
 
 unsigned short striphtml::skip_ws_end()
 {
     tchar ch;
     CStyle sty;
     parent->getch(ch, sty);
     if (ch == ' ')
     {
         do
         {
             parent->getch(ch, sty);
         }
         while (ch != '>');
     }
     return ch;
 }
 
 unsigned short striphtml::parse_m()
 {
     tchar ch;
     CStyle sty;
     parent->getch(ch, sty);
     if (ch == 'm' || ch == 'M')
     {
         ch = skip_ws_end();
         if (ch == '>')
         {
             return 0;
         }
     }
     return ch;
 }
 
 void striphtml::mygetch(tchar& ch, CStyle& sty)
 {
     parent->getch(ch, sty);
     if (ch == 10) ch = ' ';
 }
 
 void striphtml::getch(tchar& ch, CStyle& sty)
 {
     CStyle dummy;
     mygetch(ch, dummy);
     if (ch == 10) ch = ' ';
     while (ch == '<')
     {
         ch = skip_ws();
 
         switch (ch)
         {
             case 'p':
             case 'P':
                 ch = skip_ws_end();
                 if (ch == '>')
                 {
                     ch = 10;
                     continue;
                 }
                 break;
             case 'b':
             case 'B':
                 ch = skip_ws_end();
                 if (ch == '>')
                 {
                     currentstyle.setBold();
                     mygetch(ch, dummy);
                     continue;
                 }
                 else if (ch == 'r' || ch == 'R')
                 {
                     ch = skip_ws_end();
                     if (ch == '>')
                     {
                         ch = 10;
                         continue;
                     }
                 }
                 break;
             case 'i':
             case 'I':
                 ch = skip_ws_end();
                 if (ch == '>')
                 {
                     currentstyle.setItalic();
                     mygetch(ch, dummy);
                     continue;
                 }
                 break;
             case 'e':
             case 'E':
                 if ((ch = parse_m()) == 0)
                 {
                     currentstyle.setItalic();
                     mygetch(ch, dummy);
                     continue;
                 }
                 break;
             case 'h':
             case 'H':
                 mygetch(ch, dummy);
                 if ('0' < ch && ch <= '9')
                 {
                     tchar hs = ch;
                     ch = skip_ws_end();
                     if (ch == '>')
                     {
                         switch (hs)
                         {
                             case '1':
         //                      currentstyle = ucBold | ucFontBase+2 | (ucAlignCentre << ucAlignShift);
                                 currentstyle.unset();
                                 currentstyle.setFontSize(2);
                                 currentstyle.setBold();
                                 currentstyle.setCentreJustify();
                                 break;
                             case '2':
         //                      currentstyle = ucBold | ucFontBase+1;
                                 currentstyle.unset();
                                 currentstyle.setFontSize(1);
                                 currentstyle.setBold();
                                 break;
                             default:
         //                      currentstyle = ucBold | ucFontBase;
                                 currentstyle.unset();
                                 currentstyle.setBold();
                         }
                         ch = 10;
         //              mygetch(ch, dummy);
                         continue;
                     }
                 }
                 break;
             case '/':
                 mygetch(ch, dummy);
                 switch (ch)
                 {
                     case 'b':
                     case 'B':
                         ch = skip_ws_end();
                         if (ch == '>')
                         {
                             currentstyle.unsetBold();
                             mygetch(ch, dummy);
                             continue;
                         }
                         break;
                     case 'i':
                     case 'I':
                         ch = skip_ws_end();
                         if (ch == '>')
                         {
                             currentstyle.unsetItalic();
                             mygetch(ch, dummy);
                             continue;
                         }
                         break;
                     case 'e':
                     case 'E':
                         if ((ch = parse_m()) == 0)
                         {
                             currentstyle.unsetItalic();
                             mygetch(ch, dummy);
                             continue;
                         }
                         break;
                     case 'h':
                     case 'H':
                         mygetch(ch, dummy);
                         if ('0' < ch && ch <= '9')
                         {
                             ch = skip_ws_end();
                             if (ch == '>')
                             {
                                 currentstyle.unset();
                                 //mygetch(ch, dummy);
                                 ch = 10;
                                 continue;
                             }
                         }
                         break;
                     default:
                         break;
                 }
                 break;
             default:
                 break;
         }
         while (ch != '>' && ch != UEOF)
         {
             mygetch(ch, dummy);
         }
         mygetch(ch, dummy);
     }
     if (ch == '&')
     {
         mygetch(ch, dummy);
         if (ch == '#')
         {
             int id = 0;
             mygetch(ch, dummy);
             while (ch != ';' && ch != UEOF)
             {
                 id = 10*id+ch-'0';
                 mygetch(ch, dummy);
             }
             ch = id;
         }
     }
 //    sty = (dummy == ucFontBase) ? currentstyle : dummy;
     sty = currentstyle;
     return;
 }
 
 
 void textfmt::mygetch(tchar& ch, CStyle& sty)
 {
     if (uselast)
     {
         ch = lastchar;
         uselast = false;
     }
     else
     {
         parent->getch(ch, sty);
     }
 }
 
 void textfmt::getch(tchar& ch, CStyle& sty)
 {
     mygetch(ch, sty);
     do
     {
         sty = currentstyle;
         switch (ch)
         {
             case 10:
                 currentstyle.unset();
                 sty = currentstyle;
                 break;
 // Use this if you want to replace -- by em-dash
             case '-':
         //      parent->getch(ch, sty);
                 mygetch(ch, sty);
                 if (ch == '-')
                 {
                     ch = 0x2014;
                 }
                 else
                 {
                     lastchar = ch;
                     uselast = true;
                     ch = '-';
                 }
                 break;
             case '*':
                 if (currentstyle.isBold())
                 {
 // Already bold - time to turn it off?
 // The next two lines ensure that * follows a character but it works better without
         //          QChar c(lastchar);
         //          if ((lastchar != '*') && (c.isPunct() || c.isLetterOrNumber()))
                     if (lastchar != '*')
                     {
                         currentstyle.unsetBold();
                         CStyle dummy;
         //              parent->getch(ch, dummy);
                         mygetch(ch, dummy);
                     }
                 }
                 else
                 {
 // not bold - time to turn it on?
                     CStyle dummy;
         //          parent->getch(ch, dummy);
                     mygetch(ch, dummy);
                     QChar c(ch);
                     if ((ch != '*') && (c.isPunct() || c.isLetterOrNumber()))
                     {
                         currentstyle.setBold();
                     }
                     else
                     {
                         lastchar = ch;
                         uselast = true;
                         ch = '*';
                     }
                     
                 }
                 break;
             case '_':
                 if (currentstyle.isItalic())
                 {
 // Already bold - time to turn it off?
 // The next two lines ensure that * follows a character but it works better without
         //          QChar c(lastchar);
         //          if ((lastchar != '_') && (c.isPunct() || c.isLetterOrNumber()))
                     if (lastchar != '_')
                     {
                         currentstyle.unsetItalic();
                         CStyle dummy;
         //              parent->getch(ch, dummy);
                         mygetch(ch, dummy);
                     }
                 }
                 else
                 {
 // not bold - time to turn it on?
                     CStyle dummy;
         //          parent->getch(ch, dummy);
                     mygetch(ch, dummy);
                     QChar c(ch);
                     if ((ch != '_') && (c.isPunct() || c.isLetterOrNumber()))
                     {
                         currentstyle.setItalic();
                     }
                     else
                     {
                         lastchar = ch;
                         uselast = true;
                         ch = '_';
                     }
                     
                 }
                 break;
         }
     }
     while (sty != currentstyle);
     if (!uselast) lastchar = ch;
     return;
 }
 
 void remap::getch(tchar& ch, CStyle& sty)
 {
     if (q[offset] != 0)
     {
         q[offset++];
         sty = currentstyle;
         return;
     }
     parent->getch(ch, sty);
     switch (ch)
     {
         case 0x201a:
             ch = '\'';
             break;
         case 0x0192:
             ch = 'f';
             break;
         case 0x201e:
             ch = '"';
             break;
         case 0x2026:
             offset = 0;
             q[0] = '.';
             q[1] = '.';
             q[2] = 0;
             ch = '.'; // should be ...
             break;
         case 0x0160:
             ch = 'S';
             break;
         case 0x2039:
             ch = '<';
             break;
                 case 0x0152:    
             offset = 0;
             q[0] = 'E';
             q[1] = 0;
             ch = 'O';
             break;
         case 0x017d:
diff --git a/noncore/apps/opie-reader/FontControl.cpp b/noncore/apps/opie-reader/FontControl.cpp
index e03bf64..cfa8534 100644
--- a/noncore/apps/opie-reader/FontControl.cpp
+++ b/noncore/apps/opie-reader/FontControl.cpp
@@ -1,60 +1,58 @@
-#include "opie.h"
-#include "useqpe.h"
 #include "FontControl.h"
 
 int FontControl::gzoom()
 {
     int ret;
     if (m_size == g_size)
     {
         ret = m_fontsizes[m_size]*m_basesize;
     }
     else if (g_size < 0)
     {
         int f = -g_size;
         ret = (m_fontsizes[0]*m_basesize) >> (f/2);
         if (f%2) ret = (2*ret/3);
     }
     else
     {
         int f = g_size - m_maxsize + 1;
         ret = (m_fontsizes[m_maxsize-1]*m_basesize) << (f/2);
         if (f%2) ret = (3*ret/2);
     }
     return ret;
 }
 
 bool FontControl::ChangeFont(QString& n, int tgt)
 {
     QValueList<int>::Iterator it;
     QFontDatabase fdb;
     QValueList<int> sizes = fdb.pointSizes(n);
     if (sizes.count() == 0)
     {
         return false;
     }
     else
     {
         m_fontname = n;
         m_maxsize = sizes.count();
         if (m_fontsizes != NULL) delete [] m_fontsizes;
         m_fontsizes = new int[m_maxsize];
         uint i = 0;
         uint best = 0;
         for (it = sizes.begin(); it != sizes.end(); it++)
         {
 #if defined(OPIE) || !defined(USEQPE)
             m_fontsizes[i] = (*it);
 #else
             m_fontsizes[i] = (*it)/10;
 #endif
             if (abs(tgt-m_fontsizes[i]) < abs(tgt-m_fontsizes[best]))
             {
                 best = i;
             }
             i++;
         }
         g_size = m_size = best;
     }
     return true;
 }
diff --git a/noncore/apps/opie-reader/Palm2QImage.cpp b/noncore/apps/opie-reader/Palm2QImage.cpp
index bf5ece3..9339595 100644
--- a/noncore/apps/opie-reader/Palm2QImage.cpp
+++ b/noncore/apps/opie-reader/Palm2QImage.cpp
@@ -1,309 +1,308 @@
 /* -*- mode: c; indent-tabs-mode: nil; -*- */
-#include "useqpe.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef _WINDOWS
 #include <unistd.h>     /* for link */
 #endif
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdarg.h>
 
 #include <qimage.h>
 
 /***********************************************************************/
 /***********************************************************************/
 /*****                                                             *****/
 /*****   Code to decode the Palm image format to JPEG              *****/
 /*****                                                             *****/
 /***********************************************************************/
 /***********************************************************************/
 
 #define READ_BIGENDIAN_SHORT(p) (((p)[0] << 8)|((p)[1]))
 #define READ_BIGENDIAN_LONG(p)  (((p)[0] << 24)|((p)[1] << 16)|((p)[2] << 8)|((p)[3]))
 
 #define PALM_IS_COMPRESSED_FLAG        0x8000
 #define PALM_HAS_COLORMAP_FLAG        0x4000
 #define PALM_HAS_TRANSPARENCY_FLAG    0x2000
 #define PALM_DIRECT_COLOR_FLAG        0x0400
 #define PALM_4_BYTE_FIELD_FLAG        0x0200
 
 #define PALM_COMPRESSION_SCANLINE    0x00
 #define PALM_COMPRESSION_RLE        0x01
 #define PALM_COMPRESSION_PACKBITS    0x02
 #define PALM_COMPRESSION_NONE        0xFF
 
 #define PALM_COLORMAP_SIZE 232
 
 typedef struct {
   unsigned char red;
   unsigned char green;
   unsigned char blue;
 } ColorMapEntry;
 
 static ColorMapEntry Palm8BitColormap[] = {
   { 255, 255, 255 }, { 255, 204, 255 }, { 255, 153, 255 }, { 255, 102, 255 }, 
   { 255,  51, 255 }, { 255,   0, 255 }, { 255, 255, 204 }, { 255, 204, 204 }, 
   { 255, 153, 204 }, { 255, 102, 204 }, { 255,  51, 204 }, { 255,   0, 204 }, 
   { 255, 255, 153 }, { 255, 204, 153 }, { 255, 153, 153 }, { 255, 102, 153 }, 
   { 255,  51, 153 }, { 255,   0, 153 }, { 204, 255, 255 }, { 204, 204, 255 },
   { 204, 153, 255 }, { 204, 102, 255 }, { 204,  51, 255 }, { 204,   0, 255 },
   { 204, 255, 204 }, { 204, 204, 204 }, { 204, 153, 204 }, { 204, 102, 204 },
   { 204,  51, 204 }, { 204,   0, 204 }, { 204, 255, 153 }, { 204, 204, 153 },
   { 204, 153, 153 }, { 204, 102, 153 }, { 204,  51, 153 }, { 204,   0, 153 },
   { 153, 255, 255 }, { 153, 204, 255 }, { 153, 153, 255 }, { 153, 102, 255 },
   { 153,  51, 255 }, { 153,   0, 255 }, { 153, 255, 204 }, { 153, 204, 204 },
   { 153, 153, 204 }, { 153, 102, 204 }, { 153,  51, 204 }, { 153,   0, 204 },
   { 153, 255, 153 }, { 153, 204, 153 }, { 153, 153, 153 }, { 153, 102, 153 },
   { 153,  51, 153 }, { 153,   0, 153 }, { 102, 255, 255 }, { 102, 204, 255 },
   { 102, 153, 255 }, { 102, 102, 255 }, { 102,  51, 255 }, { 102,   0, 255 },
   { 102, 255, 204 }, { 102, 204, 204 }, { 102, 153, 204 }, { 102, 102, 204 },
   { 102,  51, 204 }, { 102,   0, 204 }, { 102, 255, 153 }, { 102, 204, 153 },
   { 102, 153, 153 }, { 102, 102, 153 }, { 102,  51, 153 }, { 102,   0, 153 },
   {  51, 255, 255 }, {  51, 204, 255 }, {  51, 153, 255 }, {  51, 102, 255 },
   {  51,  51, 255 }, {  51,   0, 255 }, {  51, 255, 204 }, {  51, 204, 204 },
   {  51, 153, 204 }, {  51, 102, 204 }, {  51,  51, 204 }, {  51,   0, 204 },
   {  51, 255, 153 }, {  51, 204, 153 }, {  51, 153, 153 }, {  51, 102, 153 },
   {  51,  51, 153 }, {  51,   0, 153 }, {   0, 255, 255 }, {   0, 204, 255 },
   {   0, 153, 255 }, {   0, 102, 255 }, {   0,  51, 255 }, {   0,   0, 255 },
   {   0, 255, 204 }, {   0, 204, 204 }, {   0, 153, 204 }, {   0, 102, 204 },
   {   0,  51, 204 }, {   0,   0, 204 }, {   0, 255, 153 }, {   0, 204, 153 },
   {   0, 153, 153 }, {   0, 102, 153 }, {   0,  51, 153 }, {   0,   0, 153 },
   { 255, 255, 102 }, { 255, 204, 102 }, { 255, 153, 102 }, { 255, 102, 102 },
   { 255,  51, 102 }, { 255,   0, 102 }, { 255, 255,  51 }, { 255, 204,  51 },
   { 255, 153,  51 }, { 255, 102,  51 }, { 255,  51,  51 }, { 255,   0,  51 },
   { 255, 255,   0 }, { 255, 204,   0 }, { 255, 153,   0 }, { 255, 102,   0 },
   { 255,  51,   0 }, { 255,   0,   0 }, { 204, 255, 102 }, { 204, 204, 102 },
   { 204, 153, 102 }, { 204, 102, 102 }, { 204,  51, 102 }, { 204,   0, 102 },
   { 204, 255,  51 }, { 204, 204,  51 }, { 204, 153,  51 }, { 204, 102,  51 },
   { 204,  51,  51 }, { 204,   0,  51 }, { 204, 255,   0 }, { 204, 204,   0 },
   { 204, 153,   0 }, { 204, 102,   0 }, { 204,  51,   0 }, { 204,   0,   0 },
   { 153, 255, 102 }, { 153, 204, 102 }, { 153, 153, 102 }, { 153, 102, 102 },
   { 153,  51, 102 }, { 153,   0, 102 }, { 153, 255,  51 }, { 153, 204,  51 },
   { 153, 153,  51 }, { 153, 102,  51 }, { 153,  51,  51 }, { 153,   0,  51 },
   { 153, 255,   0 }, { 153, 204,   0 }, { 153, 153,   0 }, { 153, 102,   0 },
   { 153,  51,   0 }, { 153,   0,   0 }, { 102, 255, 102 }, { 102, 204, 102 },
   { 102, 153, 102 }, { 102, 102, 102 }, { 102,  51, 102 }, { 102,   0, 102 },
   { 102, 255,  51 }, { 102, 204,  51 }, { 102, 153,  51 }, { 102, 102,  51 },
   { 102,  51,  51 }, { 102,   0,  51 }, { 102, 255,   0 }, { 102, 204,   0 },
   { 102, 153,   0 }, { 102, 102,   0 }, { 102,  51,   0 }, { 102,   0,   0 },
   {  51, 255, 102 }, {  51, 204, 102 }, {  51, 153, 102 }, {  51, 102, 102 },
   {  51,  51, 102 }, {  51,   0, 102 }, {  51, 255,  51 }, {  51, 204,  51 },
   {  51, 153,  51 }, {  51, 102,  51 }, {  51,  51,  51 }, {  51,   0,  51 },
   {  51, 255,   0 }, {  51, 204,   0 }, {  51, 153,   0 }, {  51, 102,   0 },
   {  51,  51,   0 }, {  51,   0,   0 }, {   0, 255, 102 }, {   0, 204, 102 },
   {   0, 153, 102 }, {   0, 102, 102 }, {   0,  51, 102 }, {   0,   0, 102 },
   {   0, 255,  51 }, {   0, 204,  51 }, {   0, 153,  51 }, {   0, 102,  51 },
   {   0,  51,  51 }, {   0,   0,  51 }, {   0, 255,   0 }, {   0, 204,   0 },
   {   0, 153,   0 }, {   0, 102,   0 }, {   0,  51,   0 }, {  17,  17,  17 },
   {  34,  34,  34 }, {  68,  68,  68 }, {  85,  85,  85 }, { 119, 119, 119 },
   { 136, 136, 136 }, { 170, 170, 170 }, { 187, 187, 187 }, { 221, 221, 221 },
   { 238, 238, 238 }, { 192, 192, 192 }, { 128,   0,   0 }, { 128,   0, 128 },
   {   0, 128,   0 }, {   0, 128, 128 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }};
 
 static ColorMapEntry Palm1BitColormap[] = {{ 255, 255, 255 }, { 0, 0, 0 }};
 
 static ColorMapEntry Palm2BitColormap[] = {
   { 255, 255, 255 }, { 192, 192, 192 }, { 128, 128, 128 }, { 0, 0, 0 }};
 
 static ColorMapEntry Palm4BitColormap[] = {
   { 255, 255, 255 }, { 238, 238, 238 }, { 221, 221, 221 }, { 204, 204, 204 },
   { 187, 187, 187 }, { 170, 170, 170 }, { 153, 153, 153 }, { 136, 136, 136 },
   { 119, 119, 119 }, { 102, 102, 102 }, {  85,  85,  85 }, {  68,  68,  68 },
   {  51,  51,  51 }, {  34,  34,  34 }, {  17,  17,  17 }, {   0,   0,   0 }};
 
 QImage* Palm2QImage
   (unsigned char *image_bytes_in, int byte_count_in)
 {
   unsigned int width, height, bytes_per_row, flags, next_depth_offset;
   unsigned int bits_per_pixel, version, transparent_index, compression_type, i, j, inval, inbit, mask, incount;
   unsigned int palm_red_bits, palm_green_bits, palm_blue_bits;
   unsigned char *palm_ptr, *x_ptr, *imagedata, *inbyte, *rowbuf, *lastrow,
   *imagedatastart, *palmimage;
   ColorMapEntry *colormap;
 
   palmimage = image_bytes_in;
   width = READ_BIGENDIAN_SHORT(palmimage + 0);
   height = READ_BIGENDIAN_SHORT(palmimage + 2);
   bytes_per_row = READ_BIGENDIAN_SHORT(palmimage + 4);
   flags = READ_BIGENDIAN_SHORT(palmimage + 6);
   bits_per_pixel = palmimage[8];
   version = palmimage[9];
   next_depth_offset = READ_BIGENDIAN_SHORT(palmimage + 10);
   transparent_index = palmimage[12];
   compression_type = palmimage[13];
   /* bytes 14 and 15 are reserved by Palm and always 0 */
   
 #if 0
 //  qDebug ("Palm image is %dx%d, %d bpp, version %d, flags 0x%x, compression %d", width, height, bits_per_pixel, version, flags, compression_type);
 #endif
 
   if (compression_type == PALM_COMPRESSION_PACKBITS) {
 //    qDebug ("Image uses packbits compression; not yet supported");
     return NULL;
   } else if ((compression_type != PALM_COMPRESSION_NONE) &&
     (compression_type != PALM_COMPRESSION_RLE) &&
       (compression_type != PALM_COMPRESSION_SCANLINE)) {
 //    qDebug ("Image uses unknown compression, code 0x%x", compression_type);
     return NULL;
   }
 
   /* as of PalmOS 4.0, there are 6 different kinds of Palm pixmaps:
      
      1, 2, or 4 bit grayscale
      8-bit StaticColor using the Palm standard colormap
      8-bit PseudoColor using a user-specified colormap
      16-bit DirectColor using 5 bits for red, 6 for green, and 5 for blue
      
      Each of these can be compressed with one of four compression schemes,
      "RLE", "Scanline", "PackBits", or none.
      
      We begin by constructing the colormap.
      */
 
   if (flags & PALM_HAS_COLORMAP_FLAG) {
 //    qDebug("Palm images with custom colormaps are not currently supported.\n");
     return NULL;
   } else if (bits_per_pixel == 1) {
     colormap = Palm1BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 2) {
     colormap = Palm2BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 4) {
     colormap = Palm4BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 8) {
     colormap = Palm8BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 16 && (flags & PALM_DIRECT_COLOR_FLAG)) {
     colormap = NULL;
     palm_red_bits = palmimage[16];
     palm_green_bits = palmimage[17];
     palm_blue_bits = palmimage[18];
 //    qDebug("Bits:%d, %d, %d", palm_red_bits, palm_green_bits, palm_blue_bits);
     if (palm_blue_bits > 8 || palm_green_bits > 8 || palm_red_bits > 8) {
 //      qDebug("Can't handle this format DirectColor image -- too wide in some color (%d:%d:%d)\n", palm_red_bits, palm_green_bits, palm_blue_bits);
       return NULL;
     }
     if (bits_per_pixel > (8 * sizeof(unsigned long))) {
 //      qDebug ("Can't handle this format DirectColor image -- too many bits per pixel (%d)\n", bits_per_pixel);
       return NULL;
     }
     imagedatastart = palmimage + 24;
   } else {
 //    qDebug("Unknown bits-per-pixel of %d encountered.\n", bits_per_pixel);
     return NULL;
   }
 
 #ifndef USEQPE
   QImage* qimage = new QImage(width, height, 32);
 #else
       QImage* qimage = new QImage(width, height, 16);
 #endif
 
   /* row by row, uncompress the Palm image and copy it to the JPEG buffer */
   rowbuf = new unsigned char[bytes_per_row * width];
   lastrow = new unsigned char[bytes_per_row * width];
 
   for (i=0, palm_ptr = imagedatastart , x_ptr = imagedata;  i < height;  ++i) {
 //        qDebug("inval:%x palm_ptr:%x x_ptr:%x bpr:%x", inval, palm_ptr, x_ptr, bytes_per_row);
 
     /* first, uncompress the Palm image */
     if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_RLE)) {
       for (j = 0;  j < bytes_per_row;  ) {
         incount = *palm_ptr++;
         inval = *palm_ptr++;
         memset(rowbuf + j, inval, incount);
         j += incount;
       }
     } else if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_SCANLINE)) {
       for (j = 0;  j < bytes_per_row;  j += 8) {
         incount = *palm_ptr++;
         inval = ((bytes_per_row - j) < 8) ? (bytes_per_row - j) : 8;
         for (inbit = 0;  inbit < inval;  inbit += 1) {
           if (incount & (1 << (7 - inbit)))
             rowbuf[j + inbit] = *palm_ptr++;
           else
             rowbuf[j + inbit] = lastrow[j + inbit];
         }
       }
       memcpy (lastrow, rowbuf, bytes_per_row);
     } else if (((flags & PALM_IS_COMPRESSED_FLAG) &&
                 (compression_type == PALM_COMPRESSION_NONE)) ||
                ((flags & PALM_IS_COMPRESSED_FLAG) == 0))
     {
         memcpy (rowbuf, palm_ptr, bytes_per_row);
         palm_ptr += bytes_per_row;
     }
     else {
         qDebug("Case 4");
         qDebug("Is compressed:%s", ((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true");
         qDebug("Has colourmap:%s", ((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true");
         qDebug("Has transparency:%s", ((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true");
         qDebug("Direct colour:%s", ((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true");
         qDebug("four byte field:%s", ((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true");
       memcpy (rowbuf, palm_ptr, bytes_per_row);
       palm_ptr += bytes_per_row;
     }
     /* next, write it to the GDK bitmap */
     if (colormap) {
       mask = (1 << bits_per_pixel) - 1;
       for (inbit = 8 - bits_per_pixel, inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((*inbyte) & (mask << inbit)) >> inbit;
         /* correct for oddity of the 8-bit color Palm pixmap... */
         if ((bits_per_pixel == 8) && (inval == 0xFF)) inval = 231;
         /* now lookup the correct color and set the pixel in the GTK bitmap */
         QRgb colour = qRgb(colormap[inval].red, colormap[inval].green, colormap[inval].blue);
         qimage->setPixel(j, i, colour);
         if (!inbit) {
           ++inbyte;
           inbit = 8 - bits_per_pixel;
         } else {
           inbit -= bits_per_pixel;
         }
       }
     } else if (!colormap &&
       bits_per_pixel == 16) {
       for (inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((unsigned short)inbyte[0] << (unsigned short)8) | inbyte[1];
 
 /*
         qDebug ("pixel is %d,%d (%d:%d:%d)",
                       j, i,
                       ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits),
                       ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
                       ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
 */
         QRgb colour = qRgb(
             ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), 
             ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
             ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
         qimage->setPixel(j, i, colour);
         inbyte += 2;
       }
     }
   }
 
   delete [] rowbuf;
   delete [] lastrow;
 
   return qimage;
 }
 
 QImage* hRule(int w, int h, unsigned char r, unsigned char g, unsigned char b)
 {
 ////    qDebug("hrule [%d, %d]", w, h);
     QPixmap* qimage = new QPixmap(w, h);
     qimage->fill(QColor(r,g,b));
     QImage* ret = new QImage(qimage->convertToImage());
     delete qimage;
     return ret;
 }
diff --git a/noncore/apps/opie-reader/Prefs.cpp b/noncore/apps/opie-reader/Prefs.cpp
index 5150ca5..72eefba 100644
--- a/noncore/apps/opie-reader/Prefs.cpp
+++ b/noncore/apps/opie-reader/Prefs.cpp
@@ -1,406 +1,397 @@
 /****************************************************************************
 ** Form implementation generated from reading ui file 'Prefs.ui'
 **
 ** Created: Tue Feb 11 23:53:35 2003
 **      by:  The User Interface Compiler (uic)
 **
 ** WARNING! All changes made in this file will be lost!
 ****************************************************************************/
-#include "useqpe.h"
 #include "Prefs.h"
 
-#include <qcheckbox.h>
 #include <qlabel.h>
-#include <qpushbutton.h>
-#include <qspinbox.h>
 #include <qlayout.h>
-#include <qvariant.h>
-#include <qtooltip.h>
-#include <qwhatsthis.h>
-#include <qcombobox.h>
 #include <qbuttongroup.h>
-#include <qlineedit.h>
 #ifdef USEQPE
 #include <qpe/menubutton.h>
 #include <qpe/fontdatabase.h>
 #else
 #include <qfontdatabase.h>
 #endif
 
 #include <qpe/qpeapplication.h>
 
 CLayoutPrefs::CLayoutPrefs( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
     QHBoxLayout* hb = new QHBoxLayout(this);
     QButtonGroup* bg = new QButtonGroup(2, Qt::Horizontal, tr("Text"), this);
     hb->addWidget(bg);
 
     StripCR = new QCheckBox( bg );
     StripCR->setText( tr( "Strip CR" ) );
 
     Dehyphen = new QCheckBox( bg );
     Dehyphen->setText( tr( "Dehyphen" ) );
 
     SingleSpace = new QCheckBox( bg );
     SingleSpace->setText( tr( "Single Space" ) );
 
     Unindent = new QCheckBox( bg );
     Unindent->setText( tr( "Unindent" ) );
 
     Reparagraph = new QCheckBox( bg );
     Reparagraph->setText( tr( "Reparagraph" ) );
 
     DoubleSpace = new QCheckBox( bg );
     DoubleSpace->setText( tr( "Double Space" ) );
 
     Remap = new QCheckBox( bg );
     Remap->setText( tr( "Remap" ) );
 
     Embolden = new QCheckBox( bg );
     Embolden->setText( tr( "Embolden" ) );
 
     FullJustify = new QCheckBox( bg );
     FullJustify->setText( tr( "Full Justify" ) );
 
 }
 
 /*  
  *  Destroys the object and frees any allocated resources
  */
 CLayoutPrefs::~CLayoutPrefs()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 
 
 CLayoutPrefs2::CLayoutPrefs2( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
     
     QVBoxLayout* vb = new QVBoxLayout(this);
     QGridLayout* gl = new QGridLayout(vb, 4, 3);
 
     QLabel *TextLabel;
 
     TextLabel = new QLabel( this, "TextLabel1" );
     TextLabel->setText( tr( "Indent" ) );
     gl->addWidget(TextLabel, 0, 0);
 
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Page\nOverlap" ) );
     gl->addWidget(TextLabel, 0, 1);
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Graphics\nZoom" ) );
     gl->addWidget(TextLabel, 0, 2);
 
     Indent = new QSpinBox( this, "Indent" );
     Indent->setRange(0,20);
     gl->addWidget(Indent, 1, 0);
 
     pageoverlap = new QSpinBox( this );
     pageoverlap->setRange(0,20);
     gl->addWidget(pageoverlap, 1, 1);
 
     gfxzoom = new QSpinBox( this );
     gfxzoom->setRange(0,100);
     gl->addWidget(gfxzoom, 1, 2);
 
     TextLabel = new QLabel( this, "TextLabel4" );
     TextLabel->setText( tr( "Margin" ) );
     gl->addWidget(TextLabel, 2, 0);
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Paragraph\nLeading" ) );
     gl->addWidget(TextLabel, 2, 1);
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Line\nLeading" ) );
     gl->addWidget(TextLabel, 2, 2);
 
     Margin = new QSpinBox( this, "Margin" );
     Margin->setRange(0, 100);
     gl->addWidget(Margin, 3, 0);
 
     ParaLead = new QSpinBox( this );
     ParaLead->setRange(-5, 50);
     gl->addWidget(ParaLead, 3, 1);
 
     LineLead = new QSpinBox( this );
     LineLead->setRange(-5, 50);
     gl->addWidget(LineLead, 3, 2);
 
     gl = new QGridLayout(vb, 2, 2);
 
     TextLabel = new QLabel( this);
     TextLabel->setText( tr( "Markup" ) );
     gl->addWidget(TextLabel, 0, 0, Qt::AlignBottom);
     TextLabel = new QLabel( this);
     TextLabel->setText( tr( "Font" ) );
     gl->addWidget(TextLabel, 0, 1, Qt::AlignBottom);
 
 
 #ifdef USECOMBO
     Markup = new QComboBox( this);
 #else
     Markup = new MenuButton( this);
 #endif
     Markup->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     Markup->insertItem("Auto");
     Markup->insertItem("None");
     Markup->insertItem("Text");
     Markup->insertItem("HTML");
     Markup->insertItem("PML");
     gl->addWidget(Markup, 1, 0, Qt::AlignTop);
 
 #ifdef USECOMBO
     fontselector = new QComboBox( this);
 #else
     fontselector = new MenuButton( this);
 #endif
     fontselector->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     {
 #ifdef USEQPE
         FontDatabase f;
 #else
         QFontDatabase f;
 #endif
         QStringList flist = f.families();
         for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)
         {
             fontselector->insertItem(*nm);
         }
     } // delete the FontDatabase!!!
     gl->addWidget(fontselector, 1, 1, Qt::AlignTop);
 }
 /*
 CLayoutPrefs2::CLayoutPrefs2( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
     QHBoxLayout* hb = new QHBoxLayout(this);
 
     QVBoxLayout* vb = new QVBoxLayout;
     hb->addLayout(vb);
 
     QLabel *TextLabel;
 
     TextLabel = new QLabel( this, "TextLabel1" );
     TextLabel->setText( tr( "Indent" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     Indent = new QSpinBox( this, "Indent" );
     Indent->setRange(0,20);
     vb->addWidget( Indent, 0, Qt::AlignLeft );
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Page\nOverlap" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     pageoverlap = new QSpinBox( this );
     pageoverlap->setRange(0,20);
     vb->addWidget( pageoverlap, 0, Qt::AlignLeft );
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Graphics\nZoom" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     gfxzoom = new QSpinBox( this );
     gfxzoom->setRange(0,100);
     vb->addWidget( gfxzoom, 0, Qt::AlignLeft );
 
     vb->addStretch();
 
     vb = new QVBoxLayout;
     hb->addLayout(vb);
 
     TextLabel = new QLabel( this, "TextLabel4" );
     TextLabel->setText( tr( "Margin" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     Margin = new QSpinBox( this, "Margin" );
     Margin->setRange(0, 100);
     vb->addWidget( Margin, 0, Qt::AlignLeft );
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Paragraph\nLeading" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     ParaLead = new QSpinBox( this );
     ParaLead->setRange(-5, 50);
     vb->addWidget( ParaLead, 0, Qt::AlignLeft );
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Line\nLeading" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     LineLead = new QSpinBox( this );
     LineLead->setRange(-5, 50);
     vb->addWidget( LineLead, 0, Qt::AlignLeft );
 
     vb->addStretch();
 
     vb = new QVBoxLayout;
     hb->addLayout(vb);
 
 
     TextLabel = new QLabel( this);
     TextLabel->setText( tr( "Markup" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     Markup = new MenuButton( this);
     Markup->insertItem("Auto");
     Markup->insertItem("None");
     Markup->insertItem("Text");
     Markup->insertItem("HTML");
     Markup->insertItem("PML");
     vb->addWidget( Markup, 0, Qt::AlignLeft );
 
     TextLabel = new QLabel( this);
     TextLabel->setText( tr( "Font" ) );
     vb->addWidget( TextLabel, 0, Qt::AlignBottom );
     fontselector = new MenuButton( this);
     fontselector->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     {
         FontDatabase f;
         QStringList flist = f.families();
         for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)
         {
             fontselector->insertItem(*nm);
         }
     } // delete the FontDatabase!!!
     vb->addWidget( fontselector, 0, Qt::AlignLeft );
 
     vb->addStretch();
 }
 */
 /*  
  *  Destroys the object and frees any allocated resources
  */
 CLayoutPrefs2::~CLayoutPrefs2()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 /*
 CPluckerPrefs::CPluckerPrefs( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
     Layout11 = new QVBoxLayout(this); 
     Layout11->setMargin( 0 );
 
     Depluck = new QCheckBox( this, "Depluck" );
     Depluck->setText( tr( "Depluck" ) );
     Layout11->addWidget( Depluck );
 
     Dejpluck = new QCheckBox( this, "Dejpluck" );
     Dejpluck->setText( tr( "Dejpluck" ) );
     Layout11->addWidget( Dejpluck );
 
     Continuous = new QCheckBox( this, "Continuous" );
     Continuous->setText( tr( "Continuous" ) );
     Layout11->addWidget( Continuous );
 
 }
 
 CPluckerPrefs::~CPluckerPrefs()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 */
 /*
 CMiscPrefs::CMiscPrefs( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
 
     QVBoxLayout* Layout11 = new QVBoxLayout(this); 
     Layout11->setMargin( 0 );
 
 
     QHBoxLayout* hl = new QHBoxLayout;
 
     QLabel* TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Action for\nSelect Button" ) );
     hl->addWidget(TextLabel);
 
     action = new QComboBox( this );
     action->insertItem("Open file");
     action->insertItem("Autoscroll");
     action->insertItem("Mark");
     action->insertItem("Annotate");
     action->insertItem("Fullscreen");
     hl->addWidget( action );
 
     Layout11->addLayout(hl);
 
     hl = new QHBoxLayout;
 
     TextLabel = new QLabel( this );
     TextLabel->setText( tr( "Dictionary\nApplication" ) );
     hl->addWidget(TextLabel);
     target = new QLineEdit(this);
     hl->addWidget( target );
 
     Layout11->addLayout(hl);
 
 
     QButtonGroup* bg = new QButtonGroup(1, Qt::Horizontal, "Selection Target", this);
     Layout11->addWidget( bg );
 
     annotation = new QCheckBox( bg );
     annotation->setText( tr( "Annotation" ) );
 
     dictionary = new QCheckBox( bg );
     dictionary->setText( tr( "Dictionary" ) );
 
     clipboard = new QCheckBox( bg );
     clipboard->setText( tr( "Clipboard" ) );
 
 }
 
 CMiscPrefs::~CMiscPrefs()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 */
 
 CMiscPrefs::CMiscPrefs( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
 
     QGridLayout* hl = new QGridLayout(this,1,2);
 
     hl->setMargin( 0 );
 
     QGroupBox* gb = new QGroupBox(1, Qt::Horizontal, tr("Select Action"), this);
     hl->addWidget( gb, 0, 0 );
 
     annotation = new QCheckBox( gb );
     annotation->setText( tr( "Annotation" ) );
 
     dictionary = new QCheckBox( gb );
     dictionary->setText( tr( "Dictionary" ) );
 
     clipboard = new QCheckBox( gb );
     clipboard->setText( tr( "Clipboard" ) );
 
     QButtonGroup* bg = new QButtonGroup(1, Qt::Horizontal, tr("Plucker"), this);
     hl->addWidget( bg, 0 , 1 );
 
     Depluck = new QCheckBox( bg );
     Depluck->setText( tr( "Depluck" ) );
 
     Dejpluck = new QCheckBox( bg );
     Dejpluck->setText( tr( "Dejpluck" ) );
 
     Continuous = new QCheckBox( bg );
     Continuous->setText( tr( "Continuous" ) );
 
 
 /*
 
     QGroupBox* gb = new QGroupBox(1, Qt::Horizontal, "Navigation", this);
     TextLabel = new QLabel( gb );
     TextLabel->setText( tr( "Overlap" ) );
     QSpinBox* sb = new QSpinBox( gb );
 
     Internationalisation
     Ideogram/Word
     Set Width
     Set Encoding
     Set Font
diff --git a/noncore/apps/opie-reader/QTReader.cpp b/noncore/apps/opie-reader/QTReader.cpp
index 03c8fbe..d64abb4 100644
--- a/noncore/apps/opie-reader/QTReader.cpp
+++ b/noncore/apps/opie-reader/QTReader.cpp
@@ -1,836 +1,827 @@
 /****************************************************************************
 ** $Id$
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of an example program for Qt.  This example
 ** program may be used, distributed and modified without limitation.
 **
 *****************************************************************************/
 
-#include "useqpe.h"
-#include <qpainter.h>
-#include <qimage.h>
-#include <qtimer.h>
-#include "config.h"
 #include "QTReader.h"
 #include "QTReaderApp.h"
-#include "CDrawBuffer.h"
 #ifdef USEQPE
 #include <qpe/qpeapplication.h>
 #endif
 #include <math.h>
 #include <ctype.h>
 #include <stdio.h> //for sprintf
 #ifdef USEQPE
 #include <qpe/config.h>
 #include <qpe/applnk.h>
 #include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 #endif
-#include <qfontdatabase.h>
 
 #ifdef _UNICODE
 const char *QTReader::fonts[] = { "unifont", "Courier", "Times", 0 };
 #else
 const char *QTReader::fonts[] = { "Helvetica", "Courier", "Times", 0 };
 #endif
 //const int   QTReader::fontsizes[] = { 8, 10, 12, 14, 18, 24, 30, 40, 50, 60, 70, 80, 90, 100, 0 };
 
 //const tchar *QTReader::fonts[] = { "unifont", "fixed", "micro", "smoothtimes", "Courier", "Times", 0 };
 //const int   QTReader::fontsizes[] = {10,16,17,22,0};
 //const tchar *QTReader::fonts[] = { "verdana", "Courier", "Times", 0 };
 //const int   QTReader::fontsizes[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,0};
 
 tchar QTReader::pluckernextpart[] = { 'C','l','i','c','k',' ','h','e','r','e',' ','f','o','r',' ','t','h','e',' ','n','e','x','t',' ','p','a','r','t',0 };
 tchar QTReader::jplucknextpart[] = { 'N','e','x','t',' ','P','a','r','t',' ','>','>',0 };
 //tchar QTReader::jplucknextpart[] = { 10,'#',10,'N','e','x','t',' ','P','a','r','t',' ','>','>',0 };
 
 QTReader::QTReader( QWidget *parent, const char *name, WFlags f) :
   QWidget(parent, name, f),
   m_delay(100),
   m_scrolldy1(0),
   m_scrolldy2(0),
   m_autoScroll(false),
   //textarray(NULL),
   //locnarray(NULL),
   numlines(0),
   m_fontname("unifont"),
   m_fm(NULL),
   mouseUpOn(true),
   m_twotouch(true),
   m_touchone(true),
   bDoUpdates(false),
 #ifdef _SCROLLPIPE
   m_pipeout(NULL),
 #endif
   m_border(2)
 {
     m_overlap = 1;
     setKeyCompression ( true );
 //  init();
 }
 
 /*
 QTReader::QTReader( const QString& filename, QWidget *parent=0, const tchar *name=0, WFlags f = 0) :
   QWidget(parent, name, f),
   m_textfont(0),
   m_textsize(1),
   textarray(NULL),
   numlines(0),
   bstripcr(true),
   bunindent(false),
   brepara(false),
   bdblspce(false),
   btight(false),
   bindenter(0),
   m_fm(NULL)
 {
   init();
 //  //  qDebug("Load_file(1)");
   load_file((const tchar*)filename);
 }
 */
 
 /*
 void QTReader::mouseMoveEvent(QMouseEvent* _e)
 {
 
     mouseUpOn = !(_e->pos().x() == -1);
 
     qDebug("MouseMove:[%d, %d]", _e->pos().x(), _e->pos().y());
 }
 */
 long QTReader::real_delay()
 {
     return ( 8976 + m_delay ) / ( m_linespacing * m_linespacing );
 }
 
 void QTReader::mousePressEvent( QMouseEvent* _e )
 {
     buffdoc.unsuspend();
     if (_e->button() == RightButton)
     {
         //qDebug("MousePress");
         mouseUpOn = false;
         if (m_swapmouse)
         {
                 int lineno = 0;
                 int ht = textarray[0]->lineSpacing();
                 while ((ht < _e->y()) && (lineno < numlines))
                 {
                     ht += textarray[++lineno]->lineSpacing();
                 }
                 size_t startpos, startoffset, tgt;
                 getcurrentpos(_e->x(), _e->y(), startpos, startoffset, tgt);
                 processmousewordevent(startpos, startoffset, _e, lineno);
         }
         else
             processmousepositionevent(_e);
     }
 }
 
 void QTReader::processmousepositionevent( QMouseEvent* _e )
 {
     if (buffdoc.hasnavigation())
     {
         if (_e->y() > (2*height())/3)
         {
             goDown();
         }
         else if (_e->y() < height()/3)
         {
             goUp();
         }
         else
         {
             if (_e->x() < width()/3)
             {
                 goBack();
             }
             else if (_e->x() > (2*width())/3)
             {
                 goForward();
             }
             else
             {
                 goHome();
             }
         }
     }
     else
     {
         if (_e->y() > height()/2)
         {
             goDown();
         }
         else
         {
             goUp();
         }
     }
 }
 
 void QTReader::goHome()
 {
     if (buffdoc.hasnavigation())
     {
          size_t current=pagelocate();
          size_t home=buffdoc.getHome();
          if (current!=home)
         {
             buffdoc.saveposn(current);
             locate(home);
          }
     }
 }
 
 void QTReader::goBack()
 {
     if (buffdoc.hasnavigation())
     {
         size_t target = pagelocate();
         buffdoc.writeposn(target);
         if (buffdoc.back(target))
         {
             locate(target);
         }
     }
 }
 
 void QTReader::goForward()
 {
     if (buffdoc.hasnavigation())
     {
         size_t target = pagelocate();
         if (buffdoc.forward(target))
         {
             locate(target);
         }
     }
 }
 
 linkType QTReader::getcurrentpos(int x, int y, size_t& start, size_t& offset, size_t& tgt)
 {
     int lineno = 0;
     int ht = textarray[0]->lineSpacing();
     while ((ht < y) && (lineno < numlines))
     {
         ht += textarray[++lineno]->lineSpacing();
     }
     start = locnarray[lineno];
     if (m_bMonoSpaced)
     {
         offset = (x - textarray[lineno]->offset(width(), m_border))/m_charWidth;
     }
     else
     {
         int i;
         CDrawBuffer* t = textarray[lineno];
         x = x - t->offset(width(), m_border);
         for (i = t->length(); i >= 0 && t->width(i, true, width(), m_border) > x; i--);
         offset = i;
     }
     return textarray[lineno]->getLinkType(offset, tgt);
 }
 
 void QTReader::suspend()
 {
 #ifdef OPIE
     if (memcmp("/mnt/", m_lastfile.latin1(), 5) == 0) buffdoc.suspend();
 #else
     if (memcmp("/usr/mnt.rom/", m_lastfile.latin1(), 13) == 0) buffdoc.suspend();
 #endif
 }
 
 void QTReader::setTwoTouch(bool _b)
 {
     setBackgroundColor( white );
     m_twotouch = m_touchone = _b;
 }
 
 void QTReader::setContinuous(bool _b)
 {
     buffdoc.unsuspend();
     buffdoc.setContinuous(m_continuousDocument = _b);
 }
 
 void QTReader::processmousewordevent(size_t startpos, size_t startoffset, QMouseEvent* _e, int lineno)
 {
     QString wrd;
     if (m_twotouch)
     {
         if (m_touchone)
         {
             m_touchone = false;
             m_startpos = startpos;
             m_startoffset = startoffset;
             setBackgroundColor( lightGray );
         }
         else
         {
             m_touchone = true;
             setBackgroundColor( white );
             size_t endpos, endoffset;
             endpos = startpos;
             endoffset = startoffset;
             size_t currentpos = locate();
             if (endpos >= m_startpos)
             {
                 jumpto(m_startpos);
                 for (int i = 0; i < m_startoffset; i++)
                 {
                     getch();
                 }
                 if (m_startpos == endpos)
                 {
                     for (int i = m_startoffset; i <= endoffset; i++)
                     {
                         wrd += QChar(getch());
                     }
                 }
                 else
                 {
                     while (buffdoc.explocate() <= endpos)
                     {
                         wrd += QChar(getch());
                     }
                     for (int i = 0; i < endoffset; i++)
                     {
                         wrd += QChar(getch());
                     }
                 }
                 jumpto(currentpos);
             }
         }
     }
     else if (m_bMonoSpaced)
     {
         int chno = (_e->x()-textarray[lineno]->offset(width(), m_border))/m_charWidth;
         if (chno < ustrlen(textarray[lineno]->data()))
         {
             wrd[0] = textarray[lineno]->data()[chno];
         }
     }
     else
     {
         CDrawBuffer* t = textarray[lineno];
         int first = 0;
         int tgt = _e->x() - t->offset(width(), m_border);
         while (1)
         {
             int i = first+1;
             while (QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
             if (t->width(i, true, width(), m_border) > tgt)
             {
                 wrd = toQString(t->data()+first, i - first);
         //                  qDebug("Got %s", (const char *)wrd);
                 break;
             }
             while (!QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
             if ((*t)[i] == 0) break;
             first = i;
                 }       
     }
     if (!wrd.isEmpty())
     {
         //qDebug("Selected:%s", (const char*)wrd);
         emit OnWordSelected(wrd, locnarray[lineno], (m_twotouch) ? wrd : toQString(textarray[lineno]->data()));
     }
 }
 
 void QTReader::mouseReleaseEvent( QMouseEvent* _e )
 {
     buffdoc.unsuspend();
     if (_e->button() == LeftButton)
     {
         if (mouseUpOn)
         {
         //    qDebug("MouseRelease");
             if (_e->x() > width() - m_border)
             {
                 locate(buffdoc.startSection()+((buffdoc.endSection()-buffdoc.startSection())*_e->y()+height()/2)/height());
                 return;
             }
             if (textarray[0] != NULL)
             {
                 QString line;
         //      int lineno = _e->y()/m_linespacing;
                 int lineno = 0;
                 int ht = textarray[0]->lineSpacing();
                 while ((ht < _e->y()) && (lineno < numlines))
                 {
                     ht += textarray[++lineno]->lineSpacing();
                 }
                 size_t startpos, startoffset, tgt;
                 switch (getcurrentpos(_e->x(), _e->y(), startpos, startoffset, tgt))
                 {
                     case eLink:
                     {
                         size_t saveposn = pagelocate();
                         QString href;
                         linkType lt = buffdoc.hyperlink(tgt, href);
                         if (lt == eLink)
                         {
                             buffdoc.saveposn(saveposn);
                             fillbuffer();
                             update();
                         }
                         else
                         {
                             if (lt == ePicture)
                             {
                                 QImage* pm = buffdoc.getPicture(tgt);
                                 if (pm != NULL)
                                 {
                                     emit OnShowPicture(*pm);
                                     delete pm;
                                 }
                             }
                             else
                             {
         //                      QString anchortext = textarray[lineno]->getanchortext(startoffset);
                                 if (!href.isEmpty())
                                 {
                                     emit OnURLSelected(href);
                                 }
                             }
                             locate(pagelocate());
                         }
                         return;
                     }
                     case ePicture:
                     {
         //              qDebug("Picture:%x", tgt);
                         QImage* pm = buffdoc.getPicture(tgt);
                         if (pm != NULL)
                         {
                             emit OnShowPicture(*pm);
                             delete pm;
                         }
                         else
                         {
                             locate(pagelocate());
                         }
                         return;
                     }
                     case eNone:
                         break;
                     default:
         //              qDebug("Unknown linktype");
                         return;
                 }
                 if (m_swapmouse)
                     processmousepositionevent(_e);
                 else
                     processmousewordevent(startpos, startoffset, _e, lineno);
             }
         }
         else
         {
             mouseUpOn = true;
         }
     }
 }
 
 void QTReader::focusInEvent(QFocusEvent* e)
 {
     if (m_autoScroll) timer->start(real_delay(), false);
     update();
 }
 
 void QTReader::focusOutEvent(QFocusEvent* e)
 {
     if (m_autoScroll)
     {
         timer->stop();
         //m_scrolldy1 = m_scrolldy2 = 0;
     }
 }
 
-#include <qapplication.h>
-#include <qdrawutil.h>
 #ifndef _WINDOWS
 #include <unistd.h>
 #endif
 
 void QTReader::goDown()
 {
     if (m_bpagemode)
     {
         dopagedn();
     }
     else
     {
         lineDown();
     }
 }
 
 void QTReader::goUp()
 {
     if (m_bpagemode)
     {
         dopageup();
     }
     else
     {
         lineUp();
     }
 }
 
 void QTReader::NavUp()
 {
     buffdoc.unsuspend();
     if (buffdoc.hasnavigation())
     {
 /*
         size_t target = pagelocate();
         if (buffdoc.back(target))
         {
             locate(target);
         }
 */
         locate(buffdoc.startSection());
     }
     else
     {
         goUp();
     }
 }
 
 void QTReader::NavDown()
 {
     buffdoc.unsuspend();
     if (buffdoc.hasnavigation())
     {
 /*
         size_t target = pagelocate();
         if (buffdoc.forward(target))
         {
             locate(target);
         }
 */
         dopageup(buffdoc.endSection());
     }
     else
     {
         goDown();
     }
 }
 
 void QTReader::zoomin()
 {
     if (m_fontControl.increasesize())
     {
         bool sc = m_autoScroll;
         setfont();
         m_autoScroll = false;
         locate(pagelocate());
         update();
         m_autoScroll = sc;
         if (m_autoScroll) autoscroll();
     }
 }
 
 void QTReader::zoomout()
 {
     if (m_fontControl.decreasesize())
     {
         bool sc = m_autoScroll;
         m_autoScroll = false;
         setfont();
         locate(pagelocate());
         update();
         m_autoScroll = sc;
         if (m_autoScroll) autoscroll();
     }
 }
 
 void QTReader::reduceScroll()
 {
     if (m_delay < 59049)
     {
         m_delay = (3*m_delay)/2;
         timer->changeInterval(real_delay());
     }
     else
     {
         m_delay = 59049;
     }
 }
 
 void QTReader::increaseScroll()
 {
     if (m_delay > 1024)
     {
         m_delay = (2*m_delay)/3;
         timer->changeInterval(real_delay());
     }
     else
     {
         m_delay = 1024;
     }
 }
 
 void QTReader::keyPressEvent(QKeyEvent* e)
 {
     buffdoc.unsuspend();
     ((QTReaderApp*)parent()->parent())->handlekey(e);
 //    e->ignore();
     return;
 #ifdef _SCROLLPIPE
     if (m_isPaused)
     {
         m_isPaused = false;
         if (e->key() != Key_Space)
         {
             m_autoScroll = false;
             if (m_pipeout != NULL)
             {
                 pclose(m_pipeout);
                 m_pipeout = NULL;
             }
             ((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll);
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
         }
         else
         {
             timer->start(real_delay(), false);
         }
         e->accept();
         return;
     }
 #endif
 /*
   switch (e->key())
     {
       case Key_Down:
         {
           e->accept();
           if (m_autoScroll)
           {
               if (m_delay < 59049)
               {
                   m_delay = (3*m_delay)/2;
                   timer->changeInterval(real_delay());
               }
               else
               {
                   m_delay = 59049;
               }
           }
           else
           {
               goDown();
           }
         }
       break;
       case Key_Up:
         {
           e->accept();
           if (m_autoScroll)
           {
               if (m_delay > 1024)
               {
                   m_delay = (2*m_delay)/3;
                   timer->changeInterval(real_delay());
               }
               else
               {
                   m_delay = 1024;
               }
           }
           else
           {
               goUp();
           }
         }
       break;
         case Key_Right:
         {
             e->accept();
             if (m_navkeys && buffdoc.hasnavigation())
             {
                 size_t target = pagelocate();
                 if (buffdoc.forward(target))
                 {
                     locate(target);
                 }
             }
             else zoomin();
         }
         break;
         case Key_Left:
         {
             e->accept();
             if (m_navkeys && buffdoc.hasnavigation())
             {
                 size_t target = pagelocate();
                 if (buffdoc.back(target))
                 {
                     locate(target);
                 }
             }
             else zoomout();
         }
         break;
         default:
             e->ignore();
     }
 */
 }
 
 void QTReader::setautoscroll(bool _sc)
 {
     if (_sc == m_autoScroll) return;
     if (m_autoScroll)
     {
         m_autoScroll = false;
 #ifdef USEQPE
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
 #ifdef _SCROLLPIPE
         if (m_pipeout != NULL)
         {
             pclose(m_pipeout);
             m_pipeout = NULL;
         }
 #endif
      }
     else
     {
         CDrawBuffer* reusebuffer = textarray[numlines];
         if (reusebuffer == NULL || reusebuffer->eof()) return;
         m_autoScroll = true;
 #ifdef _SCROLLPIPE
         if (!m_pipetarget.isEmpty())
         {
         //    qDebug("Opening pipe to %s", (const char*)m_pipetarget);
             m_pipeout = popen((const char*)m_pipetarget, "w");
             m_isPaused = false;
         }
 #endif
         autoscroll();
 #ifdef USEQPE
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Disable; // light is even not dimmed
 #endif
     }
 }
 
 bool QTReader::getline(CDrawBuffer *buff)
 {
     buffdoc.unsuspend();
     if (m_bMonoSpaced)
     {
         return buffdoc.getline(buff ,width(), m_charWidth, m_border);
     }
     else
     {
         return buffdoc.getline(buff, width(), m_border);
     }
 }
 
 void QTReader::doscroll()
 {
     if (!m_autoScroll)
     {
         timer->stop();
         return;
     }
 //    timer->changeInterval(real_delay());
     QPainter p( this );
     QBrush b( white);
     bitBlt(this,0,0,this,0,1,width(),-1);
     qDrawPlainRect(&p,0,height() -  2,width(),2,white,1,&b);
 
     if (++m_scrolldy1 == textarray[0]->lineSpacing())
     {
 #ifdef _SCROLLPIPE
         if (m_pipeout != NULL)
         {
             QString outstr = toQString(textarray[0]->data());
             if (!outstr.isEmpty())
             {
                 fprintf(m_pipeout, "%s\n", (const char*)outstr);
                 fflush(m_pipeout);
             }
             else if (m_pauseAfterEachPara)
             {
                 m_isPaused = true;
                 timer->stop();
             }
         //    write(m_pipeout, (const char*)outstr, outstr.length());
         //    write(m_pipeout, "\n", 1);
         //    fputc(10, m_pipeout);
         }
 #endif
         CDrawBuffer* buff = textarray[0];
         for (int i = 1; i <= numlines; i++)
         {
             textarray[i-1] = textarray[i];
             locnarray[i-1] = locnarray[i];
         }
         textarray[numlines] = buff;
         --numlines;
         m_scrolldy1 = 0;
     }
     if (++m_scrolldy2 == textarray[numlines]->lineSpacing())
     {
         m_scrolldy2 = 0;
         numlines++;
 
         if (textarray[numlines] == NULL)
         {
             textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
         locnarray[numlines] = locate();
         int ch = getline(textarray[numlines]);
         textarray[numlines-1]->render(&p, height() - textarray[numlines-1]->descent() - 2, m_bMonoSpaced, m_charWidth, width(), m_border);
         mylastpos = locate();
         if (!ch)
         {
             m_autoScroll = false;
 #ifdef _SCROLLPIPE
             for (int i = 0; i < numlines; i++)
             {
                 if (m_pipeout != NULL)
                 {
                     QString outstr = toQString(textarray[i]->data());
                     if (!outstr.isEmpty())
                     {
                         fprintf(m_pipeout, "%s\n", (const char*)outstr);
                         fflush(m_pipeout);
                     }
                 }
             }
 #endif
             ((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll);
 #ifdef USEQPE
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
         }
         emit OnRedraw();
     }
 }
 
 void QTReader::autoscroll()
 {
     timer->start(real_delay(), false);
 }
 
 void QTReader::setfont()
 {
 //    m_fontControl.Change
     m_charWidth = (m_charpc*m_fontControl.currentsize())/100;
     if (m_charWidth <= 0) m_charWidth = 1;
     m_ascent = m_fontControl.ascent();
     m_descent = m_fontControl.descent();
     m_linespacing = m_fontControl.lineSpacing();
 }
 
 void QTReader::drawFonts( QPainter *p )
 {
     if (bDoUpdates)
     {
         //qDebug("How refreshing...");
         if (buffdoc.empty()) return;
diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp
index 07af597..e759249 100644
--- a/noncore/apps/opie-reader/QTReaderApp.cpp
+++ b/noncore/apps/opie-reader/QTReaderApp.cpp
@@ -1,4222 +1,4221 @@
-/**********************************************************************

-** Copyright (C) 2000 Trolltech AS.  Allrights reserved.

-**

-** This file is part of Qt Palmtop Environment.

-**

-** This file may be distributed and/or modified under the terms of the

-** GNU General Public License version 2 as published by the Free Software

-** Foundation and appearing in the file LICENSE.GPL included in the

-** packaging of this file.

-**

-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

-**

-** See http://www.trolltech.com/gpl/ for GPL licensing information.

-**

-** Contact info@trolltech.com if any conditions of this licensing are

-** not clear to you.

-**

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

-#include "useqpe.h"

-#include <qregexp.h>

-#include <qclipboard.h>

-#include <qwidgetstack.h>

-#ifdef USEQPE

-#include <qmenubar.h>

-#include <qpe/qpetoolbar.h>

-#endif

-#include <qmenubar.h>

-#include <qtoolbar.h>

-#ifdef USEQPE

-#include <qpe/menubutton.h>

-#include <qpe/fontdatabase.h>

-#endif

-#include <qcombobox.h>

-#include <qpopupmenu.h>

-#include <qaction.h>

-#include <qapplication.h>

-#include <qlineedit.h>

-#include <qtoolbutton.h>

-#include <qspinbox.h>

-#include <qobjectlist.h>

-#ifdef USEQPE

-#include <qpe/global.h>

-#include <qpe/applnk.h>

-#endif

-#include <qfileinfo.h>

-#include <stdlib.h> //getenv

-#include <qprogressbar.h>

-#ifdef USEQPE

-#include <qpe/config.h>

-#endif

-#include <qbuttongroup.h>

-#include <qradiobutton.h>

-#ifdef USEQPE

-#include <qpe/qcopenvelope_qws.h>

-#endif

-#include "QTReader.h"

-#include "GraphicWin.h"

-#include "Bkmks.h"

-#include "cbkmkselector.h"

-#include "infowin.h"

-#include "ToolbarPrefs.h"

-#include "Prefs.h"

-#include "CAnnoEdit.h"

-#include "QFloatBar.h"

-#include "FixedFont.h"

-#include "URLDialog.h"

-//#include <qpe/fontdatabase.h>

-

-#ifdef USEQPE

-#include <qpe/resource.h>

-#include <qpe/qpeapplication.h>

-#include "fileBrowser.h"

-#else

-#include "qfiledialog.h"

-#endif

-

-#include "QTReaderApp.h"

-#include "CDrawBuffer.h"

-#include "Filedata.h"

-#include "opie.h"

-#include "useqpe.h"

-#include "names.h"

-#include "CEncoding_tables.h"

-#include "CloseDialog.h"

-

-bool CheckVersion(int&, int&, char&);

-

-#ifdef _WINDOWS

-#define PICDIR "c:\\uqtreader\\pics\\"

-#else

-#ifdef USEQPE

-#define PICDIR "opie-reader/"

-#else

-#define PICDIR "/home/tim/uqtreader/pics/"

-#endif

-#endif

-

-unsigned long QTReaderApp::m_uid = 0;

-

-void QTReaderApp::setScrollState(bool _b) { m_scrollButton->setOn(_b); }

-

-#ifdef USEQPE

-#define geticon(iconname) Resource::loadPixmap( iconname )

-#define getmyicon(iconname) Resource::loadPixmap( PICDIR iconname )

-#else

-#define geticon(iconname) QPixmap(PICDIR iconname ".png")

-#define getmyicon(iconname) geticon(iconname)

-//#define geticon(iconname) QIconSet( QPixmap(PICDIR iconname) )

-#endif

-

-#ifndef _WINDOWS

-#include <unistd.h>

-#endif

-#include <stddef.h>

-#ifndef _WINDOWS

-#include <dirent.h>

-#endif

-

-void QTReaderApp::listBkmkFiles()

-{

-    bkmkselector->clear();

-    bkmkselector->setText("Cancel");

-#ifndef USEQPE

-    int cnt = 0;

-

-    QDir d = QDir::home();                      // "/"

-    if ( !d.cd(APPDIR) ) {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-                d = QDir::home();

-                d.mkdir(APPDIR);

-                d.cd(APPDIR);

-    }

-

-

-

-

-        d.setFilter( QDir::Files | QDir::NoSymLinks );

-//        d.setSorting( QDir::Size | QDir::Reversed );

-

-        const QFileInfoList *list = d.entryInfoList();

-        QFileInfoListIterator it( *list );      // create list iterator

-        QFileInfo *fi;                          // pointer for traversing

-

-        while ( (fi=it.current()) ) {           // for each file...

-

-                    bkmkselector->insertItem(fi->fileName());

-                    cnt++;

-

-                        //qDebug( "%10li %s", fi->size(), fi->fileName().data() );

-            ++it;                               // goto next list element

-        }

-

-#else /* USEQPE */

-    int cnt = 0;

-    DIR *d;

-    d = opendir((const char *)Global::applicationFileName(APPDIR,""));

-

-    while(1)

-    {

-        struct dirent* de;

-        struct stat buf;

-        de = readdir(d);

-        if (de == NULL) break;

-

-        if (lstat((const char *)Global::applicationFileName(APPDIR,de->d_name),&buf) == 0 && S_ISREG(buf.st_mode))

-        {

-            bkmkselector->insertItem(de->d_name);

-            cnt++;

-        }

-    }

-

-    closedir(d);

-#endif

-    if (cnt > 0)

-      {

-//tjw        menu->hide();

-        editorStack->raiseWidget( bkmkselector );

-        hidetoolbars();

-        m_nBkmkAction = cRmBkmkFile;

-      }

-    else

-      QMessageBox::information(this, PROGNAME, "No bookmark files");

-}

-

-void QTReaderApp::hidetoolbars()

-{

-    menubar->hide();

-    if (fileBar != NULL) fileBar->hide();

-    if (viewBar != NULL) viewBar->hide();

-    if (navBar != NULL) navBar->hide();

-    if (markBar != NULL) markBar->hide();

-    if (m_fontVisible) m_fontBar->hide();

-    if (regVisible)

-    {

-#ifdef USEQPE

-                Global::hideInputMethod();

-#endif

-        regBar->hide();

-    }

-    if (searchVisible)

-    {

-#ifdef USEQPE

-                Global::hideInputMethod();

-#endif

-        searchBar->hide();

-    }

-}

-

-QTReaderApp::QTReaderApp( QWidget *parent, const char *name, WFlags f )

-    : QMainWindow( parent, name, f ), bFromDocView( FALSE ), m_dontSave(false),

-      fileBar(NULL), navBar(NULL), viewBar(NULL), markBar(NULL)

-{

-        m_url_clipboard = false;

-        m_url_localfile = false;

-        m_url_globalfile = false;

-                ftime(&m_lastkeytime);

-////  qDebug("Application directory = %s", (const tchar *)QPEApplication::documentDir());

-////  qDebug("Application directory = %s", (const tchar *)Global::applicationFileName("uqtreader","bkmks.xml"));

-

-    m_bcloseDisabled = true;

-    m_disableesckey = false;

-    pBkmklist = NULL;

-    pOpenlist = NULL;

-//    doc = 0;

-

-        m_fBkmksChanged = false;

-    

-  QString lang = getenv( "LANG" );

-  QString rot = getenv( "QWS_DISPLAY" );

-

-/*

-  int m_rot = 0;

-  if (rot.contains("Rot90"))

-  {

-      m_rot = 90;

-  }

-  else if (rot.contains("Rot180"))

-  {

-      m_rot = 180;

-  }

-  else if (rot.contains("Rot270"))

-  {

-      m_rot = 270;

-  }

-

-//  qDebug("Initial Rotation(%d):%s", m_rot, (const char*)rot);

-*/

-  m_autogenstr = "^ *[A-Z].*[a-z] *$";

-

-#ifdef USEQPE

-    setIcon( Resource::loadPixmap( PICDIR  "uqtreader") );

-#else

-    setIcon( QPixmap (PICDIR  "uqtreader.png") );

-#endif /* USEQPE */

-

-//    QToolBar *bar = new QToolBar( this );

-//    menubar = new QToolBar( this );

-#ifdef USEQPE

-  Config config( APPDIR );

-#else

-    QDir d = QDir::home();                      // "/"

-    if ( !d.cd(APPDIR) ) {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-                d = QDir::home();

-                d.mkdir(APPDIR);

-                d.cd(APPDIR);

-    }

-    QFileInfo fi(d, INIFILE);

-//    qDebug("Path:%s", (const char*)fi.absFilePath());

-    Config config(fi.absFilePath());

-#endif

-    config.setGroup("Toolbar");

-    m_tbmovesave = m_tbmove = config.readBoolEntry("Movable", false);

-    m_tbpolsave = m_tbpol = (ToolbarPolicy)config.readNumEntry("Policy", 1);

-    m_tbposition = (ToolBarDock)config.readNumEntry("Position", 2);

-    menubar = new QToolBar("Menus", this, m_tbposition);

-

-//    fileBar = new QToolBar("File", this);

-//    QToolBar* viewBar = new QToolBar("File", this);

-//    QToolBar* navBar = new QToolBar("File", this);

-//    QToolBar* markBar = new QToolBar("File", this);

-

-#ifdef USEQPE

-    mb = new QMenuBar( menubar );

-#else

-    mb = new QMenuBar( menubar );

-#endif

-

-//#ifdef USEQPE

-    QPopupMenu* tmp = new QPopupMenu(mb);

-    mb->insertItem( geticon( "AppsIcon" ), tmp );

-//#else

-//    QMenuBar* tmp = mb;

-//#endif

-

-    QPopupMenu *file = new QPopupMenu( mb );

-    tmp->insertItem( tr( "File" ), file );

-

-    QPopupMenu *navigation = new QPopupMenu(mb);

-    tmp->insertItem( tr( "Navigation" ), navigation );

-

-    QPopupMenu *view = new QPopupMenu( mb );

-    tmp->insertItem( tr( "View" ), view );

-

-    QPopupMenu *marks = new QPopupMenu( this );

-    tmp->insertItem( tr( "Marks" ), marks );

-

-    QPopupMenu *settings = new QPopupMenu( this );

-    tmp->insertItem( tr( "Settings" ), settings );

-

-//    addToolBar(menubar, "Menus",QMainWindow::Top);

-//    addToolBar(fileBar, "Toolbar",QMainWindow::Top);

-

-    //    QPopupMenu *edit = new QPopupMenu( this );

-

-    /*

-    QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) );

-    a->addTo( bar );

-    a->addTo( file );

-    */

-

-    editorStack = new QWidgetStack( this );

-    setCentralWidget( editorStack );

-

-    searchVisible = FALSE;

-    regVisible = FALSE;

-    m_fontVisible = false;

-

-    m_annoWin = new CAnnoEdit(editorStack);

-    editorStack->addWidget(m_annoWin, get_unique_id());

-    connect( m_annoWin, SIGNAL( finished(const QString&, const QString&) ), this, SLOT( addAnno(const QString&, const QString&) ) );

-    connect( m_annoWin, SIGNAL( cancelled() ), this, SLOT( infoClose() ) );

-

-    m_infoWin = new infowin(editorStack);

-    editorStack->addWidget(m_infoWin, get_unique_id());

-    connect( m_infoWin, SIGNAL( Close() ), this, SLOT( infoClose() ) );

-

-    m_graphicwin = new GraphicWin(editorStack);

-    editorStack->addWidget(m_graphicwin, get_unique_id());

-    connect( m_graphicwin, SIGNAL( Closed() ), this, SLOT( infoClose() ) );

-

-//    bkmkselector = new QListBox(editorStack, "Bookmarks");

-    bkmkselector = new CBkmkSelector(editorStack, "Bookmarks");

-    //    connect(bkmkselector, SIGNAL( selected(const QString&) ), this, SLOT( gotobkmk(const QString&) ) );

-    connect(bkmkselector, SIGNAL( selected(int) ), this, SLOT( gotobkmk(int) ) );

-    connect(bkmkselector, SIGNAL( cancelled() ), this, SLOT( cancelbkmk() ) );

-    editorStack->addWidget( bkmkselector, get_unique_id() );

-

-/*

-    importSelector = new FileSelector( "*", editorStack, "importselector", false );

-    connect( importSelector, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( importFile( const DocLnk & ) ) );

-

-    editorStack->addWidget( importSelector, get_unique_id() );

-

-    // don't need the close visible, it is redundant...

-    importSelector->setCloseVisible( FALSE );

-*/    

-//    qDebug("Reading file list");

-    readfilelist();

-

-    reader = new QTReader( editorStack );

-

-    reader->bDoUpdates = false;

-

-#ifdef USEQPE

-    ((QPEApplication*)qApp)->setStylusOperation(reader, QPEApplication::RightOnHold);

-#endif

-

-//    qDebug("Reading config");

-//  Config config( APPDIR );

-  config.setGroup( "View" );

-  m_debounce = config.readNumEntry("Debounce", 0);

-#ifdef USEQPE

-  m_bFloatingDialog = config.readBoolEntry("FloatDialogs", false);

-#else

-  m_bFloatingDialog = config.readBoolEntry("FloatDialogs", true);

-#endif

-  reader->bstripcr = config.readBoolEntry( "StripCr", true );

-  reader->bfulljust = config.readBoolEntry( "FullJust", false );

-  reader->setextraspace(config.readNumEntry( "ExtraSpace", 0 ));

-  reader->setlead(config.readNumEntry( "ExtraLead", 0 ));

-  reader->btextfmt = config.readBoolEntry( "TextFmt", false );

-  reader->bautofmt = config.readBoolEntry( "AutoFmt", true );

-  reader->bstriphtml = config.readBoolEntry( "StripHtml", false );

-  reader->bpeanut = config.readBoolEntry( "Peanut", false );

-  reader->bdehyphen = config.readBoolEntry( "Dehyphen", false );

-  reader->bdepluck = config.readBoolEntry( "Depluck", false );

-  reader->bdejpluck = config.readBoolEntry( "Dejpluck", false );

-  reader->bonespace = config.readBoolEntry( "OneSpace", false );

-  reader->bunindent = config.readBoolEntry( "Unindent", false );

-  reader->brepara = config.readBoolEntry( "Repara", false );

-  reader->bdblspce = config.readBoolEntry( "DoubleSpace", false );

-  reader->bindenter = config.readNumEntry( "Indent", 0 );

-  reader->m_textsize = config.readNumEntry( "FontSize", 12 );

-  reader->m_delay = config.readNumEntry( "ScrollDelay", 5184);

-  reader->m_lastfile = config.readEntry( "LastFile", QString::null );

-  reader->m_lastposn = config.readNumEntry( "LastPosn", 0 );

-  reader->m_bpagemode = config.readBoolEntry( "PageMode", true );

-  reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false);

-  reader->m_swapmouse = config.readBoolEntry( "SwapMouse", false);

-  reader->m_fontname = config.readEntry( "Fontname", "helvetica" );

-  reader->m_encd = config.readNumEntry( "Encoding", 0 );

-  reader->m_charpc = config.readNumEntry( "CharSpacing", 100 );

-  reader->m_overlap = config.readNumEntry( "Overlap", 0 );

-  reader->m_border = config.readNumEntry( "Margin", 6 );

-#ifdef REPALM

-  reader->brepalm = config.readBoolEntry( "Repalm", true );

-#endif

-  reader->bremap = config.readBoolEntry( "Remap", true );

-  reader->bmakebold = config.readBoolEntry( "MakeBold", false );

-  reader->setContinuous(config.readBoolEntry( "Continuous", true ));

-  m_targetapp = config.readEntry( "TargetApp", QString::null );

-  m_targetmsg = config.readEntry( "TargetMsg", QString::null );

-#ifdef _SCROLLPIPE

-  reader->m_pipetarget = config.readEntry( "PipeTarget", QString::null );

-  reader->m_pauseAfterEachPara = config.readBoolEntry( "PauseAfterPara", true );

-#endif

-  m_twoTouch = config.readBoolEntry( "TwoTouch", false);

-  m_doAnnotation = config.readBoolEntry( "Annotation", false);

-  m_doDictionary = config.readBoolEntry( "Dictionary", false);

-  m_doClipboard = config.readBoolEntry( "Clipboard", false);

-  m_spaceTarget = (ActionTypes)config.readNumEntry("SpaceTarget", cesAutoScroll);

-  m_escapeTarget = (ActionTypes)config.readNumEntry("EscapeTarget", cesNone);

-  m_returnTarget = (ActionTypes)config.readNumEntry("ReturnTarget", cesFullScreen);

-  m_leftTarget = (ActionTypes)config.readNumEntry("LeftTarget", cesZoomOut);

-  m_rightTarget = (ActionTypes)config.readNumEntry("RightTarget", cesZoomIn);

-  m_upTarget = (ActionTypes)config.readNumEntry("UpTarget", cesPageUp);

-  m_downTarget = (ActionTypes)config.readNumEntry("DownTarget", cesPageDown);

-

-  m_leftScroll = config.readBoolEntry("LeftScroll", false);

-  m_rightScroll = config.readBoolEntry("RightScroll", false);

-  m_upScroll = config.readBoolEntry("UpScroll", true);

-  m_downScroll = config.readBoolEntry("DownScroll", true);

-

-  m_propogatefontchange = config.readBoolEntry( "RequestorFontChange", false);

-  reader->setBaseSize(config.readNumEntry( "Basesize", 10 ));

-

-#ifndef USEQPE

-        config.setGroup( "Geometry" );

-        setGeometry(0,0,

-        config.readNumEntry( "width", QApplication::desktop()->width()/2 ),

-        config.readNumEntry( "height", QApplication::desktop()->height()/2 ));

-        move(

-        config.readNumEntry( "x", 20 ),

-        config.readNumEntry( "y", 20 ));

-#endif

-

-

-

-  setTwoTouch(m_twoTouch);

-

-    connect( reader, SIGNAL( OnShowPicture(QImage&) ), this, SLOT( showgraphic(QImage&) ) );

-

-    connect( reader, SIGNAL( OnRedraw() ), this, SLOT( OnRedraw() ) );

-    connect( reader, SIGNAL( OnWordSelected(const QString&, size_t, const QString&) ), this, SLOT( OnWordSelected(const QString&, size_t, const QString&) ) );

-    connect( reader, SIGNAL( OnURLSelected(const QString&) ), this, SLOT( OnURLSelected(const QString&) ) );

-    editorStack->addWidget( reader, get_unique_id() );

-

-    m_preferences_action = new QAction( tr( "Configuration" ), geticon( "SettingsIcon" ), QString::null, 0, this, NULL);

-    connect( m_preferences_action, SIGNAL( activated() ), this, SLOT( showprefs() ) );

-    m_preferences_action->addTo( settings );

-

-    m_saveconfig_action = new QAction( tr( "Save Config" ), QString::null, 0, this, NULL);

-    connect( m_saveconfig_action, SIGNAL( activated() ), this, SLOT( SaveConfig() ) );

-    m_saveconfig_action->addTo( settings );

-

-    m_loadconfig_action = new QAction( tr( "Load Config" ), QString::null, 0, this, NULL);

-    connect( m_loadconfig_action, SIGNAL( activated() ), this, SLOT( LoadConfig() ) );

-    m_loadconfig_action->addTo( settings );

-

-    m_tidyconfig_action = new QAction( tr( "Delete Config" ), QString::null, 0, this, NULL);

-    connect( m_tidyconfig_action, SIGNAL( activated() ), this, SLOT( TidyConfig() ) );

-    m_tidyconfig_action->addTo( settings );

-

-    settings->insertSeparator();

-    m_toolbarprefs_action = new QAction( tr( "Toolbars" ), QString::null, 0, this, NULL);

-    connect( m_toolbarprefs_action, SIGNAL( activated() ), this, SLOT( showtoolbarprefs() ) );

-    m_toolbarprefs_action->addTo( settings );

-

-    m_open_action = new QAction( tr( "Open" ), geticon( "fileopen" ), QString::null, 0, this, 0 );

-    connect( m_open_action, SIGNAL( activated() ), this, SLOT( fileOpen() ) );

-    m_open_action->addTo( file );

-

-    m_close_action = new QAction( tr( "Close" ), geticon( "close" ), QString::null, 0, this, 0 );

-    connect( m_close_action, SIGNAL( activated() ), this, SLOT( fileClose() ) );

-    m_close_action->addTo( file );

-

-#ifdef _SCRIPT

-    a = new QAction( tr( "Run Script" ), QString::null, 0, this, NULL);

-    connect( a, SIGNAL( activated() ), this, SLOT( RunScript() ) );

-    a->addTo( file );

-#endif

-    /*

-    a = new QAction( tr( "Revert" ), geticon( "close" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( fileRevert() ) );

-    a->addTo( file );

-

-    a = new QAction( tr( "Cut" ), geticon( "cut" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) );

-    a->addTo( filebar() );

-    a->addTo( edit );

-    */

-

-    m_info_action = new QAction( tr( "Info" ), geticon( "UtilsIcon" ), QString::null, 0, this, NULL);

-    connect( m_info_action, SIGNAL( activated() ), this, SLOT( showinfo() ) );

-    m_info_action->addTo( file );

-

-    m_touch_action = new QAction( tr( "Two/One Touch" ), geticon( "1to1" ), QString::null, 0, this, NULL, true );

-    connect( m_touch_action, SIGNAL( toggled(bool) ), this, SLOT( setTwoTouch(bool) ) );

-    m_touch_action->setOn(m_twoTouch);

-    m_touch_action->addTo( file );

-

-    m_find_action = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, NULL);

-     connect( m_find_action, SIGNAL( activated() ), this, SLOT( editFind() ) );

-     file->insertSeparator();

-//     a->addTo( bar );

-     m_find_action->addTo( file );

-

-    m_exportlinks_action = new QAction( tr( "Export Links" ), QString::null, 0, this, NULL);

-    connect( m_exportlinks_action, SIGNAL( activated() ), this, SLOT( ExportLinks() ) );

-    m_exportlinks_action->addTo( file );

-

-    m_scrollButton = new QAction( tr( "Scroll" ), getmyicon( "panel-arrow-down" ), QString::null, 0, this, 0, true );

-    connect( m_scrollButton, SIGNAL( toggled(bool) ), this, SLOT( autoScroll(bool) ) );

-    m_scrollButton->addTo(navigation);

-    m_scrollButton->setOn(false);

-

-    m_start_action = new QAction( tr( "Goto Start" ), geticon( "start" ), QString::null, 0, this, NULL);

-    connect( m_start_action, SIGNAL( activated() ), this, SLOT( gotoStart() ) );

-    m_start_action->addTo(navigation);

-

-    m_end_action = new QAction( tr( "Goto End" ), geticon( "finish" ), QString::null, 0, this, NULL);

-    connect( m_end_action, SIGNAL( activated() ), this, SLOT( gotoEnd() ) );

-    m_end_action->addTo(navigation);

-

-    m_jump_action = new QAction( tr( "Jump" ), geticon( "rotate" ), QString::null, 0, this, NULL);

-    connect( m_jump_action, SIGNAL( activated() ), this, SLOT( jump() ) );

-    m_jump_action->addTo(navigation);

-

-    m_pageline_action = new QAction( tr( "Page/Line Scroll" ), geticon( "pass" ), QString::null, 0, this, NULL, true );

-    connect( m_pageline_action, SIGNAL( toggled(bool) ), this, SLOT( pagemode(bool) ) );

-    m_pageline_action->addTo(navigation);

-    m_pageline_action->setOn(reader->m_bpagemode);

-

-    m_pageup_action = new QAction( tr( "Up" ), geticon( "up" ), QString::null, 0, this, 0 );

-    connect( m_pageup_action, SIGNAL( activated() ), this, SLOT( pageup() ) );

-    m_pageup_action->addTo( navigation );

-    

-    m_pagedn_action = new QAction( tr( "Down" ), geticon( "down" ), QString::null, 0, this, 0 );

-    connect( m_pagedn_action, SIGNAL( activated() ), this, SLOT( pagedn() ) );

-    m_pagedn_action->addTo( navigation );

-

-    m_back_action = new QAction( tr( "Back" ), geticon( "back" ), QString::null, 0, this, 0 );

-    connect( m_back_action, SIGNAL( activated() ), reader, SLOT( goBack() ) );

-    m_back_action->addTo( navigation );

-

-    m_home_action = new QAction( tr( "Home" ), geticon( "home" ), QString::null, 0, this, 0 );

-    connect( m_home_action, SIGNAL( activated() ), reader, SLOT( goHome() ) );

-    m_home_action->addTo( navigation );

-

-    m_forward_action = new QAction( tr( "Forward" ), geticon( "forward" ), QString::null, 0, this, 0 );

-    connect( m_forward_action, SIGNAL( activated() ), reader, SLOT( goForward() ) );

-    m_forward_action->addTo( navigation );

-

-    /*

-    a = new QAction( tr( "Find" ), QString::null, 0, this, NULL, true );

-    //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );

-    a->addTo( file );

-

-    a = new QAction( tr( "Find Again" ), QString::null, 0, this, NULL, true );

-    //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );

-    a->addTo( file );

-    */

-

-//    file->insertSeparator();

-

-#ifdef _SCROLLPIPE

-

-    QActionGroup* ag = new QActionGroup(this);

-    ag->setExclusive(false);

-    spacemenu = new QPopupMenu(this);

-    file->insertItem( tr( "Scrolling" ), spacemenu );

-

-    a = new QAction( tr( "Set Target" ), QString::null, 0, ag, NULL);

-    connect( a, SIGNAL( activated() ), this, SLOT( setpipetarget() ) );

-

-    a = new QAction( tr( "Pause Paras" ), QString::null, 0, ag, NULL, true );

-    connect( a, SIGNAL( toggled(bool) ), this, SLOT( setpause(bool) ) );

-    a->setOn(reader->m_pauseAfterEachPara);

-

-    ag->addTo(spacemenu);

-//    file->insertSeparator();

-

-#endif

-

-/*

-    a = new QAction( tr( "Import" ), QString::null, 0, this, NULL );

-    connect( a, SIGNAL( activated() ), this, SLOT( importFiles() ) );

-    a->addTo( file );

-*/

-

-    /*

-    a = new QAction( tr( "Paste" ), geticon( "paste" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) );

-    a->addTo( fileBar );

-    a->addTo( edit );

-    */

-

-//     a = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, 0 );

-

-     m_fullscreen = false;

-    m_actFullscreen = new QAction( tr( "Fullscreen" ), geticon( "fullscreen" ), QString::null, 0, this, NULL, true );

-    connect( m_actFullscreen, SIGNAL( toggled(bool) ), this, SLOT( setfullscreen(bool) ) );

-    m_actFullscreen->setOn(m_fullscreen);

-    m_actFullscreen->addTo( view );

-

-    view->insertSeparator();

-

-    m_zoomin_action = new QAction( tr( "Zoom In" ), geticon( "zoom" ), QString::null, 0, this);

-    connect( m_zoomin_action, SIGNAL( activated() ), this, SLOT( zoomin() ) );

-    m_zoomin_action->addTo( view );

-

-    m_zoomout_action = new QAction( tr( "Zoom Out" ), geticon( "mag" ), QString::null, 0, this);

-    connect( m_zoomout_action, SIGNAL( activated() ), this, SLOT( zoomout() ) );

-    m_zoomout_action->addTo( view );

-

-    view->insertSeparator();

-    m_setfont_action = new QAction( tr( "Set Font" ), getmyicon( "font" ), QString::null, 0, this);

-    connect( m_setfont_action, SIGNAL( activated() ), this, SLOT( setfont() ) );

-    m_setfont_action->addTo( view );

-

-    view->insertSeparator();

-    m_setenc_action = new QAction( tr( "Set Encoding" ), getmyicon( "charset" ), QString::null, 0, this);

-    connect( m_setenc_action, SIGNAL( activated() ), this, SLOT( chooseencoding() ) );

-    m_setenc_action->addTo( view );

-

-    m_setmono_action = new QAction( tr( "Ideogram" ), getmyicon( "ideogram" ), QString::null, 0, this, NULL, true);

-    connect( m_setmono_action, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );

-    m_setmono_action->addTo( view );

-    m_setmono_action->setOn(reader->m_bMonoSpaced);

-

-

-    //    a = new QAction( tr( "Zoom" ), QString::null, 0, this, NULL, true );

-    //    a = new QAction( tr( "Zoom" ), geticon( "mag" ), QString::null, 0, this, 0 );

-

-

-

-    //    a->addTo( filebar() );

-//     view->insertSeparator();

-

-/*

-    a = new QAction( tr( "Ideogram/Word" ), QString::null, 0, this, NULL, true );

-    connect( a, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );

-    a->setOn(reader->m_bMonoSpaced);

-    a->addTo( view );

-*/

-/*

-    a = new QAction( tr( "Set Width" ), QString::null, 0, this, NULL);

-    connect( a, SIGNAL( activated() ), this, SLOT( setspacing() ) );

-    a->addTo( view );

-*/

-

-    m_mark_action = new QAction( tr( "Bookmark" ), getmyicon( "bookmark" ), QString::null, 0, this, NULL);

-    connect( m_mark_action, SIGNAL( activated() ), this, SLOT( addbkmk() ) );

-    m_mark_action->addTo( marks );

-

-    m_annotate_action = new QAction( tr( "Annotate" ), getmyicon( "annotate" ), QString::null, 0, this, NULL);

-    connect( m_annotate_action, SIGNAL( activated() ), this, SLOT( addanno() ) );

-    m_annotate_action->addTo( marks );

-

-    m_goto_action = new QAction( tr( "Goto" ), getmyicon( "bookmark_goto" ), QString::null, 0, this, NULL, false );

-    connect( m_goto_action, SIGNAL( activated() ), this, SLOT( do_gotomark() ) );

-    m_goto_action->addTo( marks );

-

-    m_delete_action = new QAction( tr( "Delete" ), getmyicon( "bookmark_delete" ), QString::null, 0, this, NULL);

-    connect( m_delete_action, SIGNAL( activated() ), this, SLOT( do_delmark() ) );

-    m_delete_action->addTo( marks );

-

-    m_autogen_action = new QAction( tr( "Autogen" ), geticon( "exec" ), QString::null, 0, this, NULL, false );

-    connect( m_autogen_action, SIGNAL( activated() ), this, SLOT( do_autogen() ) );

-     marks->insertSeparator();

-    m_autogen_action->addTo( marks );

-

-    m_clear_action = new QAction( tr( "Clear" ), getmyicon( "bookmark_clear" ), QString::null, 0, this, NULL);

-    connect( m_clear_action, SIGNAL( activated() ), this, SLOT( clearBkmkList() ) );

-    m_clear_action->addTo( marks );

-

-    m_save_action = new QAction( tr( "Save" ), getmyicon( "bookmark_save" ), QString::null, 0, this, NULL );

-    connect( m_save_action, SIGNAL( activated() ), this, SLOT( savebkmks() ) );

-    m_save_action->addTo( marks );

-

-    m_tidy_action = new QAction( tr( "Tidy" ), getmyicon( "bookmark_tidy" ), QString::null, 0, this, NULL);

-    connect( m_tidy_action, SIGNAL( activated() ), this, SLOT( listBkmkFiles() ) );

-     marks->insertSeparator();

-    m_tidy_action->addTo( marks );

-

-    m_startBlock_action = new QAction( tr( "Start Block" ), geticon( "new" ), QString::null, 0, this, NULL);

-    connect( m_startBlock_action, SIGNAL( activated() ), this, SLOT( editMark() ) );

-    marks->insertSeparator();

-    m_startBlock_action->addTo( marks );

-

-    m_endBlock_action = new QAction( tr( "Copy Block" ), geticon( "copy" ), QString::null, 0, this, NULL);

-    connect( m_endBlock_action, SIGNAL( activated() ), this, SLOT( editCopy() ) );

-    m_endBlock_action->addTo( marks );

-

-    m_bkmkAvail = NULL;

-

-

-    setToolBarsMovable(m_tbmove);

-    addtoolbars(&config);

-

-    pbar = new QProgressBar(this);

-    pbar->hide();

-

-    searchBar = new QFloatBar( "Search", this, QMainWindow::Top, TRUE );

-

-    searchBar->setHorizontalStretchable( TRUE );

-

-    connect(searchBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));

-

-    searchEdit = new QLineEdit( searchBar, "searchEdit" );

-//      QFont f("unifont", 16 /*, QFont::Bold*/);

-//      searchEdit->setFont( f );

-    searchBar->setStretchableWidget( searchEdit );

-

-

-#ifdef __ISEARCH

-    connect( searchEdit, SIGNAL( textChanged( const QString & ) ),

-             this, SLOT( search( const QString& ) ) );

-#else

-    connect( searchEdit, SIGNAL( returnPressed( ) ),

-             this, SLOT( search( ) ) );

-#endif

-     QAction*a = new QAction( tr( "Find Next" ), geticon( "next" ), QString::null, 0, this, 0 );

-     connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );

-     a->addTo( searchBar );

-

-    a = new QAction( tr( "Close Find" ), geticon( "close" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) );

-    a->addTo( searchBar );

-

-    searchBar->hide();

-

-    regBar = new QFloatBar( "Autogen", this, QMainWindow::Top, TRUE );

-    connect(regBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));

-

-    regBar->setHorizontalStretchable( TRUE );

-

-    regEdit = new QLineEdit( regBar, "regEdit" );

-//    regEdit->setFont( f );

-

-    regBar->setStretchableWidget( regEdit );

-

-    connect( regEdit, SIGNAL( returnPressed( ) ),

-             this, SLOT( do_regaction() ) );

-

-    a = new QAction( tr( "Do Reg" ), geticon( "enter" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( do_regaction() ) );

-    a->addTo( regBar );

-

-    a = new QAction( tr( "Close Edit" ), geticon( "close" ), QString::null, 0, this, 0 );

-    connect( a, SIGNAL( activated() ), this, SLOT( regClose() ) );

-    a->addTo( regBar );

-

-    regBar->hide();

-

-    m_fontBar = new QToolBar( "Autogen", this, QMainWindow::Top, TRUE );

-

-    m_fontBar->setHorizontalStretchable( TRUE );

-

-//    qDebug("Font selector");

-    m_fontSelector = new QComboBox(false, m_fontBar);

-    m_fontBar->setStretchableWidget( m_fontSelector );

-    {

-#ifndef USEQPE

-        QFontDatabase f;

-#else

-        FontDatabase f;

-#endif

-        QStringList flist = f.families();

-        bool realfont = false;

-        for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)

-        {

-            if (reader->m_fontname == *nm)

-            {

-                realfont = true;

-            }

-            if ((*nm).contains(FIXEDFONT,false)) reader->m_fontControl.hasCourier(true, *nm);

-        }

-        if (!realfont) reader->m_fontname = flist[0];

-    } // delete the FontDatabase!!!

-    connect( m_fontSelector, SIGNAL( activated(const QString& ) ),

-             this, SLOT( do_setfont(const QString&) ) );

-    connect( m_fontSelector, SIGNAL( activated(int ) ),

-             this, SLOT( do_setencoding(int) ) );

-

-    m_fontBar->hide();

-    m_fontVisible = false;

-#ifdef USEMSGS

-    connect(qApp, SIGNAL( appMessage(const QCString&, const QByteArray& ) ),

-             this, SLOT( msgHandler(const QCString&, const QByteArray&) ) );

-#endif

-//    qDebug("Initing");

-  reader->init();

-//    qDebug("Inited");

-//    m_buttonAction[m_spaceTarget]->setOn(true);

-//    qDebug("fonting");

-    do_setfont(reader->m_fontname);

-    if (!reader->m_lastfile.isEmpty())

-    {

-        //qDebug("doclnk");

-        //doc = new DocLnk(reader->m_lastfile);

-        //qDebug("doclnk done");

-        if (pOpenlist != NULL)

-        {

-

-/*

-            int ind = 0;

-            Bkmk* p = (*pOpenlist)[ind];

-            while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)

-            {

-                p = (*pOpenlist)[++ind];

-            }

-*/

-            Bkmk* p = NULL;

-            for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)

-            {

-                p = iter.pContent();

-                if (toQString(CFiledata(p->anno()).name()) == reader->m_lastfile)

-                {

-                    break;

-                }

-        //      qDebug("Item:%s", (const char*)toQString(CFiledata(p->anno()).name()));

-                p = NULL;

-            }

-            if (p != NULL)

-            {

-        //qDebug("openfrombkmk");

-                if (!openfrombkmk(p))

-                    showEditTools();

-            }

-            else

-            {

-        //qDebug("openfile");

-                openFile( reader->m_lastfile );

-            }

-        }

-        else

-        {

-        //    qDebug("Openfile 2");

-            if (!reader->m_lastfile.isEmpty())

-                openFile( reader->m_lastfile );

-        }

-    }

-    else

-    {

-      showEditTools();

-    }

-//    qApp->processEvents();

-    reader->bDoUpdates = true;

-    reader->update();

-    config.setGroup("Version");

-    int major = config.readNumEntry("Major", 0);

-    int bkmktype = config.readNumEntry("BkmkType", 0);

-    char minor = config.readNumEntry("Minor", 0);

-    if (CheckVersion(major, bkmktype, minor))

-    {

-        config.writeEntry("Major", major);

-        config.writeEntry("BkmkType", bkmktype);

-        config.writeEntry("Minor", (int)minor);

-    }

-//    qDebug("finished update");

-}

-

-void QTReaderApp::addtoolbars(Config* config)

-{

-    config->setGroup("Toolbar");

-

-    if (fileBar != NULL)

-    {

-        if (fileBar != menubar)

-        {

-            fileBar->clear();

-        }

-        else

-        {

-            m_preferences_action->removeFrom( filebar() );

-            m_open_action->removeFrom( filebar() );

-            m_close_action->removeFrom( filebar() );

-            m_info_action->removeFrom( filebar() );

-            m_touch_action->removeFrom( filebar() );

-            m_find_action->removeFrom( filebar() );

-        }

-    }

-

-    m_preferences_action->addTo( filebar() );

-    addfilebar(config, "Open", m_open_action);

-    addfilebar(config, "Close", m_close_action);

-    addfilebar(config, "Info", m_info_action);

-    addfilebar(config, "Two/One Touch", m_touch_action);

-    addfilebar(config, "Find", m_find_action);

-

-    if (navBar != NULL)

-    {

-        if ((navBar == fileBar) && (fileBar == menubar))

-        {

-            m_scrollButton->removeFrom( navbar() );

-            m_start_action->removeFrom( navbar() );

-            m_end_action->removeFrom( navbar() );

-            m_jump_action->removeFrom( navbar() );

-            m_pageline_action->removeFrom( navbar() );

-            m_pageup_action->removeFrom( navbar() );

-            m_pagedn_action->removeFrom( navbar() );

-            m_back_action->removeFrom( navbar() );

-            m_home_action->removeFrom( navbar() );

-            m_forward_action->removeFrom( navbar() );

-        }

-        else if (navBar != fileBar)

-        {

-            navBar->clear();

-        }

-    }

-

-    addnavbar(config, "Scroll", m_scrollButton);

-    addnavbar(config, "Goto Start", m_start_action);

-    addnavbar(config, "Goto End", m_end_action);

-

-    addnavbar(config, "Jump", m_jump_action);

-    addnavbar(config, "Page/Line Scroll", m_pageline_action);

-

-    addnavbar(config, "Page Up", m_pageup_action);

-    addnavbar(config, "Page Down", m_pagedn_action);

-

-    addnavbar(config, "Back", m_back_action);

-    addnavbar(config, "Home", m_home_action);

-    addnavbar(config, "Forward", m_forward_action);

-

-    if (viewBar != NULL)

-    {

-        if ((viewBar == fileBar) && (fileBar == menubar))

-        {

-            m_actFullscreen->removeFrom( filebar() );

-            m_zoomin_action->removeFrom( viewbar() );

-            m_zoomout_action->removeFrom( viewbar() );

-            m_setfont_action->removeFrom( viewbar() );

-            m_setenc_action->removeFrom( viewbar() );

-            m_setmono_action->removeFrom( viewbar() );

-        }

-        else if (viewBar != fileBar)

-        {

-            viewBar->clear();

-        }

-    }

-

-    addviewbar(config, "Fullscreen", m_actFullscreen);

-    addviewbar(config, "Zoom In", m_zoomin_action);

-    addviewbar(config, "Zoom Out", m_zoomout_action);

-    addviewbar(config, "Set Font", m_setfont_action);

-    addviewbar(config, "Encoding Select", m_setenc_action);

-    addviewbar(config, "Ideogram Mode", m_setmono_action);

-

-    if (markBar != NULL)

-    {

-        if ((markBar == fileBar) && (fileBar == menubar))

-        {

-            m_mark_action->removeFrom( markbar() );

-            m_annotate_action->removeFrom( markbar());

-            m_goto_action->removeFrom( markbar() );

-            m_delete_action->removeFrom( markbar() );

-            m_autogen_action->removeFrom( markbar() );

-            m_clear_action->removeFrom( markbar() );

-            m_save_action->removeFrom( markbar() );

-            m_tidy_action->removeFrom( markbar() );

-            m_startBlock_action->removeFrom( markbar() );

-            m_endBlock_action->removeFrom( markbar() );

-        }

-        else if (markBar != fileBar)

-        {

-            markBar->clear();

-        }

-    }

-    addmarkbar(config, "Mark", m_mark_action);

-    addmarkbar(config, "Annotate", m_annotate_action);

-    addmarkbar(config, "Goto", m_goto_action);

-    addmarkbar(config, "Delete", m_delete_action);

-    addmarkbar(config, "Autogen", m_autogen_action);

-    addmarkbar(config, "Clear", m_clear_action);

-    addmarkbar(config, "Save", m_save_action);

-    addmarkbar(config, "Tidy", m_tidy_action);

-    addmarkbar(config, "Start Block", m_startBlock_action);

-    addmarkbar(config, "Copy Block", m_endBlock_action);

-    if (checkbar(config, "Annotation indicator"))

-    {

-        if (m_bkmkAvail == NULL)

-        {

-            m_bkmkAvail = new QAction( tr( "Annotation" ), geticon( "find" ), QString::null, 0, this, 0 );

-            connect( m_bkmkAvail, SIGNAL( activated() ), this, SLOT( showAnnotation() ) );

-        

-            m_bkmkAvail->setEnabled(false);

-        }

-        QLabel *spacer = new QLabel(markBar, "");

-        markbar()->setStretchableWidget(spacer);

-        m_bkmkAvail->removeFrom( markbar() );

-        m_bkmkAvail->addTo( markbar() );

-    }

-    else

-    {

-        if (m_bkmkAvail != NULL)

-        {

-            m_bkmkAvail->removeFrom( markbar() );

-            delete m_bkmkAvail;

-            m_bkmkAvail = NULL;

-        }

-    }

-}

-

-bool QTReaderApp::checkbar(Config* _config, const QString& key)

-{

-    return _config->readBoolEntry(key, false);

-}

-

-

-QToolBar* QTReaderApp::filebar()

-{

-    if (fileBar == NULL)

-    {

-        switch (m_tbpol)

-        {

-            case cesSingle:

-        //      qDebug("Setting filebar to menubar");

-                fileBar = menubar;

-                break;

-            default:

-                qDebug("Incorrect toolbar policy set");

-            case cesMenuTool:

-            case cesMultiple:

-        //      qDebug("Creating new file bar");

-                fileBar = new QToolBar("File", this, m_tbposition);

-                break;

-        }

-        //fileBar->setHorizontalStretchable( true );

-    }

-    return fileBar;

-}

-QToolBar* QTReaderApp::viewbar()

-{

-    if (viewBar == NULL)

-    {

-        switch (m_tbpol)

-        {

-            case cesMultiple:

-                viewBar = new QToolBar("View", this, m_tbposition);

-                break;

-            default:

-                qDebug("Incorrect toolbar policy set");

-            case cesSingle:

-            case cesMenuTool:

-                viewBar = fileBar;

-                break;

-        }

-    }

-    return viewBar;

-}

-QToolBar* QTReaderApp::navbar()

-{

-    if (navBar == NULL)

-    {

-        switch (m_tbpol)

-        {

-            case cesMultiple:

-        //      qDebug("Creating new nav bar");

-                navBar = new QToolBar("Navigation", this, m_tbposition);

-                break;

-            default:

-                qDebug("Incorrect toolbar policy set");

-            case cesSingle:

-            case cesMenuTool:

-                navBar = fileBar;

-        //      qDebug("Setting navbar to filebar");

-                break;

-        }

-    }

-    return navBar;

-}

-QToolBar* QTReaderApp::markbar()

-{

-    if (markBar == NULL)

-    {

-        switch (m_tbpol)

-        {

-            case cesMultiple:

-                markBar = new QToolBar("Marks", this, m_tbposition);

-                break;

-            default:

-                qDebug("Incorrect toolbar policy set");

-            case cesSingle:

-            case cesMenuTool:

-                markBar = fileBar;

-                break;

-        }

-    }

-    return markBar;

-}

-

-void QTReaderApp::addfilebar(Config* _config, const QString& key, QAction* a)

-{

-    if (_config->readBoolEntry(key, false)) a->addTo( filebar() );

-}

-void QTReaderApp::addnavbar(Config* _config, const QString& key, QAction* a)

-{

-    if (_config->readBoolEntry(key, false)) a->addTo( navbar() );

-}

-void QTReaderApp::addmarkbar(Config* _config, const QString& key, QAction* a)

-{

-    if (_config->readBoolEntry(key, false)) a->addTo( markbar() );

-}

-void QTReaderApp::addviewbar(Config* _config, const QString& key, QAction* a)

-{

-    if (_config->readBoolEntry(key, false)) a->addTo( viewbar() );

-}

-

-void QTReaderApp::suspend() { reader->suspend(); }

-

-#ifdef USEMSGS

-void QTReaderApp::msgHandler(const QCString& _msg, const QByteArray& _data)

-{

-    QString msg = QString::fromUtf8(_msg);

-

-////    qDebug("Received:%s", (const char*)msg);

-

-    QDataStream stream( _data, IO_ReadOnly );

-    if ( msg == "info(QString)" )

-    {

-        QString info;

-        stream >> info;

-        QMessageBox::information(this, PROGNAME, info);

-    }

-    else if ( msg == "Update(int)" )

-    {

-        int info;

-        stream >> info;

-        if (info)

-        {

-            reader->bDoUpdates = true;

-            reader->refresh();

-        }

-        else

-        {

-            reader->bDoUpdates = false;

-        }

-    }

-    else if ( msg == "warn(QString)" )

-    {

-        QString info;

-        stream >> info;

-        QMessageBox::warning(this, PROGNAME, info);

-    }

-    else if ( msg == "exit()" )

-    {

-        m_dontSave = true;

-        close();

-    }

-    else if ( msg == "pageDown()" )

-    {

-        reader->dopagedn();

-    }

-    else if ( msg == "pageUp()" )

-    {

-        reader->dopageup();

-    }

-    else if ( msg == "lineDown()" )

-    {

-        reader->lineDown();

-    }

-    else if ( msg == "lineUp()" )

-    {

-        reader->lineUp();

-    }

-    else if ( msg == "showText()" )

-    {

-        showEditTools();

-    }

-    else if ( msg == "home()" )

-    {

-        reader->goHome();

-    }

-    else if ( msg == "back()" )

-    {

-        reader->goBack();

-    }

-    else if ( msg == "forward()" )

-    {

-        reader->goForward();

-    }

-    else if ( msg == "File/Open(QString)" )

-    {

-        QString info;

-        stream >> info;

-        openFile( info );

-    }

-    else if ( msg == "File/Info()" )

-    {

-        showinfo();

-    }

-    else if ( msg == "File/Action(QString)" )

-    {

-        QString info;

-        stream >> info;

-        m_spaceTarget = ActNameToInt(info);

-    }

-    else if ( msg == "Navigation/Scroll(int)" )

-    {

-        int info;

-        stream >> info;

-        autoScroll(info);

-    }

-

-    else if ( msg == "Navigation/GotoStart()" )

-    {

-        gotoStart();

-    }

-    else if ( msg == "Navigation/GotoEnd()" )

-    {

-        gotoEnd();

-    }

-    else if ( msg == "Navigation/Jump(int)" )

-    {

-        int info;

-        stream >> info;

-        reader->locate(info);

-    }

-    else if ( msg == "Navigation/Page/LineScroll(int)" )

-    {

-        int info;

-        stream >> info;

-        pagemode(info);

-    }

-    else if ( msg == "Navigation/SetOverlap(int)" )

-    {

-        int info;

-        stream >> info;

-        reader->m_overlap = info;

-    }

-    else if ( msg == "Navigation/SetMargin(int)" )

-    {

-        int info;

-        stream >> info;

-        do_margin(info);

-    }

-    else if ( msg == "File/SetDictionary(QString)" )

-    {

-        QString info;

-        stream >> info;

-        do_settarget(info);

-    }

-#ifdef _SCROLLPIPE

-    else if ( msg == "File/SetScrollTarget(QString)" )

-    {

-        QString info;

-        stream >> info;

-        reader->m_pipetarget = info;

-    }

-#endif

-    else if ( msg == "File/Two/OneTouch(int)" )

-    {

-        int info;

-        stream >> info;

-        setTwoTouch(info);

-    }

-    else if ( msg == "Target/Annotation(int)" )

-    {

-        int info;

-        stream >> info;

-        OnAnnotation(info);

-    }

-    else if ( msg == "Target/Dictionary(int)" )

-    {

-        int info;

-        stream >> info;

-        OnDictionary(info);

-    }

-    else if ( msg == "Target/Clipboard(int)" )

-    {

-        int info;

-        stream >> info;

-        OnClipboard(info);

-    }

-    else if ( msg == "File/Find(QString)" )

-    {

-        QString info;

-        stream >> info;

-        QRegExp arg(info);

-        size_t pos = reader->pagelocate();

-        size_t start = pos;

-        CDrawBuffer test(&(reader->m_fontControl));

-        reader->getline(&test);

-        while (arg.match(toQString(test.data())) == -1)

-        {

-            pos = reader->locate();

-            if (!reader->getline(&test))

-            {

-                QMessageBox::information(this, PROGNAME, QString("Can't find\n")+info);

-                pos = start;

-                break;

-            }

-        }

-        reader->locate(pos);

-    }

-    else if ( msg == "File/Fullscreen(int)" )

-    {

-        int info;

-        stream >> info;

-        setfullscreen(info);

-    }

-    else if ( msg == "File/Continuous(int)" )

-    {

-        int info;

-        stream >> info;

-        setcontinuous(info);

-    }

-    else if ( msg == "Markup(QString)" )

-    {

-        QString info;

-        stream >> info;

-        if (info == "Auto")

-        {

-            autofmt(true);

-        }

-        if (info == "None")

-        {

-            autofmt(false);

-            textfmt(false);

-            striphtml(false);

-            peanut(false);

-        }

-        if (info == "Text")

-        {

-            textfmt(true);

-        }

-        if (info == "HTML")

-        {

-            striphtml(true);

-        }

-        if (info == "Peanut/PML")

-        {

-            peanut(true);

-        }

-    }

-    else if ( msg == "Layout/StripCR(int)" )

-    {

-        int info;

-        stream >> info;

-        stripcr(info);

-    }

-    else if ( msg == "Layout/Dehyphen(int)" )

-    {

-        int info;

-        stream >> info;

-        dehyphen(info);

-    }

-    else if ( msg == "Layout/Depluck(int)" )

-    {

-        int info;

-        stream >> info;

-        depluck(info);

-    }

-    else if ( msg == "Layout/Dejpluck(int)" )

-    {

-        int info;

-        stream >> info;

-        dejpluck(info);

-    }

-    else if ( msg == "Layout/SingleSpace(int)" )

-    {

-        int info;

-        stream >> info;

-        onespace(info);

-    }

-#ifdef REPALM

-    else if ( msg == "Layout/Repalm(int)" )

-    {

-        int info;

-        stream >> info;

-        repalm(info);

-    }

-#endif

-    else if ( msg == "Layout/Unindent(int)" )

-    {

-        int info;

-        stream >> info;

-        unindent(info);

-    }

-    else if ( msg == "Layout/Re-paragraph(int)" )

-    {

-        int info;

-        stream >> info;

-        repara(info);

-    }

-    else if ( msg == "Layout/DoubleSpace(int)" )

-    {

-        int info;

-        stream >> info;

-        dblspce(info);

-    }

-    else if ( msg == "Layout/Indent(int)" )

-    {

-        int info;

-        stream >> info;

-        reader->bindenter = info;

-        reader->setfilter(reader->getfilter());

-    }

-    else if ( msg == "Layout/Remap(int)" )

-    {

-        int info;

-        stream >> info;

-        remap(info);

-    }

-    else if ( msg == "Layout/Embolden(int)" )

-    {

-        int info;

-        stream >> info;

-        embolden(info);

-    }

-    else if ( msg == "Format/Ideogram/Word(int)" )

-    {

-        int info;

-        stream >> info;

-        monospace(info);

-    }

-    else if ( msg == "Format/SetWidth(int)" )

-    {

-        int info;

-        stream >> info;

-        reader->m_charpc = info;

-        reader->setfont();

-        reader->refresh();

-    }

-    else if ( msg == "Format/SetFont(QString,int)" )

-    {

-        QString fontname;

-        int size;

-        stream >> fontname;

-        stream >> size;

-        setfontHelper(fontname, size);

-    }

-    else if ( msg == "Marks/Autogen(QString)" )

-    {

-        QString info;

-        stream >> info;

-        do_autogen(info);

-    }

-    else if ( msg == "File/StartBlock()" )

-    {

-        editMark();

-    }

-    else if ( msg == "File/CopyBlock()" )

-    {

-        editCopy();

-    }

-}

-#endif

-ActionTypes QTReaderApp::ActNameToInt(const QString& _enc)

-{

-    for (int i = 0; i < MAX_ACTIONS; i++)

-    {

-        if (m_buttonAction[i]->text() == _enc) return (ActionTypes)i;

-    }

-    return cesAutoScroll;

-}

-

-void QTReaderApp::setfullscreen(bool sfs)

-{

-    reader->bDoUpdates = false;

-    m_fullscreen = sfs;

-    showEditTools();

-//    qApp->processEvents();

-    reader->bDoUpdates = true;

-    reader->update();

-}

-

-void QTReaderApp::buttonActionSelected(QAction* _a)

-{

-////    qDebug("es:%x : %s (%u)", _a, (const char *)(_a->text()), ActNameToInt(_a->text()));

-    m_spaceTarget = ActNameToInt(_a->text());

-}

-

-QTReaderApp::~QTReaderApp()

-{

-}

-

-void QTReaderApp::autoScroll(bool _b)

-{

-    reader->setautoscroll(_b);

-    setScrollState(reader->m_autoScroll);

-}

-

-void QTReaderApp::zoomin()

-{

-    reader->zoomin();

-}

-

-void QTReaderApp::zoomout()

-{

-    reader->zoomout();

-}

-

-void QTReaderApp::clearBkmkList()

-{

-        delete pBkmklist;

-        pBkmklist = NULL;

-        m_fBkmksChanged = false;

-}

-

-void QTReaderApp::fileClose()

-{

-    CCloseDialog* cd = new CCloseDialog(reader->m_string, false, this);

-    if (cd->exec())

-    {

-        if (pOpenlist != NULL)

-        {

-            int ind = 0;

-            Bkmk* p = (*pOpenlist)[ind];

-            while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)

-            {

-                p = (*pOpenlist)[++ind];

-            }

-            if (p != NULL) pOpenlist->erase(ind);

-            if (cd->delFile())

-            {

-                unlink((const char*)reader->m_lastfile);

-            }

-            if (cd->delMarks())

-            {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                d.remove(reader->m_string);

-#else /* USEQPE */

-                unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));

-#endif /* USEQPE */

-            }

-            if (cd->delConfig())

-            {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR "/configs");

-                d.remove(reader->m_string);

-#else /* USEQPE */

-                unlink((const char *)Global::applicationFileName(APPDIR "/configs",reader->m_string));

-#endif /* USEQPE */

-            }

-        }

-    

-        fileOpen2();

-    }

-    delete cd;

-}

-

-void QTReaderApp::updatefileinfo()

-{

-    if (reader->m_string.isEmpty()) return;

-    if (reader->m_lastfile.isEmpty()) return;

-    tchar* nm = fromQString(reader->m_string);

-    tchar* fl = fromQString(reader->m_lastfile);

-//    qDebug("Lastfile:%x", fl);

-    bool notadded = true;

-    if (pOpenlist == NULL) pOpenlist = new CList<Bkmk>;

-    else

-    {

-        for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)

-        {

-            if (ustrcmp(CFiledata(iter->anno()).name(), fl) == 0)

-            {

-                iter->value(reader->pagelocate());

-                unsigned short dlen;

-                unsigned char* data;

-                CFiledata fd(iter->anno());

-                reader->setSaveData(data, dlen, fd.content(), fd.length());

-        //      qDebug("Filedata(1):%u, %u", fd.length(), dlen);

-        //      getstate(data, dlen);

-                iter->setAnno(data, dlen);

-                notadded = false;

-                delete [] data;

-                break;

-            }

-        }

-    }

-//    qDebug("Added?:%x", notadded);

-    if (notadded)

-    {

-        struct stat fnstat;

-        stat((const char *)reader->m_lastfile, &fnstat);

-        CFiledata fd(fnstat.st_mtime, fl);

-        unsigned short dlen;

-        unsigned char* data;

-        reader->setSaveData(data, dlen, fd.content(), fd.length());

-        pOpenlist->push_front(Bkmk(nm, data, dlen, reader->pagelocate()));

-        //qDebug("Filedata(2):%u, %u", fd.length(), dlen);

-        delete [] data;

-    }

-    delete [] nm;

-    delete [] fl;

-}

-

-void QTReaderApp::fileOpen()

-{

-/*

-    menu->hide();

-    fileBar->hide();

-    if (regVisible) regBar->hide();

-    if (searchVisible) searchBar->hide();

-*/

-//    qDebug("fileOpen");

-//    if (!reader->m_lastfile.isEmpty())

-    updatefileinfo();

-    fileOpen2();

-}

-

-void QTReaderApp::fileOpen2()

-{

-    if (pBkmklist != NULL)

-    {

-        if (m_fBkmksChanged)

-        {

-            if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)

-                savebkmks();

-        }     

-        delete pBkmklist;

-        pBkmklist = NULL;

-        m_fBkmksChanged = false;

-    }

-    reader->disableAutoscroll();

-/*

-    editorStack->raiseWidget( fileSelector );

-    fileSelector->reread();

-*/

-    bool usebrowser = true;

-    if (pOpenlist != NULL)

-    {

-        m_nBkmkAction = cOpenFile;

-        if (listbkmk(pOpenlist, "Browse")) usebrowser = false;

-    }

-    if (usebrowser)

-    {

-        QString fn = usefilebrowser();

-        //qApp->processEvents();

-        if (!fn.isEmpty() && QFileInfo(fn).isFile())

-        {

-            openFile(fn);

-        }

-        reader->setFocus();

-    }

-//    reader->refresh();

-//    qDebug("HEIGHT:%d", reader->m_lastheight);

-}

-

-QString QTReaderApp::usefilebrowser()

-{

-#ifndef USEQPE

-    QString s( QFileDialog::getOpenFileName( reader->m_lastfile, QString::null, this ) );

-    return s;

-#else

-    fileBrowser* fb = new fileBrowser(false, this,"OpieReader",!m_bFloatingDialog,

-                                      0,

-        //                            WStyle_Customize | WStyle_NoBorderEx,

-                                      "*", QFileInfo(reader->m_lastfile).dirPath(true));

-

-

-    QString fn;

-    if (fb->exec())

-    {

-        fn = fb->getCurrentFile();

-    }

-//    qDebug("Selected %s", (const char*)fn);

-    delete fb;

-    showEditTools();

-    return fn;

-#endif

-}

-

-void QTReaderApp::showgraphic(QImage& pm)

-{

-    QPixmap pc;

-    pc.convertFromImage(pm);

-    m_graphicwin->setPixmap(pc);

-    editorStack->raiseWidget( m_graphicwin );

-    m_graphicwin->setFocus();

-}

-

-

-void QTReaderApp::showprefs()

-{

-    CPrefs* prefwin = new CPrefs(!m_bFloatingDialog, this);

-

-    prefwin->twotouch(m_twoTouch); 

-    prefwin->propfontchange(m_propogatefontchange);

-    prefwin->StripCR(reader->bstripcr);

-    prefwin->Dehyphen(reader->bdehyphen);

-    prefwin->SingleSpace(reader->bonespace);

-    prefwin->Unindent(reader->bunindent);

-    prefwin->Reparagraph(reader->brepara);

-    prefwin->DoubleSpace(reader->bdblspce);

-    prefwin->Remap(reader->bremap);

-    prefwin->Embolden(reader->bmakebold);

-    prefwin->FullJustify(reader->bfulljust);

-    prefwin->ParaLead(reader->getextraspace());

-    prefwin->LineLead(reader->getlead());

-    prefwin->Margin(reader->m_border);

-    prefwin->Indent(reader->bindenter);

-    if (reader->bautofmt)

-    {

-        prefwin->Markup(0);

-    }

-    else if (reader->btextfmt)

-    {

-        prefwin->Markup(2);

-    }

-    else if (reader->bstriphtml)

-    {

-        prefwin->Markup(3);

-    }

-    else if (reader->bpeanut)

-    {

-        prefwin->Markup(4);

-    }

-    else

-    {

-        prefwin->Markup(1);

-    }

-    prefwin->Depluck(reader->bdepluck);

-    prefwin->Dejpluck(reader->bdejpluck);

-    prefwin->Continuous(reader->m_continuousDocument);

-

-    prefwin->dictApplication(m_targetapp);

-    prefwin->dictMessage(m_targetmsg);

-

-    prefwin->spaceAction(m_spaceTarget);

-    prefwin->escapeAction(m_escapeTarget);

-    prefwin->returnAction(m_returnTarget);

-    prefwin->leftAction(m_leftTarget);

-    prefwin->rightAction(m_rightTarget);

-    prefwin->upAction(m_upTarget);

-    prefwin->downAction(m_downTarget);

-

-    prefwin->leftScroll(m_leftScroll);

-    prefwin->rightScroll(m_rightScroll);

-    prefwin->upScroll(m_upScroll);

-    prefwin->downScroll(m_downScroll);

-

-    prefwin->miscannotation(m_doAnnotation);

-    prefwin->miscdictionary(m_doDictionary);

-    prefwin->miscclipboard(m_doClipboard);

-

-    prefwin->SwapMouse(reader->m_swapmouse);

-

-    prefwin->Font(reader->m_fontname);

-

-    prefwin->gfxsize(reader->getBaseSize());

-

-    prefwin->pageoverlap(reader->m_overlap);

-

-    prefwin->ideogram(reader->m_bMonoSpaced);

-

-    prefwin->encoding(reader->m_encd);

-

-    prefwin->ideogramwidth(reader->m_charpc);

-

-    if (prefwin->exec())

-    {

-        m_twoTouch = prefwin->twotouch();

-        reader->setTwoTouch(m_twoTouch);

-        m_touch_action->setOn(m_twoTouch);

-

-        reader->bstripcr = prefwin->StripCR();

-        reader->bdehyphen = prefwin->Dehyphen();

-        reader->bonespace = prefwin->SingleSpace();

-        reader->bunindent = prefwin->Unindent();

-        reader->brepara = prefwin->Reparagraph();

-        reader->bdblspce = prefwin->DoubleSpace();

-        reader->bremap = prefwin->Remap();

-        reader->bmakebold = prefwin->Embolden();

-        reader->bfulljust = prefwin->FullJustify();

-        reader->setextraspace(prefwin->ParaLead());

-        reader->setlead(prefwin->LineLead());

-        reader->m_border = prefwin->Margin();

-        reader->bindenter = prefwin->Indent();

-        reader->bautofmt = reader->btextfmt = reader->bstriphtml = reader->bpeanut = false;

-        switch (prefwin->Markup())

-        {

-            case 0:

-                reader->bautofmt = true;

-                break;

-            case 1:

-                break;

-            case 2:

-                reader->btextfmt = true;

-                break;

-            case 3:

-                reader->bstriphtml = true;

-                break;

-            case 4:

-                reader->bpeanut = true;

-                break;

-            default:

-                qDebug("Format out of range");

-        }

-        reader->bdepluck = prefwin->Depluck();

-        reader->bdejpluck = prefwin->Dejpluck();

-        reader->setContinuous(prefwin->Continuous());

-

-        m_spaceTarget = (ActionTypes)prefwin->spaceAction();

-        m_escapeTarget = (ActionTypes)prefwin->escapeAction();

-        m_returnTarget = (ActionTypes)prefwin->returnAction();

-        m_leftTarget = (ActionTypes)prefwin->leftAction();

-        m_rightTarget = (ActionTypes)prefwin->rightAction();

-        m_upTarget = (ActionTypes)prefwin->upAction();

-        m_downTarget = (ActionTypes)prefwin->downAction();

-        m_leftScroll = prefwin->leftScroll();

-        m_rightScroll = prefwin->rightScroll();

-        m_upScroll = prefwin->upScroll();

-        m_downScroll = prefwin->downScroll();

-

-        m_targetapp = prefwin->dictApplication();

-        m_targetmsg = prefwin->dictMessage();

-

-        m_doAnnotation = prefwin->miscannotation();

-        m_doDictionary = prefwin->miscdictionary();

-        m_doClipboard = prefwin->miscclipboard();

-        reader->m_swapmouse = prefwin->SwapMouse();

-        reader->setBaseSize(prefwin->gfxsize());

-        reader->m_overlap = prefwin->pageoverlap();

-        reader->m_bMonoSpaced = prefwin->ideogram();

-        m_setmono_action->setOn(reader->m_bMonoSpaced);

-        reader->m_encd = prefwin->encoding();

-        reader->m_charpc = prefwin->ideogramwidth();

-

-        if (

-            reader->m_fontname != prefwin->Font()

-            ||

-            m_propogatefontchange != prefwin->propfontchange())

-        {

-            m_propogatefontchange = prefwin->propfontchange();

-            setfontHelper(prefwin->Font());

-        }

-        delete prefwin;

-        reader->setfilter(reader->getfilter());

-        reader->refresh();

-

-    }

-    else

-    {

-        delete prefwin;

-    }

-}

-

-void QTReaderApp::showtoolbarprefs()

-{

-#ifdef USEQPE

-    CBarPrefs* prefwin = new CBarPrefs(APPDIR, !m_bFloatingDialog, this);

-#else

-        QFileInfo fi;

-    QDir d = QDir::home();                      // "/"

-        if ( !d.cd(APPDIR) )

-        {                       // "/tmp"

-                qWarning( "Cannot find the \"~/%s\" directory", APPDIR );

-                d = QDir::home();

-                d.mkdir(APPDIR);

-                d.cd(APPDIR);

-        }

-        fi.setFile(d, INIFILE);

-    CBarPrefs* prefwin = new CBarPrefs(fi.absFilePath(), !m_bFloatingDialog, this);

-#endif

-    prefwin->tbpolicy(m_tbpolsave);

-    prefwin->tbposition(m_tbposition-2);

-    prefwin->tbmovable(m_tbmovesave);

-    prefwin->floating(m_bFloatingDialog);

-    if (prefwin->exec())

-    {

-        m_bFloatingDialog = prefwin->floating();

-        if (

-            m_tbpolsave != (ToolbarPolicy)prefwin->tbpolicy()

-            ||

-            m_tbposition != (ToolBarDock)(prefwin->tbposition()+2)

-            ||

-            m_tbmovesave != prefwin->tbmovable()

-            )

-        {

-            QMessageBox::warning(this, PROGNAME, "Some changes won't take effect\nuntil the next time the\napplication is started");

-        }

-        m_tbpolsave = (ToolbarPolicy)prefwin->tbpolicy();

-        m_tbposition = (ToolBarDock)(prefwin->tbposition()+2);

-        m_tbmovesave = prefwin->tbmovable();

-        bool isChanged = prefwin->isChanged();

-        delete prefwin;

-#ifdef USEQPE

-        Config config( APPDIR );

-#else

-        QFileInfo fi;

-    QDir d = QDir::home();                      // "/"

-        if ( !d.cd(APPDIR) )

-        {                       // "/tmp"

-                qWarning( "Cannot find the \"~/%s\" directory", APPDIR );

-                d = QDir::home();

-                d.mkdir(APPDIR);

-                d.cd(APPDIR);

-        }

-        fi.setFile(d, INIFILE);

-        Config config( fi.absFilePath() );

-#endif

-        if (isChanged) addtoolbars(&config);

-    }

-    else

-    {

-        delete prefwin;

-    }

-}

-

-void QTReaderApp::showinfo()

-{

-    unsigned long fs, ts, pl;

-    if (reader->empty())

-    {

-        QMessageBox::information(this, PROGNAME, "No file loaded", 1);

-    }

-    else

-    {

-        reader->sizes(fs,ts);

-        pl = reader->pagelocate();

-        m_infoWin->setFileSize(fs);

-        m_infoWin->setTextSize(ts);

-        m_infoWin->setRatio(100-(100*fs + (ts >> 1))/ts);

-        m_infoWin->setLocation(pl);

-        m_infoWin->setRead((100*pl + (ts >> 1))/ts);

-        editorStack->raiseWidget( m_infoWin );

-        m_infoWin->setFocus();

-    }

-}

-

-void QTReaderApp::addAnno(const QString& name, const QString& text, size_t posn)

-{

-    if (pBkmklist == NULL) pBkmklist = new CList<Bkmk>;

-#ifdef _UNICODE

-    CBuffer buff(name.length()+1);

-    int i;

-    for (i = 0; i < name.length(); i++)

-    {

-        buff[i] = name[i].unicode();

-    }

-    buff[i] = 0;

-    CBuffer buff2(text.length()+1);

-    for (i = 0; i < text.length(); i++)

-    {

-        buff2[i] = text[i].unicode();

-    }

-    buff2[i] = 0;

-    pBkmklist->push_front(Bkmk(buff.data(), buff2.data(), posn));

-#else

-    pBkmklist->push_front(Bkmk((const tchar*)text,posn));

-#endif

-    m_fBkmksChanged = true;

-    pBkmklist->sort();

-}

-

-void QTReaderApp::addAnno(const QString& name, const QString& text)

-{

-    if (m_annoIsEditing)

-    {

-        if (name.isEmpty())

-        {

-            QMessageBox::information(this, PROGNAME, "Need a name for the bookmark\nPlease try again", 1);

-        }

-        else

-        {

-            addAnno(name, text, m_annoWin->getPosn());

-        }

-        showEditTools();

-    }

-    else

-    {

-        if (m_annoWin->edited())

-        {

-            CBuffer buff(text.length()+1);

-            int i;

-            for (i = 0; i < text.length(); i++)

-            {

-                buff[i] = text[i].unicode();

-            }

-            buff[i] = 0;

-            m_fBkmksChanged = true;

-            m_anno->setAnno(buff.data());

-        }

-        bool found = findNextBookmark(m_anno->value()+1);

-        if (found)

-        {

-            m_annoWin->setName(toQString(m_anno->name()));

-            m_annoWin->setAnno(toQString(m_anno->anno()));

-        }

-        else

-        {

-            showEditTools();

-        }

-    }

-}

-

-bool QTReaderApp::findNextBookmark(size_t start)

-{

-    bool found = false;

-    for (CList<Bkmk>::iterator iter = pBkmklist->begin(); iter != pBkmklist->end(); iter++)

-    {

-        if (iter->value() >= start)

-        {

-            if (iter->value() < reader->locate())

-            {

-                found = true;

-                m_anno = iter.pContent();

-            }

-            break;

-        }

-    }

-    return found;

-}

-

-void QTReaderApp::addanno()

-{

-    if (reader->empty())

-    {

-        QMessageBox::information(this, PROGNAME, "No file loaded", 1);

-    }

-    else

-    {

-        m_annoWin->setName("");

-        m_annoWin->setAnno("");

-        m_annoWin->setPosn(reader->pagelocate());

-        m_annoIsEditing = true;

-        editorStack->raiseWidget( m_annoWin );

-#ifdef USEQPE

-        Global::showInputMethod();

-#endif

-        m_annoWin->setFocus();

-    }

-}

-

-void QTReaderApp::infoClose()

-{

-    showEditTools();

-}

-

-/*

-void QTReaderApp::fileRevert()

-{

-    clear();

-    fileOpen();

-}

-

-void QTReaderApp::editCut()

-{

-#ifndef QT_NO_CLIPBOARD

-    editor->cut();

-#endif

-}

-*/

-void QTReaderApp::editMark()

-{

-    m_savedpos = reader->pagelocate();

-}

-

-void QTReaderApp::editCopy()

-{

-        QClipboard* cb = QApplication::clipboard();

-        QString text;

-        int ch;

-        unsigned long currentpos = reader->pagelocate();

-        unsigned long endpos = reader->locate();

-        if (m_savedpos == 0xffffffff)

-        {

-            m_savedpos = currentpos;

-        }

-        reader->jumpto(m_savedpos);

-        while (reader->explocate() < endpos && (ch = reader->getch()) != UEOF)

-        {

-            text += ch;

-        }

-        cb->setText(text);

-        reader->locate(currentpos);

-        m_savedpos = 0xffffffff;

-}

-

-void QTReaderApp::gotoStart()

-{

-    reader->locate(reader->buffdoc.startSection());

-}

-

-void QTReaderApp::gotoEnd()

-{

-    reader->dopageup(reader->buffdoc.endSection());

-}

-

-void QTReaderApp::pageup()

-{

-    reader->NavUp();

-}

-

-void QTReaderApp::pagedn()

-{

-    reader->NavDown();

-}

-

-void QTReaderApp::pagemode(bool _b)

-{

-    reader->setpagemode(_b);

-}

-

-/*

-void QTReaderApp::setspacing()

-{

-    m_nRegAction = cMonoSpace;

-    char lcn[20];

-    sprintf(lcn, "%lu", reader->m_charpc);

-    regEdit->setText(lcn);

-    do_regedit();

-}

-*/

-void QTReaderApp::settarget()

-{

-    m_nRegAction = cSetTarget;

-    QString text = ((m_targetapp.isEmpty()) ? QString("") : m_targetapp)

-        + "/"

-        + ((m_targetmsg.isEmpty()) ? QString("") : m_targetmsg);

-    regEdit->setText(text);

-    do_regedit();

-}

-

-/*

-void QTReaderApp::do_mono(const QString& lcn)

-{

-    bool ok;

-    unsigned long ulcn = lcn.toULong(&ok);

-    if (ok)

-    {

-        reader->m_charpc = ulcn;

-        reader->setfont();

-        reader->refresh();

-        //reader->setmono(true);

-    }

-    else

-        QMessageBox::information(this, PROGNAME, "Must be a number");

-}

-*/

-/*

-void QTReaderApp::editPaste()

-{

-#ifndef QT_NO_CLIPBOARD

-    editor->paste();

-#endif

-}

-*/

-

-void QTReaderApp::editFind()

-{

-  searchStart = reader->pagelocate();

-#ifdef __ISEARCH

-  searchStack = new QStack<searchrecord>;

-#endif

-#ifdef USEQPE

-  Global::showInputMethod();

-#endif

-  searchBar->show();

-  searchVisible = TRUE;

-  searchEdit->setFocus();

-#ifdef __ISEARCH

-  searchStack->push(new searchrecord("",reader->pagelocate()));

-#endif

-}

-

-void QTReaderApp::findNext()

-{

-//  //  qDebug("findNext called\n");

-#ifdef __ISEARCH

-  QString arg = searchEdit->text();

-#else

-  QRegExp arg = searchEdit->text();

-#endif

-  CDrawBuffer test(&(reader->m_fontControl));

-  size_t start = reader->pagelocate();

-  reader->jumpto(start);

-  reader->getline(&test);

-  dosearch(start, test, arg);

-}

-

-void QTReaderApp::findClose()

-{

-  searchVisible = FALSE;

-  searchEdit->setText("");

-#ifdef USEQPE

-  Global::hideInputMethod();

-#endif

-  searchBar->hide();

-#ifdef __ISEARCH

-//  searchStack = new QStack<searchrecord>;

-  while (!searchStack->isEmpty())

-    {

-      delete searchStack->pop();

-    }

-  delete searchStack;

-#endif

-  reader->setFocus();

-}

-

-void QTReaderApp::regClose()

-{

-  regVisible = FALSE;

-  regEdit->setText("");

-  regBar->hide();

-#ifdef USEQPE

-  Global::hideInputMethod();

-#endif

-  reader->setFocus();

-}

-

-#ifdef __ISEARCH

-bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QString& arg)

-#else

-bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QRegExp& arg)

-#endif

-{

-  bool ret = true;

-    unsigned long fs, ts;

-    reader->sizes(fs,ts);

-  size_t pos = reader->locate();

-  pbar->setGeometry(searchBar->x(),searchBar->y(),searchBar->width(), searchBar->height());

-  pbar->show();

-  pbar->raise();

-  pbar->reset();

-  int offset;

-  int lastpc = (100*pos)/ts;

-  pbar->setProgress(lastpc);

-//  qApp->processEvents();

-  if (reader->buffdoc.getpara(test) >= 0)

-  {

-      reader->setFocus();

-#ifdef __ISEARCH

-      while (strstr(test.data(),(const tchar*)arg) == NULL)

-#else

-#ifdef _UNICODE

-      while ((offset = arg.match(toQString(test.data()))) == -1)

-#else

-      while (arg.match(test.data()) == -1)

-#endif

-#endif

-      {

-          pos = reader->locate();

-          int pc = (100*pos)/ts;

-          if (pc != lastpc)

-          {

-              pbar->setProgress(pc);

-              qApp->processEvents();

-              reader->setFocus();

-              lastpc = pc;

-          }

-          

-          if (reader->buffdoc.getpara(test) < 0)

-          {

-              if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)

-                  pos = searchStart;

-              else

-                  pos = start;

-              findClose();

-              pbar->hide();

-              reader->locate(pos);

-              return false;

-          }

-      }

-//      qDebug("Found it at %u:%u", pos, offset);

-      pbar->hide();

-//      qDebug("Hid");

-      reader->locate(pos+offset);

-//      qDebug("Loacted");

-//      qDebug("page up");

-      ret = true;

-  }

-  else

-  {

-              if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)

-                  pos = searchStart;

-              else

-                  pos = start;

-              ret = false;

-              findClose();

-  }

-  return ret;

-}

-

-#ifdef __ISEARCH

-void QTReaderApp::search(const QString & arg)

-{

-  searchrecord* ss = searchStack->top();

-  CBuffer test;

-  size_t start = reader->pagelocate();

-  bool haspopped = false;

-  while (arg.left(ss->s.length()) != ss->s)

-  {

-      haspopped = true;

-      start = ss->pos;

-//      reader->locate(start);

-      searchStack->pop();

-      delete ss;

-  }

-  if (haspopped) reader->locate(start);

-/*

-  if (arg.length() < ss->len)

-    {

-      start = ss->pos;

-      reader->locate(start);

-      searchStack->pop();

-      delete ss;

-    }

-*/

-  else

-    {

-      start = reader->pagelocate();

-      reader->jumpto(start);

-      searchStack->push(new searchrecord(arg,start));

-    }

-    dosearch(start, test, arg);

-}

-#else

-void QTReaderApp::search()

-{

-    findNext();

-}

-#endif

-

-void QTReaderApp::openFile( const QString &f )

-{

-//    qDebug("File:%s", (const char*)f);

-//    openFile(DocLnk(f));

-//}

-//

-//void QTReaderApp::openFile( const DocLnk &f )

-//{

-  clear();

-  QFileInfo fm(f);

-  if ( fm.exists() )

-    {

-//      QMessageBox::information(0, "Progress", "Calling fileNew()");

-#ifdef USEQPE

-        if (fm.extension( FALSE ) == "desktop")

-        {

-            DocLnk d(f);

-            QFileInfo fnew(d.file());

-            fm = fnew;

-            if (!fm.exists()) return;

-        }

-#endif

-      clear();

-

-      reader->setText(fm.baseName(), fm.absFilePath());

-      m_loadedconfig = readconfig(reader->m_string, false);

-      showEditTools();

-      readbkmks();

-      m_savedpos = 0xffffffff;

-    }

-  else

-    {

-      QMessageBox::information(this, PROGNAME, "File does not exist");

-      reader->m_lastfile = QString::null;

-    }

-        

-}

-/*

-void QTReaderApp::resizeEvent(QResizeEvent* e)

-{

-    if (m_fullscreen)

-    {

-        showNormal();

-        showFullScreen();

-    }

-}

-*/

-void QTReaderApp::handlekey(QKeyEvent* e)

-{

-//    qDebug("Keypress event");

-    timeb now;

-    ftime(&now);

-    unsigned long etime = (1000*(now.time - m_lastkeytime.time) + now.millitm)-m_lastkeytime.millitm;

-    if (etime < m_debounce)

-    {

-        return;

-    }

-    m_lastkeytime = now;

-    switch(e->key())

-    {

-        case Key_Escape:

-        //    qDebug("escape event");

-            if (m_disableesckey)

-            {

-                m_disableesckey = false;

-            }

-            else

-            {

-                m_bcloseDisabled = true;

-                if (m_fullscreen)

-                {

-                    m_actFullscreen->setOn(false);

-                    e->accept();

-                }

-                else

-                {

-        //      qDebug("escape action");

-                    doAction(m_escapeTarget, e);

-                }

-            }

-            break;

-        case Key_Space:

-        {

-            doAction(m_spaceTarget, e);

-        }

-        break;

-        case Key_Return:

-        {

-            doAction(m_returnTarget, e);

-        }

-        break;

-        case Key_Left:

-        {

-            if (reader->m_autoScroll && m_leftScroll)

-            {

-                reader->reduceScroll();

-            }

-            else

-            {

-                doAction(m_leftTarget, e);

-            }

-        }

-        break;

-        case Key_Right:

-        {

-            if (reader->m_autoScroll && m_rightScroll)

-            {

-                reader->increaseScroll();

-            }

-            else

-            {

-                doAction(m_rightTarget, e);

-            }

-        }

-        break;

-        case Key_Up:

-        {

-            if (reader->m_autoScroll && m_upScroll)

-            {

-                reader->increaseScroll();

-            }

-            else

-            {

-                doAction(m_upTarget, e);

-            }

-        }

-        break;

-        case Key_Down:

-        {

-            if (reader->m_autoScroll && m_downScroll)

-            {

-                reader->reduceScroll();

-            }

-            else

-            {

-                doAction(m_downTarget, e);

-            }

-        }

-        break;

-        default:

-        {

-            e->ignore();

-        }

-        

-/*

-        QString msg("Key press was:");

-        QString key;

-        msg += key.setNum(e->key());

-        QMessageBox::information(this, PROGNAME, msg);

-*/

-    }

-}

-

-void QTReaderApp::showEditTools()

-{

-//    if ( !doc )

-        //close();

-    if (m_fullscreen)

-    {

-        if (menubar != NULL) menubar->hide();

-        if (fileBar != NULL) fileBar->hide();

-        if (viewBar != NULL) viewBar->hide();

-        if (navBar != NULL) navBar->hide();

-        if (markBar != NULL) markBar->hide();

-        searchBar->hide();

-        regBar->hide();

-#ifdef USEQPE

-        Global::hideInputMethod();

-#endif

-        m_fontBar->hide();

-        //showNormal();

-        showFullScreen();

-    }

-    else

-    {

-        //qDebug("him");

-#ifdef USEQPE

-        Global::hideInputMethod();

-#endif

-        //qDebug("eb");

-        menubar->show();

-        if (fileBar != NULL) fileBar->show();

-        if (viewBar != NULL) viewBar->show();

-        if (navBar != NULL) navBar->show();

-        if (markBar != NULL) markBar->show();

-        mb->show();

-        if ( searchVisible )

-        {

-#ifdef USEQPE

-            Global::showInputMethod();

-#endif

-                searchBar->show();

-        }

-        if ( regVisible )

-        {

-#ifdef USEQPE

-            Global::showInputMethod();

-#endif

-                regBar->show();

-        }

-        if (m_fontVisible) m_fontBar->show();

-        //qDebug("sn");

-        showNormal();

-        //qDebug("sm");

-#ifdef USEQPE

-        showMaximized();

-#endif

-        //setCentralWidget(reader);

-    }

-

-//    qDebug("uc");

-    updateCaption();

-//    qDebug("rw");

-    editorStack->raiseWidget( reader );

-//    qDebug("sf");

-    reader->setFocus();

-    reader->refresh();

-}

-/*

-void QTReaderApp::save()

-{

-    if ( !doc )

-        return;

-    if ( !editor->edited() )

-        return;

-

-    QString rt = editor->text();

-    QString pt = rt;

-

-    if ( doc->name().isEmpty() ) {

-        unsigned ispace = pt.find( ' ' );

-        unsigned ienter = pt.find( '\n' );

-        int i = (ispace < ienter) ? ispace : ienter;

-        QString docname;

-        if ( i == -1 ) {

-            if ( pt.isEmpty() )

-                docname = "Empty Text";

-            else

-                docname = pt;

-        } else {

-            docname = pt.left( i );

-        }

-        doc->setName(docname);

-    }

-    FileManager fm;

-    fm.saveFile( *doc, rt );

-}

-*/

-

-void QTReaderApp::clear()

-{

-//    if (doc != 0)

-//      {

-//  QMessageBox::information(this, PROGNAME, "Deleting doc", 1);

-        //delete doc;

-//  QMessageBox::information(this, PROGNAME, "Deleted doc", 1);

-        //doc = 0;

-    //     }

-    reader->clear();

-}

-

-void QTReaderApp::updateCaption()

-{

-//    if ( !doc )

-        //setCaption( tr("QTReader") );

-//    else {

-        //QString s = doc->name();

-        //if ( s.isEmpty() )

-        //    s = tr( "Unnamed" );

-        setCaption( reader->m_string + " - " + tr("Reader") );

-//    }

-}

-

-void QTReaderApp::setDocument(const QString& fileref)

-{

-    bFromDocView = TRUE;

-//QMessageBox::information(0, "setDocument", fileref);

-    openFile(fileref);

-//    showEditTools();

-}

-

-void QTReaderApp::closeEvent( QCloseEvent *e )

-{

-//    qDebug("Close event");

-    if (m_fullscreen)

-    {

-        m_fullscreen = false;

-        showEditTools();

-        e->accept();

-    }

-    else if (m_dontSave)

-    {

-        e->accept();

-    }

-    else

-    {

-        if (editorStack->visibleWidget() == reader)

-        {

-            if ((m_escapeTarget != cesNone) && m_bcloseDisabled)

-            {

-        //qDebug("Close disabled");

-                m_bcloseDisabled = false;

-                e->ignore();

-            }

-            else

-            {

-                if (m_fontVisible)

-                {

-                    m_fontBar->hide();

-                    m_fontVisible = false;

-                }

-                if (regVisible)

-                {

-                    regBar->hide();

-#ifdef USEQPE

-                    Global::hideInputMethod();

-#endif

-                    regVisible = false;

-                    return;

-                }

-                if (searchVisible)

-                {

-                    searchBar->hide();

-#ifdef USEQPE

-                    Global::hideInputMethod();

-#endif

-                    searchVisible = false;

-                    return;

-                }

-                if (m_fBkmksChanged && pBkmklist != NULL)

-                {

-                    if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)

-                        savebkmks();

-                    delete pBkmklist;

-                    pBkmklist = NULL;

-                    m_fBkmksChanged = false;

-                }

-                bFromDocView = FALSE;

-                updatefileinfo();

-                saveprefs();

-                e->accept();

-            }

-        }

-        else

-        {

-            showEditTools();

-            m_disableesckey = true;

-        }

-    }

-}

-

-void QTReaderApp::do_gotomark()

-{

-    m_nBkmkAction = cGotoBkmk;

-    if (!listbkmk(pBkmklist))

-        QMessageBox::information(this, PROGNAME, "No bookmarks in memory");

-}

-

-void QTReaderApp::do_delmark()

-{

-    m_nBkmkAction = cDelBkmk;

-    if (!listbkmk(pBkmklist))

-        QMessageBox::information(this, PROGNAME, "No bookmarks in memory");

-}

-

-bool QTReaderApp::listbkmk(CList<Bkmk>* plist, const QString& _lab)

-{

-    bkmkselector->clear();

-    if (_lab.isEmpty())

-        bkmkselector->setText("Cancel");

-    else

-        bkmkselector->setText(_lab);

-    int cnt = 0;

-    if (plist != NULL)

-      {

-        for (CList<Bkmk>::iterator i = plist->begin(); i != plist->end(); i++)

-          {

-#ifdef _UNICODE

-        //      qDebug("Item:%s", (const char*)toQString(i->name()));

-            bkmkselector->insertItem(toQString(i->name()));

-#else

-            bkmkselector->insertItem(i->name());

-#endif

-            cnt++;

-          }

-      }

-    if (cnt > 0)

-      {

-          hidetoolbars();

-        editorStack->raiseWidget( bkmkselector );

-        return true;

-      }

-    else

-        return false;

-}

-

-void QTReaderApp::do_autogen()

-{

-  m_nRegAction = cAutoGen;

-  regEdit->setText(m_autogenstr);

-  do_regedit();

-}

-

-void QTReaderApp::do_regedit()

-{

-//    fileBar->hide();

-    reader->bDoUpdates = false;

-//    qDebug("Showing regbar");

-  regBar->show();

-//    qDebug("Showing kbd");

-#ifdef USEQPE

-  Global::showInputMethod();

-#endif

-  regVisible = true;

-  regEdit->setFocus();

-//  qApp->processEvents();

-    reader->bDoUpdates = true;

-    reader->update();

-}

-

-bool QTReaderApp::openfrombkmk(Bkmk* bk)

-{

-    QString fn = toQString(

-        CFiledata(bk->anno()).name()

-        );

-        //qDebug("fileinfo");

-    if (!fn.isEmpty() && QFileInfo(fn).isFile())

-    {

-        //qDebug("Opening");

-        openFile(fn);

-        struct stat fnstat;

-        stat((const char *)reader->m_lastfile, &fnstat);

-        

-        if (CFiledata(bk->anno()).date()

-            != fnstat.st_mtime)

-        {

-            CFiledata fd(bk->anno());

-            fd.setdate(fnstat.st_mtime);

-            bk->value(0);

-        }

-        else

-        {

-            unsigned short svlen = bk->filedatalen();

-            unsigned char* svdata = bk->filedata();

-            reader->putSaveData(svdata, svlen);

-        //    setstate(svdata, svlen);

-            if (svlen != 0)

-            {

-                QMessageBox::warning(this, PROGNAME, "Not all file data used\nNew version?");

-            }

-        //    qDebug("updating");

-        //    showEditTools();

-            reader->locate(bk->value());

-        }

-        return true;

-    }

-    else

-    {

-        return false;

-    }

-}

-

-void QTReaderApp::gotobkmk(int ind)

-{

-    showEditTools();

-    switch (m_nBkmkAction)

-    {

-        case cOpenFile:

-        {

-        //    qApp->processEvents();

-            if (!openfrombkmk((*pOpenlist)[ind]))

-            {

-                pOpenlist->erase(ind);

-                QMessageBox::information(this, PROGNAME, "Can't find file");

-            }

-        }

-        break;

-        case cGotoBkmk:

-            reader->locate((*pBkmklist)[ind]->value());

-            break;

-        case cDelBkmk:

-        ////    qDebug("Deleting:%s\n",(*pBkmklist)[ind]->name());

-            pBkmklist->erase(ind);

-            m_fBkmksChanged = true;

-        //    pBkmklist->sort();

-            break;

-        case cRmBkmkFile:

-                {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                d.remove(bkmkselector->text(ind));

-#else /* USEQPE */

-                unlink((const char *)Global::applicationFileName(APPDIR,bkmkselector->text(ind)));

-#endif /* USEQPE */

-                }

-            break;

-        case cLdConfig:

-            readconfig(bkmkselector->text(ind), false);

-            break;

-        case cRmConfig:

-                {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR "/configs");

-                d.remove(bkmkselector->text(ind));

-#else /* USEQPE */

-                unlink((const char *)Global::applicationFileName(APPDIR "/configs",bkmkselector->text(ind)));

-#endif /* USEQPE */

-                }

-            break;

-        case cExportLinks:

-        {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-            d.cd(APPDIR "/urls");

-            QFileInfo fi(d, bkmkselector->text(ind));

-            if (fi.exists())

-            {

-                QString outfile( QFileDialog::getSaveFileName( QString::null, QString::null, this ) );

-                if (!outfile.isEmpty())

-                {

-                    FILE* fout = fopen((const char *)outfile, "w");

-                    if (fout != NULL)

-                    {

-                        FILE* fin = fopen((const char *)fi.absFilePath(), "r");

-                        if (fin != NULL)

-                        {

-                            fprintf(fout, "<html><body>\n");

-                            int ch = 0;

-                            while ((ch = fgetc(fin)) != EOF)

-                            {

-                                fputc(ch, fout);

-                            }

-                            fclose(fin);

-                            fprintf(fout, "</html></body>\n");

-                            d.remove(bkmkselector->text(ind));

-                        }

-                        fclose(fout);

-                    }

-                    else

-                        QMessageBox::information(this, PROGNAME, "Couldn't open output");

-                }

-            }

-#else /* USEQPE */

-            FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");

-            if (fin != NULL)

-            {

-                bool allok = false;

-                fileBrowser* fb = new fileBrowser(true, this,"OpieReader",!m_bFloatingDialog, 0, "*", QString::null);

-                if (fb->exec())

-                {

-                    QString outfile = fb->getCurrentFile();

-                    FILE* fout = fopen((const char *)outfile, "w");

-                    if (fout != NULL)

-                    {

-                        fprintf(fout, "<html><body>\n");

-                        int ch = 0;

-                        while ((ch = fgetc(fin)) != EOF)

-                        {

-                            fputc(ch, fout);

-                        }

-                        fprintf(fout, "</html></body>\n");

-                        fclose(fout);

-                        allok = true;

-                    }

-                    else

-                        QMessageBox::information(this, PROGNAME, "Couldn't open output");

-                }

-                delete fb;

-                fclose(fin);

-                if (allok) unlink((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)));

-            }

-            else

-            {

-                QMessageBox::information(this, PROGNAME, "Couldn't open input");

-            }

-

-/*

-            CFileSelector *f = new CFileSelector("text/html", this, NULL, !m_bFloatingDialog, TRUE, TRUE );

-            int ret = f->exec();

-            qDebug("Return:%d", ret);

-            DocLnk* doc = f->getDoc();

-            if (doc != NULL)

-            {

-                FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");

-                QString rt;

-                rt = "<html><body>\n";

-                int ch = 0;

-                while ((ch = fgetc(fin)) != EOF)

-                {

-                    rt += (char)ch;

-                }

-                fclose(fin);

-                rt += "</html></body>\n";

-                if ( doc->name().isEmpty() )

-                {

-                    doc->setName(bkmkselector->text(ind));

-                }

-                FileManager fm;

-                fm.saveFile( *doc, rt );

-                qDebug("YES");

-            }

-            else

-            {

-                qDebug("NO");

-            }

-            delete f;

-*/

-

-#endif /* USEQPE */

-        }

-        break;

-    }

-}

-

-void QTReaderApp::cancelbkmk()

-{

-    if (m_nBkmkAction == cOpenFile)

-    {

-        QString fn = usefilebrowser();

-        if (!fn.isEmpty() && QFileInfo(fn).isFile()) openFile(fn);

-    }

-  showEditTools();

-}

-

-void QTReaderApp::jump()

-{

-  m_nRegAction = cJump;

-  char lcn[20];

-  sprintf(lcn, "%lu", reader->pagelocate());

-  regEdit->setText(lcn);

-  do_regedit();

-}

-

-void QTReaderApp::do_jump(const QString& lcn)

-{

-    bool ok;

-    unsigned long ulcn = lcn.toULong(&ok);

-    if (ok)

-        reader->locate(ulcn);

-    else

-        QMessageBox::information(this, PROGNAME, "Must be a number");

-}

-

-void QTReaderApp::do_regaction()

-{

-    reader->bDoUpdates = false;

-  regBar->hide();

-#ifdef USEQPE

-  Global::hideInputMethod();

-#endif

-  regVisible = false;

-  switch(m_nRegAction)

-  {

-      case cAutoGen:

-          do_autogen(regEdit->text());

-          break;

-      case cAddBkmk:

-          do_addbkmk(regEdit->text());

-          break;

-      case cJump:

-          do_jump(regEdit->text());

-          break;

-/*

-      case cMonoSpace:

-          do_mono(regEdit->text());

-          break;

-*/

-      case cSetTarget:

-          do_settarget(regEdit->text());

-          break;

-#ifdef _SCROLLPIPE

-      case cSetPipeTarget:

-          do_setpipetarget(regEdit->text());

-          break;

-#endif

-      case cSetConfigName:

-        //  qDebug("Saving config");

-          do_saveconfig(regEdit->text(), false);

-          break;

-  }

-//  reader->restore();

-//    fileBar->show();

-  reader->setFocus();

-//    qApp->processEvents();

-    reader->bDoUpdates = true;

-    reader->update();

-}

-

-void QTReaderApp::do_settarget(const QString& _txt)

-{

-    int ind = _txt.find('/');

-    if (ind == -1)

-    {

-        m_targetapp = "";

-        m_targetmsg = "";

-        QMessageBox::information(this, PROGNAME, "Format is\nappname/messagename");

-    }

-    else

-    {

-        m_targetapp = _txt.left(ind);

-        m_targetmsg = _txt.right(_txt.length()-ind-1);

-    }

-}

-

-void QTReaderApp::chooseencoding()

-{

-    m_fontSelector->clear();

-    m_fontSelector->insertItem("Ascii");

-    m_fontSelector->insertItem("UTF-8");

-    m_fontSelector->insertItem("UCS-2(BE)");

-    m_fontSelector->insertItem("USC-2(LE)");

-    m_fontSelector->insertItem("Palm");

-    for (unicodetable::iterator iter = unicodetable::begin(); iter != unicodetable::end(); iter++)

-    {

-        m_fontSelector->insertItem(iter->mime);

-    } // delete the FontDatabase!!!

-    m_fontSelector->setCurrentItem (reader->m_encd);

-    m_fontAction = cChooseEncoding;

-    m_fontBar->show();

-    m_fontVisible = true;

-}

-

-void QTReaderApp::setfont()

-{

-    m_fontSelector->clear();

-    {

-#ifdef USEQPE

-        FontDatabase f;

-#else

-        QFontDatabase f;

-#endif

-        QStringList flist = f.families();

-        m_fontSelector->insertStringList(flist);

-    } // delete the FontDatabase!!!

-

-    for (int i = 1; i <= m_fontSelector->count(); i++)

-    {

-        if (m_fontSelector->text(i) == reader->m_fontname)

-        {

-            m_fontSelector->setCurrentItem(i);

-            break;

-        }

-    }

-    m_fontAction = cChooseFont;

-    m_fontBar->show();

-    m_fontVisible = true;

-}

-

-void QTReaderApp::setfontHelper(const QString& lcn, int size)

-{

-    if (size == 0) size = reader->m_fontControl.currentsize();

-    if (m_propogatefontchange)

-    {

-        QFont f(lcn, 10);

-        bkmkselector->setFont( f );

-        regEdit->setFont( f );

-        searchEdit->setFont( f );

-        m_annoWin->setFont( f );

-    }

-    reader->m_fontname = lcn;

-    if (!reader->ChangeFont(size))

-    {

-        reader->ChangeFont(size);

-    }

-}

-

-void QTReaderApp::do_setencoding(int i)

-{

-//    qDebug("setencoding:%d", i);

-    if (m_fontAction == cChooseEncoding)

-    {

-        reader->setencoding(i);

-    }

-    reader->refresh();

-    m_fontBar->hide();

-    m_fontVisible = false;

-//    qDebug("showedit");

-    if (reader->isVisible()) showEditTools();

-//    qDebug("showeditdone");

-}

-

-void QTReaderApp::do_setfont(const QString& lcn)

-{

-    if (m_fontAction == cChooseFont)

-    {

-        setfontHelper(lcn);

-    }

-    reader->refresh();

-    m_fontBar->hide();

-    m_fontVisible = false;

-//    qDebug("showedit");

-    //if (reader->isVisible())

-    showEditTools();

-//    qDebug("showeditdone");

-}

-

-void QTReaderApp::do_autogen(const QString& regText)

-{

-    unsigned long fs, ts;

-    reader->sizes(fs,ts);

-//  //  qDebug("Reg:%s\n", (const tchar*)(regEdit->text()));

-  m_autogenstr = regText;

-  QRegExp re(regText);

-  CBuffer buff;

-  if (pBkmklist != NULL) delete pBkmklist;

-  pBkmklist = new CList<Bkmk>;

-  m_fBkmksChanged = true;

-

-  pbar->setGeometry(regBar->x(),regBar->y(),regBar->width(), regBar->height());

-  pbar->show();

-  pbar->raise();

-  pbar->reset();

-  reader->update();

-  qApp->processEvents();

-  reader->setFocus();

-  reader->jumpto(0);

-  int lastpc = 0;

-  int i = 0;

-  while (i >= 0)

-    {

-      unsigned int lcn = reader->locate();

-      int pc = (100*lcn)/ts;

-      if (pc != lastpc)

-      {

-        pbar->setProgress(pc);

-        qApp->processEvents();

-        if (reader->locate() != lcn) reader->jumpto(lcn);

-        reader->setFocus();

-        lastpc = pc;

-      }

-      i = reader->buffdoc.getpara(buff);

-#ifdef _UNICODE

-      if (re.match(toQString(buff.data())) != -1)

-#else

-      if (re.match(buff.data()) != -1)

-#endif

-        pBkmklist->push_back(Bkmk(buff.data(), NULL, lcn));

-    }

-  pBkmklist->sort();

-  pbar->setProgress(100);

-  qApp->processEvents();

-  pbar->hide();

-  reader->refresh();

-}

-

-void QTReaderApp::saveprefs()

-{

-//    qDebug("saveprefs");

-//  reader->saveprefs("uqtreader");

-//    if (!m_loadedconfig)

-        do_saveconfig( APPDIR, true );

-

-/*    

-    Config config( APPDIR );

-    config.setGroup( "View" );

-    

-    reader->m_lastposn = reader->pagelocate();

-    

-    config.writeEntry("FloatDialogs", m_bFloatingDialog);

-    config.writeEntry( "StripCr", reader->bstripcr );

-    config.writeEntry( "AutoFmt", reader->bautofmt );

-    config.writeEntry( "TextFmt", reader->btextfmt );

-    config.writeEntry( "StripHtml", reader->bstriphtml );

-    config.writeEntry( "Dehyphen", reader->bdehyphen );

-    config.writeEntry( "Depluck", reader->bdepluck );

-    config.writeEntry( "Dejpluck", reader->bdejpluck );

-    config.writeEntry( "OneSpace", reader->bonespace );

-    config.writeEntry( "Unindent", reader->bunindent );

-    config.writeEntry( "Repara", reader->brepara );

-    config.writeEntry( "DoubleSpace", reader->bdblspce );

-    config.writeEntry( "Indent", reader->bindenter );

-    config.writeEntry( "FontSize", (int)(reader->m_fontControl.currentsize()) );

-    config.writeEntry( "ScrollDelay", reader->m_delay);

-    config.writeEntry( "LastFile", reader->m_lastfile );

-    config.writeEntry( "LastPosn", (int)(reader->pagelocate()) );

-    config.writeEntry( "PageMode", reader->m_bpagemode );

-    config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced );

-    config.writeEntry( "SwapMouse", reader->m_swapmouse);

-    config.writeEntry( "Fontname", reader->m_fontname );

-    config.writeEntry( "Encoding", reader->m_encd );

-    config.writeEntry( "CharSpacing", reader->m_charpc );

-    config.writeEntry( "Overlap", (int)(reader->m_overlap) );

-    config.writeEntry( "Margin", (int)reader->m_border );

-    config.writeEntry( "TargetApp", m_targetapp );

-    config.writeEntry( "TargetMsg", m_targetmsg );

-#ifdef _SCROLLPIPE

-    config.writeEntry( "PipeTarget", reader->m_pipetarget );

-    config.writeEntry( "PauseAfterPara", reader->m_pauseAfterEachPara );

-#endif

-    config.writeEntry( "TwoTouch", m_twoTouch );

-    config.writeEntry( "Annotation", m_doAnnotation);

-    config.writeEntry( "Dictionary", m_doDictionary);

-    config.writeEntry( "Clipboard", m_doClipboard);

-    config.writeEntry( "SpaceTarget", m_spaceTarget);

-    config.writeEntry( "EscapeTarget", m_escapeTarget);

-    config.writeEntry( "ReturnTarget", m_returnTarget);

-    config.writeEntry( "LeftTarget", m_leftTarget);

-    config.writeEntry( "RightTarget", m_rightTarget);

-    config.writeEntry( "UpTarget", m_upTarget);

-    config.writeEntry( "DownTarget", m_downTarget);

-    config.writeEntry("LeftScroll", m_leftScroll);

-    config.writeEntry("RightScroll", m_rightScroll);

-    config.writeEntry("UpScroll", m_upScroll);

-    config.writeEntry("DownScroll", m_downScroll);

-#ifdef REPALM

-    config.writeEntry( "Repalm", reader->brepalm );

-#endif

-    config.writeEntry( "Remap", reader->bremap );

-    config.writeEntry( "Peanut", reader->bpeanut );

-    config.writeEntry( "MakeBold", reader->bmakebold );

-    config.writeEntry( "Continuous", reader->m_continuousDocument );

-    config.writeEntry( "FullJust", reader->bfulljust );

-    config.writeEntry( "ExtraSpace", reader->getextraspace() );

-    config.writeEntry( "ExtraLead", reader->getlead() );

-    config.writeEntry( "Basesize",  (int)reader->getBaseSize());

-    config.writeEntry( "RequestorFontChange", m_propogatefontchange);

-

-    config.setGroup( "Toolbar" );

-    config.writeEntry("Movable", m_tbmovesave);

-    config.writeEntry("Policy", m_tbpolsave);

-    config.writeEntry("Position", m_tbposition);

-*/

-    savefilelist();

-}

-

-/*

-void QTReaderApp::oldFile()

-{

-//  qDebug("oldFile called");

-  reader->setText(true);

-//  qDebug("settext called");

-  showEditTools();

-//  qDebug("showedit called");

-}

-*/

-

-/*

-void info_cb(Fl_Widget* o, void* _data)

-{

-

-    if (infowin == NULL)

-    {

-        

-        infowin = new Fl_Window(160,240);

-        filename = new Fl_Output(45,5,110,14,"Filename");

-        filesize = new Fl_Output(45,25,110,14,"Filesize");

-        textsize = new Fl_Output(45,45,110,14,"Textsize");

-        comprat = new CBar(45,65,110,14,"Ratio %");

-        posn = new Fl_Output(45,85,110,14,"Location");

-        frcn = new CBar(45,105,110,14,"% Read");

-        about = new Fl_Multiline_Output(5,125,150,90);

-        about->value("TWReader - $Name$\n\nA file reader program for the Agenda\n\nReads text, PalmDoc and ppms format files");

-        Fl_Button *jump_accept = new Fl_Button(62,220,35,14,"Okay");

-        infowin->set_modal();

-    }

-    if (((reader_ui *)_data)->g_filename[0] != '\0')

-    {

-        unsigned long fs,ts;

-        tchar sz[20];

-        ((reader_ui *)_data)->input->sizes(fs,ts);

-        unsigned long pl = ((reader_ui *)_data)->input->locate();

-

-        filename->value(((reader_ui *)_data)->g_filename);

-

-        sprintf(sz,"%u",fs);

-        filesize->value(sz);

-

-        sprintf(sz,"%u",ts);

-        textsize->value(sz);

-

-        comprat->value(100-(100*fs + (ts >> 1))/ts);

-

-        sprintf(sz,"%u",pl);

-        posn->value(sz);

-

-        frcn->value((100*pl + (ts >> 1))/ts);

-    }

-    infowin->show();

-}

-*/

-

-void QTReaderApp::savebkmks()

-{

-    if (pBkmklist != NULL)

-    {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                QFileInfo fi(d, reader->m_string);

-        BkmkFile bf((const char *)fi.absFilePath(), true);

-#else /* USEQPE */

-        BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string), true);

-#endif /* USEQPE */

-        bf.write(*pBkmklist);

-    }

-        m_fBkmksChanged = false;

-}

-

-void QTReaderApp::readfilelist()

-{

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                QFileInfo fi(d, ".openfiles");

-    BkmkFile bf((const char *)fi.absFilePath());

-#else /* USEQPE */

-    BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"));

-#endif /* USEQPE */

-//    qDebug("Reading open files");

-    pOpenlist = bf.readall();

-//    if (pOpenlist != NULL) qDebug("...with success");

-//    else qDebug("...without success!");

-}

-

-void QTReaderApp::savefilelist()

-{

-    if (pOpenlist != NULL)

-    {

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                QFileInfo fi(d, ".openfiles");

-        BkmkFile bf((const char *)fi.absFilePath(), true);

-#else /* USEQPE */

-        BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"), true);

-#endif /* USEQPE */

-        //qDebug("Writing open files");

-        bf.write(*pOpenlist);

-    }

-}

-

-void QTReaderApp::readbkmks()

-{

-    if (pBkmklist != NULL)

-    {

-            delete pBkmklist;

-    }

-    struct stat fnstat;

-    struct stat bkstat;

-#ifndef USEQPE

-            QDir d = QDir::home();                      // "/"

-                d.cd(APPDIR);

-                QFileInfo fi(d, reader->m_string);

-#endif /* ! USEQPE */

-    if (

-        stat((const char *)reader->m_lastfile, &fnstat) == 0

-        &&

-#ifndef USEQPE

-        stat((const char *)fi.absFilePath(), &bkstat) == 0

-#else /* USEQPE */

-        stat((const char *)Global::applicationFileName(APPDIR,reader->m_string), &bkstat) == 0

-#endif /* USEQPE */

-        )

-    {

-        if (bkstat.st_mtime < fnstat.st_mtime)

-        {

-#ifndef USEQPE

-            unlink((const char *)fi.absFilePath());

-#else /* USEQPE */

-            unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));

-#endif /* USEQPE */

-        }

-    }

-

-#ifndef USEQPE

-    BkmkFile bf((const char *)fi.absFilePath());

-#else /* USEQPE */

-    BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string));

-#endif /* USEQPE */

-

-    pBkmklist = bf.readall();

-    m_fBkmksChanged = bf.upgraded();

-    if (pBkmklist == NULL)

-    {

-        pBkmklist = reader->getbkmklist();

-    }

-    if (pBkmklist != NULL)

-        pBkmklist->sort();

-}

-

-void QTReaderApp::addbkmk()

-{

-  m_nRegAction = cAddBkmk;

-  regEdit->setText(reader->firstword());

-  do_regedit();

-}

-

-void QTReaderApp::do_addbkmk(const QString& text)

-{

-        if (text.isEmpty())

-        {

-          QMessageBox::information(this, PROGNAME, "Need a name for the bookmark\nSelect add again", 1);

-        }

-        else

-        {

-                if (pBkmklist == NULL) pBkmklist = new CList<Bkmk>;

-#ifdef _UNICODE

-                CBuffer buff;

-                int i = 0;

-                for (i = 0; i < text.length(); i++)

-                {

-                    buff[i] = text[i].unicode();

-                }

-                buff[i] = 0;

-                pBkmklist->push_front(Bkmk(buff.data(), NULL, reader->pagelocate()));

-#else

-                pBkmklist->push_front(Bkmk((const tchar*)text, reader->pagelocate()));

-#endif

-                m_fBkmksChanged = true;

-                pBkmklist->sort();

-        }

-}

-

-void QTReaderApp::OnRedraw()

-{

-    if ((pBkmklist != NULL) && (m_bkmkAvail != NULL))

-    {

-        bool found = findNextBookmark(reader->pagelocate());

-        m_bkmkAvail->setEnabled(found);

-    }

-}

-

-void QTReaderApp::showAnnotation()

-{

-    m_annoWin->setName(toQString(m_anno->name()));

-    m_annoWin->setAnno(toQString(m_anno->anno()));

-    m_annoIsEditing = false;

-#ifdef USEQPE

-    Global::showInputMethod();

-#endif

-    editorStack->raiseWidget( m_annoWin );

-    m_annoWin->setFocus();

-}

-

-void QTReaderApp::OnWordSelected(const QString& wrd, size_t posn, const QString& line)

-{

-////    qDebug("OnWordSelected(%u):%s", posn, (const char*)wrd);

-

-    if (m_doClipboard)

-    {

-        QClipboard* cb = QApplication::clipboard();

-        cb->setText(wrd);

-#ifdef USEQPE

-        if (wrd.length() > 10)

-        {

-            Global::statusMessage(wrd.left(8) + "..");

-        }

-        else

-        {

-            Global::statusMessage(wrd);

-        }

-#endif

-    }

-    if (m_doAnnotation)

-    {

-        //addAnno(wrd, "Need to be able to edit this", posn);

-        m_annoWin->setName(line);

-        m_annoWin->setAnno("");

-        m_annoWin->setPosn(posn);

-        m_annoIsEditing = true;

-#ifdef USEQPE

-        Global::showInputMethod();

-#endif

-        editorStack->raiseWidget( m_annoWin );

-    }

-#ifdef USEQPE

-    if (m_doDictionary)

-    {

-        if (!m_targetapp.isEmpty() && !m_targetmsg.isEmpty())

-        {

-            QCopEnvelope e(("QPE/Application/"+m_targetapp).utf8(), (m_targetmsg+"(QString)").utf8());

-            e << wrd;

-        }

-    }

-#endif

-}

-

-void QTReaderApp::doAction(ActionTypes a, QKeyEvent* e)

-{

-    if (a == 0)

-    {

-        e->ignore();

-    }

-    else

-    {

-        e->accept();

-        //qDebug("Accepted");

-        switch (a)

-        {

-            case cesOpenFile:

-            {

-                fileOpen();

-            }

-            break;

-            case cesAutoScroll:

-            {

-                reader->setautoscroll(!reader->m_autoScroll);

-                setScrollState(reader->m_autoScroll);

-            }

-            break;

-            case cesActionMark:

-            {

-                addbkmk();

-            }

-            break;

-            case cesFullScreen:

-            {

-                m_actFullscreen->setOn(!m_fullscreen);

-            }

-            break;

-            case cesActionAnno:

-            {

-                addanno();

-            }

-            break;

-            case cesZoomIn:

-                zoomin();

-                break;

-            case cesZoomOut:

-                zoomout();

-                break;

-            case cesBack:

-                reader->goBack();

-                break;

-            case cesForward:

-                reader->goForward();

-                break;

-            case cesHome:

-                reader->goHome();

-                break;

-            case cesPageUp:

-                reader->dopageup();

-                break;

-            case cesPageDown:

-                reader->dopagedn();

-                break;

-            case cesLineUp:

-                reader->lineUp();

-                break;

-            case cesLineDown:

-                reader->lineDown();

-                break;

-            case cesStartDoc:

-                gotoStart();

-                break;

-            case cesEndDoc:

-                gotoEnd();

-                break;

-            default:

-                qDebug("Unknown ActionType:%u", a);

-                break;

-        }

-    }

-}

-

-void QTReaderApp::setTwoTouch(bool _b) { reader->setTwoTouch(_b); }

-void QTReaderApp::restoreFocus() { reader->setFocus(); } 

-

-void QTReaderApp::SaveConfig()

-{

-    m_nRegAction = cSetConfigName;

-    regEdit->setText(reader->m_string);

-    do_regedit();

-}

-

-void QTReaderApp::do_saveconfig(const QString& _txt, bool full)

-{

-//    qDebug("do_saveconfig:%s", (const char*)_txt);

-#ifdef USEQPE

-    QString configname;

-    Config::Domain dom;

-

-    if (full)

-    {

-        configname = _txt;

-        dom = Config::User;

-    }

-    else

-    {

-        configname = Global::applicationFileName(APPDIR "/configs", _txt);

-        dom = Config::File;

-    }

-

-    Config config(configname, dom);

-    config.setGroup( "View" );

-

-#else

-        QFileInfo fi;

-        if (full)

-        {

-        //    qDebug("full:%s", (const char*)_txt);

-            QDir d = QDir::home();                      // "/"

-                if ( !d.cd(_txt) )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/%s\" directory", (const char*)_txt );

-                        d = QDir::home();

-                        d.mkdir(_txt);

-                        d.cd(_txt);

-                }

-                fi.setFile(d, INIFILE);

-        }

-        else

-        {

-            QDir d = QDir::home();                      // "/"

-                if ( !d.cd(APPDIR) )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-                        d = QDir::home();

-                        d.mkdir(APPDIR);

-                        d.cd(APPDIR);

-                }

-                if ( !d.cd("configs") )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/" APPDIR "/configs\" directory" );

-                        d = QDir::home();

-                        d.cd(APPDIR);

-                        d.mkdir("configs");

-                        d.cd("configs");

-                }

-                fi.setFile(d, _txt);

-        }

-        //qDebug("Path:%s", (const char*)fi.absFilePath());

-        Config config(fi.absFilePath());

-#endif

-

-

-    config.writeEntry( "StripCr", reader->bstripcr );

-    config.writeEntry( "AutoFmt", reader->bautofmt );

-    config.writeEntry( "TextFmt", reader->btextfmt );

-    config.writeEntry( "StripHtml", reader->bstriphtml );

-    config.writeEntry( "Dehyphen", reader->bdehyphen );

-    config.writeEntry( "Depluck", reader->bdepluck );

-    config.writeEntry( "Dejpluck", reader->bdejpluck );

-    config.writeEntry( "OneSpace", reader->bonespace );

-    config.writeEntry( "Unindent", reader->bunindent );

-    config.writeEntry( "Repara", reader->brepara );

-    config.writeEntry( "DoubleSpace", reader->bdblspce );

-    config.writeEntry( "Indent", reader->bindenter );

-    config.writeEntry( "FontSize", (int)(reader->m_fontControl.currentsize()) );

-    config.writeEntry( "ScrollDelay", reader->m_delay);

-    if (full)

-    {

-        config.writeEntry("Debounce", m_debounce);

-        config.writeEntry("FloatDialogs", m_bFloatingDialog);

-        reader->m_lastposn = reader->pagelocate();

-        config.writeEntry( "LastFile", reader->m_lastfile );

-        config.writeEntry( "LastPosn", (int)(reader->pagelocate()) );

-    }

-    config.writeEntry( "PageMode", reader->m_bpagemode );

-    config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced );

-    config.writeEntry( "SwapMouse", reader->m_swapmouse);

-    config.writeEntry( "Fontname", reader->m_fontname );

-    config.writeEntry( "Encoding", reader->m_encd );

-    config.writeEntry( "CharSpacing", reader->m_charpc );

-    config.writeEntry( "Overlap", (int)(reader->m_overlap) );

-    config.writeEntry( "Margin", (int)reader->m_border );

-    config.writeEntry( "TargetApp", m_targetapp );

-    config.writeEntry( "TargetMsg", m_targetmsg );

-#ifdef _SCROLLPIPE

-    config.writeEntry( "PipeTarget", reader->m_pipetarget );

-    config.writeEntry( "PauseAfterPara", reader->m_pauseAfterEachPara );

-#endif

-    config.writeEntry( "TwoTouch", m_twoTouch );

-    config.writeEntry( "Annotation", m_doAnnotation);

-    config.writeEntry( "Dictionary", m_doDictionary);

-    config.writeEntry( "Clipboard", m_doClipboard);

-    config.writeEntry( "SpaceTarget", m_spaceTarget);

-    config.writeEntry( "EscapeTarget", m_escapeTarget);

-    config.writeEntry( "ReturnTarget", m_returnTarget);

-    config.writeEntry( "LeftTarget", m_leftTarget);

-    config.writeEntry( "RightTarget", m_rightTarget);

-    config.writeEntry( "UpTarget", m_upTarget);

-    config.writeEntry( "DownTarget", m_downTarget);

-    config.writeEntry("LeftScroll", m_leftScroll);

-    config.writeEntry("RightScroll", m_rightScroll);

-    config.writeEntry("UpScroll", m_upScroll);

-    config.writeEntry("DownScroll", m_downScroll);

-#ifdef REPALM

-    config.writeEntry( "Repalm", reader->brepalm );

-#endif

-    config.writeEntry( "Remap", reader->bremap );

-    config.writeEntry( "Peanut", reader->bpeanut );

-    config.writeEntry( "MakeBold", reader->bmakebold );

-    config.writeEntry( "Continuous", reader->m_continuousDocument );

-    config.writeEntry( "FullJust", reader->bfulljust );

-    config.writeEntry( "ExtraSpace", reader->getextraspace() );

-    config.writeEntry( "ExtraLead", reader->getlead() );

-    config.writeEntry( "Basesize",  (int)reader->getBaseSize());

-    config.writeEntry( "RequestorFontChange", m_propogatefontchange);

-    if (full)

-    {

-        config.setGroup( "Toolbar" );

-        config.writeEntry("Movable", m_tbmovesave);

-        config.writeEntry("Policy", m_tbpolsave);

-        config.writeEntry("Position", m_tbposition);

-#ifndef USEQPE

-        config.setGroup( "Geometry" );

-        config.writeEntry( "x", x() );

-        config.writeEntry( "y", y() );

-        config.writeEntry( "width", width() );

-        config.writeEntry( "height", height() );

-#endif

-    }

-}

-

-/*

-void QTReaderApp::setstate(unsigned char* _sd, unsigned short _sdlen)

-{

-    unsigned short sdlen;

-    memcpy(&sdlen, _sd, sizeof(sdlen));

-    sdlen -= sizeof(sdlen);

-    _sd += sizeof(sdlen);

-    statedata* sd;

-    char* data;

-    if (sdlen < sizeof(statedata)+1)

-    {

-        sdlen = sizeof(statedata)+1;

-    }

-    data = new char[sdlen];

-    sd = (statedata*)data;

-    memcpy(sd, _sd, sdlen);

-    data[sdlen] = 0;

-    reader->setstate(*sd);

-    delete [] data;

-}

-

-void QTReaderApp::getstate(unsigned char*& data, unsigned short& len)

-{

-    unsigned char* olddata = data;

-    unsigned short oldlen = len;

-    len = oldlen+sizeof(unsigned short)+sizeof(statedata)+reader->m_fontname.length();

-    data = new unsigned char[len];

-    memcpy(data, olddata, oldlen);

-    delete [] olddata;

-    memcpy(data+oldlen, &len, sizeof(len));

-    statedata* sd = (statedata*)(data+oldlen+sizeof(unsigned short));

-

-    sd->bstripcr = reader->bstripcr;

-    sd->btextfmt = reader->btextfmt;

-    sd->bautofmt = reader->bautofmt;

-    sd->bstriphtml = reader->bstriphtml;

-    sd->bpeanut = reader->bpeanut;

-    sd->bdehyphen = reader->bdehyphen;

-    sd->bdepluck = reader->bdepluck;

-    sd->bdejpluck = reader->bdejpluck;

-    sd->bonespace = reader->bonespace;

-    sd->bunindent = reader->bunindent;

-    sd->brepara = reader->brepara;

-    sd->bdblspce = reader->bdblspce;

-    sd->m_bpagemode = reader->m_bpagemode;

-    sd->m_bMonoSpaced = reader->m_bMonoSpaced;

-    sd->bremap = reader->bremap;

-    sd->bmakebold = reader->bmakebold;

-    sd->Continuous = reader->m_continuousDocument;

-#ifdef REPALM

-    sd->brepalm = reader->brepalm;

-#endif

-    sd->bindenter = reader->bindenter;

-    sd->m_textsize = reader->m_textsize; //reader->m_fontControl.currentsize()

-    sd->m_encd = reader->m_encd;

-    sd->m_charpc = reader->m_charpc;

-    strcpy(sd->m_fontname, reader->m_fontname.latin1());

-}

-*/

-#ifdef _SCRIPT

-void QTReaderApp::RunScript()

-{

-    fileBrowser* fb = new fileBrowser(this,"OpieReader",!m_bFloatingDialog,

-                                      0,

-        //                            WStyle_Customize | WStyle_NoBorderEx,

-                                      "*", Global::applicationFileName(APPDIR "/scripts", ""));

-

-    QString fn;

-    if (fb->exec())

-    {

-        fn = fb->fileList[0];

-    }

-    delete fb;

-    if ( !fn.isEmpty() && fork() == 0 )

-    {

-        execlp((const char *)fn,(const char *)fn,NULL);

-    }

-}

-

-void QTReaderApp::SaveScript(const char* sname)

-{

-    FILE* f = fopen(sname,"w");

-    if (f != NULL)

-    {

-#ifdef OPIE

-        fprintf(f, "#!/bin/sh\nmsg() {\n\tqcop QPE/Application/reader \"$1\" \"$2\" \"$3\"\n}\n");

-#else

-        fprintf(f, "#!/bin/bash\nmsg() {\n\tqcop QPE/Application/uqtreader \"$1\" \"$2\" \"$3\"\n}\n");

-#endif

-        fprintf(f, "msg \"Update(int)\" 0\n");

-        fprintf(f, "msg \"Layout/StripCR(int)\" %d\n", (reader->bstripcr) ? 1:0);

-        if (reader->btextfmt) fprintf(f, "msg \"Markup(QString)\" \"Text\"\n");

-        else if (reader->bautofmt) fprintf(f, "msg \"Markup(QString)\" \"Auto\"\n");

-        else if (reader->bstriphtml) fprintf(f, "msg \"Markup(QString)\" \"HTML\"\n");

-        else if (reader->bpeanut) fprintf(f, "msg \"Markup(QString)\" \"Peanut/PML\"\n");

-        else fprintf(f, "msg \"Markup(QString)\" \"None\"\n");

-        fprintf(f, "msg \"Layout/Dehyphen(int)\" %d\n", (reader->bdehyphen) ? 1:0);

-        fprintf(f, "msg \"Layout/Depluck(int)\" %d\n", (reader->bdepluck) ? 1:0);

-        fprintf(f, "msg \"Layout/Dejpluck(int)\" %d\n", (reader->bdejpluck) ? 1:0);

-        fprintf(f, "msg \"Layout/SingleSpace(int)\" %d\n", (reader->bonespace) ? 1:0);

-        fprintf(f, "msg \"Layout/Unindent(int)\" %d\n", (reader->bunindent) ? 1:0);

-        fprintf(f, "msg \"Layout/Re-paragraph(int)\" %d\n", (reader->brepara) ? 1:0);

-        fprintf(f, "msg \"Layout/DoubleSpace(int)\" %d\n", (reader->bdblspce) ? 1:0);

-        fprintf(f, "msg \"Layout/Indent(int)\" %d\n", reader->bindenter);

-        fprintf(f, "msg \"Format/SetFont(QString,int)\" \"%s\" %d\n", (const char*)reader->m_fontname, reader->m_textsize);

-        fprintf(f, "msg \"Navigation/Page/LineScroll(int)\" %d\n", (reader->m_bpagemode) ? 1:0);

-        fprintf(f, "msg \"Format/Ideogram/Word(int)\" %d\n", (reader->m_bMonoSpaced) ? 1:0);

-        fprintf(f, "msg \"Format/Encoding(QString)\" \"%s\"\n", (const char*)m_EncodingAction[reader->m_encd]->text());

-        fprintf(f, "msg \"Format/SetWidth(int)\" %d\n", reader->m_charpc);

-        fprintf(f, "msg \"Navigation/SetOverlap(int)\" %d\n", reader->m_overlap);

-        fprintf(f, "msg \"Layout/Remap(int)\" %d\n", (reader->bremap) ? 1:0);

-        fprintf(f, "msg \"Layout/Embolden(int)\" %d\n", (reader->bmakebold) ? 1:0);

-        fprintf(f, "msg \"File/Continuous(int)\" %d\n", (reader->m_continuousDocument) ? 1:0);

-        fprintf(f, "msg \"File/SetDictionary(QString)\" \"%s/%s\"\n", (const char *)m_targetapp, (const char *)m_targetmsg);

-#ifdef _SCROLLPIPE

-        fprintf(f, "msg \"File/SetScrollTarget(QString)\" \"%s\"\n", (const char *)reader->m_pipetarget);

-#endif

-        fprintf(f, "msg \"File/Two/OneTouch(int)\" %d\n", (m_twoTouch) ? 1:0);

-        fprintf(f, "msg \"Target/Annotation(int)\" %d\n", (m_doAnnotation) ? 1:0);

-        fprintf(f, "msg \"Target/Dictionary(int)\" %d\n", (m_doDictionary) ? 1:0);

-        fprintf(f, "msg \"Target/Clipboard(int)\" %d\n", (m_doClipboard) ? 1:0);

-        fprintf(f, "msg \"File/Action(QString)\" \"%s\"\n", (const char *)m_buttonAction[m_spaceTarget]->text());

-        fprintf(f, "msg \"Update(int)\" 1\n");

-        fprintf(f, "msg \"info(QString)\" \"All Done\"\n");

-        fclose(f);

-        chmod(sname, S_IXUSR | S_IXGRP | S_IXOTH);

-    }

-}

-

-void QTReaderApp::SaveConfig()

-{

-    m_nRegAction = cSetConfigName;

-    regEdit->setText("");

-    do_regedit();

-}

-

-void QTReaderApp::do_saveconfig(const QString& _txt)

-{

-    SaveScript(Global::applicationFileName(APPDIR "/scripts", _txt));

-}

-#endif

-

-#ifdef _SCROLLPIPE

-void QTReaderApp::setpipetarget()

-{

-    m_nRegAction = cSetPipeTarget;

-    QString text = (reader->m_pipetarget.isEmpty()) ? QString("") : reader->m_pipetarget;

-    regEdit->setText(text);

-    do_regedit();

-}

-

-void QTReaderApp::do_setpipetarget(const QString& _txt)

-{

-    reader->m_pipetarget = _txt;

-}

-

-void QTReaderApp::setpause(bool sfs)

-{

-    reader->m_pauseAfterEachPara = sfs;

-}

-#endif

-

-void QTReaderApp::monospace(bool _b)

-{

-    reader->setmono(_b);

-}

-

-bool QTReaderApp::readconfig(const QString& _txt, bool full=false)

-{

-#ifdef USEQPE

-    QString configname;

-    Config::Domain dom;

-

-    if (full)

-    {

-        configname = _txt;

-        dom = Config::User;

-    }

-    else

-    {

-        configname = Global::applicationFileName(APPDIR "/configs", _txt);

-        QFileInfo fm(configname);

-        if ( !fm.exists() ) return false;

-        dom = Config::File;

-    }

-

-    Config config(configname, dom);

-    config.setGroup( "View" );

-

-#else

-        QFileInfo fi;

-        if (full)

-        {

-            QDir d = QDir::home();                      // "/"

-                if ( !d.cd(_txt) )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/%s\" directory", (const char*)_txt );

-                        d = QDir::home();

-                        d.mkdir(_txt);

-                        d.cd(_txt);

-                }

-                fi.setFile(d, INIFILE);

-        }

-        else

-        {

-            QDir d = QDir::home();                      // "/"

-                if ( !d.cd(APPDIR) )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-                        d = QDir::home();

-                        d.mkdir(APPDIR);

-                        d.cd(APPDIR);

-                }

-                if ( !d.cd("configs") )

-                {                       // "/tmp"

-                        qWarning( "Cannot find the \"~/" APPDIR "/configs\" directory" );

-                        d = QDir::home();

-                        d.mkdir("configs");

-                        d.cd("configs");

-                }

-                fi.setFile(d, _txt);

-        }

-#ifdef _WINDOWS

-        struct stat fnstat;

-    if (stat((const char *)reader->m_lastfile, &fnstat) == 0) return false; // get round fileinfo bug on windows

-#else

-        if (!fi.exists()) return false;

-#endif

-        Config config(fi.absFilePath());

-#endif

-    if (full)

-    {

-        config.setGroup("Toolbar");

-        m_tbmovesave = m_tbmove = config.readBoolEntry("Movable", false);

-        m_tbpolsave = m_tbpol = (ToolbarPolicy)config.readNumEntry("Policy", 1);

-        m_tbposition = (ToolBarDock)config.readNumEntry("Position", 2);

-    }

-    config.setGroup( "View" );

-    m_bFloatingDialog = config.readBoolEntry("FloatDialogs", false);

-    reader->bstripcr = config.readBoolEntry( "StripCr", true );

-    reader->bfulljust = config.readBoolEntry( "FullJust", false );

-    reader->setextraspace(config.readNumEntry( "ExtraSpace", 0 ));

-    reader->setlead(config.readNumEntry( "ExtraLead", 0 ));

-    reader->btextfmt = config.readBoolEntry( "TextFmt", false );

-    reader->bautofmt = config.readBoolEntry( "AutoFmt", true );

-    reader->bstriphtml = config.readBoolEntry( "StripHtml", false );

-    reader->bpeanut = config.readBoolEntry( "Peanut", false );

-    reader->bdehyphen = config.readBoolEntry( "Dehyphen", false );

-    reader->bdepluck = config.readBoolEntry( "Depluck", false );

-    reader->bdejpluck = config.readBoolEntry( "Dejpluck", false );

-    reader->bonespace = config.readBoolEntry( "OneSpace", false );

-    reader->bunindent = config.readBoolEntry( "Unindent", false );

-    reader->brepara = config.readBoolEntry( "Repara", false );

-    reader->bdblspce = config.readBoolEntry( "DoubleSpace", false );

-    reader->bindenter = config.readNumEntry( "Indent", 0 );

-    reader->m_textsize = config.readNumEntry( "FontSize", 12 );

-    reader->m_delay = config.readNumEntry( "ScrollDelay", 5184);

-    if (full)

-    {

-        reader->m_lastfile = config.readEntry( "LastFile", QString::null );

-        reader->m_lastposn = config.readNumEntry( "LastPosn", 0 );

-    }

-    reader->m_bpagemode = config.readBoolEntry( "PageMode", true );

-    reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false);

-    reader->m_swapmouse = config.readBoolEntry( "SwapMouse", false);

-     reader->m_fontname = config.readEntry( "Fontname", "helvetica" );

-    reader->m_encd = config.readNumEntry( "Encoding", 0 );

-    reader->m_charpc = config.readNumEntry( "CharSpacing", 100 );

-    reader->m_overlap = config.readNumEntry( "Overlap", 0 );

-    reader->m_border = config.readNumEntry( "Margin", 6 );

-#ifdef REPALM

-    reader->brepalm = config.readBoolEntry( "Repalm", true );

-#endif

-    reader->bremap = config.readBoolEntry( "Remap", true );

-    reader->bmakebold = config.readBoolEntry( "MakeBold", false );

-    reader->setContinuous(config.readBoolEntry( "Continuous", true ));

-    m_targetapp = config.readEntry( "TargetApp", QString::null );

-    m_targetmsg = config.readEntry( "TargetMsg", QString::null );

-#ifdef _SCROLLPIPE

-    reader->m_pipetarget = config.readEntry( "PipeTarget", QString::null );

-    reader->m_pauseAfterEachPara = config.readBoolEntry( "PauseAfterPara", true );

-#endif

-    m_twoTouch = config.readBoolEntry( "TwoTouch", false);

-    m_doAnnotation = config.readBoolEntry( "Annotation", false);

-    m_doDictionary = config.readBoolEntry( "Dictionary", false);

-    m_doClipboard = config.readBoolEntry( "Clipboard", false);

-    m_spaceTarget = (ActionTypes)config.readNumEntry("SpaceTarget", cesAutoScroll);

-    m_escapeTarget = (ActionTypes)config.readNumEntry("EscapeTarget", cesNone);

-    m_returnTarget = (ActionTypes)config.readNumEntry("ReturnTarget", cesFullScreen);

-    m_leftTarget = (ActionTypes)config.readNumEntry("LeftTarget", cesZoomOut);

-    m_rightTarget = (ActionTypes)config.readNumEntry("RightTarget", cesZoomIn);

-    m_upTarget = (ActionTypes)config.readNumEntry("UpTarget", cesPageUp);

-    m_downTarget = (ActionTypes)config.readNumEntry("DownTarget", cesPageDown);

-

-    m_leftScroll = config.readBoolEntry("LeftScroll", false);

-    m_rightScroll = config.readBoolEntry("RightScroll", false);

-    m_upScroll = config.readBoolEntry("UpScroll", true);

-    m_downScroll = config.readBoolEntry("DownScroll", true);

-    m_propogatefontchange = config.readBoolEntry( "RequestorFontChange", false);

-    reader->setBaseSize(config.readNumEntry( "Basesize", 10 ));

-    reader->setTwoTouch(m_twoTouch);

-

-    m_touch_action->setOn(m_twoTouch);

-    m_setmono_action->setOn(reader->m_bMonoSpaced);

-    setfontHelper(reader->m_fontname);

-    if (full)

-    {

-        addtoolbars(&config);

-    }

-    reader->setfilter(reader->getfilter());

-    reader->refresh();

-    return true;

-}

-

-bool QTReaderApp::PopulateConfig(const char* tgtdir)

-{

-    bkmkselector->clear();

-    bkmkselector->setText("Cancel");

-#ifndef USEQPE

-    int cnt = 0;

-

-    QDir d = QDir::home();                      // "/"

-    if ( !d.cd(APPDIR) ) {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-        d = QDir::home();

-        d.mkdir(APPDIR);

-        d.cd(APPDIR);

-    }

-    if ( !d.cd(tgtdir) ) {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "/%s\" directory", tgtdir );

-        d = QDir::home();

-        d.mkdir(tgtdir);

-        d.cd(tgtdir);

-    }

-    d.setFilter( QDir::Files | QDir::NoSymLinks );

-//        d.setSorting( QDir::Size | QDir::Reversed );

-

-    const QFileInfoList *list = d.entryInfoList();

-    QFileInfoListIterator it( *list );      // create list iterator

-    QFileInfo *fi;                          // pointer for traversing

-

-    while ( (fi=it.current()) ) {           // for each file...

-  

-        bkmkselector->insertItem(fi->fileName());

-        cnt++;

-                        

-        //qDebug( "%10li %s", fi->size(), fi->fileName().data() );

-        ++it;                               // goto next list element

-    }

- 

-#else /* USEQPE */

-    int cnt = 0;

-    DIR *d;

-    char* finaldir;

-    finaldir = new char[strlen(APPDIR)+1+strlen(tgtdir)+1];

-    strcpy(finaldir, APPDIR);

-    strcat(finaldir, "/");

-    strcat(finaldir, tgtdir);

-    d = opendir((const char *)Global::applicationFileName(finaldir,""));

-

-    while(1)

-    {

-        struct dirent* de;

-        struct stat buf;

-        de = readdir(d);

-        if (de == NULL) break;

-

-        if (lstat((const char *)Global::applicationFileName(finaldir,de->d_name),&buf) == 0 && S_ISREG(buf.st_mode))

-        {

-            bkmkselector->insertItem(de->d_name);

-            cnt++;

-        }

-    }

-    delete [] finaldir;

-    closedir(d);

-#endif

-    return (cnt > 0);

-}

-

-void QTReaderApp::LoadConfig()

-{

-    if (PopulateConfig("configs"))

-      {

-        editorStack->raiseWidget( bkmkselector );

-        hidetoolbars();

-        m_nBkmkAction = cLdConfig;

-      }

-    else

-      QMessageBox::information(this, PROGNAME, "No config files");

-}

-

-void QTReaderApp::TidyConfig()

-{

-    if (PopulateConfig("configs"))

-      {

-        editorStack->raiseWidget( bkmkselector );

-        hidetoolbars();

-        m_nBkmkAction = cRmConfig;

-      }

-    else

-      QMessageBox::information(this, PROGNAME, "No config files");

-}

-

-void QTReaderApp::ExportLinks()

-{

-    if (PopulateConfig("urls"))

-      {

-        editorStack->raiseWidget( bkmkselector );

-        hidetoolbars();

-        m_nBkmkAction = cExportLinks;

-      }

-    else

-      QMessageBox::information(this, PROGNAME, "No url files");

-}

-

-void QTReaderApp::OnURLSelected(const QString& href)

-{

-    CURLDialog* urld = new CURLDialog(href, false, this);

-    urld->clipboard(m_url_clipboard);

-    urld->localfile(m_url_localfile);

-    urld->globalfile(m_url_globalfile);

-    if (urld->exec())

-    {

-        m_url_clipboard = urld->clipboard();

-        m_url_localfile = urld->localfile();

-        m_url_globalfile = urld->globalfile();

-        if (m_url_clipboard)

-        {

-            QClipboard* cb = QApplication::clipboard();

-            cb->setText(href);

-            qDebug("<a href=\"%s\">%s</a>", (const char*)href, (const char*)href);

-        }

-        if (m_url_localfile)

-        {

-            writeUrl(reader->m_string, href);

-        }

-        if (m_url_globalfile)

-        {

-            writeUrl("GlobalURLFile", href);

-        }

-    }

-    delete urld;

-}

-

-void QTReaderApp::writeUrl(const QString& file, const QString& href)

-{

-    QString filename;

-#ifdef USEQPE

-    filename = Global::applicationFileName(APPDIR "/urls", file);

-#else

-    QFileInfo fi;

-    QDir d = QDir::home();                      // "/"

-    if ( !d.cd(APPDIR) )

-    {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );

-        d = QDir::home();

-        d.mkdir(APPDIR);

-        d.cd(APPDIR);

-    }

-    if ( !d.cd("urls") )

-    {                       // "/tmp"

-        qWarning( "Cannot find the \"~/" APPDIR "/urls\" directory" );

-        d = QDir::home();

-        d.cd(APPDIR);

-        d.mkdir("urls");

-        d.cd("urls");

-    }

-    fi.setFile(d, file);

-    filename = fi.absFilePath();

-#endif

-    FILE* fout = fopen(filename, "a");

-    if (fout != NULL)

-    {

-        fprintf(fout, "<p><a href=\"%s\">%s</a>\n", (const char*)href, (const char*)href);

-        fclose(fout);

-    }

-    else

-    {

-        QMessageBox::warning(this, PROGNAME, "Problem with writing URL");

-    }

-}

+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS.  Allrights reserved.
+**
+** This file is part of Qt Palmtop Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#include "useqpe.h"
+#include <qregexp.h>
+#include <qclipboard.h>
+#include <qwidgetstack.h>
+#ifdef USEQPE
+#include <qmenubar.h>
+#include <qpe/qpetoolbar.h>
+#endif
+#include <qmenubar.h>
+#include <qtoolbar.h>
+#ifdef USEQPE
+#include <qpe/menubutton.h>
+#include <qpe/fontdatabase.h>
+#endif
+#include <qcombobox.h>
+#include <qpopupmenu.h>
+#include <qaction.h>
+#include <qapplication.h>
+#include <qlineedit.h>
+#include <qtoolbutton.h>
+#include <qspinbox.h>
+#include <qobjectlist.h>
+#ifdef USEQPE
+#include <qpe/global.h>
+#include <qpe/applnk.h>
+#endif
+#include <qfileinfo.h>
+#include <stdlib.h> //getenv
+#include <qprogressbar.h>
+#ifdef USEQPE
+#include <qpe/config.h>
+#endif
+#include <qbuttongroup.h>
+#include <qradiobutton.h>
+#ifdef USEQPE
+#include <qpe/qcopenvelope_qws.h>
+#endif
+#include "QTReader.h"
+#include "GraphicWin.h"
+#include "Bkmks.h"
+#include "cbkmkselector.h"
+#include "infowin.h"
+#include "ToolbarPrefs.h"
+#include "Prefs.h"
+#include "CAnnoEdit.h"
+#include "QFloatBar.h"
+#include "FixedFont.h"
+#include "URLDialog.h"
+//#include <qpe/fontdatabase.h>
+
+#ifdef USEQPE
+#include <qpe/resource.h>
+#include <qpe/qpeapplication.h>
+#include "fileBrowser.h"
+#else
+#include "qfiledialog.h"
+#endif
+
+#include "QTReaderApp.h"
+#include "CDrawBuffer.h"
+#include "Filedata.h"
+#include "opie.h"
+#include "names.h"
+#include "CEncoding_tables.h"
+#include "CloseDialog.h"
+
+bool CheckVersion(int&, int&, char&);
+
+#ifdef _WINDOWS
+#define PICDIR "c:\\uqtreader\\pics\\"
+#else
+#ifdef USEQPE
+#define PICDIR "opie-reader/"
+#else
+#define PICDIR "/home/tim/uqtreader/pics/"
+#endif
+#endif
+
+unsigned long QTReaderApp::m_uid = 0;
+
+void QTReaderApp::setScrollState(bool _b) { m_scrollButton->setOn(_b); }
+
+#ifdef USEQPE
+#define geticon(iconname) Resource::loadPixmap( iconname )
+#define getmyicon(iconname) Resource::loadPixmap( PICDIR iconname )
+#else
+#define geticon(iconname) QPixmap(PICDIR iconname ".png")
+#define getmyicon(iconname) geticon(iconname)
+//#define geticon(iconname) QIconSet( QPixmap(PICDIR iconname) )
+#endif
+
+#ifndef _WINDOWS
+#include <unistd.h>
+#endif
+#include <stddef.h>
+#ifndef _WINDOWS
+#include <dirent.h>
+#endif
+
+void QTReaderApp::listBkmkFiles()
+{
+    bkmkselector->clear();
+    bkmkselector->setText("Cancel");
+#ifndef USEQPE
+    int cnt = 0;
+
+    QDir d = QDir::home();                      // "/"
+    if ( !d.cd(APPDIR) ) {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+                d = QDir::home();
+                d.mkdir(APPDIR);
+                d.cd(APPDIR);
+    }
+
+
+
+
+        d.setFilter( QDir::Files | QDir::NoSymLinks );
+//        d.setSorting( QDir::Size | QDir::Reversed );
+
+        const QFileInfoList *list = d.entryInfoList();
+        QFileInfoListIterator it( *list );      // create list iterator
+        QFileInfo *fi;                          // pointer for traversing
+
+        while ( (fi=it.current()) ) {           // for each file...
+
+                    bkmkselector->insertItem(fi->fileName());
+                    cnt++;
+
+                        //qDebug( "%10li %s", fi->size(), fi->fileName().data() );
+            ++it;                               // goto next list element
+        }
+
+#else /* USEQPE */
+    int cnt = 0;
+    DIR *d;
+    d = opendir((const char *)Global::applicationFileName(APPDIR,""));
+
+    while(1)
+    {
+        struct dirent* de;
+        struct stat buf;
+        de = readdir(d);
+        if (de == NULL) break;
+
+        if (lstat((const char *)Global::applicationFileName(APPDIR,de->d_name),&buf) == 0 && S_ISREG(buf.st_mode))
+        {
+            bkmkselector->insertItem(de->d_name);
+            cnt++;
+        }
+    }
+
+    closedir(d);
+#endif
+    if (cnt > 0)
+      {
+//tjw        menu->hide();
+        editorStack->raiseWidget( bkmkselector );
+        hidetoolbars();
+        m_nBkmkAction = cRmBkmkFile;
+      }
+    else
+      QMessageBox::information(this, PROGNAME, "No bookmark files");
+}
+
+void QTReaderApp::hidetoolbars()
+{
+    menubar->hide();
+    if (fileBar != NULL) fileBar->hide();
+    if (viewBar != NULL) viewBar->hide();
+    if (navBar != NULL) navBar->hide();
+    if (markBar != NULL) markBar->hide();
+    if (m_fontVisible) m_fontBar->hide();
+    if (regVisible)
+    {
+#ifdef USEQPE
+                Global::hideInputMethod();
+#endif
+        regBar->hide();
+    }
+    if (searchVisible)
+    {
+#ifdef USEQPE
+                Global::hideInputMethod();
+#endif
+        searchBar->hide();
+    }
+}
+
+QTReaderApp::QTReaderApp( QWidget *parent, const char *name, WFlags f )
+    : QMainWindow( parent, name, f ), bFromDocView( FALSE ), m_dontSave(false),
+      fileBar(NULL), navBar(NULL), viewBar(NULL), markBar(NULL)
+{
+        m_url_clipboard = false;
+        m_url_localfile = false;
+        m_url_globalfile = false;
+                ftime(&m_lastkeytime);
+////  qDebug("Application directory = %s", (const tchar *)QPEApplication::documentDir());
+////  qDebug("Application directory = %s", (const tchar *)Global::applicationFileName("uqtreader","bkmks.xml"));
+
+    m_bcloseDisabled = true;
+    m_disableesckey = false;
+    pBkmklist = NULL;
+    pOpenlist = NULL;
+//    doc = 0;
+
+        m_fBkmksChanged = false;
+    
+  QString lang = getenv( "LANG" );
+  QString rot = getenv( "QWS_DISPLAY" );
+
+/*
+  int m_rot = 0;
+  if (rot.contains("Rot90"))
+  {
+      m_rot = 90;
+  }
+  else if (rot.contains("Rot180"))
+  {
+      m_rot = 180;
+  }
+  else if (rot.contains("Rot270"))
+  {
+      m_rot = 270;
+  }
+
+//  qDebug("Initial Rotation(%d):%s", m_rot, (const char*)rot);
+*/
+  m_autogenstr = "^ *[A-Z].*[a-z] *$";
+
+#ifdef USEQPE
+    setIcon( Resource::loadPixmap( PICDIR  "uqtreader") );
+#else
+    setIcon( QPixmap (PICDIR  "uqtreader.png") );
+#endif /* USEQPE */
+
+//    QToolBar *bar = new QToolBar( this );
+//    menubar = new QToolBar( this );
+#ifdef USEQPE
+  Config config( APPDIR );
+#else
+    QDir d = QDir::home();                      // "/"
+    if ( !d.cd(APPDIR) ) {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+                d = QDir::home();
+                d.mkdir(APPDIR);
+                d.cd(APPDIR);
+    }
+    QFileInfo fi(d, INIFILE);
+//    qDebug("Path:%s", (const char*)fi.absFilePath());
+    Config config(fi.absFilePath());
+#endif
+    config.setGroup("Toolbar");
+    m_tbmovesave = m_tbmove = config.readBoolEntry("Movable", false);
+    m_tbpolsave = m_tbpol = (ToolbarPolicy)config.readNumEntry("Policy", 1);
+    m_tbposition = (ToolBarDock)config.readNumEntry("Position", 2);
+    menubar = new QToolBar("Menus", this, m_tbposition);
+
+//    fileBar = new QToolBar("File", this);
+//    QToolBar* viewBar = new QToolBar("File", this);
+//    QToolBar* navBar = new QToolBar("File", this);
+//    QToolBar* markBar = new QToolBar("File", this);
+
+#ifdef USEQPE
+    mb = new QMenuBar( menubar );
+#else
+    mb = new QMenuBar( menubar );
+#endif
+
+//#ifdef USEQPE
+    QPopupMenu* tmp = new QPopupMenu(mb);
+    mb->insertItem( geticon( "AppsIcon" ), tmp );
+//#else
+//    QMenuBar* tmp = mb;
+//#endif
+
+    QPopupMenu *file = new QPopupMenu( mb );
+    tmp->insertItem( tr( "File" ), file );
+
+    QPopupMenu *navigation = new QPopupMenu(mb);
+    tmp->insertItem( tr( "Navigation" ), navigation );
+
+    QPopupMenu *view = new QPopupMenu( mb );
+    tmp->insertItem( tr( "View" ), view );
+
+    QPopupMenu *marks = new QPopupMenu( this );
+    tmp->insertItem( tr( "Marks" ), marks );
+
+    QPopupMenu *settings = new QPopupMenu( this );
+    tmp->insertItem( tr( "Settings" ), settings );
+
+//    addToolBar(menubar, "Menus",QMainWindow::Top);
+//    addToolBar(fileBar, "Toolbar",QMainWindow::Top);
+
+    //    QPopupMenu *edit = new QPopupMenu( this );
+
+    /*
+    QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) );
+    a->addTo( bar );
+    a->addTo( file );
+    */
+
+    editorStack = new QWidgetStack( this );
+    setCentralWidget( editorStack );
+
+    searchVisible = FALSE;
+    regVisible = FALSE;
+    m_fontVisible = false;
+
+    m_annoWin = new CAnnoEdit(editorStack);
+    editorStack->addWidget(m_annoWin, get_unique_id());
+    connect( m_annoWin, SIGNAL( finished(const QString&, const QString&) ), this, SLOT( addAnno(const QString&, const QString&) ) );
+    connect( m_annoWin, SIGNAL( cancelled() ), this, SLOT( infoClose() ) );
+
+    m_infoWin = new infowin(editorStack);
+    editorStack->addWidget(m_infoWin, get_unique_id());
+    connect( m_infoWin, SIGNAL( Close() ), this, SLOT( infoClose() ) );
+
+    m_graphicwin = new GraphicWin(editorStack);
+    editorStack->addWidget(m_graphicwin, get_unique_id());
+    connect( m_graphicwin, SIGNAL( Closed() ), this, SLOT( infoClose() ) );
+
+//    bkmkselector = new QListBox(editorStack, "Bookmarks");
+    bkmkselector = new CBkmkSelector(editorStack, "Bookmarks");
+    //    connect(bkmkselector, SIGNAL( selected(const QString&) ), this, SLOT( gotobkmk(const QString&) ) );
+    connect(bkmkselector, SIGNAL( selected(int) ), this, SLOT( gotobkmk(int) ) );
+    connect(bkmkselector, SIGNAL( cancelled() ), this, SLOT( cancelbkmk() ) );
+    editorStack->addWidget( bkmkselector, get_unique_id() );
+
+/*
+    importSelector = new FileSelector( "*", editorStack, "importselector", false );
+    connect( importSelector, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( importFile( const DocLnk & ) ) );
+
+    editorStack->addWidget( importSelector, get_unique_id() );
+
+    // don't need the close visible, it is redundant...
+    importSelector->setCloseVisible( FALSE );
+*/    
+//    qDebug("Reading file list");
+    readfilelist();
+
+    reader = new QTReader( editorStack );
+
+    reader->bDoUpdates = false;
+
+#ifdef USEQPE
+    ((QPEApplication*)qApp)->setStylusOperation(reader, QPEApplication::RightOnHold);
+#endif
+
+//    qDebug("Reading config");
+//  Config config( APPDIR );
+  config.setGroup( "View" );
+  m_debounce = config.readNumEntry("Debounce", 0);
+#ifdef USEQPE
+  m_bFloatingDialog = config.readBoolEntry("FloatDialogs", false);
+#else
+  m_bFloatingDialog = config.readBoolEntry("FloatDialogs", true);
+#endif
+  reader->bstripcr = config.readBoolEntry( "StripCr", true );
+  reader->bfulljust = config.readBoolEntry( "FullJust", false );
+  reader->setextraspace(config.readNumEntry( "ExtraSpace", 0 ));
+  reader->setlead(config.readNumEntry( "ExtraLead", 0 ));
+  reader->btextfmt = config.readBoolEntry( "TextFmt", false );
+  reader->bautofmt = config.readBoolEntry( "AutoFmt", true );
+  reader->bstriphtml = config.readBoolEntry( "StripHtml", false );
+  reader->bpeanut = config.readBoolEntry( "Peanut", false );
+  reader->bdehyphen = config.readBoolEntry( "Dehyphen", false );
+  reader->bdepluck = config.readBoolEntry( "Depluck", false );
+  reader->bdejpluck = config.readBoolEntry( "Dejpluck", false );
+  reader->bonespace = config.readBoolEntry( "OneSpace", false );
+  reader->bunindent = config.readBoolEntry( "Unindent", false );
+  reader->brepara = config.readBoolEntry( "Repara", false );
+  reader->bdblspce = config.readBoolEntry( "DoubleSpace", false );
+  reader->bindenter = config.readNumEntry( "Indent", 0 );
+  reader->m_textsize = config.readNumEntry( "FontSize", 12 );
+  reader->m_delay = config.readNumEntry( "ScrollDelay", 5184);
+  reader->m_lastfile = config.readEntry( "LastFile", QString::null );
+  reader->m_lastposn = config.readNumEntry( "LastPosn", 0 );
+  reader->m_bpagemode = config.readBoolEntry( "PageMode", true );
+  reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false);
+  reader->m_swapmouse = config.readBoolEntry( "SwapMouse", false);
+  reader->m_fontname = config.readEntry( "Fontname", "helvetica" );
+  reader->m_encd = config.readNumEntry( "Encoding", 0 );
+  reader->m_charpc = config.readNumEntry( "CharSpacing", 100 );
+  reader->m_overlap = config.readNumEntry( "Overlap", 0 );
+  reader->m_border = config.readNumEntry( "Margin", 6 );
+#ifdef REPALM
+  reader->brepalm = config.readBoolEntry( "Repalm", true );
+#endif
+  reader->bremap = config.readBoolEntry( "Remap", true );
+  reader->bmakebold = config.readBoolEntry( "MakeBold", false );
+  reader->setContinuous(config.readBoolEntry( "Continuous", true ));
+  m_targetapp = config.readEntry( "TargetApp", QString::null );
+  m_targetmsg = config.readEntry( "TargetMsg", QString::null );
+#ifdef _SCROLLPIPE
+  reader->m_pipetarget = config.readEntry( "PipeTarget", QString::null );
+  reader->m_pauseAfterEachPara = config.readBoolEntry( "PauseAfterPara", true );
+#endif
+  m_twoTouch = config.readBoolEntry( "TwoTouch", false);
+  m_doAnnotation = config.readBoolEntry( "Annotation", false);
+  m_doDictionary = config.readBoolEntry( "Dictionary", false);
+  m_doClipboard = config.readBoolEntry( "Clipboard", false);
+  m_spaceTarget = (ActionTypes)config.readNumEntry("SpaceTarget", cesAutoScroll);
+  m_escapeTarget = (ActionTypes)config.readNumEntry("EscapeTarget", cesNone);
+  m_returnTarget = (ActionTypes)config.readNumEntry("ReturnTarget", cesFullScreen);
+  m_leftTarget = (ActionTypes)config.readNumEntry("LeftTarget", cesZoomOut);
+  m_rightTarget = (ActionTypes)config.readNumEntry("RightTarget", cesZoomIn);
+  m_upTarget = (ActionTypes)config.readNumEntry("UpTarget", cesPageUp);
+  m_downTarget = (ActionTypes)config.readNumEntry("DownTarget", cesPageDown);
+
+  m_leftScroll = config.readBoolEntry("LeftScroll", false);
+  m_rightScroll = config.readBoolEntry("RightScroll", false);
+  m_upScroll = config.readBoolEntry("UpScroll", true);
+  m_downScroll = config.readBoolEntry("DownScroll", true);
+
+  m_propogatefontchange = config.readBoolEntry( "RequestorFontChange", false);
+  reader->setBaseSize(config.readNumEntry( "Basesize", 10 ));
+
+#ifndef USEQPE
+        config.setGroup( "Geometry" );
+        setGeometry(0,0,
+        config.readNumEntry( "width", QApplication::desktop()->width()/2 ),
+        config.readNumEntry( "height", QApplication::desktop()->height()/2 ));
+        move(
+        config.readNumEntry( "x", 20 ),
+        config.readNumEntry( "y", 20 ));
+#endif
+
+
+
+  setTwoTouch(m_twoTouch);
+
+    connect( reader, SIGNAL( OnShowPicture(QImage&) ), this, SLOT( showgraphic(QImage&) ) );
+
+    connect( reader, SIGNAL( OnRedraw() ), this, SLOT( OnRedraw() ) );
+    connect( reader, SIGNAL( OnWordSelected(const QString&, size_t, const QString&) ), this, SLOT( OnWordSelected(const QString&, size_t, const QString&) ) );
+    connect( reader, SIGNAL( OnURLSelected(const QString&) ), this, SLOT( OnURLSelected(const QString&) ) );
+    editorStack->addWidget( reader, get_unique_id() );
+
+    m_preferences_action = new QAction( tr( "Configuration" ), geticon( "SettingsIcon" ), QString::null, 0, this, NULL);
+    connect( m_preferences_action, SIGNAL( activated() ), this, SLOT( showprefs() ) );
+    m_preferences_action->addTo( settings );
+
+    m_saveconfig_action = new QAction( tr( "Save Config" ), QString::null, 0, this, NULL);
+    connect( m_saveconfig_action, SIGNAL( activated() ), this, SLOT( SaveConfig() ) );
+    m_saveconfig_action->addTo( settings );
+
+    m_loadconfig_action = new QAction( tr( "Load Config" ), QString::null, 0, this, NULL);
+    connect( m_loadconfig_action, SIGNAL( activated() ), this, SLOT( LoadConfig() ) );
+    m_loadconfig_action->addTo( settings );
+
+    m_tidyconfig_action = new QAction( tr( "Delete Config" ), QString::null, 0, this, NULL);
+    connect( m_tidyconfig_action, SIGNAL( activated() ), this, SLOT( TidyConfig() ) );
+    m_tidyconfig_action->addTo( settings );
+
+    settings->insertSeparator();
+    m_toolbarprefs_action = new QAction( tr( "Toolbars" ), QString::null, 0, this, NULL);
+    connect( m_toolbarprefs_action, SIGNAL( activated() ), this, SLOT( showtoolbarprefs() ) );
+    m_toolbarprefs_action->addTo( settings );
+
+    m_open_action = new QAction( tr( "Open" ), geticon( "fileopen" ), QString::null, 0, this, 0 );
+    connect( m_open_action, SIGNAL( activated() ), this, SLOT( fileOpen() ) );
+    m_open_action->addTo( file );
+
+    m_close_action = new QAction( tr( "Close" ), geticon( "close" ), QString::null, 0, this, 0 );
+    connect( m_close_action, SIGNAL( activated() ), this, SLOT( fileClose() ) );
+    m_close_action->addTo( file );
+
+#ifdef _SCRIPT
+    a = new QAction( tr( "Run Script" ), QString::null, 0, this, NULL);
+    connect( a, SIGNAL( activated() ), this, SLOT( RunScript() ) );
+    a->addTo( file );
+#endif
+    /*
+    a = new QAction( tr( "Revert" ), geticon( "close" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( fileRevert() ) );
+    a->addTo( file );
+
+    a = new QAction( tr( "Cut" ), geticon( "cut" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) );
+    a->addTo( filebar() );
+    a->addTo( edit );
+    */
+
+    m_info_action = new QAction( tr( "Info" ), geticon( "UtilsIcon" ), QString::null, 0, this, NULL);
+    connect( m_info_action, SIGNAL( activated() ), this, SLOT( showinfo() ) );
+    m_info_action->addTo( file );
+
+    m_touch_action = new QAction( tr( "Two/One Touch" ), geticon( "1to1" ), QString::null, 0, this, NULL, true );
+    connect( m_touch_action, SIGNAL( toggled(bool) ), this, SLOT( setTwoTouch(bool) ) );
+    m_touch_action->setOn(m_twoTouch);
+    m_touch_action->addTo( file );
+
+    m_find_action = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, NULL);
+     connect( m_find_action, SIGNAL( activated() ), this, SLOT( editFind() ) );
+     file->insertSeparator();
+//     a->addTo( bar );
+     m_find_action->addTo( file );
+
+    m_exportlinks_action = new QAction( tr( "Export Links" ), QString::null, 0, this, NULL);
+    connect( m_exportlinks_action, SIGNAL( activated() ), this, SLOT( ExportLinks() ) );
+    m_exportlinks_action->addTo( file );
+
+    m_scrollButton = new QAction( tr( "Scroll" ), getmyicon( "panel-arrow-down" ), QString::null, 0, this, 0, true );
+    connect( m_scrollButton, SIGNAL( toggled(bool) ), this, SLOT( autoScroll(bool) ) );
+    m_scrollButton->addTo(navigation);
+    m_scrollButton->setOn(false);
+
+    m_start_action = new QAction( tr( "Goto Start" ), geticon( "start" ), QString::null, 0, this, NULL);
+    connect( m_start_action, SIGNAL( activated() ), this, SLOT( gotoStart() ) );
+    m_start_action->addTo(navigation);
+
+    m_end_action = new QAction( tr( "Goto End" ), geticon( "finish" ), QString::null, 0, this, NULL);
+    connect( m_end_action, SIGNAL( activated() ), this, SLOT( gotoEnd() ) );
+    m_end_action->addTo(navigation);
+
+    m_jump_action = new QAction( tr( "Jump" ), geticon( "rotate" ), QString::null, 0, this, NULL);
+    connect( m_jump_action, SIGNAL( activated() ), this, SLOT( jump() ) );
+    m_jump_action->addTo(navigation);
+
+    m_pageline_action = new QAction( tr( "Page/Line Scroll" ), geticon( "pass" ), QString::null, 0, this, NULL, true );
+    connect( m_pageline_action, SIGNAL( toggled(bool) ), this, SLOT( pagemode(bool) ) );
+    m_pageline_action->addTo(navigation);
+    m_pageline_action->setOn(reader->m_bpagemode);
+
+    m_pageup_action = new QAction( tr( "Up" ), geticon( "up" ), QString::null, 0, this, 0 );
+    connect( m_pageup_action, SIGNAL( activated() ), this, SLOT( pageup() ) );
+    m_pageup_action->addTo( navigation );
+    
+    m_pagedn_action = new QAction( tr( "Down" ), geticon( "down" ), QString::null, 0, this, 0 );
+    connect( m_pagedn_action, SIGNAL( activated() ), this, SLOT( pagedn() ) );
+    m_pagedn_action->addTo( navigation );
+
+    m_back_action = new QAction( tr( "Back" ), geticon( "back" ), QString::null, 0, this, 0 );
+    connect( m_back_action, SIGNAL( activated() ), reader, SLOT( goBack() ) );
+    m_back_action->addTo( navigation );
+
+    m_home_action = new QAction( tr( "Home" ), geticon( "home" ), QString::null, 0, this, 0 );
+    connect( m_home_action, SIGNAL( activated() ), reader, SLOT( goHome() ) );
+    m_home_action->addTo( navigation );
+
+    m_forward_action = new QAction( tr( "Forward" ), geticon( "forward" ), QString::null, 0, this, 0 );
+    connect( m_forward_action, SIGNAL( activated() ), reader, SLOT( goForward() ) );
+    m_forward_action->addTo( navigation );
+
+    /*
+    a = new QAction( tr( "Find" ), QString::null, 0, this, NULL, true );
+    //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );
+    a->addTo( file );
+
+    a = new QAction( tr( "Find Again" ), QString::null, 0, this, NULL, true );
+    //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );
+    a->addTo( file );
+    */
+
+//    file->insertSeparator();
+
+#ifdef _SCROLLPIPE
+
+    QActionGroup* ag = new QActionGroup(this);
+    ag->setExclusive(false);
+    spacemenu = new QPopupMenu(this);
+    file->insertItem( tr( "Scrolling" ), spacemenu );
+
+    a = new QAction( tr( "Set Target" ), QString::null, 0, ag, NULL);
+    connect( a, SIGNAL( activated() ), this, SLOT( setpipetarget() ) );
+
+    a = new QAction( tr( "Pause Paras" ), QString::null, 0, ag, NULL, true );
+    connect( a, SIGNAL( toggled(bool) ), this, SLOT( setpause(bool) ) );
+    a->setOn(reader->m_pauseAfterEachPara);
+
+    ag->addTo(spacemenu);
+//    file->insertSeparator();
+
+#endif
+
+/*
+    a = new QAction( tr( "Import" ), QString::null, 0, this, NULL );
+    connect( a, SIGNAL( activated() ), this, SLOT( importFiles() ) );
+    a->addTo( file );
+*/
+
+    /*
+    a = new QAction( tr( "Paste" ), geticon( "paste" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) );
+    a->addTo( fileBar );
+    a->addTo( edit );
+    */
+
+//     a = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, 0 );
+
+     m_fullscreen = false;
+    m_actFullscreen = new QAction( tr( "Fullscreen" ), geticon( "fullscreen" ), QString::null, 0, this, NULL, true );
+    connect( m_actFullscreen, SIGNAL( toggled(bool) ), this, SLOT( setfullscreen(bool) ) );
+    m_actFullscreen->setOn(m_fullscreen);
+    m_actFullscreen->addTo( view );
+
+    view->insertSeparator();
+
+    m_zoomin_action = new QAction( tr( "Zoom In" ), geticon( "zoom" ), QString::null, 0, this);
+    connect( m_zoomin_action, SIGNAL( activated() ), this, SLOT( zoomin() ) );
+    m_zoomin_action->addTo( view );
+
+    m_zoomout_action = new QAction( tr( "Zoom Out" ), geticon( "mag" ), QString::null, 0, this);
+    connect( m_zoomout_action, SIGNAL( activated() ), this, SLOT( zoomout() ) );
+    m_zoomout_action->addTo( view );
+
+    view->insertSeparator();
+    m_setfont_action = new QAction( tr( "Set Font" ), getmyicon( "font" ), QString::null, 0, this);
+    connect( m_setfont_action, SIGNAL( activated() ), this, SLOT( setfont() ) );
+    m_setfont_action->addTo( view );
+
+    view->insertSeparator();
+    m_setenc_action = new QAction( tr( "Set Encoding" ), getmyicon( "charset" ), QString::null, 0, this);
+    connect( m_setenc_action, SIGNAL( activated() ), this, SLOT( chooseencoding() ) );
+    m_setenc_action->addTo( view );
+
+    m_setmono_action = new QAction( tr( "Ideogram" ), getmyicon( "ideogram" ), QString::null, 0, this, NULL, true);
+    connect( m_setmono_action, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );
+    m_setmono_action->addTo( view );
+    m_setmono_action->setOn(reader->m_bMonoSpaced);
+
+
+    //    a = new QAction( tr( "Zoom" ), QString::null, 0, this, NULL, true );
+    //    a = new QAction( tr( "Zoom" ), geticon( "mag" ), QString::null, 0, this, 0 );
+
+
+
+    //    a->addTo( filebar() );
+//     view->insertSeparator();
+
+/*
+    a = new QAction( tr( "Ideogram/Word" ), QString::null, 0, this, NULL, true );
+    connect( a, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );
+    a->setOn(reader->m_bMonoSpaced);
+    a->addTo( view );
+*/
+/*
+    a = new QAction( tr( "Set Width" ), QString::null, 0, this, NULL);
+    connect( a, SIGNAL( activated() ), this, SLOT( setspacing() ) );
+    a->addTo( view );
+*/
+
+    m_mark_action = new QAction( tr( "Bookmark" ), getmyicon( "bookmark" ), QString::null, 0, this, NULL);
+    connect( m_mark_action, SIGNAL( activated() ), this, SLOT( addbkmk() ) );
+    m_mark_action->addTo( marks );
+
+    m_annotate_action = new QAction( tr( "Annotate" ), getmyicon( "annotate" ), QString::null, 0, this, NULL);
+    connect( m_annotate_action, SIGNAL( activated() ), this, SLOT( addanno() ) );
+    m_annotate_action->addTo( marks );
+
+    m_goto_action = new QAction( tr( "Goto" ), getmyicon( "bookmark_goto" ), QString::null, 0, this, NULL, false );
+    connect( m_goto_action, SIGNAL( activated() ), this, SLOT( do_gotomark() ) );
+    m_goto_action->addTo( marks );
+
+    m_delete_action = new QAction( tr( "Delete" ), getmyicon( "bookmark_delete" ), QString::null, 0, this, NULL);
+    connect( m_delete_action, SIGNAL( activated() ), this, SLOT( do_delmark() ) );
+    m_delete_action->addTo( marks );
+
+    m_autogen_action = new QAction( tr( "Autogen" ), geticon( "exec" ), QString::null, 0, this, NULL, false );
+    connect( m_autogen_action, SIGNAL( activated() ), this, SLOT( do_autogen() ) );
+     marks->insertSeparator();
+    m_autogen_action->addTo( marks );
+
+    m_clear_action = new QAction( tr( "Clear" ), getmyicon( "bookmark_clear" ), QString::null, 0, this, NULL);
+    connect( m_clear_action, SIGNAL( activated() ), this, SLOT( clearBkmkList() ) );
+    m_clear_action->addTo( marks );
+
+    m_save_action = new QAction( tr( "Save" ), getmyicon( "bookmark_save" ), QString::null, 0, this, NULL );
+    connect( m_save_action, SIGNAL( activated() ), this, SLOT( savebkmks() ) );
+    m_save_action->addTo( marks );
+
+    m_tidy_action = new QAction( tr( "Tidy" ), getmyicon( "bookmark_tidy" ), QString::null, 0, this, NULL);
+    connect( m_tidy_action, SIGNAL( activated() ), this, SLOT( listBkmkFiles() ) );
+     marks->insertSeparator();
+    m_tidy_action->addTo( marks );
+
+    m_startBlock_action = new QAction( tr( "Start Block" ), geticon( "new" ), QString::null, 0, this, NULL);
+    connect( m_startBlock_action, SIGNAL( activated() ), this, SLOT( editMark() ) );
+    marks->insertSeparator();
+    m_startBlock_action->addTo( marks );
+
+    m_endBlock_action = new QAction( tr( "Copy Block" ), geticon( "copy" ), QString::null, 0, this, NULL);
+    connect( m_endBlock_action, SIGNAL( activated() ), this, SLOT( editCopy() ) );
+    m_endBlock_action->addTo( marks );
+
+    m_bkmkAvail = NULL;
+
+
+    setToolBarsMovable(m_tbmove);
+    addtoolbars(&config);
+
+    pbar = new QProgressBar(this);
+    pbar->hide();
+
+    searchBar = new QFloatBar( "Search", this, QMainWindow::Top, TRUE );
+
+    searchBar->setHorizontalStretchable( TRUE );
+
+    connect(searchBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));
+
+    searchEdit = new QLineEdit( searchBar, "searchEdit" );
+//      QFont f("unifont", 16 /*, QFont::Bold*/);
+//      searchEdit->setFont( f );
+    searchBar->setStretchableWidget( searchEdit );
+
+
+#ifdef __ISEARCH
+    connect( searchEdit, SIGNAL( textChanged( const QString & ) ),
+             this, SLOT( search( const QString& ) ) );
+#else
+    connect( searchEdit, SIGNAL( returnPressed( ) ),
+             this, SLOT( search( ) ) );
+#endif
+     QAction*a = new QAction( tr( "Find Next" ), geticon( "next" ), QString::null, 0, this, 0 );
+     connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );
+     a->addTo( searchBar );
+
+    a = new QAction( tr( "Close Find" ), geticon( "close" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) );
+    a->addTo( searchBar );
+
+    searchBar->hide();
+
+    regBar = new QFloatBar( "Autogen", this, QMainWindow::Top, TRUE );
+    connect(regBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));
+
+    regBar->setHorizontalStretchable( TRUE );
+
+    regEdit = new QLineEdit( regBar, "regEdit" );
+//    regEdit->setFont( f );
+
+    regBar->setStretchableWidget( regEdit );
+
+    connect( regEdit, SIGNAL( returnPressed( ) ),
+             this, SLOT( do_regaction() ) );
+
+    a = new QAction( tr( "Do Reg" ), geticon( "enter" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( do_regaction() ) );
+    a->addTo( regBar );
+
+    a = new QAction( tr( "Close Edit" ), geticon( "close" ), QString::null, 0, this, 0 );
+    connect( a, SIGNAL( activated() ), this, SLOT( regClose() ) );
+    a->addTo( regBar );
+
+    regBar->hide();
+
+    m_fontBar = new QToolBar( "Autogen", this, QMainWindow::Top, TRUE );
+
+    m_fontBar->setHorizontalStretchable( TRUE );
+
+//    qDebug("Font selector");
+    m_fontSelector = new QComboBox(false, m_fontBar);
+    m_fontBar->setStretchableWidget( m_fontSelector );
+    {
+#ifndef USEQPE
+        QFontDatabase f;
+#else
+        FontDatabase f;
+#endif
+        QStringList flist = f.families();
+        bool realfont = false;
+        for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)
+        {
+            if (reader->m_fontname == *nm)
+            {
+                realfont = true;
+            }
+            if ((*nm).contains(FIXEDFONT,false)) reader->m_fontControl.hasCourier(true, *nm);
+        }
+        if (!realfont) reader->m_fontname = flist[0];
+    } // delete the FontDatabase!!!
+    connect( m_fontSelector, SIGNAL( activated(const QString& ) ),
+             this, SLOT( do_setfont(const QString&) ) );
+    connect( m_fontSelector, SIGNAL( activated(int ) ),
+             this, SLOT( do_setencoding(int) ) );
+
+    m_fontBar->hide();
+    m_fontVisible = false;
+#ifdef USEMSGS
+    connect(qApp, SIGNAL( appMessage(const QCString&, const QByteArray& ) ),
+             this, SLOT( msgHandler(const QCString&, const QByteArray&) ) );
+#endif
+//    qDebug("Initing");
+  reader->init();
+//    qDebug("Inited");
+//    m_buttonAction[m_spaceTarget]->setOn(true);
+//    qDebug("fonting");
+    do_setfont(reader->m_fontname);
+    if (!reader->m_lastfile.isEmpty())
+    {
+        //qDebug("doclnk");
+        //doc = new DocLnk(reader->m_lastfile);
+        //qDebug("doclnk done");
+        if (pOpenlist != NULL)
+        {
+
+/*
+            int ind = 0;
+            Bkmk* p = (*pOpenlist)[ind];
+            while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)
+            {
+                p = (*pOpenlist)[++ind];
+            }
+*/
+            Bkmk* p = NULL;
+            for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)
+            {
+                p = iter.pContent();
+                if (toQString(CFiledata(p->anno()).name()) == reader->m_lastfile)
+                {
+                    break;
+                }
+        //      qDebug("Item:%s", (const char*)toQString(CFiledata(p->anno()).name()));
+                p = NULL;
+            }
+            if (p != NULL)
+            {
+        //qDebug("openfrombkmk");
+                if (!openfrombkmk(p))
+                    showEditTools();
+            }
+            else
+            {
+        //qDebug("openfile");
+                openFile( reader->m_lastfile );
+            }
+        }
+        else
+        {
+        //    qDebug("Openfile 2");
+            if (!reader->m_lastfile.isEmpty())
+                openFile( reader->m_lastfile );
+        }
+    }
+    else
+    {
+      showEditTools();
+    }
+//    qApp->processEvents();
+    reader->bDoUpdates = true;
+    reader->update();
+    config.setGroup("Version");
+    int major = config.readNumEntry("Major", 0);
+    int bkmktype = config.readNumEntry("BkmkType", 0);
+    char minor = config.readNumEntry("Minor", 0);
+    if (CheckVersion(major, bkmktype, minor))
+    {
+        config.writeEntry("Major", major);
+        config.writeEntry("BkmkType", bkmktype);
+        config.writeEntry("Minor", (int)minor);
+    }
+//    qDebug("finished update");
+}
+
+void QTReaderApp::addtoolbars(Config* config)
+{
+    config->setGroup("Toolbar");
+
+    if (fileBar != NULL)
+    {
+        if (fileBar != menubar)
+        {
+            fileBar->clear();
+        }
+        else
+        {
+            m_preferences_action->removeFrom( filebar() );
+            m_open_action->removeFrom( filebar() );
+            m_close_action->removeFrom( filebar() );
+            m_info_action->removeFrom( filebar() );
+            m_touch_action->removeFrom( filebar() );
+            m_find_action->removeFrom( filebar() );
+        }
+    }
+
+    m_preferences_action->addTo( filebar() );
+    addfilebar(config, "Open", m_open_action);
+    addfilebar(config, "Close", m_close_action);
+    addfilebar(config, "Info", m_info_action);
+    addfilebar(config, "Two/One Touch", m_touch_action);
+    addfilebar(config, "Find", m_find_action);
+
+    if (navBar != NULL)
+    {
+        if ((navBar == fileBar) && (fileBar == menubar))
+        {
+            m_scrollButton->removeFrom( navbar() );
+            m_start_action->removeFrom( navbar() );
+            m_end_action->removeFrom( navbar() );
+            m_jump_action->removeFrom( navbar() );
+            m_pageline_action->removeFrom( navbar() );
+            m_pageup_action->removeFrom( navbar() );
+            m_pagedn_action->removeFrom( navbar() );
+            m_back_action->removeFrom( navbar() );
+            m_home_action->removeFrom( navbar() );
+            m_forward_action->removeFrom( navbar() );
+        }
+        else if (navBar != fileBar)
+        {
+            navBar->clear();
+        }
+    }
+
+    addnavbar(config, "Scroll", m_scrollButton);
+    addnavbar(config, "Goto Start", m_start_action);
+    addnavbar(config, "Goto End", m_end_action);
+
+    addnavbar(config, "Jump", m_jump_action);
+    addnavbar(config, "Page/Line Scroll", m_pageline_action);
+
+    addnavbar(config, "Page Up", m_pageup_action);
+    addnavbar(config, "Page Down", m_pagedn_action);
+
+    addnavbar(config, "Back", m_back_action);
+    addnavbar(config, "Home", m_home_action);
+    addnavbar(config, "Forward", m_forward_action);
+
+    if (viewBar != NULL)
+    {
+        if ((viewBar == fileBar) && (fileBar == menubar))
+        {
+            m_actFullscreen->removeFrom( filebar() );
+            m_zoomin_action->removeFrom( viewbar() );
+            m_zoomout_action->removeFrom( viewbar() );
+            m_setfont_action->removeFrom( viewbar() );
+            m_setenc_action->removeFrom( viewbar() );
+            m_setmono_action->removeFrom( viewbar() );
+        }
+        else if (viewBar != fileBar)
+        {
+            viewBar->clear();
+        }
+    }
+
+    addviewbar(config, "Fullscreen", m_actFullscreen);
+    addviewbar(config, "Zoom In", m_zoomin_action);
+    addviewbar(config, "Zoom Out", m_zoomout_action);
+    addviewbar(config, "Set Font", m_setfont_action);
+    addviewbar(config, "Encoding Select", m_setenc_action);
+    addviewbar(config, "Ideogram Mode", m_setmono_action);
+
+    if (markBar != NULL)
+    {
+        if ((markBar == fileBar) && (fileBar == menubar))
+        {
+            m_mark_action->removeFrom( markbar() );
+            m_annotate_action->removeFrom( markbar());
+            m_goto_action->removeFrom( markbar() );
+            m_delete_action->removeFrom( markbar() );
+            m_autogen_action->removeFrom( markbar() );
+            m_clear_action->removeFrom( markbar() );
+            m_save_action->removeFrom( markbar() );
+            m_tidy_action->removeFrom( markbar() );
+            m_startBlock_action->removeFrom( markbar() );
+            m_endBlock_action->removeFrom( markbar() );
+        }
+        else if (markBar != fileBar)
+        {
+            markBar->clear();
+        }
+    }
+    addmarkbar(config, "Mark", m_mark_action);
+    addmarkbar(config, "Annotate", m_annotate_action);
+    addmarkbar(config, "Goto", m_goto_action);
+    addmarkbar(config, "Delete", m_delete_action);
+    addmarkbar(config, "Autogen", m_autogen_action);
+    addmarkbar(config, "Clear", m_clear_action);
+    addmarkbar(config, "Save", m_save_action);
+    addmarkbar(config, "Tidy", m_tidy_action);
+    addmarkbar(config, "Start Block", m_startBlock_action);
+    addmarkbar(config, "Copy Block", m_endBlock_action);
+    if (checkbar(config, "Annotation indicator"))
+    {
+        if (m_bkmkAvail == NULL)
+        {
+            m_bkmkAvail = new QAction( tr( "Annotation" ), geticon( "find" ), QString::null, 0, this, 0 );
+            connect( m_bkmkAvail, SIGNAL( activated() ), this, SLOT( showAnnotation() ) );
+        
+            m_bkmkAvail->setEnabled(false);
+        }
+        QLabel *spacer = new QLabel(markBar, "");
+        markbar()->setStretchableWidget(spacer);
+        m_bkmkAvail->removeFrom( markbar() );
+        m_bkmkAvail->addTo( markbar() );
+    }
+    else
+    {
+        if (m_bkmkAvail != NULL)
+        {
+            m_bkmkAvail->removeFrom( markbar() );
+            delete m_bkmkAvail;
+            m_bkmkAvail = NULL;
+        }
+    }
+}
+
+bool QTReaderApp::checkbar(Config* _config, const QString& key)
+{
+    return _config->readBoolEntry(key, false);
+}
+
+
+QToolBar* QTReaderApp::filebar()
+{
+    if (fileBar == NULL)
+    {
+        switch (m_tbpol)
+        {
+            case cesSingle:
+        //      qDebug("Setting filebar to menubar");
+                fileBar = menubar;
+                break;
+            default:
+                qDebug("Incorrect toolbar policy set");
+            case cesMenuTool:
+            case cesMultiple:
+        //      qDebug("Creating new file bar");
+                fileBar = new QToolBar("File", this, m_tbposition);
+                break;
+        }
+        //fileBar->setHorizontalStretchable( true );
+    }
+    return fileBar;
+}
+QToolBar* QTReaderApp::viewbar()
+{
+    if (viewBar == NULL)
+    {
+        switch (m_tbpol)
+        {
+            case cesMultiple:
+                viewBar = new QToolBar("View", this, m_tbposition);
+                break;
+            default:
+                qDebug("Incorrect toolbar policy set");
+            case cesSingle:
+            case cesMenuTool:
+                viewBar = fileBar;
+                break;
+        }
+    }
+    return viewBar;
+}
+QToolBar* QTReaderApp::navbar()
+{
+    if (navBar == NULL)
+    {
+        switch (m_tbpol)
+        {
+            case cesMultiple:
+        //      qDebug("Creating new nav bar");
+                navBar = new QToolBar("Navigation", this, m_tbposition);
+                break;
+            default:
+                qDebug("Incorrect toolbar policy set");
+            case cesSingle:
+            case cesMenuTool:
+                navBar = fileBar;
+        //      qDebug("Setting navbar to filebar");
+                break;
+        }
+    }
+    return navBar;
+}
+QToolBar* QTReaderApp::markbar()
+{
+    if (markBar == NULL)
+    {
+        switch (m_tbpol)
+        {
+            case cesMultiple:
+                markBar = new QToolBar("Marks", this, m_tbposition);
+                break;
+            default:
+                qDebug("Incorrect toolbar policy set");
+            case cesSingle:
+            case cesMenuTool:
+                markBar = fileBar;
+                break;
+        }
+    }
+    return markBar;
+}
+
+void QTReaderApp::addfilebar(Config* _config, const QString& key, QAction* a)
+{
+    if (_config->readBoolEntry(key, false)) a->addTo( filebar() );
+}
+void QTReaderApp::addnavbar(Config* _config, const QString& key, QAction* a)
+{
+    if (_config->readBoolEntry(key, false)) a->addTo( navbar() );
+}
+void QTReaderApp::addmarkbar(Config* _config, const QString& key, QAction* a)
+{
+    if (_config->readBoolEntry(key, false)) a->addTo( markbar() );
+}
+void QTReaderApp::addviewbar(Config* _config, const QString& key, QAction* a)
+{
+    if (_config->readBoolEntry(key, false)) a->addTo( viewbar() );
+}
+
+void QTReaderApp::suspend() { reader->suspend(); }
+
+#ifdef USEMSGS
+void QTReaderApp::msgHandler(const QCString& _msg, const QByteArray& _data)
+{
+    QString msg = QString::fromUtf8(_msg);
+
+////    qDebug("Received:%s", (const char*)msg);
+
+    QDataStream stream( _data, IO_ReadOnly );
+    if ( msg == "info(QString)" )
+    {
+        QString info;
+        stream >> info;
+        QMessageBox::information(this, PROGNAME, info);
+    }
+    else if ( msg == "Update(int)" )
+    {
+        int info;
+        stream >> info;
+        if (info)
+        {
+            reader->bDoUpdates = true;
+            reader->refresh();
+        }
+        else
+        {
+            reader->bDoUpdates = false;
+        }
+    }
+    else if ( msg == "warn(QString)" )
+    {
+        QString info;
+        stream >> info;
+        QMessageBox::warning(this, PROGNAME, info);
+    }
+    else if ( msg == "exit()" )
+    {
+        m_dontSave = true;
+        close();
+    }
+    else if ( msg == "pageDown()" )
+    {
+        reader->dopagedn();
+    }
+    else if ( msg == "pageUp()" )
+    {
+        reader->dopageup();
+    }
+    else if ( msg == "lineDown()" )
+    {
+        reader->lineDown();
+    }
+    else if ( msg == "lineUp()" )
+    {
+        reader->lineUp();
+    }
+    else if ( msg == "showText()" )
+    {
+        showEditTools();
+    }
+    else if ( msg == "home()" )
+    {
+        reader->goHome();
+    }
+    else if ( msg == "back()" )
+    {
+        reader->goBack();
+    }
+    else if ( msg == "forward()" )
+    {
+        reader->goForward();
+    }
+    else if ( msg == "File/Open(QString)" )
+    {
+        QString info;
+        stream >> info;
+        openFile( info );
+    }
+    else if ( msg == "File/Info()" )
+    {
+        showinfo();
+    }
+    else if ( msg == "File/Action(QString)" )
+    {
+        QString info;
+        stream >> info;
+        m_spaceTarget = ActNameToInt(info);
+    }
+    else if ( msg == "Navigation/Scroll(int)" )
+    {
+        int info;
+        stream >> info;
+        autoScroll(info);
+    }
+
+    else if ( msg == "Navigation/GotoStart()" )
+    {
+        gotoStart();
+    }
+    else if ( msg == "Navigation/GotoEnd()" )
+    {
+        gotoEnd();
+    }
+    else if ( msg == "Navigation/Jump(int)" )
+    {
+        int info;
+        stream >> info;
+        reader->locate(info);
+    }
+    else if ( msg == "Navigation/Page/LineScroll(int)" )
+    {
+        int info;
+        stream >> info;
+        pagemode(info);
+    }
+    else if ( msg == "Navigation/SetOverlap(int)" )
+    {
+        int info;
+        stream >> info;
+        reader->m_overlap = info;
+    }
+    else if ( msg == "Navigation/SetMargin(int)" )
+    {
+        int info;
+        stream >> info;
+        do_margin(info);
+    }
+    else if ( msg == "File/SetDictionary(QString)" )
+    {
+        QString info;
+        stream >> info;
+        do_settarget(info);
+    }
+#ifdef _SCROLLPIPE
+    else if ( msg == "File/SetScrollTarget(QString)" )
+    {
+        QString info;
+        stream >> info;
+        reader->m_pipetarget = info;
+    }
+#endif
+    else if ( msg == "File/Two/OneTouch(int)" )
+    {
+        int info;
+        stream >> info;
+        setTwoTouch(info);
+    }
+    else if ( msg == "Target/Annotation(int)" )
+    {
+        int info;
+        stream >> info;
+        OnAnnotation(info);
+    }
+    else if ( msg == "Target/Dictionary(int)" )
+    {
+        int info;
+        stream >> info;
+        OnDictionary(info);
+    }
+    else if ( msg == "Target/Clipboard(int)" )
+    {
+        int info;
+        stream >> info;
+        OnClipboard(info);
+    }
+    else if ( msg == "File/Find(QString)" )
+    {
+        QString info;
+        stream >> info;
+        QRegExp arg(info);
+        size_t pos = reader->pagelocate();
+        size_t start = pos;
+        CDrawBuffer test(&(reader->m_fontControl));
+        reader->getline(&test);
+        while (arg.match(toQString(test.data())) == -1)
+        {
+            pos = reader->locate();
+            if (!reader->getline(&test))
+            {
+                QMessageBox::information(this, PROGNAME, QString("Can't find\n")+info);
+                pos = start;
+                break;
+            }
+        }
+        reader->locate(pos);
+    }
+    else if ( msg == "File/Fullscreen(int)" )
+    {
+        int info;
+        stream >> info;
+        setfullscreen(info);
+    }
+    else if ( msg == "File/Continuous(int)" )
+    {
+        int info;
+        stream >> info;
+        setcontinuous(info);
+    }
+    else if ( msg == "Markup(QString)" )
+    {
+        QString info;
+        stream >> info;
+        if (info == "Auto")
+        {
+            autofmt(true);
+        }
+        if (info == "None")
+        {
+            autofmt(false);
+            textfmt(false);
+            striphtml(false);
+            peanut(false);
+        }
+        if (info == "Text")
+        {
+            textfmt(true);
+        }
+        if (info == "HTML")
+        {
+            striphtml(true);
+        }
+        if (info == "Peanut/PML")
+        {
+            peanut(true);
+        }
+    }
+    else if ( msg == "Layout/StripCR(int)" )
+    {
+        int info;
+        stream >> info;
+        stripcr(info);
+    }
+    else if ( msg == "Layout/Dehyphen(int)" )
+    {
+        int info;
+        stream >> info;
+        dehyphen(info);
+    }
+    else if ( msg == "Layout/Depluck(int)" )
+    {
+        int info;
+        stream >> info;
+        depluck(info);
+    }
+    else if ( msg == "Layout/Dejpluck(int)" )
+    {
+        int info;
+        stream >> info;
+        dejpluck(info);
+    }
+    else if ( msg == "Layout/SingleSpace(int)" )
+    {
+        int info;
+        stream >> info;
+        onespace(info);
+    }
+#ifdef REPALM
+    else if ( msg == "Layout/Repalm(int)" )
+    {
+        int info;
+        stream >> info;
+        repalm(info);
+    }
+#endif
+    else if ( msg == "Layout/Unindent(int)" )
+    {
+        int info;
+        stream >> info;
+        unindent(info);
+    }
+    else if ( msg == "Layout/Re-paragraph(int)" )
+    {
+        int info;
+        stream >> info;
+        repara(info);
+    }
+    else if ( msg == "Layout/DoubleSpace(int)" )
+    {
+        int info;
+        stream >> info;
+        dblspce(info);
+    }
+    else if ( msg == "Layout/Indent(int)" )
+    {
+        int info;
+        stream >> info;
+        reader->bindenter = info;
+        reader->setfilter(reader->getfilter());
+    }
+    else if ( msg == "Layout/Remap(int)" )
+    {
+        int info;
+        stream >> info;
+        remap(info);
+    }
+    else if ( msg == "Layout/Embolden(int)" )
+    {
+        int info;
+        stream >> info;
+        embolden(info);
+    }
+    else if ( msg == "Format/Ideogram/Word(int)" )
+    {
+        int info;
+        stream >> info;
+        monospace(info);
+    }
+    else if ( msg == "Format/SetWidth(int)" )
+    {
+        int info;
+        stream >> info;
+        reader->m_charpc = info;
+        reader->setfont();
+        reader->refresh();
+    }
+    else if ( msg == "Format/SetFont(QString,int)" )
+    {
+        QString fontname;
+        int size;
+        stream >> fontname;
+        stream >> size;
+        setfontHelper(fontname, size);
+    }
+    else if ( msg == "Marks/Autogen(QString)" )
+    {
+        QString info;
+        stream >> info;
+        do_autogen(info);
+    }
+    else if ( msg == "File/StartBlock()" )
+    {
+        editMark();
+    }
+    else if ( msg == "File/CopyBlock()" )
+    {
+        editCopy();
+    }
+}
+#endif
+ActionTypes QTReaderApp::ActNameToInt(const QString& _enc)
+{
+    for (int i = 0; i < MAX_ACTIONS; i++)
+    {
+        if (m_buttonAction[i]->text() == _enc) return (ActionTypes)i;
+    }
+    return cesAutoScroll;
+}
+
+void QTReaderApp::setfullscreen(bool sfs)
+{
+    reader->bDoUpdates = false;
+    m_fullscreen = sfs;
+    showEditTools();
+//    qApp->processEvents();
+    reader->bDoUpdates = true;
+    reader->update();
+}
+
+void QTReaderApp::buttonActionSelected(QAction* _a)
+{
+////    qDebug("es:%x : %s (%u)", _a, (const char *)(_a->text()), ActNameToInt(_a->text()));
+    m_spaceTarget = ActNameToInt(_a->text());
+}
+
+QTReaderApp::~QTReaderApp()
+{
+}
+
+void QTReaderApp::autoScroll(bool _b)
+{
+    reader->setautoscroll(_b);
+    setScrollState(reader->m_autoScroll);
+}
+
+void QTReaderApp::zoomin()
+{
+    reader->zoomin();
+}
+
+void QTReaderApp::zoomout()
+{
+    reader->zoomout();
+}
+
+void QTReaderApp::clearBkmkList()
+{
+        delete pBkmklist;
+        pBkmklist = NULL;
+        m_fBkmksChanged = false;
+}
+
+void QTReaderApp::fileClose()
+{
+    CCloseDialog* cd = new CCloseDialog(reader->m_string, false, this);
+    if (cd->exec())
+    {
+        if (pOpenlist != NULL)
+        {
+            int ind = 0;
+            Bkmk* p = (*pOpenlist)[ind];
+            while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)
+            {
+                p = (*pOpenlist)[++ind];
+            }
+            if (p != NULL) pOpenlist->erase(ind);
+            if (cd->delFile())
+            {
+                unlink((const char*)reader->m_lastfile);
+            }
+            if (cd->delMarks())
+            {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                d.remove(reader->m_string);
+#else /* USEQPE */
+                unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));
+#endif /* USEQPE */
+            }
+            if (cd->delConfig())
+            {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR "/configs");
+                d.remove(reader->m_string);
+#else /* USEQPE */
+                unlink((const char *)Global::applicationFileName(APPDIR "/configs",reader->m_string));
+#endif /* USEQPE */
+            }
+        }
+    
+        fileOpen2();
+    }
+    delete cd;
+}
+
+void QTReaderApp::updatefileinfo()
+{
+    if (reader->m_string.isEmpty()) return;
+    if (reader->m_lastfile.isEmpty()) return;
+    tchar* nm = fromQString(reader->m_string);
+    tchar* fl = fromQString(reader->m_lastfile);
+//    qDebug("Lastfile:%x", fl);
+    bool notadded = true;
+    if (pOpenlist == NULL) pOpenlist = new CList<Bkmk>;
+    else
+    {
+        for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)
+        {
+            if (ustrcmp(CFiledata(iter->anno()).name(), fl) == 0)
+            {
+                iter->value(reader->pagelocate());
+                unsigned short dlen;
+                unsigned char* data;
+                CFiledata fd(iter->anno());
+                reader->setSaveData(data, dlen, fd.content(), fd.length());
+        //      qDebug("Filedata(1):%u, %u", fd.length(), dlen);
+        //      getstate(data, dlen);
+                iter->setAnno(data, dlen);
+                notadded = false;
+                delete [] data;
+                break;
+            }
+        }
+    }
+//    qDebug("Added?:%x", notadded);
+    if (notadded)
+    {
+        struct stat fnstat;
+        stat((const char *)reader->m_lastfile, &fnstat);
+        CFiledata fd(fnstat.st_mtime, fl);
+        unsigned short dlen;
+        unsigned char* data;
+        reader->setSaveData(data, dlen, fd.content(), fd.length());
+        pOpenlist->push_front(Bkmk(nm, data, dlen, reader->pagelocate()));
+        //qDebug("Filedata(2):%u, %u", fd.length(), dlen);
+        delete [] data;
+    }
+    delete [] nm;
+    delete [] fl;
+}
+
+void QTReaderApp::fileOpen()
+{
+/*
+    menu->hide();
+    fileBar->hide();
+    if (regVisible) regBar->hide();
+    if (searchVisible) searchBar->hide();
+*/
+//    qDebug("fileOpen");
+//    if (!reader->m_lastfile.isEmpty())
+    updatefileinfo();
+    fileOpen2();
+}
+
+void QTReaderApp::fileOpen2()
+{
+    if (pBkmklist != NULL)
+    {
+        if (m_fBkmksChanged)
+        {
+            if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)
+                savebkmks();
+        }     
+        delete pBkmklist;
+        pBkmklist = NULL;
+        m_fBkmksChanged = false;
+    }
+    reader->disableAutoscroll();
+/*
+    editorStack->raiseWidget( fileSelector );
+    fileSelector->reread();
+*/
+    bool usebrowser = true;
+    if (pOpenlist != NULL)
+    {
+        m_nBkmkAction = cOpenFile;
+        if (listbkmk(pOpenlist, "Browse")) usebrowser = false;
+    }
+    if (usebrowser)
+    {
+        QString fn = usefilebrowser();
+        //qApp->processEvents();
+        if (!fn.isEmpty() && QFileInfo(fn).isFile())
+        {
+            openFile(fn);
+        }
+        reader->setFocus();
+    }
+//    reader->refresh();
+//    qDebug("HEIGHT:%d", reader->m_lastheight);
+}
+
+QString QTReaderApp::usefilebrowser()
+{
+#ifndef USEQPE
+    QString s( QFileDialog::getOpenFileName( reader->m_lastfile, QString::null, this ) );
+    return s;
+#else
+    fileBrowser* fb = new fileBrowser(false, this,"OpieReader",!m_bFloatingDialog,
+                                      0,
+        //                            WStyle_Customize | WStyle_NoBorderEx,
+                                      "*", QFileInfo(reader->m_lastfile).dirPath(true));
+
+
+    QString fn;
+    if (fb->exec())
+    {
+        fn = fb->getCurrentFile();
+    }
+//    qDebug("Selected %s", (const char*)fn);
+    delete fb;
+    showEditTools();
+    return fn;
+#endif
+}
+
+void QTReaderApp::showgraphic(QImage& pm)
+{
+    QPixmap pc;
+    pc.convertFromImage(pm);
+    m_graphicwin->setPixmap(pc);
+    editorStack->raiseWidget( m_graphicwin );
+    m_graphicwin->setFocus();
+}
+
+
+void QTReaderApp::showprefs()
+{
+    CPrefs* prefwin = new CPrefs(!m_bFloatingDialog, this);
+
+    prefwin->twotouch(m_twoTouch); 
+    prefwin->propfontchange(m_propogatefontchange);
+    prefwin->StripCR(reader->bstripcr);
+    prefwin->Dehyphen(reader->bdehyphen);
+    prefwin->SingleSpace(reader->bonespace);
+    prefwin->Unindent(reader->bunindent);
+    prefwin->Reparagraph(reader->brepara);
+    prefwin->DoubleSpace(reader->bdblspce);
+    prefwin->Remap(reader->bremap);
+    prefwin->Embolden(reader->bmakebold);
+    prefwin->FullJustify(reader->bfulljust);
+    prefwin->ParaLead(reader->getextraspace());
+    prefwin->LineLead(reader->getlead());
+    prefwin->Margin(reader->m_border);
+    prefwin->Indent(reader->bindenter);
+    if (reader->bautofmt)
+    {
+        prefwin->Markup(0);
+    }
+    else if (reader->btextfmt)
+    {
+        prefwin->Markup(2);
+    }
+    else if (reader->bstriphtml)
+    {
+        prefwin->Markup(3);
+    }
+    else if (reader->bpeanut)
+    {
+        prefwin->Markup(4);
+    }
+    else
+    {
+        prefwin->Markup(1);
+    }
+    prefwin->Depluck(reader->bdepluck);
+    prefwin->Dejpluck(reader->bdejpluck);
+    prefwin->Continuous(reader->m_continuousDocument);
+
+    prefwin->dictApplication(m_targetapp);
+    prefwin->dictMessage(m_targetmsg);
+
+    prefwin->spaceAction(m_spaceTarget);
+    prefwin->escapeAction(m_escapeTarget);
+    prefwin->returnAction(m_returnTarget);
+    prefwin->leftAction(m_leftTarget);
+    prefwin->rightAction(m_rightTarget);
+    prefwin->upAction(m_upTarget);
+    prefwin->downAction(m_downTarget);
+
+    prefwin->leftScroll(m_leftScroll);
+    prefwin->rightScroll(m_rightScroll);
+    prefwin->upScroll(m_upScroll);
+    prefwin->downScroll(m_downScroll);
+
+    prefwin->miscannotation(m_doAnnotation);
+    prefwin->miscdictionary(m_doDictionary);
+    prefwin->miscclipboard(m_doClipboard);
+
+    prefwin->SwapMouse(reader->m_swapmouse);
+
+    prefwin->Font(reader->m_fontname);
+
+    prefwin->gfxsize(reader->getBaseSize());
+
+    prefwin->pageoverlap(reader->m_overlap);
+
+    prefwin->ideogram(reader->m_bMonoSpaced);
+
+    prefwin->encoding(reader->m_encd);
+
+    prefwin->ideogramwidth(reader->m_charpc);
+
+    if (prefwin->exec())
+    {
+        m_twoTouch = prefwin->twotouch();
+        reader->setTwoTouch(m_twoTouch);
+        m_touch_action->setOn(m_twoTouch);
+
+        reader->bstripcr = prefwin->StripCR();
+        reader->bdehyphen = prefwin->Dehyphen();
+        reader->bonespace = prefwin->SingleSpace();
+        reader->bunindent = prefwin->Unindent();
+        reader->brepara = prefwin->Reparagraph();
+        reader->bdblspce = prefwin->DoubleSpace();
+        reader->bremap = prefwin->Remap();
+        reader->bmakebold = prefwin->Embolden();
+        reader->bfulljust = prefwin->FullJustify();
+        reader->setextraspace(prefwin->ParaLead());
+        reader->setlead(prefwin->LineLead());
+        reader->m_border = prefwin->Margin();
+        reader->bindenter = prefwin->Indent();
+        reader->bautofmt = reader->btextfmt = reader->bstriphtml = reader->bpeanut = false;
+        switch (prefwin->Markup())
+        {
+            case 0:
+                reader->bautofmt = true;
+                break;
+            case 1:
+                break;
+            case 2:
+                reader->btextfmt = true;
+                break;
+            case 3:
+                reader->bstriphtml = true;
+                break;
+            case 4:
+                reader->bpeanut = true;
+                break;
+            default:
+                qDebug("Format out of range");
+        }
+        reader->bdepluck = prefwin->Depluck();
+        reader->bdejpluck = prefwin->Dejpluck();
+        reader->setContinuous(prefwin->Continuous());
+
+        m_spaceTarget = (ActionTypes)prefwin->spaceAction();
+        m_escapeTarget = (ActionTypes)prefwin->escapeAction();
+        m_returnTarget = (ActionTypes)prefwin->returnAction();
+        m_leftTarget = (ActionTypes)prefwin->leftAction();
+        m_rightTarget = (ActionTypes)prefwin->rightAction();
+        m_upTarget = (ActionTypes)prefwin->upAction();
+        m_downTarget = (ActionTypes)prefwin->downAction();
+        m_leftScroll = prefwin->leftScroll();
+        m_rightScroll = prefwin->rightScroll();
+        m_upScroll = prefwin->upScroll();
+        m_downScroll = prefwin->downScroll();
+
+        m_targetapp = prefwin->dictApplication();
+        m_targetmsg = prefwin->dictMessage();
+
+        m_doAnnotation = prefwin->miscannotation();
+        m_doDictionary = prefwin->miscdictionary();
+        m_doClipboard = prefwin->miscclipboard();
+        reader->m_swapmouse = prefwin->SwapMouse();
+        reader->setBaseSize(prefwin->gfxsize());
+        reader->m_overlap = prefwin->pageoverlap();
+        reader->m_bMonoSpaced = prefwin->ideogram();
+        m_setmono_action->setOn(reader->m_bMonoSpaced);
+        reader->m_encd = prefwin->encoding();
+        reader->m_charpc = prefwin->ideogramwidth();
+
+        if (
+            reader->m_fontname != prefwin->Font()
+            ||
+            m_propogatefontchange != prefwin->propfontchange())
+        {
+            m_propogatefontchange = prefwin->propfontchange();
+            setfontHelper(prefwin->Font());
+        }
+        delete prefwin;
+        reader->setfilter(reader->getfilter());
+        reader->refresh();
+
+    }
+    else
+    {
+        delete prefwin;
+    }
+}
+
+void QTReaderApp::showtoolbarprefs()
+{
+#ifdef USEQPE
+    CBarPrefs* prefwin = new CBarPrefs(APPDIR, !m_bFloatingDialog, this);
+#else
+        QFileInfo fi;
+    QDir d = QDir::home();                      // "/"
+        if ( !d.cd(APPDIR) )
+        {                       // "/tmp"
+                qWarning( "Cannot find the \"~/%s\" directory", APPDIR );
+                d = QDir::home();
+                d.mkdir(APPDIR);
+                d.cd(APPDIR);
+        }
+        fi.setFile(d, INIFILE);
+    CBarPrefs* prefwin = new CBarPrefs(fi.absFilePath(), !m_bFloatingDialog, this);
+#endif
+    prefwin->tbpolicy(m_tbpolsave);
+    prefwin->tbposition(m_tbposition-2);
+    prefwin->tbmovable(m_tbmovesave);
+    prefwin->floating(m_bFloatingDialog);
+    if (prefwin->exec())
+    {
+        m_bFloatingDialog = prefwin->floating();
+        if (
+            m_tbpolsave != (ToolbarPolicy)prefwin->tbpolicy()
+            ||
+            m_tbposition != (ToolBarDock)(prefwin->tbposition()+2)
+            ||
+            m_tbmovesave != prefwin->tbmovable()
+            )
+        {
+            QMessageBox::warning(this, PROGNAME, "Some changes won't take effect\nuntil the next time the\napplication is started");
+        }
+        m_tbpolsave = (ToolbarPolicy)prefwin->tbpolicy();
+        m_tbposition = (ToolBarDock)(prefwin->tbposition()+2);
+        m_tbmovesave = prefwin->tbmovable();
+        bool isChanged = prefwin->isChanged();
+        delete prefwin;
+#ifdef USEQPE
+        Config config( APPDIR );
+#else
+        QFileInfo fi;
+    QDir d = QDir::home();                      // "/"
+        if ( !d.cd(APPDIR) )
+        {                       // "/tmp"
+                qWarning( "Cannot find the \"~/%s\" directory", APPDIR );
+                d = QDir::home();
+                d.mkdir(APPDIR);
+                d.cd(APPDIR);
+        }
+        fi.setFile(d, INIFILE);
+        Config config( fi.absFilePath() );
+#endif
+        if (isChanged) addtoolbars(&config);
+    }
+    else
+    {
+        delete prefwin;
+    }
+}
+
+void QTReaderApp::showinfo()
+{
+    unsigned long fs, ts, pl;
+    if (reader->empty())
+    {
+        QMessageBox::information(this, PROGNAME, "No file loaded", 1);
+    }
+    else
+    {
+        reader->sizes(fs,ts);
+        pl = reader->pagelocate();
+        m_infoWin->setFileSize(fs);
+        m_infoWin->setTextSize(ts);
+        m_infoWin->setRatio(100-(100*fs + (ts >> 1))/ts);
+        m_infoWin->setLocation(pl);
+        m_infoWin->setRead((100*pl + (ts >> 1))/ts);
+        editorStack->raiseWidget( m_infoWin );
+        m_infoWin->setFocus();
+    }
+}
+
+void QTReaderApp::addAnno(const QString& name, const QString& text, size_t posn)
+{
+    if (pBkmklist == NULL) pBkmklist = new CList<Bkmk>;
+#ifdef _UNICODE
+    CBuffer buff(name.length()+1);
+    int i;
+    for (i = 0; i < name.length(); i++)
+    {
+        buff[i] = name[i].unicode();
+    }
+    buff[i] = 0;
+    CBuffer buff2(text.length()+1);
+    for (i = 0; i < text.length(); i++)
+    {
+        buff2[i] = text[i].unicode();
+    }
+    buff2[i] = 0;
+    pBkmklist->push_front(Bkmk(buff.data(), buff2.data(), posn));
+#else
+    pBkmklist->push_front(Bkmk((const tchar*)text,posn));
+#endif
+    m_fBkmksChanged = true;
+    pBkmklist->sort();
+}
+
+void QTReaderApp::addAnno(const QString& name, const QString& text)
+{
+    if (m_annoIsEditing)
+    {
+        if (name.isEmpty())
+        {
+            QMessageBox::information(this, PROGNAME, "Need a name for the bookmark\nPlease try again", 1);
+        }
+        else
+        {
+            addAnno(name, text, m_annoWin->getPosn());
+        }
+        showEditTools();
+    }
+    else
+    {
+        if (m_annoWin->edited())
+        {
+            CBuffer buff(text.length()+1);
+            int i;
+            for (i = 0; i < text.length(); i++)
+            {
+                buff[i] = text[i].unicode();
+            }
+            buff[i] = 0;
+            m_fBkmksChanged = true;
+            m_anno->setAnno(buff.data());
+        }
+        bool found = findNextBookmark(m_anno->value()+1);
+        if (found)
+        {
+            m_annoWin->setName(toQString(m_anno->name()));
+            m_annoWin->setAnno(toQString(m_anno->anno()));
+        }
+        else
+        {
+            showEditTools();
+        }
+    }
+}
+
+bool QTReaderApp::findNextBookmark(size_t start)
+{
+    bool found = false;
+    for (CList<Bkmk>::iterator iter = pBkmklist->begin(); iter != pBkmklist->end(); iter++)
+    {
+        if (iter->value() >= start)
+        {
+            if (iter->value() < reader->locate())
+            {
+                found = true;
+                m_anno = iter.pContent();
+            }
+            break;
+        }
+    }
+    return found;
+}
+
+void QTReaderApp::addanno()
+{
+    if (reader->empty())
+    {
+        QMessageBox::information(this, PROGNAME, "No file loaded", 1);
+    }
+    else
+    {
+        m_annoWin->setName("");
+        m_annoWin->setAnno("");
+        m_annoWin->setPosn(reader->pagelocate());
+        m_annoIsEditing = true;
+        editorStack->raiseWidget( m_annoWin );
+#ifdef USEQPE
+        Global::showInputMethod();
+#endif
+        m_annoWin->setFocus();
+    }
+}
+
+void QTReaderApp::infoClose()
+{
+    showEditTools();
+}
+
+/*
+void QTReaderApp::fileRevert()
+{
+    clear();
+    fileOpen();
+}
+
+void QTReaderApp::editCut()
+{
+#ifndef QT_NO_CLIPBOARD
+    editor->cut();
+#endif
+}
+*/
+void QTReaderApp::editMark()
+{
+    m_savedpos = reader->pagelocate();
+}
+
+void QTReaderApp::editCopy()
+{
+        QClipboard* cb = QApplication::clipboard();
+        QString text;
+        int ch;
+        unsigned long currentpos = reader->pagelocate();
+        unsigned long endpos = reader->locate();
+        if (m_savedpos == 0xffffffff)
+        {
+            m_savedpos = currentpos;
+        }
+        reader->jumpto(m_savedpos);
+        while (reader->explocate() < endpos && (ch = reader->getch()) != UEOF)
+        {
+            text += ch;
+        }
+        cb->setText(text);
+        reader->locate(currentpos);
+        m_savedpos = 0xffffffff;
+}
+
+void QTReaderApp::gotoStart()
+{
+    reader->locate(reader->buffdoc.startSection());
+}
+
+void QTReaderApp::gotoEnd()
+{
+    reader->dopageup(reader->buffdoc.endSection());
+}
+
+void QTReaderApp::pageup()
+{
+    reader->NavUp();
+}
+
+void QTReaderApp::pagedn()
+{
+    reader->NavDown();
+}
+
+void QTReaderApp::pagemode(bool _b)
+{
+    reader->setpagemode(_b);
+}
+
+/*
+void QTReaderApp::setspacing()
+{
+    m_nRegAction = cMonoSpace;
+    char lcn[20];
+    sprintf(lcn, "%lu", reader->m_charpc);
+    regEdit->setText(lcn);
+    do_regedit();
+}
+*/
+void QTReaderApp::settarget()
+{
+    m_nRegAction = cSetTarget;
+    QString text = ((m_targetapp.isEmpty()) ? QString("") : m_targetapp)
+        + "/"
+        + ((m_targetmsg.isEmpty()) ? QString("") : m_targetmsg);
+    regEdit->setText(text);
+    do_regedit();
+}
+
+/*
+void QTReaderApp::do_mono(const QString& lcn)
+{
+    bool ok;
+    unsigned long ulcn = lcn.toULong(&ok);
+    if (ok)
+    {
+        reader->m_charpc = ulcn;
+        reader->setfont();
+        reader->refresh();
+        //reader->setmono(true);
+    }
+    else
+        QMessageBox::information(this, PROGNAME, "Must be a number");
+}
+*/
+/*
+void QTReaderApp::editPaste()
+{
+#ifndef QT_NO_CLIPBOARD
+    editor->paste();
+#endif
+}
+*/
+
+void QTReaderApp::editFind()
+{
+  searchStart = reader->pagelocate();
+#ifdef __ISEARCH
+  searchStack = new QStack<searchrecord>;
+#endif
+#ifdef USEQPE
+  Global::showInputMethod();
+#endif
+  searchBar->show();
+  searchVisible = TRUE;
+  searchEdit->setFocus();
+#ifdef __ISEARCH
+  searchStack->push(new searchrecord("",reader->pagelocate()));
+#endif
+}
+
+void QTReaderApp::findNext()
+{
+//  //  qDebug("findNext called\n");
+#ifdef __ISEARCH
+  QString arg = searchEdit->text();
+#else
+  QRegExp arg = searchEdit->text();
+#endif
+  CDrawBuffer test(&(reader->m_fontControl));
+  size_t start = reader->pagelocate();
+  reader->jumpto(start);
+  reader->getline(&test);
+  dosearch(start, test, arg);
+}
+
+void QTReaderApp::findClose()
+{
+  searchVisible = FALSE;
+  searchEdit->setText("");
+#ifdef USEQPE
+  Global::hideInputMethod();
+#endif
+  searchBar->hide();
+#ifdef __ISEARCH
+//  searchStack = new QStack<searchrecord>;
+  while (!searchStack->isEmpty())
+    {
+      delete searchStack->pop();
+    }
+  delete searchStack;
+#endif
+  reader->setFocus();
+}
+
+void QTReaderApp::regClose()
+{
+  regVisible = FALSE;
+  regEdit->setText("");
+  regBar->hide();
+#ifdef USEQPE
+  Global::hideInputMethod();
+#endif
+  reader->setFocus();
+}
+
+#ifdef __ISEARCH
+bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QString& arg)
+#else
+bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QRegExp& arg)
+#endif
+{
+  bool ret = true;
+    unsigned long fs, ts;
+    reader->sizes(fs,ts);
+  size_t pos = reader->locate();
+  pbar->setGeometry(searchBar->x(),searchBar->y(),searchBar->width(), searchBar->height());
+  pbar->show();
+  pbar->raise();
+  pbar->reset();
+  int offset;
+  int lastpc = (100*pos)/ts;
+  pbar->setProgress(lastpc);
+//  qApp->processEvents();
+  if (reader->buffdoc.getpara(test) >= 0)
+  {
+      reader->setFocus();
+#ifdef __ISEARCH
+      while (strstr(test.data(),(const tchar*)arg) == NULL)
+#else
+#ifdef _UNICODE
+      while ((offset = arg.match(toQString(test.data()))) == -1)
+#else
+      while (arg.match(test.data()) == -1)
+#endif
+#endif
+      {
+          pos = reader->locate();
+          int pc = (100*pos)/ts;
+          if (pc != lastpc)
+          {
+              pbar->setProgress(pc);
+              qApp->processEvents();
+              reader->setFocus();
+              lastpc = pc;
+          }
+          
+          if (reader->buffdoc.getpara(test) < 0)
+          {
+              if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)
+                  pos = searchStart;
+              else
+                  pos = start;
+              findClose();
+              pbar->hide();
+              reader->locate(pos);
+              return false;
+          }
+      }
+//      qDebug("Found it at %u:%u", pos, offset);
+      pbar->hide();
+//      qDebug("Hid");
+      reader->locate(pos+offset);
+//      qDebug("Loacted");
+//      qDebug("page up");
+      ret = true;
+  }
+  else
+  {
+              if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)
+                  pos = searchStart;
+              else
+                  pos = start;
+              ret = false;
+              findClose();
+  }
+  return ret;
+}
+
+#ifdef __ISEARCH
+void QTReaderApp::search(const QString & arg)
+{
+  searchrecord* ss = searchStack->top();
+  CBuffer test;
+  size_t start = reader->pagelocate();
+  bool haspopped = false;
+  while (arg.left(ss->s.length()) != ss->s)
+  {
+      haspopped = true;
+      start = ss->pos;
+//      reader->locate(start);
+      searchStack->pop();
+      delete ss;
+  }
+  if (haspopped) reader->locate(start);
+/*
+  if (arg.length() < ss->len)
+    {
+      start = ss->pos;
+      reader->locate(start);
+      searchStack->pop();
+      delete ss;
+    }
+*/
+  else
+    {
+      start = reader->pagelocate();
+      reader->jumpto(start);
+      searchStack->push(new searchrecord(arg,start));
+    }
+    dosearch(start, test, arg);
+}
+#else
+void QTReaderApp::search()
+{
+    findNext();
+}
+#endif
+
+void QTReaderApp::openFile( const QString &f )
+{
+//    qDebug("File:%s", (const char*)f);
+//    openFile(DocLnk(f));
+//}
+//
+//void QTReaderApp::openFile( const DocLnk &f )
+//{
+  clear();
+  QFileInfo fm(f);
+  if ( fm.exists() )
+    {
+//      QMessageBox::information(0, "Progress", "Calling fileNew()");
+#ifdef USEQPE
+        if (fm.extension( FALSE ) == "desktop")
+        {
+            DocLnk d(f);
+            QFileInfo fnew(d.file());
+            fm = fnew;
+            if (!fm.exists()) return;
+        }
+#endif
+      clear();
+
+      reader->setText(fm.baseName(), fm.absFilePath());
+      m_loadedconfig = readconfig(reader->m_string, false);
+      showEditTools();
+      readbkmks();
+      m_savedpos = 0xffffffff;
+    }
+  else
+    {
+      QMessageBox::information(this, PROGNAME, "File does not exist");
+      reader->m_lastfile = QString::null;
+    }
+        
+}
+/*
+void QTReaderApp::resizeEvent(QResizeEvent* e)
+{
+    if (m_fullscreen)
+    {
+        showNormal();
+        showFullScreen();
+    }
+}
+*/
+void QTReaderApp::handlekey(QKeyEvent* e)
+{
+//    qDebug("Keypress event");
+    timeb now;
+    ftime(&now);
+    unsigned long etime = (1000*(now.time - m_lastkeytime.time) + now.millitm)-m_lastkeytime.millitm;
+    if (etime < m_debounce)
+    {
+        return;
+    }
+    m_lastkeytime = now;
+    switch(e->key())
+    {
+        case Key_Escape:
+        //    qDebug("escape event");
+            if (m_disableesckey)
+            {
+                m_disableesckey = false;
+            }
+            else
+            {
+                m_bcloseDisabled = true;
+                if (m_fullscreen)
+                {
+                    m_actFullscreen->setOn(false);
+                    e->accept();
+                }
+                else
+                {
+        //      qDebug("escape action");
+                    doAction(m_escapeTarget, e);
+                }
+            }
+            break;
+        case Key_Space:
+        {
+            doAction(m_spaceTarget, e);
+        }
+        break;
+        case Key_Return:
+        {
+            doAction(m_returnTarget, e);
+        }
+        break;
+        case Key_Left:
+        {
+            if (reader->m_autoScroll && m_leftScroll)
+            {
+                reader->reduceScroll();
+            }
+            else
+            {
+                doAction(m_leftTarget, e);
+            }
+        }
+        break;
+        case Key_Right:
+        {
+            if (reader->m_autoScroll && m_rightScroll)
+            {
+                reader->increaseScroll();
+            }
+            else
+            {
+                doAction(m_rightTarget, e);
+            }
+        }
+        break;
+        case Key_Up:
+        {
+            if (reader->m_autoScroll && m_upScroll)
+            {
+                reader->increaseScroll();
+            }
+            else
+            {
+                doAction(m_upTarget, e);
+            }
+        }
+        break;
+        case Key_Down:
+        {
+            if (reader->m_autoScroll && m_downScroll)
+            {
+                reader->reduceScroll();
+            }
+            else
+            {
+                doAction(m_downTarget, e);
+            }
+        }
+        break;
+        default:
+        {
+            e->ignore();
+        }
+        
+/*
+        QString msg("Key press was:");
+        QString key;
+        msg += key.setNum(e->key());
+        QMessageBox::information(this, PROGNAME, msg);
+*/
+    }
+}
+
+void QTReaderApp::showEditTools()
+{
+//    if ( !doc )
+        //close();
+    if (m_fullscreen)
+    {
+        if (menubar != NULL) menubar->hide();
+        if (fileBar != NULL) fileBar->hide();
+        if (viewBar != NULL) viewBar->hide();
+        if (navBar != NULL) navBar->hide();
+        if (markBar != NULL) markBar->hide();
+        searchBar->hide();
+        regBar->hide();
+#ifdef USEQPE
+        Global::hideInputMethod();
+#endif
+        m_fontBar->hide();
+        //showNormal();
+        showFullScreen();
+    }
+    else
+    {
+        //qDebug("him");
+#ifdef USEQPE
+        Global::hideInputMethod();
+#endif
+        //qDebug("eb");
+        menubar->show();
+        if (fileBar != NULL) fileBar->show();
+        if (viewBar != NULL) viewBar->show();
+        if (navBar != NULL) navBar->show();
+        if (markBar != NULL) markBar->show();
+        mb->show();
+        if ( searchVisible )
+        {
+#ifdef USEQPE
+            Global::showInputMethod();
+#endif
+                searchBar->show();
+        }
+        if ( regVisible )
+        {
+#ifdef USEQPE
+            Global::showInputMethod();
+#endif
+                regBar->show();
+        }
+        if (m_fontVisible) m_fontBar->show();
+        //qDebug("sn");
+        showNormal();
+        //qDebug("sm");
+#ifdef USEQPE
+        showMaximized();
+#endif
+        //setCentralWidget(reader);
+    }
+
+//    qDebug("uc");
+    updateCaption();
+//    qDebug("rw");
+    editorStack->raiseWidget( reader );
+//    qDebug("sf");
+    reader->setFocus();
+    reader->refresh();
+}
+/*
+void QTReaderApp::save()
+{
+    if ( !doc )
+        return;
+    if ( !editor->edited() )
+        return;
+
+    QString rt = editor->text();
+    QString pt = rt;
+
+    if ( doc->name().isEmpty() ) {
+        unsigned ispace = pt.find( ' ' );
+        unsigned ienter = pt.find( '\n' );
+        int i = (ispace < ienter) ? ispace : ienter;
+        QString docname;
+        if ( i == -1 ) {
+            if ( pt.isEmpty() )
+                docname = "Empty Text";
+            else
+                docname = pt;
+        } else {
+            docname = pt.left( i );
+        }
+        doc->setName(docname);
+    }
+    FileManager fm;
+    fm.saveFile( *doc, rt );
+}
+*/
+
+void QTReaderApp::clear()
+{
+//    if (doc != 0)
+//      {
+//  QMessageBox::information(this, PROGNAME, "Deleting doc", 1);
+        //delete doc;
+//  QMessageBox::information(this, PROGNAME, "Deleted doc", 1);
+        //doc = 0;
+    //     }
+    reader->clear();
+}
+
+void QTReaderApp::updateCaption()
+{
+//    if ( !doc )
+        //setCaption( tr("QTReader") );
+//    else {
+        //QString s = doc->name();
+        //if ( s.isEmpty() )
+        //    s = tr( "Unnamed" );
+        setCaption( reader->m_string + " - " + tr("Reader") );
+//    }
+}
+
+void QTReaderApp::setDocument(const QString& fileref)
+{
+    bFromDocView = TRUE;
+//QMessageBox::information(0, "setDocument", fileref);
+    openFile(fileref);
+//    showEditTools();
+}
+
+void QTReaderApp::closeEvent( QCloseEvent *e )
+{
+//    qDebug("Close event");
+    if (m_fullscreen)
+    {
+        m_fullscreen = false;
+        showEditTools();
+        e->accept();
+    }
+    else if (m_dontSave)
+    {
+        e->accept();
+    }
+    else
+    {
+        if (editorStack->visibleWidget() == reader)
+        {
+            if ((m_escapeTarget != cesNone) && m_bcloseDisabled)
+            {
+        //qDebug("Close disabled");
+                m_bcloseDisabled = false;
+                e->ignore();
+            }
+            else
+            {
+                if (m_fontVisible)
+                {
+                    m_fontBar->hide();
+                    m_fontVisible = false;
+                }
+                if (regVisible)
+                {
+                    regBar->hide();
+#ifdef USEQPE
+                    Global::hideInputMethod();
+#endif
+                    regVisible = false;
+                    return;
+                }
+                if (searchVisible)
+                {
+                    searchBar->hide();
+#ifdef USEQPE
+                    Global::hideInputMethod();
+#endif
+                    searchVisible = false;
+                    return;
+                }
+                if (m_fBkmksChanged && pBkmklist != NULL)
+                {
+                    if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)
+                        savebkmks();
+                    delete pBkmklist;
+                    pBkmklist = NULL;
+                    m_fBkmksChanged = false;
+                }
+                bFromDocView = FALSE;
+                updatefileinfo();
+                saveprefs();
+                e->accept();
+            }
+        }
+        else
+        {
+            showEditTools();
+            m_disableesckey = true;
+        }
+    }
+}
+
+void QTReaderApp::do_gotomark()
+{
+    m_nBkmkAction = cGotoBkmk;
+    if (!listbkmk(pBkmklist))
+        QMessageBox::information(this, PROGNAME, "No bookmarks in memory");
+}
+
+void QTReaderApp::do_delmark()
+{
+    m_nBkmkAction = cDelBkmk;
+    if (!listbkmk(pBkmklist))
+        QMessageBox::information(this, PROGNAME, "No bookmarks in memory");
+}
+
+bool QTReaderApp::listbkmk(CList<Bkmk>* plist, const QString& _lab)
+{
+    bkmkselector->clear();
+    if (_lab.isEmpty())
+        bkmkselector->setText("Cancel");
+    else
+        bkmkselector->setText(_lab);
+    int cnt = 0;
+    if (plist != NULL)
+      {
+        for (CList<Bkmk>::iterator i = plist->begin(); i != plist->end(); i++)
+          {
+#ifdef _UNICODE
+        //      qDebug("Item:%s", (const char*)toQString(i->name()));
+            bkmkselector->insertItem(toQString(i->name()));
+#else
+            bkmkselector->insertItem(i->name());
+#endif
+            cnt++;
+          }
+      }
+    if (cnt > 0)
+      {
+          hidetoolbars();
+        editorStack->raiseWidget( bkmkselector );
+        return true;
+      }
+    else
+        return false;
+}
+
+void QTReaderApp::do_autogen()
+{
+  m_nRegAction = cAutoGen;
+  regEdit->setText(m_autogenstr);
+  do_regedit();
+}
+
+void QTReaderApp::do_regedit()
+{
+//    fileBar->hide();
+    reader->bDoUpdates = false;
+//    qDebug("Showing regbar");
+  regBar->show();
+//    qDebug("Showing kbd");
+#ifdef USEQPE
+  Global::showInputMethod();
+#endif
+  regVisible = true;
+  regEdit->setFocus();
+//  qApp->processEvents();
+    reader->bDoUpdates = true;
+    reader->update();
+}
+
+bool QTReaderApp::openfrombkmk(Bkmk* bk)
+{
+    QString fn = toQString(
+        CFiledata(bk->anno()).name()
+        );
+        //qDebug("fileinfo");
+    if (!fn.isEmpty() && QFileInfo(fn).isFile())
+    {
+        //qDebug("Opening");
+        openFile(fn);
+        struct stat fnstat;
+        stat((const char *)reader->m_lastfile, &fnstat);
+        
+        if (CFiledata(bk->anno()).date()
+            != fnstat.st_mtime)
+        {
+            CFiledata fd(bk->anno());
+            fd.setdate(fnstat.st_mtime);
+            bk->value(0);
+        }
+        else
+        {
+            unsigned short svlen = bk->filedatalen();
+            unsigned char* svdata = bk->filedata();
+            reader->putSaveData(svdata, svlen);
+        //    setstate(svdata, svlen);
+            if (svlen != 0)
+            {
+                QMessageBox::warning(this, PROGNAME, "Not all file data used\nNew version?");
+            }
+        //    qDebug("updating");
+        //    showEditTools();
+            reader->locate(bk->value());
+        }
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void QTReaderApp::gotobkmk(int ind)
+{
+    showEditTools();
+    switch (m_nBkmkAction)
+    {
+        case cOpenFile:
+        {
+        //    qApp->processEvents();
+            if (!openfrombkmk((*pOpenlist)[ind]))
+            {
+                pOpenlist->erase(ind);
+                QMessageBox::information(this, PROGNAME, "Can't find file");
+            }
+        }
+        break;
+        case cGotoBkmk:
+            reader->locate((*pBkmklist)[ind]->value());
+            break;
+        case cDelBkmk:
+        ////    qDebug("Deleting:%s\n",(*pBkmklist)[ind]->name());
+            pBkmklist->erase(ind);
+            m_fBkmksChanged = true;
+        //    pBkmklist->sort();
+            break;
+        case cRmBkmkFile:
+                {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                d.remove(bkmkselector->text(ind));
+#else /* USEQPE */
+                unlink((const char *)Global::applicationFileName(APPDIR,bkmkselector->text(ind)));
+#endif /* USEQPE */
+                }
+            break;
+        case cLdConfig:
+            readconfig(bkmkselector->text(ind), false);
+            break;
+        case cRmConfig:
+                {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR "/configs");
+                d.remove(bkmkselector->text(ind));
+#else /* USEQPE */
+                unlink((const char *)Global::applicationFileName(APPDIR "/configs",bkmkselector->text(ind)));
+#endif /* USEQPE */
+                }
+            break;
+        case cExportLinks:
+        {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+            d.cd(APPDIR "/urls");
+            QFileInfo fi(d, bkmkselector->text(ind));
+            if (fi.exists())
+            {
+                QString outfile( QFileDialog::getSaveFileName( QString::null, QString::null, this ) );
+                if (!outfile.isEmpty())
+                {
+                    FILE* fout = fopen((const char *)outfile, "w");
+                    if (fout != NULL)
+                    {
+                        FILE* fin = fopen((const char *)fi.absFilePath(), "r");
+                        if (fin != NULL)
+                        {
+                            fprintf(fout, "<html><body>\n");
+                            int ch = 0;
+                            while ((ch = fgetc(fin)) != EOF)
+                            {
+                                fputc(ch, fout);
+                            }
+                            fclose(fin);
+                            fprintf(fout, "</html></body>\n");
+                            d.remove(bkmkselector->text(ind));
+                        }
+                        fclose(fout);
+                    }
+                    else
+                        QMessageBox::information(this, PROGNAME, "Couldn't open output");
+                }
+            }
+#else /* USEQPE */
+            FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");
+            if (fin != NULL)
+            {
+                bool allok = false;
+                fileBrowser* fb = new fileBrowser(true, this,"OpieReader",!m_bFloatingDialog, 0, "*", QString::null);
+                if (fb->exec())
+                {
+                    QString outfile = fb->getCurrentFile();
+                    FILE* fout = fopen((const char *)outfile, "w");
+                    if (fout != NULL)
+                    {
+                        fprintf(fout, "<html><body>\n");
+                        int ch = 0;
+                        while ((ch = fgetc(fin)) != EOF)
+                        {
+                            fputc(ch, fout);
+                        }
+                        fprintf(fout, "</html></body>\n");
+                        fclose(fout);
+                        allok = true;
+                    }
+                    else
+                        QMessageBox::information(this, PROGNAME, "Couldn't open output");
+                }
+                delete fb;
+                fclose(fin);
+                if (allok) unlink((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)));
+            }
+            else
+            {
+                QMessageBox::information(this, PROGNAME, "Couldn't open input");
+            }
+
+/*
+            CFileSelector *f = new CFileSelector("text/html", this, NULL, !m_bFloatingDialog, TRUE, TRUE );
+            int ret = f->exec();
+            qDebug("Return:%d", ret);
+            DocLnk* doc = f->getDoc();
+            if (doc != NULL)
+            {
+                FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");
+                QString rt;
+                rt = "<html><body>\n";
+                int ch = 0;
+                while ((ch = fgetc(fin)) != EOF)
+                {
+                    rt += (char)ch;
+                }
+                fclose(fin);
+                rt += "</html></body>\n";
+                if ( doc->name().isEmpty() )
+                {
+                    doc->setName(bkmkselector->text(ind));
+                }
+                FileManager fm;
+                fm.saveFile( *doc, rt );
+                qDebug("YES");
+            }
+            else
+            {
+                qDebug("NO");
+            }
+            delete f;
+*/
+
+#endif /* USEQPE */
+        }
+        break;
+    }
+}
+
+void QTReaderApp::cancelbkmk()
+{
+    if (m_nBkmkAction == cOpenFile)
+    {
+        QString fn = usefilebrowser();
+        if (!fn.isEmpty() && QFileInfo(fn).isFile()) openFile(fn);
+    }
+  showEditTools();
+}
+
+void QTReaderApp::jump()
+{
+  m_nRegAction = cJump;
+  char lcn[20];
+  sprintf(lcn, "%lu", reader->pagelocate());
+  regEdit->setText(lcn);
+  do_regedit();
+}
+
+void QTReaderApp::do_jump(const QString& lcn)
+{
+    bool ok;
+    unsigned long ulcn = lcn.toULong(&ok);
+    if (ok)
+        reader->locate(ulcn);
+    else
+        QMessageBox::information(this, PROGNAME, "Must be a number");
+}
+
+void QTReaderApp::do_regaction()
+{
+    reader->bDoUpdates = false;
+  regBar->hide();
+#ifdef USEQPE
+  Global::hideInputMethod();
+#endif
+  regVisible = false;
+  switch(m_nRegAction)
+  {
+      case cAutoGen:
+          do_autogen(regEdit->text());
+          break;
+      case cAddBkmk:
+          do_addbkmk(regEdit->text());
+          break;
+      case cJump:
+          do_jump(regEdit->text());
+          break;
+/*
+      case cMonoSpace:
+          do_mono(regEdit->text());
+          break;
+*/
+      case cSetTarget:
+          do_settarget(regEdit->text());
+          break;
+#ifdef _SCROLLPIPE
+      case cSetPipeTarget:
+          do_setpipetarget(regEdit->text());
+          break;
+#endif
+      case cSetConfigName:
+        //  qDebug("Saving config");
+          do_saveconfig(regEdit->text(), false);
+          break;
+  }
+//  reader->restore();
+//    fileBar->show();
+  reader->setFocus();
+//    qApp->processEvents();
+    reader->bDoUpdates = true;
+    reader->update();
+}
+
+void QTReaderApp::do_settarget(const QString& _txt)
+{
+    int ind = _txt.find('/');
+    if (ind == -1)
+    {
+        m_targetapp = "";
+        m_targetmsg = "";
+        QMessageBox::information(this, PROGNAME, "Format is\nappname/messagename");
+    }
+    else
+    {
+        m_targetapp = _txt.left(ind);
+        m_targetmsg = _txt.right(_txt.length()-ind-1);
+    }
+}
+
+void QTReaderApp::chooseencoding()
+{
+    m_fontSelector->clear();
+    m_fontSelector->insertItem("Ascii");
+    m_fontSelector->insertItem("UTF-8");
+    m_fontSelector->insertItem("UCS-2(BE)");
+    m_fontSelector->insertItem("USC-2(LE)");
+    m_fontSelector->insertItem("Palm");
+    for (unicodetable::iterator iter = unicodetable::begin(); iter != unicodetable::end(); iter++)
+    {
+        m_fontSelector->insertItem(iter->mime);
+    } // delete the FontDatabase!!!
+    m_fontSelector->setCurrentItem (reader->m_encd);
+    m_fontAction = cChooseEncoding;
+    m_fontBar->show();
+    m_fontVisible = true;
+}
+
+void QTReaderApp::setfont()
+{
+    m_fontSelector->clear();
+    {
+#ifdef USEQPE
+        FontDatabase f;
+#else
+        QFontDatabase f;
+#endif
+        QStringList flist = f.families();
+        m_fontSelector->insertStringList(flist);
+    } // delete the FontDatabase!!!
+
+    for (int i = 1; i <= m_fontSelector->count(); i++)
+    {
+        if (m_fontSelector->text(i) == reader->m_fontname)
+        {
+            m_fontSelector->setCurrentItem(i);
+            break;
+        }
+    }
+    m_fontAction = cChooseFont;
+    m_fontBar->show();
+    m_fontVisible = true;
+}
+
+void QTReaderApp::setfontHelper(const QString& lcn, int size)
+{
+    if (size == 0) size = reader->m_fontControl.currentsize();
+    if (m_propogatefontchange)
+    {
+        QFont f(lcn, 10);
+        bkmkselector->setFont( f );
+        regEdit->setFont( f );
+        searchEdit->setFont( f );
+        m_annoWin->setFont( f );
+    }
+    reader->m_fontname = lcn;
+    if (!reader->ChangeFont(size))
+    {
+        reader->ChangeFont(size);
+    }
+}
+
+void QTReaderApp::do_setencoding(int i)
+{
+//    qDebug("setencoding:%d", i);
+    if (m_fontAction == cChooseEncoding)
+    {
+        reader->setencoding(i);
+    }
+    reader->refresh();
+    m_fontBar->hide();
+    m_fontVisible = false;
+//    qDebug("showedit");
+    if (reader->isVisible()) showEditTools();
+//    qDebug("showeditdone");
+}
+
+void QTReaderApp::do_setfont(const QString& lcn)
+{
+    if (m_fontAction == cChooseFont)
+    {
+        setfontHelper(lcn);
+    }
+    reader->refresh();
+    m_fontBar->hide();
+    m_fontVisible = false;
+//    qDebug("showedit");
+    //if (reader->isVisible())
+    showEditTools();
+//    qDebug("showeditdone");
+}
+
+void QTReaderApp::do_autogen(const QString& regText)
+{
+    unsigned long fs, ts;
+    reader->sizes(fs,ts);
+//  //  qDebug("Reg:%s\n", (const tchar*)(regEdit->text()));
+  m_autogenstr = regText;
+  QRegExp re(regText);
+  CBuffer buff;
+  if (pBkmklist != NULL) delete pBkmklist;
+  pBkmklist = new CList<Bkmk>;
+  m_fBkmksChanged = true;
+
+  pbar->setGeometry(regBar->x(),regBar->y(),regBar->width(), regBar->height());
+  pbar->show();
+  pbar->raise();
+  pbar->reset();
+  reader->update();
+  qApp->processEvents();
+  reader->setFocus();
+  reader->jumpto(0);
+  int lastpc = 0;
+  int i = 0;
+  while (i >= 0)
+    {
+      unsigned int lcn = reader->locate();
+      int pc = (100*lcn)/ts;
+      if (pc != lastpc)
+      {
+        pbar->setProgress(pc);
+        qApp->processEvents();
+        if (reader->locate() != lcn) reader->jumpto(lcn);
+        reader->setFocus();
+        lastpc = pc;
+      }
+      i = reader->buffdoc.getpara(buff);
+#ifdef _UNICODE
+      if (re.match(toQString(buff.data())) != -1)
+#else
+      if (re.match(buff.data()) != -1)
+#endif
+        pBkmklist->push_back(Bkmk(buff.data(), NULL, lcn));
+    }
+  pBkmklist->sort();
+  pbar->setProgress(100);
+  qApp->processEvents();
+  pbar->hide();
+  reader->refresh();
+}
+
+void QTReaderApp::saveprefs()
+{
+//    qDebug("saveprefs");
+//  reader->saveprefs("uqtreader");
+//    if (!m_loadedconfig)
+        do_saveconfig( APPDIR, true );
+
+/*    
+    Config config( APPDIR );
+    config.setGroup( "View" );
+    
+    reader->m_lastposn = reader->pagelocate();
+    
+    config.writeEntry("FloatDialogs", m_bFloatingDialog);
+    config.writeEntry( "StripCr", reader->bstripcr );
+    config.writeEntry( "AutoFmt", reader->bautofmt );
+    config.writeEntry( "TextFmt", reader->btextfmt );
+    config.writeEntry( "StripHtml", reader->bstriphtml );
+    config.writeEntry( "Dehyphen", reader->bdehyphen );
+    config.writeEntry( "Depluck", reader->bdepluck );
+    config.writeEntry( "Dejpluck", reader->bdejpluck );
+    config.writeEntry( "OneSpace", reader->bonespace );
+    config.writeEntry( "Unindent", reader->bunindent );
+    config.writeEntry( "Repara", reader->brepara );
+    config.writeEntry( "DoubleSpace", reader->bdblspce );
+    config.writeEntry( "Indent", reader->bindenter );
+    config.writeEntry( "FontSize", (int)(reader->m_fontControl.currentsize()) );
+    config.writeEntry( "ScrollDelay", reader->m_delay);
+    config.writeEntry( "LastFile", reader->m_lastfile );
+    config.writeEntry( "LastPosn", (int)(reader->pagelocate()) );
+    config.writeEntry( "PageMode", reader->m_bpagemode );
+    config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced );
+    config.writeEntry( "SwapMouse", reader->m_swapmouse);
+    config.writeEntry( "Fontname", reader->m_fontname );
+    config.writeEntry( "Encoding", reader->m_encd );
+    config.writeEntry( "CharSpacing", reader->m_charpc );
+    config.writeEntry( "Overlap", (int)(reader->m_overlap) );
+    config.writeEntry( "Margin", (int)reader->m_border );
+    config.writeEntry( "TargetApp", m_targetapp );
+    config.writeEntry( "TargetMsg", m_targetmsg );
+#ifdef _SCROLLPIPE
+    config.writeEntry( "PipeTarget", reader->m_pipetarget );
+    config.writeEntry( "PauseAfterPara", reader->m_pauseAfterEachPara );
+#endif
+    config.writeEntry( "TwoTouch", m_twoTouch );
+    config.writeEntry( "Annotation", m_doAnnotation);
+    config.writeEntry( "Dictionary", m_doDictionary);
+    config.writeEntry( "Clipboard", m_doClipboard);
+    config.writeEntry( "SpaceTarget", m_spaceTarget);
+    config.writeEntry( "EscapeTarget", m_escapeTarget);
+    config.writeEntry( "ReturnTarget", m_returnTarget);
+    config.writeEntry( "LeftTarget", m_leftTarget);
+    config.writeEntry( "RightTarget", m_rightTarget);
+    config.writeEntry( "UpTarget", m_upTarget);
+    config.writeEntry( "DownTarget", m_downTarget);
+    config.writeEntry("LeftScroll", m_leftScroll);
+    config.writeEntry("RightScroll", m_rightScroll);
+    config.writeEntry("UpScroll", m_upScroll);
+    config.writeEntry("DownScroll", m_downScroll);
+#ifdef REPALM
+    config.writeEntry( "Repalm", reader->brepalm );
+#endif
+    config.writeEntry( "Remap", reader->bremap );
+    config.writeEntry( "Peanut", reader->bpeanut );
+    config.writeEntry( "MakeBold", reader->bmakebold );
+    config.writeEntry( "Continuous", reader->m_continuousDocument );
+    config.writeEntry( "FullJust", reader->bfulljust );
+    config.writeEntry( "ExtraSpace", reader->getextraspace() );
+    config.writeEntry( "ExtraLead", reader->getlead() );
+    config.writeEntry( "Basesize",  (int)reader->getBaseSize());
+    config.writeEntry( "RequestorFontChange", m_propogatefontchange);
+
+    config.setGroup( "Toolbar" );
+    config.writeEntry("Movable", m_tbmovesave);
+    config.writeEntry("Policy", m_tbpolsave);
+    config.writeEntry("Position", m_tbposition);
+*/
+    savefilelist();
+}
+
+/*
+void QTReaderApp::oldFile()
+{
+//  qDebug("oldFile called");
+  reader->setText(true);
+//  qDebug("settext called");
+  showEditTools();
+//  qDebug("showedit called");
+}
+*/
+
+/*
+void info_cb(Fl_Widget* o, void* _data)
+{
+
+    if (infowin == NULL)
+    {
+        
+        infowin = new Fl_Window(160,240);
+        filename = new Fl_Output(45,5,110,14,"Filename");
+        filesize = new Fl_Output(45,25,110,14,"Filesize");
+        textsize = new Fl_Output(45,45,110,14,"Textsize");
+        comprat = new CBar(45,65,110,14,"Ratio %");
+        posn = new Fl_Output(45,85,110,14,"Location");
+        frcn = new CBar(45,105,110,14,"% Read");
+        about = new Fl_Multiline_Output(5,125,150,90);
+        about->value("TWReader - $Name$\n\nA file reader program for the Agenda\n\nReads text, PalmDoc and ppms format files");
+        Fl_Button *jump_accept = new Fl_Button(62,220,35,14,"Okay");
+        infowin->set_modal();
+    }
+    if (((reader_ui *)_data)->g_filename[0] != '\0')
+    {
+        unsigned long fs,ts;
+        tchar sz[20];
+        ((reader_ui *)_data)->input->sizes(fs,ts);
+        unsigned long pl = ((reader_ui *)_data)->input->locate();
+
+        filename->value(((reader_ui *)_data)->g_filename);
+
+        sprintf(sz,"%u",fs);
+        filesize->value(sz);
+
+        sprintf(sz,"%u",ts);
+        textsize->value(sz);
+
+        comprat->value(100-(100*fs + (ts >> 1))/ts);
+
+        sprintf(sz,"%u",pl);
+        posn->value(sz);
+
+        frcn->value((100*pl + (ts >> 1))/ts);
+    }
+    infowin->show();
+}
+*/
+
+void QTReaderApp::savebkmks()
+{
+    if (pBkmklist != NULL)
+    {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                QFileInfo fi(d, reader->m_string);
+        BkmkFile bf((const char *)fi.absFilePath(), true);
+#else /* USEQPE */
+        BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string), true);
+#endif /* USEQPE */
+        bf.write(*pBkmklist);
+    }
+        m_fBkmksChanged = false;
+}
+
+void QTReaderApp::readfilelist()
+{
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                QFileInfo fi(d, ".openfiles");
+    BkmkFile bf((const char *)fi.absFilePath());
+#else /* USEQPE */
+    BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"));
+#endif /* USEQPE */
+//    qDebug("Reading open files");
+    pOpenlist = bf.readall();
+//    if (pOpenlist != NULL) qDebug("...with success");
+//    else qDebug("...without success!");
+}
+
+void QTReaderApp::savefilelist()
+{
+    if (pOpenlist != NULL)
+    {
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                QFileInfo fi(d, ".openfiles");
+        BkmkFile bf((const char *)fi.absFilePath(), true);
+#else /* USEQPE */
+        BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"), true);
+#endif /* USEQPE */
+        //qDebug("Writing open files");
+        bf.write(*pOpenlist);
+    }
+}
+
+void QTReaderApp::readbkmks()
+{
+    if (pBkmklist != NULL)
+    {
+            delete pBkmklist;
+    }
+    struct stat fnstat;
+    struct stat bkstat;
+#ifndef USEQPE
+            QDir d = QDir::home();                      // "/"
+                d.cd(APPDIR);
+                QFileInfo fi(d, reader->m_string);
+#endif /* ! USEQPE */
+    if (
+        stat((const char *)reader->m_lastfile, &fnstat) == 0
+        &&
+#ifndef USEQPE
+        stat((const char *)fi.absFilePath(), &bkstat) == 0
+#else /* USEQPE */
+        stat((const char *)Global::applicationFileName(APPDIR,reader->m_string), &bkstat) == 0
+#endif /* USEQPE */
+        )
+    {
+        if (bkstat.st_mtime < fnstat.st_mtime)
+        {
+#ifndef USEQPE
+            unlink((const char *)fi.absFilePath());
+#else /* USEQPE */
+            unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));
+#endif /* USEQPE */
+        }
+    }
+
+#ifndef USEQPE
+    BkmkFile bf((const char *)fi.absFilePath());
+#else /* USEQPE */
+    BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string));
+#endif /* USEQPE */
+
+    pBkmklist = bf.readall();
+    m_fBkmksChanged = bf.upgraded();
+    if (pBkmklist == NULL)
+    {
+        pBkmklist = reader->getbkmklist();
+    }
+    if (pBkmklist != NULL)
+        pBkmklist->sort();
+}
+
+void QTReaderApp::addbkmk()
+{
+  m_nRegAction = cAddBkmk;
+  regEdit->setText(reader->firstword());
+  do_regedit();
+}
+
+void QTReaderApp::do_addbkmk(const QString& text)
+{
+        if (text.isEmpty())
+        {
+          QMessageBox::information(this, PROGNAME, "Need a name for the bookmark\nSelect add again", 1);
+        }
+        else
+        {
+                if (pBkmklist == NULL) pBkmklist = new CList<Bkmk>;
+#ifdef _UNICODE
+                CBuffer buff;
+                int i = 0;
+                for (i = 0; i < text.length(); i++)
+                {
+                    buff[i] = text[i].unicode();
+                }
+                buff[i] = 0;
+                pBkmklist->push_front(Bkmk(buff.data(), NULL, reader->pagelocate()));
+#else
+                pBkmklist->push_front(Bkmk((const tchar*)text, reader->pagelocate()));
+#endif
+                m_fBkmksChanged = true;
+                pBkmklist->sort();
+        }
+}
+
+void QTReaderApp::OnRedraw()
+{
+    if ((pBkmklist != NULL) && (m_bkmkAvail != NULL))
+    {
+        bool found = findNextBookmark(reader->pagelocate());
+        m_bkmkAvail->setEnabled(found);
+    }
+}
+
+void QTReaderApp::showAnnotation()
+{
+    m_annoWin->setName(toQString(m_anno->name()));
+    m_annoWin->setAnno(toQString(m_anno->anno()));
+    m_annoIsEditing = false;
+#ifdef USEQPE
+    Global::showInputMethod();
+#endif
+    editorStack->raiseWidget( m_annoWin );
+    m_annoWin->setFocus();
+}
+
+void QTReaderApp::OnWordSelected(const QString& wrd, size_t posn, const QString& line)
+{
+////    qDebug("OnWordSelected(%u):%s", posn, (const char*)wrd);
+
+    if (m_doClipboard)
+    {
+        QClipboard* cb = QApplication::clipboard();
+        cb->setText(wrd);
+#ifdef USEQPE
+        if (wrd.length() > 10)
+        {
+            Global::statusMessage(wrd.left(8) + "..");
+        }
+        else
+        {
+            Global::statusMessage(wrd);
+        }
+#endif
+    }
+    if (m_doAnnotation)
+    {
+        //addAnno(wrd, "Need to be able to edit this", posn);
+        m_annoWin->setName(line);
+        m_annoWin->setAnno("");
+        m_annoWin->setPosn(posn);
+        m_annoIsEditing = true;
+#ifdef USEQPE
+        Global::showInputMethod();
+#endif
+        editorStack->raiseWidget( m_annoWin );
+    }
+#ifdef USEQPE
+    if (m_doDictionary)
+    {
+        if (!m_targetapp.isEmpty() && !m_targetmsg.isEmpty())
+        {
+            QCopEnvelope e(("QPE/Application/"+m_targetapp).utf8(), (m_targetmsg+"(QString)").utf8());
+            e << wrd;
+        }
+    }
+#endif
+}
+
+void QTReaderApp::doAction(ActionTypes a, QKeyEvent* e)
+{
+    if (a == 0)
+    {
+        e->ignore();
+    }
+    else
+    {
+        e->accept();
+        //qDebug("Accepted");
+        switch (a)
+        {
+            case cesOpenFile:
+            {
+                fileOpen();
+            }
+            break;
+            case cesAutoScroll:
+            {
+                reader->setautoscroll(!reader->m_autoScroll);
+                setScrollState(reader->m_autoScroll);
+            }
+            break;
+            case cesActionMark:
+            {
+                addbkmk();
+            }
+            break;
+            case cesFullScreen:
+            {
+                m_actFullscreen->setOn(!m_fullscreen);
+            }
+            break;
+            case cesActionAnno:
+            {
+                addanno();
+            }
+            break;
+            case cesZoomIn:
+                zoomin();
+                break;
+            case cesZoomOut:
+                zoomout();
+                break;
+            case cesBack:
+                reader->goBack();
+                break;
+            case cesForward:
+                reader->goForward();
+                break;
+            case cesHome:
+                reader->goHome();
+                break;
+            case cesPageUp:
+                reader->dopageup();
+                break;
+            case cesPageDown:
+                reader->dopagedn();
+                break;
+            case cesLineUp:
+                reader->lineUp();
+                break;
+            case cesLineDown:
+                reader->lineDown();
+                break;
+            case cesStartDoc:
+                gotoStart();
+                break;
+            case cesEndDoc:
+                gotoEnd();
+                break;
+            default:
+                qDebug("Unknown ActionType:%u", a);
+                break;
+        }
+    }
+}
+
+void QTReaderApp::setTwoTouch(bool _b) { reader->setTwoTouch(_b); }
+void QTReaderApp::restoreFocus() { reader->setFocus(); } 
+
+void QTReaderApp::SaveConfig()
+{
+    m_nRegAction = cSetConfigName;
+    regEdit->setText(reader->m_string);
+    do_regedit();
+}
+
+void QTReaderApp::do_saveconfig(const QString& _txt, bool full)
+{
+//    qDebug("do_saveconfig:%s", (const char*)_txt);
+#ifdef USEQPE
+    QString configname;
+    Config::Domain dom;
+
+    if (full)
+    {
+        configname = _txt;
+        dom = Config::User;
+    }
+    else
+    {
+        configname = Global::applicationFileName(APPDIR "/configs", _txt);
+        dom = Config::File;
+    }
+
+    Config config(configname, dom);
+    config.setGroup( "View" );
+
+#else
+        QFileInfo fi;
+        if (full)
+        {
+        //    qDebug("full:%s", (const char*)_txt);
+            QDir d = QDir::home();                      // "/"
+                if ( !d.cd(_txt) )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/%s\" directory", (const char*)_txt );
+                        d = QDir::home();
+                        d.mkdir(_txt);
+                        d.cd(_txt);
+                }
+                fi.setFile(d, INIFILE);
+        }
+        else
+        {
+            QDir d = QDir::home();                      // "/"
+                if ( !d.cd(APPDIR) )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+                        d = QDir::home();
+                        d.mkdir(APPDIR);
+                        d.cd(APPDIR);
+                }
+                if ( !d.cd("configs") )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/" APPDIR "/configs\" directory" );
+                        d = QDir::home();
+                        d.cd(APPDIR);
+                        d.mkdir("configs");
+                        d.cd("configs");
+                }
+                fi.setFile(d, _txt);
+        }
+        //qDebug("Path:%s", (const char*)fi.absFilePath());
+        Config config(fi.absFilePath());
+#endif
+
+
+    config.writeEntry( "StripCr", reader->bstripcr );
+    config.writeEntry( "AutoFmt", reader->bautofmt );
+    config.writeEntry( "TextFmt", reader->btextfmt );
+    config.writeEntry( "StripHtml", reader->bstriphtml );
+    config.writeEntry( "Dehyphen", reader->bdehyphen );
+    config.writeEntry( "Depluck", reader->bdepluck );
+    config.writeEntry( "Dejpluck", reader->bdejpluck );
+    config.writeEntry( "OneSpace", reader->bonespace );
+    config.writeEntry( "Unindent", reader->bunindent );
+    config.writeEntry( "Repara", reader->brepara );
+    config.writeEntry( "DoubleSpace", reader->bdblspce );
+    config.writeEntry( "Indent", reader->bindenter );
+    config.writeEntry( "FontSize", (int)(reader->m_fontControl.currentsize()) );
+    config.writeEntry( "ScrollDelay", reader->m_delay);
+    if (full)
+    {
+        config.writeEntry("Debounce", m_debounce);
+        config.writeEntry("FloatDialogs", m_bFloatingDialog);
+        reader->m_lastposn = reader->pagelocate();
+        config.writeEntry( "LastFile", reader->m_lastfile );
+        config.writeEntry( "LastPosn", (int)(reader->pagelocate()) );
+    }
+    config.writeEntry( "PageMode", reader->m_bpagemode );
+    config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced );
+    config.writeEntry( "SwapMouse", reader->m_swapmouse);
+    config.writeEntry( "Fontname", reader->m_fontname );
+    config.writeEntry( "Encoding", reader->m_encd );
+    config.writeEntry( "CharSpacing", reader->m_charpc );
+    config.writeEntry( "Overlap", (int)(reader->m_overlap) );
+    config.writeEntry( "Margin", (int)reader->m_border );
+    config.writeEntry( "TargetApp", m_targetapp );
+    config.writeEntry( "TargetMsg", m_targetmsg );
+#ifdef _SCROLLPIPE
+    config.writeEntry( "PipeTarget", reader->m_pipetarget );
+    config.writeEntry( "PauseAfterPara", reader->m_pauseAfterEachPara );
+#endif
+    config.writeEntry( "TwoTouch", m_twoTouch );
+    config.writeEntry( "Annotation", m_doAnnotation);
+    config.writeEntry( "Dictionary", m_doDictionary);
+    config.writeEntry( "Clipboard", m_doClipboard);
+    config.writeEntry( "SpaceTarget", m_spaceTarget);
+    config.writeEntry( "EscapeTarget", m_escapeTarget);
+    config.writeEntry( "ReturnTarget", m_returnTarget);
+    config.writeEntry( "LeftTarget", m_leftTarget);
+    config.writeEntry( "RightTarget", m_rightTarget);
+    config.writeEntry( "UpTarget", m_upTarget);
+    config.writeEntry( "DownTarget", m_downTarget);
+    config.writeEntry("LeftScroll", m_leftScroll);
+    config.writeEntry("RightScroll", m_rightScroll);
+    config.writeEntry("UpScroll", m_upScroll);
+    config.writeEntry("DownScroll", m_downScroll);
+#ifdef REPALM
+    config.writeEntry( "Repalm", reader->brepalm );
+#endif
+    config.writeEntry( "Remap", reader->bremap );
+    config.writeEntry( "Peanut", reader->bpeanut );
+    config.writeEntry( "MakeBold", reader->bmakebold );
+    config.writeEntry( "Continuous", reader->m_continuousDocument );
+    config.writeEntry( "FullJust", reader->bfulljust );
+    config.writeEntry( "ExtraSpace", reader->getextraspace() );
+    config.writeEntry( "ExtraLead", reader->getlead() );
+    config.writeEntry( "Basesize",  (int)reader->getBaseSize());
+    config.writeEntry( "RequestorFontChange", m_propogatefontchange);
+    if (full)
+    {
+        config.setGroup( "Toolbar" );
+        config.writeEntry("Movable", m_tbmovesave);
+        config.writeEntry("Policy", m_tbpolsave);
+        config.writeEntry("Position", m_tbposition);
+#ifndef USEQPE
+        config.setGroup( "Geometry" );
+        config.writeEntry( "x", x() );
+        config.writeEntry( "y", y() );
+        config.writeEntry( "width", width() );
+        config.writeEntry( "height", height() );
+#endif
+    }
+}
+
+/*
+void QTReaderApp::setstate(unsigned char* _sd, unsigned short _sdlen)
+{
+    unsigned short sdlen;
+    memcpy(&sdlen, _sd, sizeof(sdlen));
+    sdlen -= sizeof(sdlen);
+    _sd += sizeof(sdlen);
+    statedata* sd;
+    char* data;
+    if (sdlen < sizeof(statedata)+1)
+    {
+        sdlen = sizeof(statedata)+1;
+    }
+    data = new char[sdlen];
+    sd = (statedata*)data;
+    memcpy(sd, _sd, sdlen);
+    data[sdlen] = 0;
+    reader->setstate(*sd);
+    delete [] data;
+}
+
+void QTReaderApp::getstate(unsigned char*& data, unsigned short& len)
+{
+    unsigned char* olddata = data;
+    unsigned short oldlen = len;
+    len = oldlen+sizeof(unsigned short)+sizeof(statedata)+reader->m_fontname.length();
+    data = new unsigned char[len];
+    memcpy(data, olddata, oldlen);
+    delete [] olddata;
+    memcpy(data+oldlen, &len, sizeof(len));
+    statedata* sd = (statedata*)(data+oldlen+sizeof(unsigned short));
+
+    sd->bstripcr = reader->bstripcr;
+    sd->btextfmt = reader->btextfmt;
+    sd->bautofmt = reader->bautofmt;
+    sd->bstriphtml = reader->bstriphtml;
+    sd->bpeanut = reader->bpeanut;
+    sd->bdehyphen = reader->bdehyphen;
+    sd->bdepluck = reader->bdepluck;
+    sd->bdejpluck = reader->bdejpluck;
+    sd->bonespace = reader->bonespace;
+    sd->bunindent = reader->bunindent;
+    sd->brepara = reader->brepara;
+    sd->bdblspce = reader->bdblspce;
+    sd->m_bpagemode = reader->m_bpagemode;
+    sd->m_bMonoSpaced = reader->m_bMonoSpaced;
+    sd->bremap = reader->bremap;
+    sd->bmakebold = reader->bmakebold;
+    sd->Continuous = reader->m_continuousDocument;
+#ifdef REPALM
+    sd->brepalm = reader->brepalm;
+#endif
+    sd->bindenter = reader->bindenter;
+    sd->m_textsize = reader->m_textsize; //reader->m_fontControl.currentsize()
+    sd->m_encd = reader->m_encd;
+    sd->m_charpc = reader->m_charpc;
+    strcpy(sd->m_fontname, reader->m_fontname.latin1());
+}
+*/
+#ifdef _SCRIPT
+void QTReaderApp::RunScript()
+{
+    fileBrowser* fb = new fileBrowser(this,"OpieReader",!m_bFloatingDialog,
+                                      0,
+        //                            WStyle_Customize | WStyle_NoBorderEx,
+                                      "*", Global::applicationFileName(APPDIR "/scripts", ""));
+
+    QString fn;
+    if (fb->exec())
+    {
+        fn = fb->fileList[0];
+    }
+    delete fb;
+    if ( !fn.isEmpty() && fork() == 0 )
+    {
+        execlp((const char *)fn,(const char *)fn,NULL);
+    }
+}
+
+void QTReaderApp::SaveScript(const char* sname)
+{
+    FILE* f = fopen(sname,"w");
+    if (f != NULL)
+    {
+#ifdef OPIE
+        fprintf(f, "#!/bin/sh\nmsg() {\n\tqcop QPE/Application/reader \"$1\" \"$2\" \"$3\"\n}\n");
+#else
+        fprintf(f, "#!/bin/bash\nmsg() {\n\tqcop QPE/Application/uqtreader \"$1\" \"$2\" \"$3\"\n}\n");
+#endif
+        fprintf(f, "msg \"Update(int)\" 0\n");
+        fprintf(f, "msg \"Layout/StripCR(int)\" %d\n", (reader->bstripcr) ? 1:0);
+        if (reader->btextfmt) fprintf(f, "msg \"Markup(QString)\" \"Text\"\n");
+        else if (reader->bautofmt) fprintf(f, "msg \"Markup(QString)\" \"Auto\"\n");
+        else if (reader->bstriphtml) fprintf(f, "msg \"Markup(QString)\" \"HTML\"\n");
+        else if (reader->bpeanut) fprintf(f, "msg \"Markup(QString)\" \"Peanut/PML\"\n");
+        else fprintf(f, "msg \"Markup(QString)\" \"None\"\n");
+        fprintf(f, "msg \"Layout/Dehyphen(int)\" %d\n", (reader->bdehyphen) ? 1:0);
+        fprintf(f, "msg \"Layout/Depluck(int)\" %d\n", (reader->bdepluck) ? 1:0);
+        fprintf(f, "msg \"Layout/Dejpluck(int)\" %d\n", (reader->bdejpluck) ? 1:0);
+        fprintf(f, "msg \"Layout/SingleSpace(int)\" %d\n", (reader->bonespace) ? 1:0);
+        fprintf(f, "msg \"Layout/Unindent(int)\" %d\n", (reader->bunindent) ? 1:0);
+        fprintf(f, "msg \"Layout/Re-paragraph(int)\" %d\n", (reader->brepara) ? 1:0);
+        fprintf(f, "msg \"Layout/DoubleSpace(int)\" %d\n", (reader->bdblspce) ? 1:0);
+        fprintf(f, "msg \"Layout/Indent(int)\" %d\n", reader->bindenter);
+        fprintf(f, "msg \"Format/SetFont(QString,int)\" \"%s\" %d\n", (const char*)reader->m_fontname, reader->m_textsize);
+        fprintf(f, "msg \"Navigation/Page/LineScroll(int)\" %d\n", (reader->m_bpagemode) ? 1:0);
+        fprintf(f, "msg \"Format/Ideogram/Word(int)\" %d\n", (reader->m_bMonoSpaced) ? 1:0);
+        fprintf(f, "msg \"Format/Encoding(QString)\" \"%s\"\n", (const char*)m_EncodingAction[reader->m_encd]->text());
+        fprintf(f, "msg \"Format/SetWidth(int)\" %d\n", reader->m_charpc);
+        fprintf(f, "msg \"Navigation/SetOverlap(int)\" %d\n", reader->m_overlap);
+        fprintf(f, "msg \"Layout/Remap(int)\" %d\n", (reader->bremap) ? 1:0);
+        fprintf(f, "msg \"Layout/Embolden(int)\" %d\n", (reader->bmakebold) ? 1:0);
+        fprintf(f, "msg \"File/Continuous(int)\" %d\n", (reader->m_continuousDocument) ? 1:0);
+        fprintf(f, "msg \"File/SetDictionary(QString)\" \"%s/%s\"\n", (const char *)m_targetapp, (const char *)m_targetmsg);
+#ifdef _SCROLLPIPE
+        fprintf(f, "msg \"File/SetScrollTarget(QString)\" \"%s\"\n", (const char *)reader->m_pipetarget);
+#endif
+        fprintf(f, "msg \"File/Two/OneTouch(int)\" %d\n", (m_twoTouch) ? 1:0);
+        fprintf(f, "msg \"Target/Annotation(int)\" %d\n", (m_doAnnotation) ? 1:0);
+        fprintf(f, "msg \"Target/Dictionary(int)\" %d\n", (m_doDictionary) ? 1:0);
+        fprintf(f, "msg \"Target/Clipboard(int)\" %d\n", (m_doClipboard) ? 1:0);
+        fprintf(f, "msg \"File/Action(QString)\" \"%s\"\n", (const char *)m_buttonAction[m_spaceTarget]->text());
+        fprintf(f, "msg \"Update(int)\" 1\n");
+        fprintf(f, "msg \"info(QString)\" \"All Done\"\n");
+        fclose(f);
+        chmod(sname, S_IXUSR | S_IXGRP | S_IXOTH);
+    }
+}
+
+void QTReaderApp::SaveConfig()
+{
+    m_nRegAction = cSetConfigName;
+    regEdit->setText("");
+    do_regedit();
+}
+
+void QTReaderApp::do_saveconfig(const QString& _txt)
+{
+    SaveScript(Global::applicationFileName(APPDIR "/scripts", _txt));
+}
+#endif
+
+#ifdef _SCROLLPIPE
+void QTReaderApp::setpipetarget()
+{
+    m_nRegAction = cSetPipeTarget;
+    QString text = (reader->m_pipetarget.isEmpty()) ? QString("") : reader->m_pipetarget;
+    regEdit->setText(text);
+    do_regedit();
+}
+
+void QTReaderApp::do_setpipetarget(const QString& _txt)
+{
+    reader->m_pipetarget = _txt;
+}
+
+void QTReaderApp::setpause(bool sfs)
+{
+    reader->m_pauseAfterEachPara = sfs;
+}
+#endif
+
+void QTReaderApp::monospace(bool _b)
+{
+    reader->setmono(_b);
+}
+
+bool QTReaderApp::readconfig(const QString& _txt, bool full=false)
+{
+#ifdef USEQPE
+    QString configname;
+    Config::Domain dom;
+
+    if (full)
+    {
+        configname = _txt;
+        dom = Config::User;
+    }
+    else
+    {
+        configname = Global::applicationFileName(APPDIR "/configs", _txt);
+        QFileInfo fm(configname);
+        if ( !fm.exists() ) return false;
+        dom = Config::File;
+    }
+
+    Config config(configname, dom);
+    config.setGroup( "View" );
+
+#else
+        QFileInfo fi;
+        if (full)
+        {
+            QDir d = QDir::home();                      // "/"
+                if ( !d.cd(_txt) )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/%s\" directory", (const char*)_txt );
+                        d = QDir::home();
+                        d.mkdir(_txt);
+                        d.cd(_txt);
+                }
+                fi.setFile(d, INIFILE);
+        }
+        else
+        {
+            QDir d = QDir::home();                      // "/"
+                if ( !d.cd(APPDIR) )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+                        d = QDir::home();
+                        d.mkdir(APPDIR);
+                        d.cd(APPDIR);
+                }
+                if ( !d.cd("configs") )
+                {                       // "/tmp"
+                        qWarning( "Cannot find the \"~/" APPDIR "/configs\" directory" );
+                        d = QDir::home();
+                        d.mkdir("configs");
+                        d.cd("configs");
+                }
+                fi.setFile(d, _txt);
+        }
+#ifdef _WINDOWS
+        struct stat fnstat;
+    if (stat((const char *)reader->m_lastfile, &fnstat) == 0) return false; // get round fileinfo bug on windows
+#else
+        if (!fi.exists()) return false;
+#endif
+        Config config(fi.absFilePath());
+#endif
+    if (full)
+    {
+        config.setGroup("Toolbar");
+        m_tbmovesave = m_tbmove = config.readBoolEntry("Movable", false);
+        m_tbpolsave = m_tbpol = (ToolbarPolicy)config.readNumEntry("Policy", 1);
+        m_tbposition = (ToolBarDock)config.readNumEntry("Position", 2);
+    }
+    config.setGroup( "View" );
+    m_bFloatingDialog = config.readBoolEntry("FloatDialogs", false);
+    reader->bstripcr = config.readBoolEntry( "StripCr", true );
+    reader->bfulljust = config.readBoolEntry( "FullJust", false );
+    reader->setextraspace(config.readNumEntry( "ExtraSpace", 0 ));
+    reader->setlead(config.readNumEntry( "ExtraLead", 0 ));
+    reader->btextfmt = config.readBoolEntry( "TextFmt", false );
+    reader->bautofmt = config.readBoolEntry( "AutoFmt", true );
+    reader->bstriphtml = config.readBoolEntry( "StripHtml", false );
+    reader->bpeanut = config.readBoolEntry( "Peanut", false );
+    reader->bdehyphen = config.readBoolEntry( "Dehyphen", false );
+    reader->bdepluck = config.readBoolEntry( "Depluck", false );
+    reader->bdejpluck = config.readBoolEntry( "Dejpluck", false );
+    reader->bonespace = config.readBoolEntry( "OneSpace", false );
+    reader->bunindent = config.readBoolEntry( "Unindent", false );
+    reader->brepara = config.readBoolEntry( "Repara", false );
+    reader->bdblspce = config.readBoolEntry( "DoubleSpace", false );
+    reader->bindenter = config.readNumEntry( "Indent", 0 );
+    reader->m_textsize = config.readNumEntry( "FontSize", 12 );
+    reader->m_delay = config.readNumEntry( "ScrollDelay", 5184);
+    if (full)
+    {
+        reader->m_lastfile = config.readEntry( "LastFile", QString::null );
+        reader->m_lastposn = config.readNumEntry( "LastPosn", 0 );
+    }
+    reader->m_bpagemode = config.readBoolEntry( "PageMode", true );
+    reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false);
+    reader->m_swapmouse = config.readBoolEntry( "SwapMouse", false);
+     reader->m_fontname = config.readEntry( "Fontname", "helvetica" );
+    reader->m_encd = config.readNumEntry( "Encoding", 0 );
+    reader->m_charpc = config.readNumEntry( "CharSpacing", 100 );
+    reader->m_overlap = config.readNumEntry( "Overlap", 0 );
+    reader->m_border = config.readNumEntry( "Margin", 6 );
+#ifdef REPALM
+    reader->brepalm = config.readBoolEntry( "Repalm", true );
+#endif
+    reader->bremap = config.readBoolEntry( "Remap", true );
+    reader->bmakebold = config.readBoolEntry( "MakeBold", false );
+    reader->setContinuous(config.readBoolEntry( "Continuous", true ));
+    m_targetapp = config.readEntry( "TargetApp", QString::null );
+    m_targetmsg = config.readEntry( "TargetMsg", QString::null );
+#ifdef _SCROLLPIPE
+    reader->m_pipetarget = config.readEntry( "PipeTarget", QString::null );
+    reader->m_pauseAfterEachPara = config.readBoolEntry( "PauseAfterPara", true );
+#endif
+    m_twoTouch = config.readBoolEntry( "TwoTouch", false);
+    m_doAnnotation = config.readBoolEntry( "Annotation", false);
+    m_doDictionary = config.readBoolEntry( "Dictionary", false);
+    m_doClipboard = config.readBoolEntry( "Clipboard", false);
+    m_spaceTarget = (ActionTypes)config.readNumEntry("SpaceTarget", cesAutoScroll);
+    m_escapeTarget = (ActionTypes)config.readNumEntry("EscapeTarget", cesNone);
+    m_returnTarget = (ActionTypes)config.readNumEntry("ReturnTarget", cesFullScreen);
+    m_leftTarget = (ActionTypes)config.readNumEntry("LeftTarget", cesZoomOut);
+    m_rightTarget = (ActionTypes)config.readNumEntry("RightTarget", cesZoomIn);
+    m_upTarget = (ActionTypes)config.readNumEntry("UpTarget", cesPageUp);
+    m_downTarget = (ActionTypes)config.readNumEntry("DownTarget", cesPageDown);
+
+    m_leftScroll = config.readBoolEntry("LeftScroll", false);
+    m_rightScroll = config.readBoolEntry("RightScroll", false);
+    m_upScroll = config.readBoolEntry("UpScroll", true);
+    m_downScroll = config.readBoolEntry("DownScroll", true);
+    m_propogatefontchange = config.readBoolEntry( "RequestorFontChange", false);
+    reader->setBaseSize(config.readNumEntry( "Basesize", 10 ));
+    reader->setTwoTouch(m_twoTouch);
+
+    m_touch_action->setOn(m_twoTouch);
+    m_setmono_action->setOn(reader->m_bMonoSpaced);
+    setfontHelper(reader->m_fontname);
+    if (full)
+    {
+        addtoolbars(&config);
+    }
+    reader->setfilter(reader->getfilter());
+    reader->refresh();
+    return true;
+}
+
+bool QTReaderApp::PopulateConfig(const char* tgtdir)
+{
+    bkmkselector->clear();
+    bkmkselector->setText("Cancel");
+#ifndef USEQPE
+    int cnt = 0;
+
+    QDir d = QDir::home();                      // "/"
+    if ( !d.cd(APPDIR) ) {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+        d = QDir::home();
+        d.mkdir(APPDIR);
+        d.cd(APPDIR);
+    }
+    if ( !d.cd(tgtdir) ) {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "/%s\" directory", tgtdir );
+        d = QDir::home();
+        d.mkdir(tgtdir);
+        d.cd(tgtdir);
+    }
+    d.setFilter( QDir::Files | QDir::NoSymLinks );
+//        d.setSorting( QDir::Size | QDir::Reversed );
+
+    const QFileInfoList *list = d.entryInfoList();
+    QFileInfoListIterator it( *list );      // create list iterator
+    QFileInfo *fi;                          // pointer for traversing
+
+    while ( (fi=it.current()) ) {           // for each file...
+  
+        bkmkselector->insertItem(fi->fileName());
+        cnt++;
+                        
+        //qDebug( "%10li %s", fi->size(), fi->fileName().data() );
+        ++it;                               // goto next list element
+    }
+ 
+#else /* USEQPE */
+    int cnt = 0;
+    DIR *d;
+    char* finaldir;
+    finaldir = new char[strlen(APPDIR)+1+strlen(tgtdir)+1];
+    strcpy(finaldir, APPDIR);
+    strcat(finaldir, "/");
+    strcat(finaldir, tgtdir);
+    d = opendir((const char *)Global::applicationFileName(finaldir,""));
+
+    while(1)
+    {
+        struct dirent* de;
+        struct stat buf;
+        de = readdir(d);
+        if (de == NULL) break;
+
+        if (lstat((const char *)Global::applicationFileName(finaldir,de->d_name),&buf) == 0 && S_ISREG(buf.st_mode))
+        {
+            bkmkselector->insertItem(de->d_name);
+            cnt++;
+        }
+    }
+    delete [] finaldir;
+    closedir(d);
+#endif
+    return (cnt > 0);
+}
+
+void QTReaderApp::LoadConfig()
+{
+    if (PopulateConfig("configs"))
+      {
+        editorStack->raiseWidget( bkmkselector );
+        hidetoolbars();
+        m_nBkmkAction = cLdConfig;
+      }
+    else
+      QMessageBox::information(this, PROGNAME, "No config files");
+}
+
+void QTReaderApp::TidyConfig()
+{
+    if (PopulateConfig("configs"))
+      {
+        editorStack->raiseWidget( bkmkselector );
+        hidetoolbars();
+        m_nBkmkAction = cRmConfig;
+      }
+    else
+      QMessageBox::information(this, PROGNAME, "No config files");
+}
+
+void QTReaderApp::ExportLinks()
+{
+    if (PopulateConfig("urls"))
+      {
+        editorStack->raiseWidget( bkmkselector );
+        hidetoolbars();
+        m_nBkmkAction = cExportLinks;
+      }
+    else
+      QMessageBox::information(this, PROGNAME, "No url files");
+}
+
+void QTReaderApp::OnURLSelected(const QString& href)
+{
+    CURLDialog* urld = new CURLDialog(href, false, this);
+    urld->clipboard(m_url_clipboard);
+    urld->localfile(m_url_localfile);
+    urld->globalfile(m_url_globalfile);
+    if (urld->exec())
+    {
+        m_url_clipboard = urld->clipboard();
+        m_url_localfile = urld->localfile();
+        m_url_globalfile = urld->globalfile();
+        if (m_url_clipboard)
+        {
+            QClipboard* cb = QApplication::clipboard();
+            cb->setText(href);
+            qDebug("<a href=\"%s\">%s</a>", (const char*)href, (const char*)href);
+        }
+        if (m_url_localfile)
+        {
+            writeUrl(reader->m_string, href);
+        }
+        if (m_url_globalfile)
+        {
+            writeUrl("GlobalURLFile", href);
+        }
+    }
+    delete urld;
+}
+
+void QTReaderApp::writeUrl(const QString& file, const QString& href)
+{
+    QString filename;
+#ifdef USEQPE
+    filename = Global::applicationFileName(APPDIR "/urls", file);
+#else
+    QFileInfo fi;
+    QDir d = QDir::home();                      // "/"
+    if ( !d.cd(APPDIR) )
+    {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
+        d = QDir::home();
+        d.mkdir(APPDIR);
+        d.cd(APPDIR);
+    }
+    if ( !d.cd("urls") )
+    {                       // "/tmp"
+        qWarning( "Cannot find the \"~/" APPDIR "/urls\" directory" );
+        d = QDir::home();
+        d.cd(APPDIR);
+        d.mkdir("urls");
+        d.cd("urls");
+    }
+    fi.setFile(d, file);
+    filename = fi.absFilePath();
+#endif
+    FILE* fout = fopen(filename, "a");
+    if (fout != NULL)
+    {
+        fprintf(fout, "<p><a href=\"%s\">%s</a>\n", (const char*)href, (const char*)href);
+        fclose(fout);
+    }
+    else
+    {
+        QMessageBox::warning(this, PROGNAME, "Problem with writing URL");
+    }
+}
diff --git a/noncore/apps/opie-reader/ToolbarPrefs.cpp b/noncore/apps/opie-reader/ToolbarPrefs.cpp
index d878829..0347736 100644
--- a/noncore/apps/opie-reader/ToolbarPrefs.cpp
+++ b/noncore/apps/opie-reader/ToolbarPrefs.cpp
@@ -1,406 +1,396 @@
 /****************************************************************************
 ** Form implementation generated from reading ui file 'Prefs.ui'
 **
 ** Created: Tue Feb 11 23:53:35 2003
 **      by:  The User Interface Compiler (uic)
 **
 ** WARNING! All changes made in this file will be lost!
 ****************************************************************************/
-#include "useqpe.h"
 #include "ToolbarPrefs.h"
 
-#include <qcheckbox.h>
-#include <qlabel.h>
-#include <qpushbutton.h>
-#include <qspinbox.h>
 #include <qlayout.h>
-#include <qvariant.h>
-#include <qtooltip.h>
-#include <qwhatsthis.h>
-#include <qcombobox.h>
 #include <qbuttongroup.h>
-#include <qlineedit.h>
 #ifdef USEQPE
 #include <qpe/menubutton.h>
 #endif
 #include <qpe/qpeapplication.h>
 
 CBarPrefs::CBarPrefs(const QString& appdir, bool fs, QWidget* parent, const char* name) : QDialog(parent, name, true), config( appdir )
 {
     setCaption(tr( "Toolbar Settings" ) );
     QTabWidget* td = new QTabWidget(this);
     misc = new CMiscBarPrefs(this);
     filebar = new CFileBarPrefs(config, this);
     navbar = new CNavBarPrefs(config, this);
     viewbar = new CViewBarPrefs(config, this);
     markbar = new CMarkBarPrefs(config, this);
     indbar = new CIndBarPrefs(config, this);
     td->addTab(filebar, tr("File"));
     td->addTab(navbar, tr("Navigation"));
     td->addTab(viewbar, tr("View"));
     td->addTab(markbar, tr("Marks"));
     td->addTab(indbar, tr("Indicators"));
     td->addTab(misc, tr("Policy"));
     QVBoxLayout* v = new QVBoxLayout(this);
     v->addWidget(td);
 
     if (fs)
         QPEApplication::showDialog( this );
 }
 
 /*
 CBarPrefs1::CBarPrefs1( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     config.setGroup( "Toolbar" );
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(3, Qt::Horizontal, "File", this);
     vb->addWidget(bg);
 
     open = new QCheckBox( tr("Open"), bg );
     open->setChecked(config.readBoolEntry( "Open", false ));
     connect(open, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     close = new QCheckBox( tr("Close"), bg );
     close->setChecked(config.readBoolEntry( "Close", false ));
     connect(close, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     info = new QCheckBox( tr("Info"), bg );
     info->setChecked(config.readBoolEntry( "Info", false ));
     connect(info, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     twotouch = new QCheckBox( tr("Two/One\nTouch"), bg );
     twotouch->setChecked(config.readBoolEntry( "Two/One Touch", false ));
     connect(twotouch, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     find = new QCheckBox( tr("Find"), bg );
     find->setChecked(config.readBoolEntry( "Find", false ));
     connect(find, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     bg = new QGroupBox(2, Qt::Horizontal, "Navigation", this);
     vb->addWidget(bg);
     scroll = new QCheckBox( tr("Scroll"), bg );
     scroll->setChecked(config.readBoolEntry( "Scroll", false ));
     connect(scroll, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     navigation = new QCheckBox( tr("Back/Home/Forward"), bg );
     navigation->setChecked(config.readBoolEntry( "Back/Home/Forward", false ));
     connect(navigation, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     page = new QCheckBox( tr("Page\nUp/Down"), bg );
     page->setChecked(config.readBoolEntry( "Page Up/Down", false ));
     connect(page, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     startend = new QCheckBox( tr("Goto Start/End"), bg );
     startend->setChecked(config.readBoolEntry( "Goto Start/End", false ));
     connect(startend, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     jump = new QCheckBox( tr("Jump"), bg );
     jump->setChecked(config.readBoolEntry( "Jump", false ));
     connect(jump, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     pageline = new QCheckBox( tr("Page/Line Scroll"), bg );
     pageline->setChecked(config.readBoolEntry( "Page/Line Scroll", false ));
     connect(pageline, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CBarPrefs1::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Open", open->isChecked());
     config.writeEntry( "Close", close->isChecked());
     config.writeEntry( "Info", info->isChecked());
     config.writeEntry( "Two/One Touch", twotouch->isChecked());
     config.writeEntry( "Find", find->isChecked());
     config.writeEntry( "Scroll", scroll->isChecked());
     config.writeEntry( "Back/Home/Forward", navigation->isChecked());
     config.writeEntry( "Page Up/Down", page->isChecked());
     config.writeEntry( "Goto Start/End", startend->isChecked());
     config.writeEntry( "Jump", jump->isChecked());
     config.writeEntry( "Page/Line Scroll", pageline->isChecked());
 }
 
 CBarPrefs1::~CBarPrefs1()
 {
 }
 */
 /*
 CBarPrefs2::CBarPrefs2( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(3, Qt::Horizontal, "View", this);
     vb->addWidget(bg);
 
     config.setGroup( "Toolbar" );
 
     fullscreen = new QCheckBox( tr("Fullscreen"), bg );
     fullscreen->setChecked(config.readBoolEntry( "Fullscreen", false ));
     connect(fullscreen, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     zoom = new QCheckBox( tr("Zoom"), bg );
     zoom->setChecked(config.readBoolEntry( "Zoom In/Out", false ));
     connect(zoom, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     setfont = new QCheckBox( tr("Set Font"), bg );
     setfont->setChecked(config.readBoolEntry( "Set Font", false ));
     connect(setfont, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     encoding = new QCheckBox( tr("Encoding"), bg );
     encoding->setChecked(config.readBoolEntry("Encoding Select", false));
     connect(encoding, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     ideogram = new QCheckBox( tr("Ideogram"), bg );
     ideogram->setChecked(config.readBoolEntry("Ideogram Mode", false));
     connect(ideogram, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     bg = new QGroupBox(3, Qt::Horizontal, "Marks", this);
     vb->addWidget(bg);
     mark = new QCheckBox( tr("Bookmark"), bg );
     mark->setChecked(config.readBoolEntry( "Mark", false ));
     connect(mark, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     annotate = new QCheckBox( tr("Annotate"), bg );
     annotate->setChecked(config.readBoolEntry( "Annotate", false ));
     connect(annotate, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     go_to = new QCheckBox( tr("Goto"), bg );
     go_to->setChecked(config.readBoolEntry( "Goto", false ));
     connect(go_to, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     Delete = new QCheckBox( tr("Delete"), bg );
     Delete->setChecked(config.readBoolEntry( "Delete", false ));
     connect(Delete, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     autogen = new QCheckBox( tr("Autogen"), bg );
     autogen->setChecked(config.readBoolEntry( "Autogen", false ));
     connect(autogen, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     clear = new QCheckBox( tr("Clear"), bg );
     clear->setChecked(config.readBoolEntry( "Clear", false ));
     connect(clear, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     save = new QCheckBox( tr("Save"), bg );
     save->setChecked(config.readBoolEntry( "Save", false ));
     connect(save, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     tidy = new QCheckBox( tr("Tidy"), bg );
     tidy->setChecked(config.readBoolEntry( "Tidy", false ));
     connect(tidy, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     block = new QCheckBox( tr("Mark/Copy"), bg );
     block->setChecked(config.readBoolEntry( "Start/Copy Block", false ));
     connect(block, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     bg = new QGroupBox(1, Qt::Horizontal, "Indicators", this);
     vb->addWidget(bg);
     indannotate = new QCheckBox( tr("Annotation"), bg );
     indannotate->setChecked(config.readBoolEntry( "Annotation indicator", false ));
     connect(indannotate, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CBarPrefs2::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Fullscreen", fullscreen->isChecked());
     config.writeEntry( "Zoom In/Out", zoom->isChecked());
     config.writeEntry( "Set Font", setfont->isChecked());
     config.writeEntry("Encoding Select", encoding->isChecked());
     config.writeEntry("Ideogram Mode", ideogram->isChecked());
 
     config.writeEntry( "Mark", mark->isChecked());
     config.writeEntry( "Annotate", annotate->isChecked());
     config.writeEntry( "Goto", go_to->isChecked());
     config.writeEntry( "Delete", Delete->isChecked());
     config.writeEntry( "Autogen", autogen->isChecked());
     config.writeEntry( "Clear", clear->isChecked());
     config.writeEntry( "Save", save->isChecked());
     config.writeEntry( "Tidy", tidy->isChecked());
     config.writeEntry( "Start/Copy Block", block->isChecked());
     config.writeEntry( "Annotation indicator", indannotate->isChecked());
 }
 
 CBarPrefs2::~CBarPrefs2()
 {
 }
 */
 
 CFileBarPrefs::CFileBarPrefs( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     config.setGroup( "Toolbar" );
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(2, Qt::Horizontal, "File", this);
     vb->addWidget(bg);
 
     open = new QCheckBox( tr("Open"), bg );
     open->setChecked(config.readBoolEntry( "Open", false ));
     connect(open, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     close = new QCheckBox( tr("Close"), bg );
     close->setChecked(config.readBoolEntry( "Close", false ));
     connect(close, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     info = new QCheckBox( tr("Info"), bg );
     info->setChecked(config.readBoolEntry( "Info", false ));
     connect(info, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     twotouch = new QCheckBox( tr("Two/One\nTouch"), bg );
     twotouch->setChecked(config.readBoolEntry( "Two/One Touch", false ));
     connect(twotouch, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     find = new QCheckBox( tr("Find"), bg );
     find->setChecked(config.readBoolEntry( "Find", false ));
     connect(find, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CFileBarPrefs::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Open", open->isChecked());
     config.writeEntry( "Close", close->isChecked());
     config.writeEntry( "Info", info->isChecked());
     config.writeEntry( "Two/One Touch", twotouch->isChecked());
     config.writeEntry( "Find", find->isChecked());
 }
 
 CFileBarPrefs::~CFileBarPrefs()
 {
 }
 
 CNavBarPrefs::CNavBarPrefs( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     config.setGroup( "Toolbar" );
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(2, Qt::Horizontal, "Navigation", this);
     vb->addWidget(bg);
     scroll = new QCheckBox( tr("Scroll"), bg );
     scroll->setChecked(config.readBoolEntry( "Scroll", false ));
     connect(scroll, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     navback = new QCheckBox( tr("Back"), bg );
     navback->setChecked(config.readBoolEntry( "Back", false ));
     connect(navback, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     navhome = new QCheckBox( tr("Home"), bg );
     navhome->setChecked(config.readBoolEntry( "Home", false ));
     connect(navhome, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     navforward = new QCheckBox( tr("Forward"), bg );
     navforward->setChecked(config.readBoolEntry( "Forward", false ));
     connect(navforward, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     pageup = new QCheckBox( tr("Page Up"), bg );
     pageup->setChecked(config.readBoolEntry( "Page Up", false ));
     connect(pageup, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     pagedown = new QCheckBox( tr("Page Down"), bg );
     pagedown->setChecked(config.readBoolEntry( "Page Down", false ));
     connect(pagedown, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     gotostart = new QCheckBox( tr("Goto Start"), bg );
     gotostart->setChecked(config.readBoolEntry( "Goto Start", false ));
     connect(gotostart, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     gotoend = new QCheckBox( tr("Goto End"), bg );
     gotoend->setChecked(config.readBoolEntry( "Goto End", false ));
     connect(gotoend, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     jump = new QCheckBox( tr("Jump"), bg );
     jump->setChecked(config.readBoolEntry( "Jump", false ));
     connect(jump, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     pageline = new QCheckBox( tr("Page/Line Scroll"), bg );
     pageline->setChecked(config.readBoolEntry( "Page/Line Scroll", false ));
     connect(pageline, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CNavBarPrefs::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Scroll", scroll->isChecked());
     config.writeEntry( "Back", navback->isChecked());
     config.writeEntry( "Home", navhome->isChecked());
     config.writeEntry( "Forward", navforward->isChecked());
     config.writeEntry( "Page Up", pageup->isChecked());
     config.writeEntry( "Page Down", pagedown->isChecked());
     config.writeEntry( "Goto Start", gotostart->isChecked());
     config.writeEntry( "Goto End", gotoend->isChecked());
     config.writeEntry( "Jump", jump->isChecked());
     config.writeEntry( "Page/Line Scroll", pageline->isChecked());
 }
 
 CNavBarPrefs::~CNavBarPrefs()
 {
 }
 
 CViewBarPrefs::CViewBarPrefs( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(2, Qt::Horizontal, "View", this);
     vb->addWidget(bg);
 
     config.setGroup( "Toolbar" );
 
     fullscreen = new QCheckBox( tr("Fullscreen"), bg );
     fullscreen->setChecked(config.readBoolEntry( "Fullscreen", false ));
     connect(fullscreen, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     zoomin = new QCheckBox( tr("Zoom In"), bg );
     zoomin->setChecked(config.readBoolEntry( "Zoom In", false ));
     connect(zoomin, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     zoomout = new QCheckBox( tr("Zoom Out"), bg );
     zoomout->setChecked(config.readBoolEntry( "Zoom Out", false ));
     connect(zoomout, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     setfont = new QCheckBox( tr("Set Font"), bg );
     setfont->setChecked(config.readBoolEntry( "Set Font", false ));
     connect(setfont, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
 
     encoding = new QCheckBox( tr("Encoding"), bg );
     encoding->setChecked(config.readBoolEntry("Encoding Select", false));
     connect(encoding, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     ideogram = new QCheckBox( tr("Ideogram"), bg );
     ideogram->setChecked(config.readBoolEntry("Ideogram Mode", false));
     connect(ideogram, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CViewBarPrefs::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Fullscreen", fullscreen->isChecked());
     config.writeEntry( "Zoom In", zoomin->isChecked());
     config.writeEntry( "Zoom Out", zoomout->isChecked());
     config.writeEntry( "Set Font", setfont->isChecked());
     config.writeEntry("Encoding Select", encoding->isChecked());
     config.writeEntry("Ideogram Mode", ideogram->isChecked());
 }
 
 CViewBarPrefs::~CViewBarPrefs()
 {
 }
 
 CMarkBarPrefs::CMarkBarPrefs( Config& _config, QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl ), config(_config)
 {
     QVBoxLayout* vb = new QVBoxLayout(this);
 
     QGroupBox* bg = new QGroupBox(2, Qt::Horizontal, "Marks", this);
     vb->addWidget(bg);
     mark = new QCheckBox( tr("Bookmark"), bg );
     mark->setChecked(config.readBoolEntry( "Mark", false ));
     connect(mark, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     annotate = new QCheckBox( tr("Annotate"), bg );
     annotate->setChecked(config.readBoolEntry( "Annotate", false ));
     connect(annotate, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     go_to = new QCheckBox( tr("Goto"), bg );
     go_to->setChecked(config.readBoolEntry( "Goto", false ));
     connect(go_to, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     Delete = new QCheckBox( tr("Delete"), bg );
     Delete->setChecked(config.readBoolEntry( "Delete", false ));
     connect(Delete, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     autogen = new QCheckBox( tr("Autogen"), bg );
     autogen->setChecked(config.readBoolEntry( "Autogen", false ));
     connect(autogen, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     clear = new QCheckBox( tr("Clear"), bg );
     clear->setChecked(config.readBoolEntry( "Clear", false ));
     connect(clear, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     save = new QCheckBox( tr("Save"), bg );
     save->setChecked(config.readBoolEntry( "Save", false ));
     connect(save, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     tidy = new QCheckBox( tr("Tidy"), bg );
     tidy->setChecked(config.readBoolEntry( "Tidy", false ));
     connect(tidy, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     startblock = new QCheckBox( tr("Mark Block"), bg );
     startblock->setChecked(config.readBoolEntry( "Start Block", false ));
     connect(startblock, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     copyblock = new QCheckBox( tr("Copy Block"), bg );
     copyblock->setChecked(config.readBoolEntry( "Copy Block", false ));
     connect(copyblock, SIGNAL(stateChanged(int)), this, SLOT( isChanged(int) ) );
     m_isChanged = false;
 }
 
 void CMarkBarPrefs::saveall()
 {
     config.setGroup( "Toolbar" );
     config.writeEntry( "Mark", mark->isChecked());
     config.writeEntry( "Annotate", annotate->isChecked());
diff --git a/noncore/apps/opie-reader/fileBrowser.cpp b/noncore/apps/opie-reader/fileBrowser.cpp
index 05f2c31..ebd14f3 100644
--- a/noncore/apps/opie-reader/fileBrowser.cpp
+++ b/noncore/apps/opie-reader/fileBrowser.cpp
@@ -1,269 +1,266 @@
 /****************************************************************************
 
 Derived from a file browser which was
 
 ** copyright 2001 ljp ljp@llornkcor.com
 
 Extensive modification by Tim Wentford to allow it to work in rotated mode
 
 ****************************************************************************/
 #include "fileBrowser.h"
 
 #include "QtrListView.h"
 #include <qlineedit.h>
 #include <qpushbutton.h>
-#include <qfile.h>
-#include <qmessagebox.h>
 #ifndef _WINDOWS
 #include <unistd.h>
 #endif
 #include <qlayout.h>
 #ifdef _WINDOWS
 #include <direct.h>
 #endif
 
 #include <qpe/qpeapplication.h>
 
-#include "opie.h"
 
 fileBrowser::fileBrowser( bool allownew, QWidget* parent,  const char* name, bool modal, WFlags fl , const QString filter, const QString iPath )
     : QDialog( parent, name, true,
                fl/* | WStyle_Customize | WStyle_Tool*/),
       filterspec(QDir::All)
 {
 //    showMaximized();
     if ( !name )
         setName( "fileBrowser" );
 /*
     if (parent != NULL)
     {
 #ifdef OPIE
         move(0,0);
         resize( parent->width(), parent->height() );
 #else
         setGeometry(parent->x(), parent->y(), parent->width(), parent->height() );
 #endif
     }
 */
 //    showFullScreen();
     setCaption(tr( "Browse for file" ) );
     filterStr=filter;
 
     buttonOk = new QPushButton( this, "buttonOk" );
     buttonOk->setFixedSize( 25, 25 );
     buttonOk->setAutoDefault( false );
     buttonOk->setText( tr( "/" ) );
 
     buttonShowHidden = new QPushButton( this, "buttonShowHidden" );
 //    buttonShowHidden->setFixedSize( 50, 25 );
     buttonShowHidden->setText( tr( "Hidden" ) );
     buttonShowHidden->setAutoDefault( false );
     buttonShowHidden->setToggleButton( true );
     buttonShowHidden->setOn( false );
 
     dirLabel = new QLabel(this, "DirLabel");
     dirLabel->setAlignment(AlignLeft | AlignVCenter | ExpandTabs | WordBreak);
     dirLabel->setText(currentDir.canonicalPath());
 
     ListView = new QtrListView( this, "ListView" );
     ListView->addColumn( tr( "Name" ) );
     ListView->setSorting( 2, FALSE);
     ListView->addColumn( tr( "Size" ) );
     ListView->setSelectionMode(QListView::Single);
     ListView->setAllColumnsShowFocus( TRUE );
     ListView->setColumnWidthMode(0, QListView::Manual);
     ListView->setColumnWidthMode(1, QListView::Manual);
 
     // signals and slots connections
     connect( buttonShowHidden, SIGNAL( toggled(bool) ), this, SLOT( setHidden(bool) ) );
     connect( buttonOk, SIGNAL( clicked() ), this, SLOT( OnRoot() ) );
     connect( ListView, SIGNAL(doubleClicked( QListViewItem*)), SLOT(listDoubleClicked(QListViewItem *)) );
     connect( ListView, SIGNAL(clicked( QListViewItem*)), SLOT(listClicked(QListViewItem *)) );
     connect( ListView, SIGNAL(OnOKButton( QListViewItem*)), SLOT(listClicked(QListViewItem *)) );
     connect( ListView, SIGNAL(OnCentreButton( QListViewItem*)), SLOT(listClicked(QListViewItem *)) );
     connect( ListView, SIGNAL(OnCancelButton()), SLOT(OnCancel()) );
 
     QVBoxLayout* grid = new QVBoxLayout(this);
     QHBoxLayout* hgrid = new QHBoxLayout(grid);
     hgrid->addWidget(dirLabel,1);
     hgrid->addWidget(buttonShowHidden);
     hgrid->addWidget(buttonOk);
     grid->addWidget(ListView,1);
     if (allownew)
     {
         m_filename = new QLineEdit(this);
         grid->addWidget(m_filename);
         connect( m_filename, SIGNAL( returnPressed() ), this, SLOT( onReturn() ));
     }
     else
     {
         m_filename = NULL;
     }
 
     if (QFileInfo(iPath).exists())
     {
         currentDir.setPath(iPath);
 #ifdef _WINDOWS
         _chdir(iPath.latin1());
 #else
         chdir(iPath.latin1());
 #endif
     }
     else
     {
         currentDir.setPath(QDir::currentDirPath());
         chdir(QDir::currentDirPath().latin1());
     }
 
     populateList();
 
     if (modal)
         QPEApplication::showDialog( this );
 }
 
 void fileBrowser::resizeEvent(QResizeEvent* e)
 {
     ListView->setColumnWidth(1,(ListView->width())/4);
     ListView->setColumnWidth(0,ListView->width()-20-ListView->columnWidth(1));    
 }
 
 fileBrowser::~fileBrowser()
 {
 }
 
 
 void fileBrowser::populateList()
 {
     ListView->clear();
 ////qDebug(currentDir.canonicalPath());
 //    currentDir.setFilter( QDir::Files | QDir::Dirs | QDir::Hidden | QDir::NoSymLinks );
     currentDir.setFilter( filterspec );
     currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst);
     currentDir.setMatchAllDirs(TRUE);
 
     currentDir.setNameFilter(filterStr);
 //    currentDir.setNameFilter("*.txt;*.etx");
     QString fileL, fileS;
     const QFileInfoList *list = currentDir.entryInfoList();
     QFileInfoListIterator it(*list);
     QFileInfo *fi;
     while ( (fi=it.current()) )
     {
         if (fi->fileName() != ".")
         {
             fileS.sprintf( "%10li", fi->size() );
             fileL.sprintf( "%s",fi->fileName().data() );
             if( fi->isDir() )
             {
                 fileL+="/";
             } 
             else 
             {
 ////        qDebug("Not a dir: "+currentDir.canonicalPath()+fileL);
             }
             new QListViewItem( ListView,fileL,fileS );
         }
         ++it;
     }
     ListView->setSorting( 2, FALSE);
     dirLabel->setText("Current Directory:\n"+currentDir.canonicalPath());
     ListView->setFocus();
 }
 
 void fileBrowser::upDir()
 {
 ////    qDebug(currentDir.canonicalPath());
 }
 
 void fileBrowser::listClicked(QListViewItem *selectedItem)
 {
     if (selectedItem == NULL) return;
     QString strItem=selectedItem->text(0);
 
 ////    qDebug("%s", (const char*)strItem);
     
 
     QString strSize=selectedItem->text(1);
 
     strSize.stripWhiteSpace();
 
     bool ok;
 
     QFileInfo fi(strItem);
     while (fi.isSymLink()) fi.setFile(fi.readLink());
     if (fi.isDir())
     {
         strItem=QDir::cleanDirPath(currentDir.canonicalPath()+"/"+strItem);
 
         if(QDir(strItem).exists())
         {
             currentDir.cd(strItem, TRUE);
             populateList();
         }
     } else
     {
         QListViewItem *selectedItem = ListView->selectedItem();
         if (selectedItem == NULL)
         {
             filename = "";
         }
         else
         {
             filename = QDir::cleanDirPath(currentDir.canonicalPath()+"/"+selectedItem->text(0));
         }
         OnOK();
     }
     chdir(strItem.latin1());
 //
 
 }
 
 // you may want to switch these 2 functions. I like single clicks
 void fileBrowser::listDoubleClicked(QListViewItem *selectedItem)
 {
 }
 
 QString fileBrowser::getCurrentFile()
 {
     return filename;
 }
 
 void fileBrowser::OnOK()
 {
     accept();
 }
 
 void fileBrowser::OnRoot()
 {
     currentDir.cd("/", TRUE);
     populateList();
     chdir("/");
 }
 
 void fileBrowser::OnCancel()
 {
     reject();
 }
 
 void fileBrowser::setHidden(bool _hidden)
 {
     if (_hidden)
         filterspec = QDir::All | QDir::Hidden;
     else
         filterspec = QDir::All;
     populateList();
 }
 
 void fileBrowser::onReturn()
 {
     QListViewItem *selectedItem = ListView->selectedItem();
     if (selectedItem == NULL)
     {
         filename = m_filename->text();
     }
     else
     {
         filename = QDir::cleanDirPath(currentDir.canonicalPath()+"/"+m_filename->text());
     }
     OnOK();
 }
diff --git a/noncore/apps/opie-reader/main.cpp b/noncore/apps/opie-reader/main.cpp
index 3e1f5e7..6d706c4 100644
--- a/noncore/apps/opie-reader/main.cpp
+++ b/noncore/apps/opie-reader/main.cpp
@@ -1,50 +1,48 @@
 #include "useqpe.h"
 #ifdef USEQPE
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 #include "QTReaderApp.h"
 
 #include "signal.h"
-#include "stdio.h"
-#include "time.h"
 
 
 #ifdef USEQPE
 QTReaderApp* app = NULL;
 
 void handler(int signum)
 {
     if (app != NULL)
     {
         app->suspend();
         app->saveprefs();
     }
     signal(signum, handler);
 }
 #endif
 
 int main( int argc, char ** argv )
 {
 
 #ifdef USEQPE
     signal(SIGCONT, handler);
     QPEApplication a( argc, argv );
     QTReaderApp m;
     a.showMainDocumentWidget( &m );
     app = &m;
 #else
     QApplication a( argc, argv );
     QTReaderApp m;
     a.setMainWidget( &m );
         if (argc > 1)
         {
             m.setDocument(argv[1]);
         }
 #endif
 
 
     return a.exec();
 }
 
diff --git a/noncore/apps/opie-reader/plucker.cpp b/noncore/apps/opie-reader/plucker.cpp
index e49e35f..e52fd6a 100644
--- a/noncore/apps/opie-reader/plucker.cpp
+++ b/noncore/apps/opie-reader/plucker.cpp
@@ -1,156 +1,151 @@
-#include "useqpe.h"
 #include <stdio.h>
 #include <string.h>
-#include <qmessagebox.h>
-#include <qpixmap.h>
 #ifdef USEQPE
 #include <qpe/qcopenvelope_qws.h>
 #endif
 #ifdef LOCALPICTURES
 #include <qscrollview.h>
 #endif
 #ifdef USEQPE
 #include <qpe/global.h>
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
-#include <qclipboard.h>
 
 #include "plucker.h"
-#include "Aportis.h"
 #include "Palm2QImage.h"
 
 
 struct CPlucker_dataRecord
 {
     UInt16 uid;
     UInt16 nParagraphs;
     UInt16 size;
     UInt8 type;
     UInt8 reserved;
 };
 
 int CPlucker::HeaderSize()
 {
     return sizeof(CPlucker_dataRecord);
 }
 
 void CPlucker::GetHeader(UInt16& uid, UInt16& nParagraphs, UInt32& size, UInt8& type, UInt8& reserved)
 {
     CPlucker_dataRecord thishdr;
     fread(&thishdr, 1, HeaderSize(), fin);
     uid = ntohs(thishdr.uid);
     nParagraphs = ntohs(thishdr.nParagraphs);
     size = ntohs(thishdr.size);
     type = thishdr.type;
     reserved = thishdr.reserved;
 }
 
 CPlucker::CPlucker()
  { /*printf("constructing:%x\n",fin);*/ }
 
 bool CPlucker::CorrectDecoder()
 {
     return (memcmp(&head.type, "DataPlkr", 8) == 0);
 }
 
 int CPlucker::bgetch()
 {
     int ch = EOF;
     if (bufferpos >= buffercontent)
     {
         if (!m_continuous) return EOF;
         if (bufferrec >= ntohs(head.recordList.numRecords) - 1) return EOF;
         ////qDebug("Passing through %u", currentpos);
         if (!expand(bufferrec+1)) return EOF;
         mystyle.unset();
         if (m_ParaOffsets[m_nextParaIndex] == 0)
         {
             while (m_ParaOffsets[m_nextParaIndex+1] == 0)
             {
         //      qDebug("Skipping extraspace:%d", m_ParaAttrs[m_nextParaIndex]&7);
                 m_nextParaIndex++;
             }
         }
         mystyle.setExtraSpace((m_ParaAttrs[m_nextParaIndex]&7)*2);
         //qDebug("Using extraspace:%d", m_ParaAttrs[m_nextParaIndex]&7);
         ch = 10;
         EOPPhase = 4;
     }
     else if (bufferpos == m_nextPara)
     {
         while (bufferpos == m_nextPara)
         {
             UInt16 attr = m_ParaAttrs[m_nextParaIndex];
             m_nextParaIndex++;
         //    qDebug("Skipping extraspace:%d", m_ParaAttrs[m_nextParaIndex]&7);
             if (m_nextParaIndex == m_nParas)
             {
                 m_nextPara = -1;
             }
             else
             {
                 m_nextPara += m_ParaOffsets[m_nextParaIndex];
             }
         }
         mystyle.unset();
         mystyle.setExtraSpace((m_ParaAttrs[m_nextParaIndex]&7)*2);
         //qDebug("Using extraspace:%d", m_ParaAttrs[m_nextParaIndex]&7);
         if (m_lastBreak == locate())
         {
             currentpos++;
             ch = expandedtextbuffer[bufferpos++];
         }
         else
         {
             ch = 10;
         }
     }
     else
     {
         currentpos++;
         ch = expandedtextbuffer[bufferpos++];
     }
     return ch;
 }
 
 tchar CPlucker::getch(bool fast)
 {
     mystyle.clearPicture();
 
     if (EOPPhase > 0)
     {
         int ch = 10;
         switch (EOPPhase)
         {
             case 4:
                 if (!fast) mystyle.setPicture(false, hRule(100,5));
                 mystyle.setCentreJustify();
                 ch = '#';
                 break;
             case 3:
                 mystyle.setFontSize(3);
                 ch = 10;
                 break;
             case 2:
                 ch = 10;
                 break;
             case 1:
                 mystyle.unset();
             default:
                 ch = 10;
         }
         EOPPhase--;
         return ch;
     }
 
     return getch_base(fast);
 }
 
 QImage* CPlucker::imagefromdata(UInt8* imgbuffer, UInt32 imgsize)
 {
     QImage* qimage = Palm2QImage(imgbuffer, imgsize);
     delete [] imgbuffer;
     return qimage;
 }
diff --git a/noncore/apps/opie-reader/plucker_base.cpp b/noncore/apps/opie-reader/plucker_base.cpp
index 9047a45..caa945d 100644
--- a/noncore/apps/opie-reader/plucker_base.cpp
+++ b/noncore/apps/opie-reader/plucker_base.cpp
@@ -1,1067 +1,1062 @@
 #include "useqpe.h"
 #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 "plucker_base.h"
 #include "Aportis.h"
 #include "Palm2QImage.h"
 
 CPlucker_base::CPlucker_base() :
 #ifdef LOCALPICTURES
     m_viewer(NULL),
     m_picture(NULL),
 #endif
     expandedtextbuffer(NULL),
     compressedtextbuffer(NULL)
 //,    urls(NULL)
  { /*printf("constructing:%x\n",fin);*/ }
 
 
 void CPlucker_base::Expand(UInt32 reclen, UInt8 type, UInt8* buffer, UInt32 buffersize)
 {
     if (type%2 == 0)
     {
         fread(buffer, reclen, sizeof(char), fin);
     }
     else
     {
         UInt8* readbuffer = NULL;
         if (reclen > compressedbuffersize)
         {
             readbuffer = new UInt8[reclen];
         }
         else
         {
             readbuffer = compressedtextbuffer;
         }
         if (readbuffer != NULL)
         {
             fread(readbuffer, reclen, sizeof(char), fin);
             switch (ntohs(hdr0.version))
             {
                 case 2:
                     UnZip(readbuffer, reclen, buffer, buffersize);
                     break;
                 case 1:
                     UnDoc(readbuffer, reclen, buffer, buffersize);
                     break;
             }
             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
     {
         QMessageBox::information(NULL,
                                  QString(PROGNAME),
                                  QString("No external links\nin this pluck")
             );
     }
     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)
 {
     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();
     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;
             }
         }
     }
 //    qDebug("Time(1): %u", clock()-start);
 /*
     expand(recptr);
     mystyle.unset();
     bufferpos = n-textlength;
     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;
 */
 //    start = clock();
 
     UInt16 thisrec = 0;
     unsigned long locpos = 0;
     unsigned long bs = 0;
     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 <= n);
 
 //    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();
     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));
     }
     if (m_nParas > 0)
     {
         m_nextPara = m_ParaOffsets[0];
         //qDebug("First offset = %u", m_nextPara);
         m_nextParaIndex = 0;
     }
     else
     {
         m_nextPara = -1;
     }
 
     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);
     bufferpos = 0;
     bufferrec = thisrec;
     //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);
 }
 
 void 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;
     }
 }
 
 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)
 {
     m_lastBreak = 0;
     if (!Cpdb::openfile(src))
     {
         return -1;
     }
 
     if (!CorrectDecoder()) return -1;
 
     gotorecordnumber(0);
     fread(&hdr0, 1, 6, fin);
     setbuffersize();
     compressedtextbuffer = new UInt8[compressedbuffersize];
     expandedtextbuffer = new UInt8[buffersize];
 
     //qDebug("Total number of records:%u", ntohs(head.recordList.numRecords));
     
     unsigned int nrecs = ntohs(hdr0.nRecords);
     //qDebug("Version %u, no. recs %u", ntohs(hdr0.version), nrecs);
     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;
     }
     textlength = 0;
     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);
     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);
     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, QString& wrd)
 {
     visited.push_front(n);
     UInt16 tuid = (n >> 16);
     n &= 0xffff;
 //    //qDebug("Hyper:<%u,%u>", tuid, n);
     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))
         {
             char *turl = geturl(tuid);
             if (turl == NULL)
             {
                 QMessageBox::information(NULL,
                                          QString(PROGNAME),
                                          QString("Couldn't find link")
                     );
             }
             else
             {
                 wrd = turl;
 #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);
                 delete [] turl;
             }
             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)
             {
                 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);
         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];
             n = noff;
         }
         if (n > thishdr_size)
         {
             QMessageBox::information(NULL,
                                  QString(PROGNAME),
                                  QString("Error in link\nOffset too big")
                 );
             return eNone;
         }
         //qDebug("Hyper:<%u,%u>", tuid, n);
         while (bufferpos < n && bufferpos < buffercontent) getch_base(true);
 /*      // 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;
 }
 
 tchar CPlucker_base::getch_base(bool fast)
 {
     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();
                 }
                 else
                 {
                     mystyle.setUnderline();
                 }
                 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();
                 mystyle.setFontSize(0);
                 switch (ch)
                 {
                     case 0:
                         break;
                     case 1:
                         mystyle.setBold();
                         mystyle.setFontSize(3);
                         break;
                     case 2:
                         mystyle.setBold();
                         mystyle.setFontSize(2);
                         break;
                     case 3:
                         mystyle.setBold();
                         mystyle.setFontSize(1);
                         break;
                     case 4:
diff --git a/noncore/apps/opie-reader/ppm.cpp b/noncore/apps/opie-reader/ppm.cpp
index e8bf110..1face46 100644
--- a/noncore/apps/opie-reader/ppm.cpp
+++ b/noncore/apps/opie-reader/ppm.cpp
@@ -1,387 +1,386 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include "arith.h"
 #include "ppm.h"
 
 /****************************************************************************
  * Gestion des noeuds
  ****************************************************************************/
 
 /* 
  * Désallocation du noeud p
  */
 
 void ppm_worker::Node_Free(UINT p) {
   node_heap[node_free_last].free_next=p;
   node_heap[p].free_next=NIL;
   node_free_last=p;
   node_free_nb++;
 }
 
 /*
  * Allocation d'un noeud
  * s'il ne reste plus de place, on désalloue le contexte le moins utilisé.
  */
 
 UINT ppm_worker::Node_Alloc(void)  {
   UINT p;
   if (node_free_nb<=2) Context_DeleteLast();
   p=node_free_first;
   node_free_first=node_heap[node_free_first].free_next;
   node_free_nb--;
 #ifdef DEBUG
   printf("Node_Alloc: p=%d\n",p);
 #endif
   return p;
 }
 
 /****************************************************************************
  * Gestion des contextes 
  ****************************************************************************/
 
 
 /* 
  * Mise au début de la liste des contextes du contexte c 
  */
 void ppm_worker::Context_MoveFirst(UINT c) {
   NODE *ctx;
    
   if (c!=ctx_first)  {
     ctx=&node_heap[c];
     /* suppression du contexte dans la liste */
     if (c==ctx_last)  {
       ctx_last=ctx->hdr.ctx_prev;
     } else  {
       node_heap[ctx->hdr.ctx_prev].hdr.ctx_next=ctx->hdr.ctx_next;
       node_heap[ctx->hdr.ctx_next].hdr.ctx_prev=ctx->hdr.ctx_prev;
     }
     /* insertion au début de la liste */
     node_heap[ctx_first].hdr.ctx_prev=c;
     ctx->hdr.ctx_next=ctx_first;
     ctx_first=c;
   }
 }
 
 /*
  * Destruction du contexte le moins utilisé (ctx_last)
  */
 void ppm_worker::Context_DeleteLast(void) {
   NODE *n;
   UINT h,h_next,node,node_next;
   USHORT *p;
    
   n=&node_heap[ctx_last];
    
   /* libération dans la table de hachage. Comme on ne dispose pas de
    * pointeur hash_prev dans les contextes, il faut parcourir toute
    * la liste. Heureusement, celle-ci est de longueur faible en moyenne
    */
   h_next=n->hdr.hash_next;
   h=h_next;
   while (h<HASH_ADDRESS) h=node_heap[h].hdr.hash_next;
   p=&hash_table[h-HASH_ADDRESS];
   while (*p!=ctx_last) p=&node_heap[*p].hdr.hash_next;
   *p=h_next;
    
   /* libération des noeuds & modification de ctx_last */
    
   if (n->hdr.sf_max>=2)  {
     node=n->hdr.sf.l.sf_next;
     while (1) {
       node_next=node_heap[node].sf.sf_next;
       Node_Free(node);
       if (node_next==NIL) break;
       node=node_next;
     }
   } 
 
   node=ctx_last;
   ctx_last=n->hdr.ctx_prev;
   Node_Free(node);
   ctx_nb--;
 }
 
 /* 
  * Création d'un nouveau contexte avec un seul symbole sym de fréquence 1
  * Utilisation implicite de sym_context et sym_hash.
  * Libération de mémoire si nécessaire, et mise en premier dans la liste
  */
 void ppm_worker::Context_New(int sym,int order) {
   NODE *ctx;
   UINT i,c;
 
 #ifdef DEBUG   
   printf("Context_New: sym=%d o=%d\n",sym,order);
 #endif
 
   c=Node_Alloc();
   ctx=&node_heap[c];
    
   /* mise du contexte en tête de la liste */
   ctx->hdr.ctx_next=ctx_first;
   node_heap[ctx_first].hdr.ctx_prev=c;
   ctx_first=c;
   ctx_nb++;
    
   /* insertion dans la table de hachage */
   ctx->hdr.hash_next=hash_table[sym_hash[order]];
   hash_table[sym_hash[order]]=ctx_first;
 
   /* initialisation du contexte */
   ctx->hdr.order=order;
   for(i=0;i<order;i++) ctx->hdr.sym[i]=sym_context[i+1];
 
   ctx->hdr.sf_max=0;
   ctx->hdr.sf.sf[0].sym=sym;
   ctx->hdr.sf.sf[0].freq=1;
 #ifdef DEBUG
   Context_Print(ctx_first);
 #endif
 }
 
 /*
  * Ajout d'un nouveau symbole au contexte c
  */
 
 void ppm_worker::Context_NewSym(int sym,UINT c) {
   NODE *n,*m;
   UINT p,sf_max;
 
 #ifdef DEBUG   
   printf("Context_NewSym: sym=%d c=%d\n",sym,c);
   Context_Print(c);
 #endif
 
   n=&node_heap[c];
   sf_max=n->hdr.sf_max;
   n->hdr.sf_max++;
   if (sf_max==0)  {
     n->hdr.sf.sf[1].sym=sym;
     n->hdr.sf.sf[1].freq=1;
   } else if (sf_max==1)  {
     p=Node_Alloc();
     m=&node_heap[p];
     m->sf.sf[0]=n->hdr.sf.sf[0];
     m->sf.sf[1]=n->hdr.sf.sf[1];
     m->sf.sf[2].sym=sym;
     m->sf.sf[2].freq=1;
     m->sf.sf_next=NIL;
     n->hdr.sf.l.sf_next=p;
     n->hdr.sf.l.freq_tot=((UINT)m->sf.sf[0].freq+(UINT)m->sf.sf[1].freq+1);
   } else  {
     n->hdr.sf.l.freq_tot++;
     m=&node_heap[n->hdr.sf.l.sf_next];
     while (sf_max>=NODE_SFNB)  {
       sf_max-=NODE_SFNB;
       m=&node_heap[m->sf.sf_next];
     }
     sf_max++;
     if (sf_max==NODE_SFNB)  {
       p=Node_Alloc();
       m->sf.sf_next=p;
       m=&node_heap[p];
       m->sf.sf_next=NIL;
       sf_max=0;
     }
     m->sf.sf[sf_max].sym=sym;
     m->sf.sf[sf_max].freq=1;
   }
 #ifdef DEBUG
   Context_Print(c);
 #endif
 }
 
 
 #ifdef STAT
 int hash_nb=1;
 int hash_cnt=0;
 #endif 
 
 /*
  * Recherche d'un contexte, utilisation de façon implicite de sym_context
  * et de sym_hash.
  * C'est une procédure très critique qui doit être particulièrement optimisée
  */
 
 UINT ppm_worker::Context_Search(int order)  {
   UCHAR *sym;
   UINT i,p;
   NODE *n;
 #ifdef DEBUG   
   printf("Context_Search: o=%d\n",order);
 #endif
    
   p=hash_table[sym_hash[order]];
   sym=&sym_context[1];
 #ifdef STAT
   hash_nb++;
 #endif
   while (p<HASH_ADDRESS)  {
 #ifdef STAT
     hash_cnt++;
 #endif
     n=&node_heap[p];
     if (n->hdr.order==order)  {
       if (order==0) return p;
       i=0;
       while (sym[i]==n->hdr.sym[i]) {
         i++;
         if (i==order) return p;
       }
     }
     p=n->hdr.hash_next;
   }
   return HASH_ADDRESS;
 }
 
 /*
  * Cette macro est HORRIBLE mais permet de simplifier beaucoup le parcours
  * des listes de couples symbole,fréquence tout en ayant un code rapide.
  * Une alternative élégante mais lente aurait été de passer une fonction
  * en paramètre contenant le code à exécuter
  */
 
 #define SF_Read(n,p,code_to_execute) \
 {\
          UINT nb,i;\
          nb=(UINT)n->hdr.sf_max+1;\
    if (nb<=HDR_SFNB)  {\
       p=&n->hdr.sf.sf[0];\
    } else {\
       p=&node_heap[n->hdr.sf.l.sf_next].sf.sf[0];\
       while (nb>NODE_SFNB) {\
                                  for(i=0;i<NODE_SFNB;i++)  {\
                                                 code_to_execute;\
                                                 p++;\
                                  }\
                                  p=&node_heap[ *((USHORT *)p) ].sf.sf[0];\
                                  nb-=NODE_SFNB;\
       }\
    }\
    for(i=0;i<nb;i++)  {\
                         code_to_execute;\
       p++;\
    }\
 }
 
 
 /* 
  * Renormalisation d'un contexte, ie, division de toutes les fréquences 
  * par 2 et élimination des symboles de fréquence nulle  
  * Note: le contexte obtenu n'est jamais vide. 
  * Une amélioration prévue mais non implémentée serait de trier le contexte
  * dans l'ordre des fréquences décroissantes pour accélérer la recherche.
  * Les gains en vitesse seraient de toute façon assez faibles car les
  * contextes sont de toute façon à peu près triés vu leur méthode de 
  * construction: les caractères sont ajoutés à la fin de la liste 
  */
 void ppm_worker::Context_Renorm(UINT ctx) {
   NODE *n,*m;
   UINT a,b,c,i,freq_tot,sf_nb;
   SYMFREQ s,*p,tab_sf[SYM_NB];
          
 #ifdef DEBUG   
   printf("Context_Renorm: c=%d\n",ctx);
   Context_Print(ctx);
 #endif 
    
   n=&node_heap[ctx];
   freq_tot=0;
   sf_nb=0;
          
   SF_Read(n,p, {
     s=*p;
     s.freq=s.freq/2;
     if (s.freq!=0) {
       freq_tot+=s.freq;
       tab_sf[sf_nb]=s;
       sf_nb++;
     }
   } );
          
          
   /* libération des noeuds utilisés pour stocker les symboles */
   if (n->hdr.sf_max>=HDR_SFNB) {
     a=n->hdr.sf.l.sf_next;
     do {
       b=node_heap[a].sf.sf_next;
       Node_Free(a);
       a=b;
     } while (a!=NIL);
   }
                                  
   /* reconstruction de la liste des "sf_nb" symboles d'apres le tableau
    * "tab_sf"
    */ 
 
   n->hdr.sf_max=sf_nb-1;
   if (sf_nb<=HDR_SFNB)  {
     for(i=0;i<sf_nb;i++) n->hdr.sf.sf[i]=tab_sf[i];
   } else  {
     a=Node_Alloc();
     n->hdr.sf.l.sf_next=a;
     n->hdr.sf.l.freq_tot=freq_tot;
     m=&node_heap[a];
     i=0;
     c=0;
     while (1) {
       m->sf.sf[c]=tab_sf[i];
       i++;
       if (i==sf_nb) break;
       c++;
       if (c==NODE_SFNB)  {
         c=0;
         a=Node_Alloc();
         m->sf.sf_next=a;
         m=&node_heap[a];
       }
     }
     m->sf.sf_next=NIL;
   }
 
 #ifdef DEBUG
   Context_Print(ctx);
 #endif
 }
 
 
 /*
  * Mise à jour des index dans la table de hachage et des caractères du
  * contexte courant.
  * La fonction de hachage a été choisie de façon empirique en controlant
  * qu'elle donne en moyenne de bons résultats.
  */
 void ppm_worker::Hash_Update(int sym) {
   UINT i,k;
    
   for(i=ORDER_MAX;i>=2;i--) 
     sym_context[i]=sym_context[i-1];
   sym_context[1]=sym;
    
   for(i=ORDER_MAX;i>=2;i--) {  
     k=sym_hash[i-1];
     sym_hash[i]=( (k<<6)-k+sym ) & (HASH_SIZE-1);
   }
   sym_hash[1]=sym+1;
 }
 
 
 /****************************************************************************
  * Système d'exclusion des symboles 
  ****************************************************************************/
 
 
 /*
  * Remise à zéro du tableau d'exclusion des symboles 
  */
 void ppm_worker::Sym_ExcludeReset(void) {
   UINT i;
    
   sym_excl_code++;
   if (sym_excl_code==0)  {
     for(i=0;i<SYM_NB;i++) sym_excl[i]=0;
     sym_excl_code=1;
   }
 }
 
 
diff --git a/noncore/apps/opie-reader/version.cpp b/noncore/apps/opie-reader/version.cpp
index 3796b67..864e4c1 100644
--- a/noncore/apps/opie-reader/version.cpp
+++ b/noncore/apps/opie-reader/version.cpp
@@ -1,39 +1,37 @@
 #include "version.h"
-#include "names.h"
-#include <qmessagebox.h>
 
 bool CheckVersion(int& major, int& bkmktype, char& minor)
 {
     if (
         (major != MAJOR)
         ||
         (bkmktype != BKMKTYPE)
         ||
         (minor != MINOR)
         )
     {
         major = MAJOR;
         bkmktype = BKMKTYPE;
         minor = MINOR;
 /*
         QMessageBox::warning(NULL, PROGNAME,
                              "This is the first time that you have\n"
                              "run this version of OpieReader.\n\n"
                              "There are two new icons visible at\n"
                              "the left end of the toolbar. The left\n"
                              "one brings up the menus, the next\n"
                              "one brings up the settings dialog.\n\n"
                              "Start by tapping the settings icon\n"
                              "and selecting the Buttons tab to\n"
                              "make sure that the buttons are\n"
                              "mapped as you expect\n\n"
                              "Next go to Settings/Toolbars via the\n"
                              "menu icon to set up your toolbars.");
 */
         return true;
     }
     else
     {
         return false;
     }
 }
diff --git a/noncore/apps/opie-sheet/Excel.cpp b/noncore/apps/opie-sheet/Excel.cpp
index 225c3e1..fc49d56 100644
--- a/noncore/apps/opie-sheet/Excel.cpp
+++ b/noncore/apps/opie-sheet/Excel.cpp
@@ -1,395 +1,392 @@
 
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <time.h>
 #include <sys/types.h>
 #include <strings.h>
-#include <qstring.h>
-#include <qlist.h>
-#include <qarray.h>
 #include "Excel.h"
 
 static xfrecord formatter[] = {
 { 0xe , DATEFORMAT, "%m/%d/%y"},
 { 0xf , DATEFORMAT, "%d-%b-%y"},
 { 0x10, DATEFORMAT, "%d-%b"},
 { 0x11, DATEFORMAT, "%b-%y"},
 { 0x12, DATEFORMAT, "%I:%M %p"},
 { 0x13, DATEFORMAT, "%I:%M:%S %p"},
 { 0x14, DATEFORMAT, "%H:%M"},
 { 0x15, DATEFORMAT, "%H:%M:%S"},
 { 0x16, DATEFORMAT, "%m/%d/%y %H:%M"},
 { 0x2d, DATEFORMAT, "%M:%S"},
 { 0x2e, DATEFORMAT, "%H:%M:%S"},
 { 0x2f, DATEFORMAT, "%M:%S"},
 { 0xa5, DATEFORMAT, "%m/%d/%y %I:%M %p"},
 { 0x1 , NUMBERFORMAT, "%.0f"},
 { 0x2 , NUMBERFORMAT, "%.2f"},
 { 0x3 , NUMBERFORMAT, "#,##%.0f"},
 { 0x4 , NUMBERFORMAT, "#,##%.2f"},
 { 0x5 , NUMBERFORMAT, "$#,##%.0f"},
 { 0x6 , NUMBERFORMAT, "$#,##%.0f"},
 { 0x7 , NUMBERFORMAT, "$#,##%.2f"},
 { 0x8 , NUMBERFORMAT, "$#,##%.2f"},
 { 0x9 , NUMBERFORMAT, "%.0f%%"},
 { 0xa , NUMBERFORMAT, "%.2f%%"},
 { 0xb , NUMBERFORMAT, "%e"},
 { 0x25, NUMBERFORMAT, "#,##%.0f;(#,##0)"},
 { 0x26, NUMBERFORMAT, "#,##%.0f;(#,##0)"},
 { 0x27, NUMBERFORMAT, "#,##%.2f;(#,##0.00)"},
 { 0x28, NUMBERFORMAT, "#,##%.2f;(#,##0.00)"},
 { 0x29, NUMBERFORMAT, "#,##%.0f;(#,##0)"},
 { 0x2a, NUMBERFORMAT, "$#,##%.0f;($#,##0)"},
 { 0x2b, NUMBERFORMAT, "#,##%.2f;(#,##0.00)"},
 { 0x2c, NUMBERFORMAT, "$#,##%.2f;($#,##0.00)"},
 { 0x30, NUMBERFORMAT, "##0.0E0"},
 { 0, 0, ""}
 };
 
 
 
 int ExcelBook::Integer2Byte(int b1, int b2)
 {
         int i1 = b1 & 0xff;
         int i2 = b2 & 0xff;
         int val = i2 << 8 | i1;
         return val;
 };
 
 int ExcelBook::Integer4Byte(int b1,int b2,int b3,int b4)
 {
         int i1 = Integer2Byte(b1, b2);
         int i2 = Integer2Byte(b3, b4);
         int val = i2 << 16 | i1;
         return val;
 };
 
 int ExcelBook::Integer2ByteFile(FILE *f) {
         int i1, i2;
         i1 = fgetc(f);
         i2 = fgetc(f);
         return Integer2Byte(i1,i2);
 };
 
 float ExcelBook::Float4Byte(int b1, int b2, int b3, int b4)
 {
         int i;
         float f;
         unsigned char *ieee;
         ieee = (unsigned char *) &f;
         for (i = 0; i < 4; i++) ieee[i] = 0;
         ieee[0] = ((int)b4) & 0xff;
         ieee[1] = ((int)b3) & 0xff;
         ieee[2] = ((int)b2) & 0xff;
         ieee[3] = ((int)b1) & 0xff;
         return f;
 };
 
 double ExcelBook::Double4Byte(int b1, int b2, int b3, int b4)
 {
         long int rk;
         double value;
 
         rk=Integer4Byte(b1,b2,b3,b4);
         //printf("Double4Bytes:%d,%d,%d,%d\r\n",b1,b2,b3,b4);
         if ( (rk & 0x02) != 0)
         {
                 long int intval = rk >> 2; //drops the 2 bits
                 printf("Double4Byte:intval=%d, rk=%d, rk>>2=%d\r\n",intval,rk,rk>>2);
                 value = (double) intval;
                 printf("Double4Byte: VALUEINT=%f\r\n",value);
                 if ( (rk & 0x01) != 0)
                 {
                         value /= 100.0;
                 };
                 return value;
         }else
         {
 
                 union { double d; unsigned long int b[2]; } dbl_byte;
                 unsigned long int valbits = (rk & 0xfffffffc);
                 #if defined(__arm__) && !defined(__vfp__)
                 dbl_byte.b[0]=valbits;
                 dbl_byte.b[1]=0;
                 #else
                 dbl_byte.b[0]=0;
                 dbl_byte.b[1]=valbits;
                 #endif
                 printf("dbl_byte.b[0]=%d,dbl_byte.b[1]=%d\r\n",dbl_byte.b[0],dbl_byte.b[1]);
                 value=dbl_byte.d;
                 printf("Double4Byte: VALUE=%f\r\n",value);
 
                 if ( (rk & 0x01) != 0)
                 {
                         value /= 100.0;
                 };
                 return value;
             };
 };
 
 void ExcelBook::DetectEndian(void)
 {
         int end;
         long i = 0x44332211;
         unsigned char* a = (unsigned char*) &i;
         end = (*a != 0x11);
         if (end == 1) {
                 endian = BIG_ENDIAN;
                 printf("BIGENDIAN!\r\n");
         } else {
                 endian = LITTLE_ENDIAN;
                 printf("LITTLEENDIAN!\r\n");
         }
 };
 
 double ExcelBook::Double8Byte(int b1, int b2, int b3, int b4, int b5, int b6, int b7, int b8)
 {
         int i;
         double d;
         unsigned char *ieee;
         ieee = (unsigned char *)&d;
         for (i = 0; i < 8; i++) ieee[i] = 0;
         if (endian == BIG_ENDIAN) {
                 ieee[0] = ((int)b8) & 0xff;ieee[1] = ((int)b7) & 0xff;
                 ieee[2] = ((int)b6) & 0xff;ieee[3] = ((int)b5) & 0xff;
                 ieee[4] = ((int)b4) & 0xff;ieee[5] = ((int)b3) & 0xff;
                 ieee[6] = ((int)b2) & 0xff;ieee[7] = ((int)b1) & 0xff;
         } else {
                 ieee[0] = ((int)b1) & 0xff;ieee[1] = ((int)b2) & 0xff;
                 ieee[2] = ((int)b3) & 0xff;ieee[3] = ((int)b4) & 0xff;
                 ieee[4] = ((int)b5) & 0xff;ieee[5] = ((int)b6) & 0xff;
                 ieee[6] = ((int)b7) & 0xff;ieee[7] = ((int)b8) & 0xff;
         }
         return d;
 };
 
 bool ExcelBook::OpenFile(char *Filename)
 {
         printf("Opening excel file!\r\n");
         File= fopen(Filename, "r");
         Position=0; // first byte index in file
         XFRecords.resize(0);
         SharedStrings.resize(0);
         Names.resize(0);
         Sheets.resize(0);
         if(File==NULL) return false;
         printf("Opened excel file!\r\n");
         return true;
 };
 
 bool ExcelBook::CloseFile(void)
 {
         int w1;
         for(w1=0;w1<(int)XFRecords.count();w1++)
         {
                 if(XFRecords[w1]!=NULL) {delete XFRecords[w1];XFRecords[w1]=NULL;};
         };
         for(w1=0;w1<(int)SharedStrings.count();w1++)
         {
                 if(SharedStrings[w1]!=NULL) {delete SharedStrings[w1];SharedStrings[w1]=NULL;};
         };
         for(w1=0;w1<(int)Names.count();w1++)
         {
                 if(Names[w1]!=NULL) {delete Names[w1];Names[w1]=NULL;};
         };
         for(w1=0;w1<(int)Sheets.count();w1++)
         {
                 if(Sheets[w1]!=NULL) {delete Sheets[w1];Sheets[w1]=NULL;};
         };
         XFRecords.resize(0);
         SharedStrings.resize(0);
         Names.resize(0);
         Sheets.resize(0);
         fclose(File);
         printf("closed excel file!\r\n");
         if(File==NULL) return true;
         return false;
 };
 
 void ExcelBook::SeekPosition(int pos)
 {
         if(!feof(File))
         {
         Position=pos;
         //printf("SeekPosition:Pos:%d\r\n",Position);
         fseek(File,pos,SEEK_SET);
         };
 };
 
 void ExcelBook::SeekSkip(int pos)
 {
         if(!feof(File))
         {
         Position=Position+pos;
         //printf("SeekSkip:Pos:%d\r\n",Position);
         fseek(File, Position, SEEK_SET);
         };
 };
 
 int ExcelBook::FileEOF(void)
 {
         if(File!=NULL) return(feof(File)); else return 0;
         //EOF is defined in stdlib as -1
 };
 
 int ExcelBook::Get2Bytes(void)
 {
         int i1,i2;
         i1=0; i2=0;
         if (!feof(File))
         {
                 i1=fgetc(File);
                 Position++;
         };
         if (!feof(File))
         {
                 i2=fgetc(File);
                 Position++;
         };
         return Integer2Byte(i1,i2);
 };
 
 char* ExcelBook::Read(int pos, int length)
 {
         int i;
         char *data;
         data= new char[length];
         SeekPosition(pos);
         for(i=0; i<length; i++)
         {
                 if(!feof(File)) data[i]=fgetc(File);
         };
         Position= Position+length;
         return data;
 };
 
 QString ExcelBook::ReadUnicodeChar(int pos, int length)
 {
         int i;
         QString data;
         int i1=' ',i2=' ',ii;
         SeekPosition(pos);
         for(i=0; i<length; i++)
         {
                 if(!feof(File)) i1=fgetc(File);
                 if(!feof(File)) i2=fgetc(File);
                 ii=Integer2Byte(i1,i2);
                 data.append(ii);
                 Position+=2;
         };
         return data;
 };
 
 QString* ExcelBook::GetString(int num)
 {
         if(num>=0 && num<(int)SharedStrings.count())
         {
                 return SharedStrings[num];
         };
         return new QString("");
 };
 
 int ExcelBook::SeekBOF(void)
 {
         int opcode,version,streamtype,length,ret=0;
         char *data;
         while(!feof(File))
         {
                 opcode=Get2Bytes();
                 if(opcode==XL_BOF)
                 {
                         length=Get2Bytes();
                         data=Read(Position,length);
                         version=Integer2Byte(data[0], data[1]);
                         streamtype=Integer2Byte(data[2], data[3]);
                         printf("SEEKBOF:opcode=XLBOF, %d ,version %d\r\n",Position,version);
                         delete data; data=NULL;
                         if (version==BIFF8) ret=8;
                                 else if(version==BIFF7) ret=7;
                         printf("SEEKBOF:versionBIFF%d\r\n",ret);
                         if(streamtype==WBKGLOBAL) return ret *2;
                                 else if(streamtype==WRKSHEET) return ret *1;
                         return 1;
                 };
         };
         return 0;
 };
 
 ExcelBREC* ExcelBook::GetBREC(void)
 {
         ExcelBREC* rec;
         rec= new ExcelBREC;
         if(FileEOF()) return NULL;
         rec->data=NULL;
         rec->code=Get2Bytes();
         rec->length=Get2Bytes();
         rec->position=Position;
         SeekSkip(rec->length);
         return rec;
 };
 
 ExcelBREC* ExcelBook::PeekBREC(void)
 {
         int oldpos;
         ExcelBREC* NextRec;
         oldpos=Position;
         NextRec=GetBREC();
         SeekPosition(oldpos);
         return NextRec;
 };
 
 char* ExcelBook::GetDataOfBREC(ExcelBREC* record)
 {
         if(record->data==NULL)
         {
                 ConvertCharToArray(record,Read(record->position,record->length),record->length);
         };
         return record->data;//new?
 };
 
 void ExcelBook::ConvertCharToArray(ExcelBREC* record, char* chars, int length)
 {
         record->data=new char[length];
         for(int w1=0;w1<=length-1;w1++)
                 record->data[w1]=chars[w1];
 };
 
 
 bool ExcelSheet::InitCells()
 {
         int r;
         Cells.resize(rows * cols + cols+1);
         if(Cells.count()==0) return false;
         for(r=0;r < Cells.count();r++)
         {
                 Cells[r]=NULL;
         };
         return true;
 };
 
 void ExcelSheet::Set(int row, int col, ExcelCell* cell)
 {
         if(cell!=NULL&&(row*cols+col)<Cells.count())
         {
         Cells[row*cols+col]=cell;
         };
 };
 
 ExcelCell* ExcelSheet::Get(int row, int col)
 {
         ExcelCell* cell;
         cell=Cells[row*cols+col];
         if(cell==NULL) return NULL;
         return cell;
 };
 
 int ExcelBook::SheetHandleRecord(ExcelSheet* sheet, ExcelBREC* record)
 {
         char* data=NULL;
         switch (record->code)
         {
                 case XL_DIMENSION:
                 data = GetDataOfBREC(record);
                         if (record->length == 10)
diff --git a/noncore/apps/opie-sheet/mainwindow.cpp b/noncore/apps/opie-sheet/mainwindow.cpp
index 3d3c688..1fb2a3d 100644
--- a/noncore/apps/opie-sheet/mainwindow.cpp
+++ b/noncore/apps/opie-sheet/mainwindow.cpp
@@ -1,408 +1,404 @@
 /***************************************************************************
  *                                                                         *
  *   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 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "mainwindow.h"
 
-#include <qpe/filemanager.h>
-#include <qpe/qcopenvelope_qws.h>
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 
 #include <qmessagebox.h>
-#include <qfile.h>
-#include <qtranslator.h>
 #include <qradiobutton.h>
 
 #include "cellformat.h"
 #include "numberdlg.h"
 #include "textdlg.h"
 #include "sortdlg.h"
 #include "finddlg.h"
 
 #define DEFAULT_NUM_ROWS 300
 #define DEFAULT_NUM_COLS (26*3)
 #define DEFAULT_NUM_SHEETS 3
 
 MainWindow::MainWindow(QWidget *parent, const char* n, WFlags fl)
            :QMainWindow(parent, n, fl)
 {
   // initialize variables
   documentModified=FALSE;
 
   // construct objects
   currentDoc=0;
   fileSelector=new FileSelector("application/sheet-qt", this, QString::null);
   ExcelSelector=new FileSelector("application/excel",this,QString::null,FALSE);
   connect(fileSelector, SIGNAL(closeMe()), this, SLOT(selectorHide()));
   connect(fileSelector, SIGNAL(newSelected(const DocLnk &)), this, SLOT(selectorFileNew(const DocLnk &)));
   connect(fileSelector, SIGNAL(fileSelected(const DocLnk &)), this, SLOT(selectorFileOpen(const DocLnk &)));
   connect(ExcelSelector,SIGNAL(fileSelected(const DocLnk &)),this,SLOT(slotImportExcel(const DocLnk &)));
   connect(ExcelSelector,SIGNAL(closeMe()), this, SLOT(ExcelSelectorHide()));
 
 
   listSheets.setAutoDelete(TRUE);
 
   initActions();
   initMenu();
   initEditToolbar();
   initFunctionsToolbar();
   initStandardToolbar();
   initSheet();
 
   // set window title
   setCaption(tr("Opie Sheet"));
 
   // create sheets
   selectorFileNew(DocLnk());
 }
 
 MainWindow::~MainWindow()
 {
   if (currentDoc) delete currentDoc;
 }
 
 void MainWindow::documentSave(DocLnk *lnkDoc)
 {
   FileManager fm;
   QByteArray streamBuffer;
   QDataStream stream(streamBuffer, IO_WriteOnly);
 
   typeSheet *currentSheet=findSheet(sheet->getName());
   if (!currentSheet)
   {
     QMessageBox::critical(this, tr("Error"), tr("Inconsistency error!"));
     return;
   }
   sheet->copySheetData(&currentSheet->data);
   stream.writeRawBytes("SQT100", 6);
   stream << (Q_UINT32)listSheets.count();
   for (typeSheet *tempSheet=listSheets.first(); tempSheet; tempSheet=listSheets.next())
   {
     stream << tempSheet->name << (Q_UINT32)tempSheet->data.count();
     for (typeCellData *tempCell=tempSheet->data.first(); tempCell; tempCell=tempSheet->data.next())
       stream << (Q_UINT32)tempCell->col << (Q_UINT32)tempCell->row << tempCell->borders.right << tempCell->borders.bottom << tempCell->background << (Q_UINT32)tempCell->alignment << tempCell->fontColor << tempCell->font << tempCell->data;
   }
 
   lnkDoc->setType("application/sheet-qt");
   if (!fm.saveFile(*lnkDoc, streamBuffer))
   {
     QMessageBox::critical(this, tr("Error"), tr("File cannot be saved!"));
     return;
   }
   documentModified=FALSE;
 }
 
 void MainWindow::documentOpen(const DocLnk &lnkDoc)
 {
   FileManager fm;
   QByteArray streamBuffer;
   if (!lnkDoc.isValid() || !fm.loadFile(lnkDoc, streamBuffer))
   {
     QMessageBox::critical(this, tr("Error"), tr("File cannot be opened!"));
     documentModified=FALSE;
     selectorFileNew(DocLnk());
     return;
   }
   QDataStream stream(streamBuffer, IO_ReadOnly);
 
   Q_UINT32 countSheet, countCell, i, j, row, col, alignment;
   typeSheet *newSheet;
   typeCellData *newCell;
 
   char fileFormat[7];
   stream.readRawBytes(fileFormat, 6);
   fileFormat[6]=0;
   if ((QString)fileFormat!="SQT100")
   {
     QMessageBox::critical(this, tr("Error"), tr("Invalid file format!"));
     documentModified=FALSE;
     selectorFileNew(DocLnk());
     return;
   }
 
   stream >> countSheet;
   for (i=0; i<countSheet; ++i)
   {
     newSheet=new typeSheet;
     newSheet->data.setAutoDelete(TRUE);
     stream >> newSheet->name >> countCell;
     comboSheets->insertItem(newSheet->name);
 
     for (j=0; j<countCell; ++j)
     {
       newCell=new typeCellData;
       stream >> col >> row >> newCell->borders.right >> newCell->borders.bottom >> newCell->background >> alignment >> newCell->fontColor >> newCell->font >> newCell->data;
       newCell->col=col;
       newCell->row=row;
       newCell->alignment=(Qt::AlignmentFlags)alignment;
       newSheet->data.append(newCell);
     }
     listSheets.append(newSheet);
 
     if (i==0)
     {
       sheet->setName(newSheet->name);
       sheet->setSheetData(&newSheet->data);
     }
   }
 }
 
 int MainWindow::saveCurrentFile(bool ask)
 {
   if (ask)
   {
     int result=QMessageBox::information(this, tr("Save File"), tr("Do you want to save the current file?"), QMessageBox::Yes, QMessageBox::No, QMessageBox::Cancel);
     if (result!=QMessageBox::Yes) return result;
   }
 
   if (!currentDoc->isValid())
   {
     TextDialog dialogText(this);
     if (dialogText.exec(tr("Save File"), tr("&File Name:"), tr("UnnamedFile"))!=QDialog::Accepted || dialogText.getValue().isEmpty()) return QMessageBox::Cancel;
 
     currentDoc->setName(dialogText.getValue());
     currentDoc->setFile(QString::null);
     currentDoc->setLinkFile(QString::null);
   }
 
   documentSave(currentDoc);
   return QMessageBox::Yes;
 }
 
 void MainWindow::selectorFileNew(const DocLnk &lnkDoc)
 {
   selectorHide();
 
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) return;
   if (currentDoc) delete currentDoc;
   currentDoc = new DocLnk(lnkDoc);
   editData->clear();
   listSheets.clear();
   comboSheets->clear();
 
   typeSheet *newSheet=createNewSheet();
   newSheet->data.setAutoDelete(TRUE);
   sheet->setName(newSheet->name);
   sheet->setSheetData(&newSheet->data);
   for (int i=1; i<DEFAULT_NUM_SHEETS; ++i)
     createNewSheet();
   documentModified=FALSE;
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) e->ignore();
   else e->accept();
 }
 
 void MainWindow::selectorFileOpen(const DocLnk &lnkDoc)
 {
   selectorHide();
 
   if (documentModified && saveCurrentFile()==QMessageBox::Cancel) return;
   if (currentDoc) delete currentDoc;
   currentDoc = new DocLnk();
   listSheets.clear();
   comboSheets->clear();
 
   documentOpen(lnkDoc);
   documentModified=FALSE;
 }
 
 void MainWindow::selectorShow()
 {
   sheet->hide();
   setCentralWidget(fileSelector);
   fileSelector->show();
   fileSelector->reread();
 }
 
 void MainWindow::selectorHide()
 {
   fileSelector->hide();
   setCentralWidget(sheet);
   sheet->show();
 }
 
 void MainWindow::slotFileNew()
 {
   selectorFileNew(DocLnk());
 }
 
 void MainWindow::slotFileOpen()
 {
   selectorShow();
 }
 
 void MainWindow::slotImportExcelOpen()
 {
   sheet->hide();
   setCentralWidget(ExcelSelector);
   ExcelSelector->show();
   ExcelSelector->reread();
 }
 
 void MainWindow::ExcelSelectorHide()
 {
   ExcelSelector->hide();
   setCentralWidget(sheet);
   sheet->show();
 }
 
 void MainWindow::slotFileSave()
 {
   saveCurrentFile(FALSE);
 }
 
 void MainWindow::setDocument(const QString &applnk_filename)
 {
   selectorFileOpen(DocLnk(applnk_filename));
 }
 
 void MainWindow::initActions()
 {
   fileNew=new QAction(tr("New File"), Resource::loadPixmap( "new" ), tr("&New"), 0, this);
   connect(fileNew, SIGNAL(activated()), this, SLOT(slotFileNew()));
   fileOpen=new QAction(tr("Open File"), Resource::loadPixmap( "fileopen" ), tr("&Open"), 0, this);
   connect(fileOpen, SIGNAL(activated()), this, SLOT(slotFileOpen()));
   fileSave=new QAction(tr("Save File"),Resource::loadPixmap( "save" ), tr("&Save"), 0, this);
   connect(fileSave, SIGNAL(activated()), this, SLOT(slotFileSave()));
   fileSaveAs=new QAction(tr("Save File As"), Resource::loadPixmap( "save" ), tr("Save &As"), 0, this);
   connect(fileSaveAs, SIGNAL(activated()), this, SLOT(slotFileSaveAs()));
 
   //fileQuit=new QAction(tr("Quit"), tr("&Quit"), 0, this);
   //connect(fileQuit, SIGNAL(activated()), this, SLOT(close()));
   fileExcelImport=new QAction(tr("Import Excel file"),Resource::loadPixmap( "opie-sheet/excel16" ),tr("Import E&xcel file"),0,this);
   connect(fileExcelImport, SIGNAL(activated()), this, SLOT(slotImportExcelOpen()));
 
   // helpGeneral=new QAction(tr("General Help"), QPixmap(help_general_xpm), tr("&General"), 0, this);
   //connect(helpGeneral, SIGNAL(activated()), this, SLOT(slotHelpGeneral()));
   //helpAbout=new QAction(tr("About Opie Sheet"), tr("&About"), 0, this);
   //connect(helpAbout, SIGNAL(activated()), this, SLOT(slotHelpAbout()));
 
   editAccept=new QAction(tr("Accept"),Resource::loadPixmap( "enter" ) , tr("&Accept"), 0, this);
   connect(editAccept, SIGNAL(activated()), this, SLOT(slotEditAccept()));
   editCancel=new QAction(tr("Cancel"), Resource::loadPixmap( "close" ), tr("&Cancel"), 0, this);
   connect(editCancel, SIGNAL(activated()), this, SLOT(slotEditCancel()));
   editCellSelect=new QAction(tr("Cell Selector"), Resource::loadPixmap( "opie-sheet/cell-select" ), tr("Cell &Selector"), 0, this);
   editCellSelect->setToggleAction(TRUE);
   connect(editCellSelect, SIGNAL(toggled(bool)), this, SLOT(slotCellSelect(bool)));
   editCut=new QAction(tr("Cut Cells"), tr("Cu&t"), 0, this);
   editCopy=new QAction(tr("Copy Cells"), tr("&Copy"), 0, this);
   editPaste=new QAction(tr("Paste Cells"), tr("&Paste"), 0, this);
   connect(editPaste, SIGNAL(activated()), this, SLOT(slotEditPaste()));
   editPasteContents=new QAction(tr("Paste Contents"), tr("Paste Cont&ents"), 0, this);
   connect(editPasteContents, SIGNAL(activated()), this, SLOT(slotEditPasteContents()));
   editClear=new QAction(tr("Clear Cells"), tr("C&lear"), 0, this);
 
   insertCells=new QAction(tr("Insert Cells"), tr("C&ells"), 0, this);
   connect(insertCells, SIGNAL(activated()), this, SLOT(slotInsertCells()));
   insertRows=new QAction(tr("Insert Rows"), tr("&Rows"), 0, this);
   connect(insertRows, SIGNAL(activated()), this, SLOT(slotInsertRows()));
   insertCols=new QAction(tr("Insert Columns"), tr("&Columns"), 0, this);
   connect(insertCols, SIGNAL(activated()), this, SLOT(slotInsertCols()));
   insertSheets=new QAction(tr("Add Sheets"), tr("&Sheets"), 0, this);
   connect(insertSheets, SIGNAL(activated()), this, SLOT(slotInsertSheets()));
 
   formatCells=new QAction(tr("Cells"), tr("&Cells"), 0, this);
   connect(formatCells, SIGNAL(activated()), this, SLOT(slotFormatCells()));
 
   rowHeight=new QAction(tr("Row Height"), tr("H&eight"), 0, this);
   connect(rowHeight, SIGNAL(activated()), this, SLOT(slotRowHeight()));
   rowAdjust=new QAction(tr("Adjust Row"), tr("&Adjust"), 0, this);
   connect(rowAdjust, SIGNAL(activated()), this, SLOT(slotRowAdjust()));
   rowShow=new QAction(tr("Show Row"), tr("&Show"), 0, this);
   connect(rowShow, SIGNAL(activated()), this, SLOT(slotRowShow()));
   rowHide=new QAction(tr("Hide Row"), tr("&Hide"), 0, this);
   connect(rowHide, SIGNAL(activated()), this, SLOT(slotRowHide()));
 
   colWidth=new QAction(tr("Column Width"), tr("&Width"), 0, this);
   connect(colWidth, SIGNAL(activated()), this, SLOT(slotColumnWidth()));
   colAdjust=new QAction(tr("Adjust Column"), tr("&Adjust"), 0, this);
   connect(colAdjust, SIGNAL(activated()), this, SLOT(slotColumnAdjust()));
   colShow=new QAction(tr("Show Column"), tr("&Show"), 0, this);
   connect(colShow, SIGNAL(activated()), this, SLOT(slotColumnShow()));
   colHide=new QAction(tr("Hide Column"), tr("&Hide"), 0, this);
   connect(colHide, SIGNAL(activated()), this, SLOT(slotColumnHide()));
 
   sheetRename=new QAction(tr("Rename Sheet"), tr("&Rename"), 0, this);
   connect(sheetRename, SIGNAL(activated()), this, SLOT(slotSheetRename()));
   sheetRemove=new QAction(tr("Remove Sheet"), tr("R&emove"), 0, this);
   connect(sheetRemove, SIGNAL(activated()), this, SLOT(slotSheetRemove()));
 
   dataSort=new QAction(tr("Sort Data"), tr("&Sort"), 0, this);
   connect(dataSort, SIGNAL(activated()), this, SLOT(slotDataSort()));
   dataFindReplace=new QAction(tr("Find && Replace"), tr("&Find && Replace"), 0, this);
   connect(dataFindReplace, SIGNAL(activated()), this, SLOT(slotDataFindReplace()));
 
   funcEqual=new QAction(tr("Equal To"), Resource::loadPixmap( "opie-sheet/func-equal" ), tr("&Equal To"), 0, this);
   funcEqual->setToolTip("=");
   connect(funcEqual, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcPlus=new QAction(tr("Addition"), Resource::loadPixmap( "opie-sheet/func-plus" ), tr("&Addition"), 0, this);
   funcPlus->setToolTip("+");
   connect(funcPlus, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcMinus=new QAction(tr("Subtraction"), Resource::loadPixmap( "opie-sheet/func-minus" ), tr("&Subtraction"), 0, this);
   funcMinus->setToolTip("-");
   connect(funcMinus, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcCross=new QAction(tr("Multiplication"), Resource::loadPixmap ("opie-sheet/func-cross" ), tr("&Multiplication"), 0, this);
   funcCross->setToolTip("*");
   connect(funcCross, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcDivide=new QAction(tr("Division"), Resource::loadPixmap( "opie-sheet/func-divide" ), tr("&Division"), 0, this);
   funcDivide->setToolTip("/");
   connect(funcDivide, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcParanOpen=new QAction(tr("Open ParanthesistempCellData->row+row1, tempCellData->col+col1"), Resource::loadPixmap( "opie-sheet/func-paran-open" ), tr("&Open Paranthesis"), 0, this);
   funcParanOpen->setToolTip("(");
   connect(funcParanOpen, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcParanClose=new QAction(tr("Close Paranthesis"), Resource::loadPixmap( "opie-sheet/func-paran-close" ), tr("&Close Paranthesis"), 0, this);
   funcParanClose->setToolTip(")");
   connect(funcParanClose, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
   funcComma=new QAction(tr("Comma"), Resource::loadPixmap( "opie-sheet/func-comma" ), tr("&Comma"), 0, this);
   funcComma->setToolTip(",");
   connect(funcComma, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
 }
 
 void MainWindow::initMenu()
 {
   menu=new QMenuBar(this);
 
   menuFile=new QPopupMenu;
   fileNew->addTo(menuFile);
   fileOpen->addTo(menuFile);
   fileSave->addTo(menuFile);
   fileSaveAs->addTo(menuFile);
 //  menuFile->insertSeparator();
 //  fileQuit->addTo(menuFile);
   menuFile->insertSeparator();
   fileExcelImport->addTo(menuFile);
   menu->insertItem(tr("&File"), menuFile);
 
   menuEdit=new QPopupMenu;
   editAccept->addTo(menuEdit);
   editCancel->addTo(menuEdit);
   editCellSelect->addTo(menuEdit);
   menuEdit->insertSeparator();
   editCut->addTo(menuEdit);
   editCopy->addTo(menuEdit);
   editPaste->addTo(menuEdit);
   editPasteContents->addTo(menuEdit);
   editClear->addTo(menuEdit);
   menu->insertItem(tr("&Edit"), menuEdit);
 
   menuInsert=new QPopupMenu;
   menu->insertItem(tr("&Insert"), menuInsert);
 
   menuFormat=new QPopupMenu;
   formatCells->addTo(menuFormat);
   menu->insertItem(tr("&Format"), menuFormat);
 
diff --git a/noncore/apps/opie-sheet/sheet.cpp b/noncore/apps/opie-sheet/sheet.cpp
index e1e4744..f303d33 100644
--- a/noncore/apps/opie-sheet/sheet.cpp
+++ b/noncore/apps/opie-sheet/sheet.cpp
@@ -1,401 +1,400 @@
 /***************************************************************************
  *                                                                         *
  *   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 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
  * Opie Sheet (formerly Sheet/Qt)
  * by Serdar Ozler <sozler@sitebest.com>
  */
 
 #include "sheet.h"
 
-#include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <math.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 
 #define DEFAULT_COL_WIDTH 50
 
 Sheet::Sheet(int numRows, int numCols, QWidget *parent)
       :QTable(numRows, numCols, parent)
 {
   defaultBorders.right=defaultBorders.bottom=QPen(Qt::gray, 1, Qt::SolidLine);
   defaultCellData.data="";
   defaultCellData.background=QBrush(Qt::white, Qt::SolidPattern);
   defaultCellData.alignment=(Qt::AlignmentFlags)(Qt::AlignLeft | Qt::AlignTop);
   defaultCellData.fontColor=Qt::black;
   defaultCellData.font=font();
   defaultCellData.borders=defaultBorders;
 
   clicksLocked=FALSE;
   selectionNo=-1;
   setSelectionMode(QTable::Single);
 
   sheetData.setAutoDelete(TRUE);
   clipboardData.setAutoDelete(TRUE);
   for (int i=0; i<numCols; ++i)
     horizontalHeader()->setLabel(i, getHeaderString(i+1), DEFAULT_COL_WIDTH);
 
 
   connect(this, SIGNAL(currentChanged(int, int)), this, SLOT(slotCellSelected(int, int)));
   connect(this, SIGNAL(valueChanged(int, int)), this, SLOT(slotCellChanged(int, int)));
 }
 
 Sheet::~Sheet()
 {
 }
 
 typeCellData *Sheet::findCellData(int row, int col)
 {
   typeCellData *tempCellData;
   for (tempCellData=sheetData.first(); tempCellData; tempCellData=sheetData.next())
     {
         if (tempCellData->row==row && tempCellData->col==col) return tempCellData;
     }
   return NULL;
 }
 
 void Sheet::slotCellSelected(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (cellData)
   {
     emit currentDataChanged(cellData->data);
   }else
     emit currentDataChanged("");
 }
 
 typeCellData *Sheet::createCellData(int row, int col)
 {
   if (row<0 || col<0) return NULL;
   typeCellData *cellData=new typeCellData;
   cellData->row=row;
   cellData->col=col;
   cellData->data=defaultCellData.data;
   cellData->borders=defaultCellData.borders;
   cellData->alignment=defaultCellData.alignment;
   cellData->font=defaultCellData.font;
   cellData->fontColor=defaultCellData.fontColor;
   cellData->background=defaultCellData.background;
   sheetData.append(cellData);
   return cellData;
 }
 
 void Sheet::slotCellChanged(int row, int col)
 {
   typeCellData *cellData=findCellData(row, col);
   if (!cellData) cellData=createCellData(row, col);
   if (cellData) cellData->data=text(row, col);
   for (cellData=sheetData.first(); cellData; cellData=sheetData.next())
   {
         // modified by Toussis Manolis koppermind@panafonet.gr
         // the parser was crashing if there were no closed parenthesis.
         int w1,ii=0;
         for(w1=0;w1<=(int)text(row, col).length();w1++)
         {
                 if(text(row,col)[w1]=='(') ii++;
                 if(text(row,col)[w1]==')') ii--;
         };
         if(ii==0) setText(cellData->row, cellData->col, dataParser(findCellName(cellData->row, cellData->col), cellData->data));
         //end of modification
         // old was plain:
         //setText(cellData->row, cellData->col, dataParser(findCellName(cellData->row, cellData->col), cellData->data));
   };
   emit sheetModified();
 }
 
 
 void Sheet::ReCalc(void)
 {
         typeCellData* cellData;
         for (cellData=sheetData.first(); cellData; cellData=sheetData.next())
             {
                 //printf("cellchanged:%d, %d\r\n",cellData->row,cellData->col);
 
                 slotCellChanged(cellData->row,cellData->col);
         };
 };
 
 
 
 
 void Sheet::swapCells(int row1, int col1, int row2, int col2)
 {
   typeCellData *cellData1=findCellData(row1, col1), *cellData2=findCellData(row2, col2);
   if (!cellData1) cellData1=createCellData(row1, col1);
   if (!cellData2) cellData2=createCellData(row2, col2);
   if (cellData1 && cellData2)
   {
     QString tempData(cellData1->data);
     cellData1->data=cellData2->data;
     cellData2->data=tempData;
     setText(cellData1->row, cellData1->col, dataParser(findCellName(cellData1->row, cellData1->col), cellData1->data));
     setText(cellData2->row, cellData2->col, dataParser(findCellName(cellData2->row, cellData2->col), cellData2->data));
     emit sheetModified();
   }
 }
 
 QString Sheet::getParameter(const QString &parameters, int paramNo, bool giveError, const QString funcName)
 {
   QString params(parameters);
   int position;
   for (int i=0; i<paramNo; ++i)
   {
     position=params.find(',');
     if (position<0)
     {
       if (giveError) QMessageBox::critical(this, tr("Error"), tr("Too few arguments to function '"+funcName+'\''));
       //printf("params:%s\r\n",parameters.ascii());
       return QString(NULL);
     }
     params=params.mid(position+1);
   }
   position=params.find(',');
   if (position<0) return params;
   return params.left(position);
 }
 
 bool Sheet::findRange(const QString &variable1, const QString &variable2, int *row1, int *col1, int *row2, int *col2)
 {
   int row, col;
   if (!findRowColumn(variable1, row1, col1, FALSE) || !findRowColumn(variable2, row2, col2, FALSE)) return FALSE;
   if (*row1>*row2)
   {
     row=*row1;
     *row1=*row2;
     *row2=row;
   }
   if (*col1>*col2)
   {
     col=*col1;
     *col1=*col2;
     *col2=col;
   }
   return TRUE;
 }
 
 bool Sheet::findRowColumn(const QString &variable, int *row, int *col, bool giveError)
 {
   int position=variable.find(QRegExp("\\d"));
   if (position<1)
   {
     if (giveError) QMessageBox::critical(this, tr("Error"), tr("Invalid variable: '"+variable+'\''));
     return FALSE;
   }
   *row=variable.mid(position).toInt()-1;
   *col=getHeaderColumn(variable.left(position))-1;
   return TRUE;
 }
 
 QString Sheet::calculateVariable(const QString &variable)
 {
   bool ok;
   printf("calculateVariable=%s,len=%d\r\n",variable.ascii(),variable.length());
   if(variable.left(1)=="\"") return QString(variable.mid(1,variable.length()-2));
   double tempResult=variable.toDouble(&ok);
   if (ok)
   {
         if(tempResult!=0.0)
         {
                 return QString::number(tempResult);
         }
         else
         {
                 if(variable!="0" || variable!="0.0") return QString(variable); // hereis a string variable
                 return QString::number(tempResult);
         };
   };
 
   int row, col;
   if(findRowColumn(variable, &row, &col, FALSE)) return dataParser(variable, text(row,col));
   //return (findRowColumn(variable, &row, &col, TRUE) ? dataParser(variable, text(row, col)) : 0);
   return QString(variable);
 }
 
 double Sheet::BesselI0(double x)
 {
         //Returns the modi ed Bessel function I0(x) for any real x.
         double ax,ans;
         double y;
         if ((ax=fabs(x)) < 3.75)
         {
                 y=x/3.75;
                 y*=y;
                 ans=1.0+y*(3.5156229+y*(3.0899424+y*(1.2067492 +y*(0.2659732+y*(0.360768e-1+y*0.45813e-2)))));
         }else
         {
                 y=3.75/ax;
                 ans=(exp(ax)/sqrt(ax))*(0.39894228+y*(0.1328592e-1 +y*(0.225319e-2+y*(-0.157565e-2+y*(0.916281e-2 +y*(-0.2057706e-1+y*(0.2635537e-1+y*(-0.1647633e-1 +y*0.392377e-2))))))));
         }
         return ans;
 };
 
 double Sheet::BesselI1(double x)
 {
         double ax,ans;
         double y;
         if ((ax=fabs(x)) < 3.75)
         {
                 y=x/3.75;
                 y*=y;
                 ans=ax*(0.5+y*(0.87890594+y*(0.51498869+y*(0.15084934 +y*(0.2658733e-1+y*(0.301532e-2+y*0.32411e-3))))));
         } else
         {
                 y=3.75/ax;
                 ans=0.2282967e-1+y*(-0.2895312e-1+y*(0.1787654e-1 -y*0.420059e-2)); ans=0.39894228+y*(-0.3988024e-1+y*(-0.362018e-2 +y*(0.163801e-2+y*(-0.1031555e-1+y*ans))));
                 ans *= (exp(ax)/sqrt(ax));
         }
         return x < 0.0 ? -ans : ans;
 };
 
 double Sheet::BesselI(int n, double x)
 {
         double ACC=40.0;
         double BIGNO=1.0e10;
         double BIGNI=1.0e-10;
         int j;
         double bi,bim,bip,tox,ans;
         if (n < 2) return 0.0;
         if (x == 0.0) return 0.0; else
                 {
                         tox=2.0/fabs(x);
                         bip=ans=0.0;
                         bi=1.0;
                         for (j=2*(n+(int) sqrt(ACC*n));j>0;j--)
                         {
                                 bim=bip+j*tox*bi;
                                 bip=bi;
                                 bi=bim;
                                 if (fabs(bi) > BIGNO)
                                         {
                                                 ans *= BIGNI;
                                                 bi *= BIGNI;
                                                 bip *= BIGNI;
                                         }
                                 if (j == n) ans=bip;
                         }
                 ans *= BesselI0(x)/bi;
                 return x < 0.0 && (n & 1) ? -ans : ans;
                 }
 };
 
 double Sheet::BesselK0(double x)
 {
         double y,ans;
         if (x <= 2.0)
         {
                 y=x*x/4.0;
                 ans=(-log(x/2.0)*BesselI0(x))+(-0.57721566+y*(0.42278420 +y*(0.23069756+y*(0.3488590e-1+y*(0.262698e-2 +y*(0.10750e-3+y*0.74e-5))))));
         } else
         {
                 y=2.0/x;
                 ans=(exp(-x)/sqrt(x))*(1.25331414+y*(-0.7832358e-1 +y*(0.2189568e-1+y*(-0.1062446e-1+y*(0.587872e-2 +y*(-0.251540e-2+y*0.53208e-3))))));
         }
 return ans;
 };
 
 double Sheet::BesselK1(double x)
 {
         double y,ans;
         if (x <= 2.0)
         {
                 y=x*x/4.0;
                 ans=(log(x/2.0)*BesselI1(x))+(1.0/x)*(1.0+y*(0.15443144 +y*(-0.67278579+y*(-0.18156897+y*(-0.1919402e-1 +y*(-0.110404e-2+y*(-0.4686e-4)))))));
         } else
         {
                 y=2.0/x;
                 ans=(exp(-x)/sqrt(x))*(1.25331414+y*(0.23498619 +y*(-0.3655620e-1+y*(0.1504268e-1+y*(-0.780353e-2 +y*(0.325614e-2+y*(-0.68245e-3)))))));
         }
         return ans;
 };
 
 double Sheet::BesselK(int n, double x)
 {
         int j;
         double bk,bkm,bkp,tox;
         if (n < 2) return 0.0;
         tox=2.0/x;
         bkm=BesselK0(x);
         bk=BesselK1(x);
         for (j=1;j<n;j++)
         {
                 bkp=bkm+j*tox*bk;
                 bkm=bk;
                 bk=bkp;
         }
         return bk;
 };
 
 double Sheet::BesselJ0(double x)
 {
         double ax,z;
         double xx,y,ans,ans1,ans2;
         if ((ax=fabs(x)) < 8.0)
         {
                 y=x*x;
                 ans1=57568490574.0+y*(-13362590354.0+y*(651619640.7 +y*(-11214424.18+y*(77392.33017+y*(-184.9052456)))));
                 ans2=57568490411.0+y*(1029532985.0+y*(9494680.718 +y*(59272.64853+y*(267.8532712+y*1.0))));
                 ans=ans1/ans2;
         } else
         {
                 z=8.0/ax;
                 y=z*z;
                 xx=ax-0.785398164;
                 ans1=1.0+y*(-0.1098628627e-2+y*(0.2734510407e-4 +y*(-0.2073370639e-5+y*0.2093887211e-6)));
                 ans2 = -0.1562499995e-1+y*(0.1430488765e-3 +y*(-0.6911147651e-5+y*(0.7621095161e-6 -y*0.934935152e-7)));
                 ans=sqrt(0.636619772/ax)*(cos(xx)*ans1-z*sin(xx)*ans2);
         }
         return ans;
 };
 
 double Sheet::BesselY0(double x)
 {
         double z;
         double xx,y,ans,ans1,ans2;
         if (x < 8.0)
         {
                 y=x*x;
                 ans1 = -2957821389.0+y*(7062834065.0+y*(-512359803.6 +y*(10879881.29+y*(-86327.92757+y*228.4622733))));
                 ans2=40076544269.0+y*(745249964.8+y*(7189466.438 +y*(47447.26470+y*(226.1030244+y*1.0))));
                 ans=(ans1/ans2)+0.636619772*BesselJ0(x)*log(x);
         } else
         {
                 z=8.0/x;
                 y=z*z;
                 xx=x-0.785398164;
                 ans1=1.0+y*(-0.1098628627e-2+y*(0.2734510407e-4 +y*(-0.2073370639e-5+y*0.2093887211e-6)));
                 ans2 = -0.1562499995e-1+y*(0.1430488765e-3 +y*(-0.6911147651e-5+y*(0.7621095161e-6 +y*(-0.934945152e-7))));
                 ans=sqrt(0.636619772/x)*(sin(xx)*ans1+z*cos(xx)*ans2);
         }
         return ans;
 };
 
 double Sheet::BesselJ1(double x)
 {
         double ax,z;
         double xx,y,ans,ans1,ans2;
         if ((ax=fabs(x)) < 8.0)
         {
                 y=x*x;
                 ans1=x*(72362614232.0+y*(-7895059235.0+y*(242396853.1 +y*(-2972611.439+y*(15704.48260+y*(-30.16036606))))));
                 ans2=144725228442.0+y*(2300535178.0+y*(18583304.74 +y*(99447.43394+y*(376.9991397+y*1.0))));
                 ans=ans1/ans2;
         } else
         {
                 z=8.0/ax; y=z*z; xx=ax-2.356194491;
                 ans1=1.0+y*(0.183105e-2+y*(-0.3516396496e-4 +y*(0.2457520174e-5+y*(-0.240337019e-6))));
                 ans2=0.04687499995+y*(-0.2002690873e-3 +y*(0.8449199096e-5+y*(-0.88228987e-6 +y*0.105787412e-6)));
                 ans=sqrt(0.636619772/ax)*(cos(xx)*ans1-z*sin(xx)*ans2);
                 if (x < 0.0) ans = -ans;
         }
         return ans;
 };
 
 double Sheet::BesselY1(double x)