g++ 3.2 fixes... repeat after me "I won't repeat default arguments in the definition I have already given in the declaration"

5 files changed, 7 insertions, 7 deletions

diff --git a/noncore/apps/opie-reader/Bkmks.cpp b/noncore/apps/opie-reader/Bkmks.cpp
index 998601a..a8bee13 100644
--- a/noncore/apps/opie-reader/Bkmks.cpp
+++ b/noncore/apps/opie-reader/Bkmks.cpp
@@ -1,322 +1,322 @@
 #include "name.h"
 #include <qmessagebox.h>
 
 #include "Bkmks.h"
 
 #include "StyleConsts.h"
 #include "Markups.h"
 #include "my_list.h"
 #include "version.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 = false)
+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/CBuffer.cpp b/noncore/apps/opie-reader/CBuffer.cpp
index 526b25f..0780a88 100644
--- a/noncore/apps/opie-reader/CBuffer.cpp
+++ b/noncore/apps/opie-reader/CBuffer.cpp
@@ -1,46 +1,46 @@
 #include "CBuffer.h"
 
 CBufferBase& CBufferBase::assign(const void* sztmp, size_t ms)
 {
     if (ms*membersize > len)
     {
         delete [] buffer;
         buffer = new unsigned char[len = ms*membersize];
     }
     memcpy(buffer, sztmp, ms*membersize);
     return *this;
 }
 
-CBufferBase::CBufferBase(size_t ms, size_t n = 16) : len(n), membersize(ms)
+CBufferBase::CBufferBase(size_t ms, size_t n) : len(n), membersize(ms)
 {
     buffer = new unsigned char[len*membersize];
     memset(buffer, 0, len*membersize);
 }
 
 void* CBufferBase::operator[](int i)
 {
     if ((i+1)*membersize > len)
     {
         unsigned char* oldbuffer = buffer;
         buffer = new unsigned char[(i+1)*membersize];
         memcpy(buffer, oldbuffer, len);
         memset(buffer+len, 0, (i+1)*membersize-len);
         len = (i+1)*membersize;
         delete [] oldbuffer;
     }
     return buffer+i*membersize;
 }
 
-size_t CBufferBase::bstrlen(unsigned char* _buffer = NULL)
+size_t CBufferBase::bstrlen(unsigned char* _buffer)
 {
     if (_buffer == NULL) _buffer = buffer;
     unsigned char* zero = new unsigned char[membersize];
     memset(zero,0,membersize);
     unsigned char* element = _buffer;
     while (memcmp(element, zero, membersize) != 0)
     {
         element += membersize;
     }
     delete [] zero;
     return (element - _buffer)/membersize;
 }
diff --git a/noncore/apps/opie-reader/QTReader.cpp b/noncore/apps/opie-reader/QTReader.cpp
index 3995ee7..f2ee027 100644
--- a/noncore/apps/opie-reader/QTReader.cpp
+++ b/noncore/apps/opie-reader/QTReader.cpp
@@ -1,1327 +1,1327 @@
 /****************************************************************************
 ** $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 <qpainter.h>
 #include "config.h"
 #include "QTReader.h"
 #include "QTReaderApp.h"
 #include "CDrawBuffer.h"
 #include <qpe/qpeapplication.h>
 #include <math.h>
 #include <ctype.h>
 #include <stdio.h> //for sprintf
 #include <qpe/config.h>
 #include <qpe/applnk.h>
 #include <qfontdatabase.h>
 #include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 #include "StateData.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};
 
-QTReader::QTReader( QWidget *parent=0, const char *name=0, WFlags f = 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),
   m_navkeys(true)
 {
     m_overlap = 1;
 //  init();
 }
 /*
-QTReader::QTReader( const QString& filename, QWidget *parent=0, const tchar *name=0, WFlags f = 0) :
+QTReader::QTReader( const QString& filename, QWidget *parent, const tchar *name, WFlags f ) :
   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);
 }
 */
 
 long QTReader::real_delay()
 {
     return ( 8976 + m_delay ) / ( m_linespacing * m_linespacing );
 }
 
 void QTReader::mousePressEvent( QMouseEvent* _e )
 {
     buffdoc.unsuspend();
     if (_e->button() == RightButton)
     {
         mouseUpOn = false;
         if (buffdoc.hasnavigation())
         {
             if (_e->y() > (2*height())/3)
             {
                 goDown();
             }
             else if (_e->y() < height()/3)
             {
                 goUp();
             }
             else
             {
                 if (_e->x() < width()/3)
                 {
                     size_t target = pagelocate();
                     if (buffdoc.back(target))
                     {
                         locate(target);
                     }
                 }
                 else if (_e->x() > (2*width())/3)
                 {
                     size_t target = pagelocate();
                     if (buffdoc.forward(target))
                     {
                         locate(target);
                     }
                 }
                 else
                 {
                     buffdoc.saveposn(pagelocate());
                     locate(buffdoc.getHome());
                 }
             }
         }
         else
         {
             if (_e->y() > height()/2)
             {
                 goDown();
             }
             else
             {
                 goUp();
             }
         }
     }
 }
 
 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/m_charWidth;
     }
     else
     {
         int i;
         CDrawBuffer* t = textarray[lineno];
         x = x - t->offset(width());
         for (i = t->length(); i >= 0 && t->width(i) > x; i--);
         offset = i;
     }
     return textarray[lineno]->getLinkType(offset, tgt);
 }
 
 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::mouseReleaseEvent( QMouseEvent* _e )
 {
     buffdoc.unsuspend();
     if (_e->button() == LeftButton)
     {
         if (mouseUpOn)
         {
             if (textarray[0] != NULL)
             {
                 QString wrd, 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();
                         if (buffdoc.hyperlink(tgt))
                         {
                             buffdoc.saveposn(saveposn);
                             fillbuffer();
                             update();
                         }
                         else
                         {
                             locate(pagelocate());
                         }
                         return;
                     }
                     case ePicture:
                     {
                         qDebug("Picture:%x", tgt);
                         QPixmap* 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_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()/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());
                     while (1)
                     {
                         int i = first+1;
                         while (QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
                         if (t->width(i) > tgt)
                         {
                             wrd = toQString(t->data()+first, i - first);
                             break;
                         }
                         while (!QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
                         if ((*t)[i] == 0) break;
                         first = i;
                             }   
                 }
                 if (!wrd.isEmpty())
                 {
                     emit OnWordSelected(wrd, locnarray[lineno], (m_twotouch) ? wrd : toQString(textarray[lineno]->data()));
                 }
             }
         }
         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>
 #include <unistd.h>
 
 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::keyPressEvent(QKeyEvent* e)
 {
     buffdoc.unsuspend();
   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_Left:
         {
           e->accept();
           if (m_textfont > 0)
             {
               m_textfont--;
               setfont(NULL);
               locate(pagelocate());
               update();
             }
         }
       break;
       case Key_Right:
         {
           e->accept();
           if (fonts[++m_textfont] == 0)
             {
               m_textfont--;
             }
           else
             {
               setfont(NULL);
               locate(pagelocate());
               update();
             }
         }
       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;
         case Key_Space:
         case Key_Return:
         {
           e->accept();
           emit OnActionPressed();
         }
         break;
         default:
             e->ignore();
     }
 }
 
 void QTReader::setautoscroll(bool _sc)
 {
     if (_sc == m_autoScroll) return;
     if (m_autoScroll)
     {
         m_autoScroll = false;
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
      }
     else
     {
         CDrawBuffer* reusebuffer = textarray[numlines];
         if (reusebuffer == NULL || reusebuffer->eof()) return;
         m_autoScroll = true;
         autoscroll();
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Disable; // light is even not dimmed
     }
 }
 
 bool QTReader::getline(CDrawBuffer *buff)
 {
     buffdoc.unsuspend();
     if (m_bMonoSpaced)
     {
         return buffdoc.getline(buff ,width(), m_charWidth);
     }
     else
     {
         return buffdoc.getline(buff, width());
     }
 }
 
 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())
     {
         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());
         mylastpos = locate();
         if (!ch)
         {
             m_autoScroll = false;
             ((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll);
         }
         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;
         setfont();
         if (m_lastwidth != width())
         {
             qDebug("Not Optimised %d", m_lastwidth);
             m_lastwidth = width();
             m_lastheight = height();
             locate(pagelocate());
             qDebug("Not Optimised %d", m_lastwidth);
         }
         else 
         {
             if (m_lastheight > height())
             {
                 qDebug("Optimised < %d", numlines);
                 int ypos = 0;
                 for (int i = 0; i < numlines; i++)
                 {
                     if ((ypos += textarray[i]->lineSpacing()) > height())
                     {
                         numlines = i;
                         jumpto(locnarray[i+1]);
                         break;
                     }
                 }
                 qDebug("Optimised < %d", numlines);
                 m_lastheight = height();
             }
             else if (m_lastheight < height())
             {
                 qDebug("Optimised > %d", numlines);
                 int ypos = 0;
                 for (int i = 0; i <= numlines; i++)
                 {
                     ypos += textarray[i]->lineSpacing();
                 }
                 fillbuffer(numlines+1, ypos);
                 qDebug("Optimised > %d", numlines);
                 m_lastheight = height();
             }
             if (numlines > 0)
             {
                 int ypos = textarray[0]->ascent();
                 textarray[0]->render( p, ypos, m_bMonoSpaced, m_charWidth, width());
                 for (int i = 1; i < numlines; i++)
                 {
         //  ypos += (textarray[i-1]->lineSpacing() + textarray[i]->lineSpacing())/2;
                     ypos += (textarray[i-1]->descent() + textarray[i]->ascent())+
                         (textarray[i-1]->lineExtraSpacing() + textarray[i]->lineExtraSpacing())/2;
                     textarray[i]->render( p, ypos, m_bMonoSpaced, m_charWidth, width());
                 }
 //      mylastpos = locate();
             }
         }
         m_scrolldy1 = m_scrolldy2 = 0;
         emit OnRedraw();
     }
     else
     {
         qDebug("Not so refreshing...");
     }
 }
 
 QString QTReader::firstword()
 {
     if (m_bMonoSpaced)
     {
         return toQString(textarray[0]->data());
     }
     else
     {
         int start, end, len, j;
         for (j = 0; j < numlines; j++)
         {
             len = textarray[j]->length();
             for (start = 0; start < len && !isalpha((*textarray[j])[start]); start++);
             if (start < len) break;
         }
         if (j < numlines)
         {
             QString ret = "";
             for (end = start; end < len && isalpha((*textarray[j])[end]); end++)
                 ret += (*textarray[j])[end];
             if (ret.isEmpty()) ret = "Current position";
             return ret;
         }
         else
             return "Current position";
     }
 }
 
 //
 // Construct the QTReader with buttons.
 //
 
 bool QTReader::ChangeFont(int tgt)
 {
     return m_fontControl.ChangeFont(m_fontname, tgt);
 }
 
 void QTReader::init()
 {
   //    setCaption( "Qt Draw Demo Application" );
 
     buffdoc.unsuspend();
   setBackgroundColor( white );
 //  QPainter p(this);
 //  p.setBackgroundMode( Qt::OpaqueMode );
   buffdoc.setfilter(getfilter());
   ChangeFont(m_textsize);
   setFocusPolicy(QWidget::StrongFocus);
     //    resize( 240, 320 );
   //setFocus();
     timer = new QTimer(this);
     connect(timer, SIGNAL(timeout()), this, SLOT(doscroll()));
 //  QMessageBox::information(this, "init", m_lastfile, 1);
     setfont();
 /*
     if (!m_lastfile.isEmpty())
     {
         m_string = DocLnk(m_lastfile).name();
         load_file(m_lastfile);
     }
 */
 }
 
 //
 // Clean up
 //
 QTReader::~QTReader()
 {
 }
 
 //
 // Calls the drawing function as specified by the radio buttons.
 //
 
 void QTReader::drawIt( QPainter *p )
 {
     drawFonts(p);
 }
 
 //
 // Called when the print button is clicked.
 //
 /*
 void QTReader::printIt()
 {
 #ifndef QT_NO_PRINTER
     if ( printer->setup( this ) ) {
         QPainter paint;
         if ( !paint.begin( printer ) )
             return;
         drawIt( &paint );
     }
 #endif
 }
 */
 //
 // Called when the widget needs to be updated.
 //
 
 void QTReader::paintEvent( QPaintEvent * )
 {
     QPainter paint( this );
     drawIt( &paint );
 }
 
 //
 // Called when the widget has been resized.
 // Moves the button group to the upper right corner
 // of the widget.
 
 /*
 void QTReader::resizeEvent( QResizeEvent * )
 {
   //  qDebug("resize:(%u,%u)", width(), height());
   //    bgroup->move( width()-bgroup->width(), 0 );
 }
 */
 
 //
 // Create and display our widget.
 //
 /*
 int main( int argc, tchar **argv )
 {
     QApplication app( argc, argv );
     QTReader   draw;
     app.setMainWidget( &draw );
     draw.setCaption("Qt Example - Drawdemo");
     draw.show();
     return app.exec();
 }
 */
 
 
 bool QTReader::locate(unsigned long n) {
   //printf("Locate\n");
     buffdoc.unsuspend();
   buffdoc.locate(n);
   //  qDebug("&buffdoc.located");
   fillbuffer();
   //  qDebug("&Buffer filled");
   update();
   //  qDebug("&Located");
   return true;
 }
 
 unsigned int QTReader::screenlines()
 {
   //  int linespacing = (tight) ? m_ascent : m_ascent+m_descent;
   //  return (height()-m_descent)/(m_linespacing);
   return (height()-2)/(m_linespacing);
 };
 
 bool QTReader::fillbuffer(int reuse, int ht)
 {
     buffdoc.unsuspend();
     if (buffdoc.empty()) return false;
     m_scrolldy1 = m_scrolldy2 = 0;
     int ch;
     bool ret = false;
     unsigned int oldpagepos = locnarray[reuse];
     int ypos = ht;
     numlines = reuse;
     while (ypos < height() || numlines < 2)
     {
         if (textarray[numlines] == NULL)
         {
             textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
         locnarray[numlines] = locate();
         int ch = getline(textarray[numlines]);
         ypos += textarray[numlines]->lineSpacing();
         numlines++;
         if (!ch)
         {
             if (numlines - reuse == 1 /*&& locnarray[numlines] == buffdoc.locate()*/)
             {
                 locate(oldpagepos);
                 return false;
             }
             else
             {
                 --numlines;
                 mylastpos = locate();
                 return true;
             }
         }
     }
     
     --numlines;
     mylastpos = locate();
     
     return true;
 }
 
 
 void QTReader::dopagedn()
 {
     buffdoc.unsuspend();
     int skip = 0, ypos = 0;
     if (locate() != mylastpos)
     {
         //qDebug("Jumping to %u", mylastpos);
         jumpto(mylastpos);
     }
     CDrawBuffer* reusebuffer = textarray[numlines];
     if (reusebuffer != NULL && reusebuffer->eof()) return;
     if (reusebuffer != NULL)
     {
         for (int i = 0; i <= m_overlap; i++)
         {
             int offset = numlines - m_overlap + i;
             reusebuffer = textarray[offset];
             size_t reuselocn = locnarray[offset];
             textarray[offset] = textarray[i];
             textarray[i] = reusebuffer;
         //    reusebuffer->empty();
             locnarray[offset] = locnarray[i];
             locnarray[i] = reuselocn;
             ypos += textarray[i]->lineSpacing();
             skip++;
         }
     }
     if (fillbuffer(skip, ypos))
     {
         update();
     }
 }
 
 void QTReader::dopageup()
 {
     buffdoc.unsuspend();
   dopageup(locnarray[(m_overlap < numlines) ? m_overlap : numlines/2]);
 }
 
 void QTReader::dopageup(unsigned int target)
 {
     buffdoc.unsuspend();
     CBufferFace<CDrawBuffer*> buff;
     CBufferFace<size_t> loc;
 
   size_t delta, guess = 2048;
   bool ch = true;
   int nbfl, ypos = 0;
 
   while (1)
   {
       ch = true;
       nbfl = 0;
       if (target < guess)
       {
           delta = 0; // 0 is a flag to say don't guess any more
           jumpto( (m_continuousDocument) ? 0 : buffdoc.startSection() );
       }
       else if (!m_continuousDocument && (target - guess < buffdoc.startSection()))
       {
           delta = 0; // 0 is a flag to say don't guess any more
           jumpto(buffdoc.startSection());
       }
       else
       {
           delta = guess;
           
           jumpto(target - delta);
           
           buff[0] = new CDrawBuffer(&m_fontControl);
           
           do
           {
               
               if (!getline(buff[0])) break;
               
               if (locate() > target) break;
           }
           while (!buffdoc.iseol());
       }
       
       ypos = 0;
       while (locate() < target) 
       {
           if (buff[nbfl] == NULL) buff[nbfl] = new CDrawBuffer(&m_fontControl);
           loc[nbfl] = locate();
           ch = getline(buff[nbfl]);
           ypos += buff[nbfl]->lineSpacing();
           nbfl++;
           if (!ch) break;
       }
       if (ypos < height() && (delta != 0))
       {
           for (int i = 0; i < nbfl; i++)
           {
               delete buff[i];
               buff[i] = NULL;
           }
           guess <<= 1;
           continue;
       }
       break;
   }
   if (ch)
   {
       if (buff[nbfl] == NULL) buff[nbfl] = new CDrawBuffer(&m_fontControl);
       loc[nbfl] = locate();
       int ch = getline(buff[nbfl]);
       nbfl++;
   }
   ypos = 0;
   numlines = 0;
   while (ypos < height() && numlines <= nbfl-1)
   {
       ypos += buff[nbfl - numlines - 1]->lineSpacing();
       numlines++;
   }
   --numlines;
   int offset = nbfl-1;
   offset -= numlines;
   ypos = 0;
   for (int i = 0; i <= numlines; i++)
   {
       delete textarray[i];
       textarray[i] = buff[offset+i];
       locnarray[i] = loc[offset + i];
       ypos += textarray[i]->lineSpacing();
   }
   for (int i = 0; i < nbfl - numlines - 1; i++)
   {
       delete buff[i];
   }
 
   while (ypos < height())
   {
       numlines++;
       locnarray[numlines] = locate();
       if (textarray[numlines] == NULL) textarray[numlines] = new CDrawBuffer(&m_fontControl);
       if (!getline(textarray[numlines])) break;
       ypos += textarray[numlines]->lineSpacing();
   }
 
   mylastpos = locate();
 
   update();
 }
 
 bool QTReader::load_file(const char *newfile, unsigned int _lcn)
 {
 //  QMessageBox::information(this, "Name", name, 1);
 //  QMessageBox::information(this, "load_file", newfile, 1);
 
   bool bRC = false;
   unsigned int lcn = _lcn;
   if (m_lastfile == newfile)
     {
       lcn = m_lastposn;
     }
   m_lastfile = newfile;
   //  QMessageBox::information(0, "Opening...", newfile);
   m_lastwidth = width();
   m_lastheight = height();
   if (buffdoc.openfile(this,newfile) == 0)
     {
       bRC = true;
       buffdoc.setContinuous(m_continuousDocument);
       //  qDebug("buffdoc.openfile done");
       locate(lcn);
       //  qDebug("buffdoc.locate done");
     }
   setfilter(getfilter());
   update();
   //  qDebug("Updated");
   return bRC;
 }
 
 void QTReader::lineDown()
 {
     int ypos = 0;
     int offset = numlines;
 
     for (int i = 0; i <= numlines; i++)
     {
         if ((ypos += textarray[numlines-i]->lineSpacing()) > height())
         {
             offset = i-1;
             break;
         }
     }
     offset = numlines - offset;
     for (int i = offset; i <= numlines; i++)
     {
         CDrawBuffer* buff = textarray[i-offset];
         textarray[i-offset] = textarray[i];
         locnarray[i-offset] = locnarray[i];
         textarray[i] = buff;
     }
     numlines = numlines - offset + 1;
     locnarray[numlines] = locate();
     if (textarray[numlines] == NULL)
     {
         textarray[numlines] = new CDrawBuffer(&m_fontControl);
     }
     getline(textarray[numlines]);
     mylastpos = locate();
     update();
 }
 /*
 void QTReader::lineUp()
 {
   CBuffer** buff = textarray;
   unsigned int *loc = new unsigned int[numlines];
   int cbptr = 0;
   if (locate() != mylastpos) jumpto(mylastpos);
   unsigned int target = locnarray[numlines-1];
   if (buffdoc.hasrandomaccess())
     {
       unsigned int delta = locate()-pagelocate();
       if (delta < 64) delta = 64;
       do
         {
           delta <<= 1;
           if (delta >= target)
             {
               delta = target;
               jumpto(0);
               for (int i = 0; i < numlines; i++)
                 {
                   loc[i] = locate();
                   getline(buff[i]);
                 }
               break;
             }
           jumpto(target-delta);
           do
             {
               buffdoc.getline(buff[0],width());
 #ifdef WS
               //printf("Trying:%s\n",buff[0]);
 #endif
               if (locate() > target) continue;
             }
           while (!buffdoc.iseol());
           for (int i = 0; i < numlines; i++)
             {
               loc[i] = locate();
               buffdoc.getline(buff[i],width());
 #ifdef WS
               //printf("Filling:%s\n",buff[i]);
 #endif
             }
         }
       while (locate() >= target && delta < 4096);
 #ifdef WS
       //printf("Delta:%u\n",delta);
 #endif
     }
   else
     {
       jumpto(0);
       for (int i = 0; i < numlines; i++)
         {
           loc[i] = locate();
           buffdoc.getline(buff[i],width());
         }
     }
   cbptr = 0;
   while (locate() < target)
     {
       loc[cbptr] = locate();
       buffdoc.getline(buff[cbptr], width());
 #ifdef WS
       //printf("Adding:%s\n",buff[cbptr]->data());
 #endif
       cbptr = (cbptr+1) % numlines;
     }
   pagepos = loc[cbptr];
   textarray = new CBuffer*[numlines];
   for (int i = 0; i < numlines; i++)
     {
       int j = (cbptr+i)%numlines;
       textarray[i] = buff[j];
       locnarray[i] = loc[j];
     }
   delete [] buff;
   delete [] loc;
   mylastpos = locate();
   update();
 }
 */
 void QTReader::lineUp()
 {
     buffdoc.unsuspend();
   CDrawBuffer* buff = textarray[numlines];
   unsigned int loc;
   unsigned int end = locnarray[numlines];
   int cbptr = 0;
   if (locate() != mylastpos) jumpto(mylastpos);
   unsigned int target = locnarray[0];
   if (target == 0) return;
   if (!m_continuousDocument && (target == buffdoc.startSection())) return;
   if (buffdoc.hasrandomaccess())
     {
       unsigned int delta = locate()-pagelocate();
       if (delta < 64) delta = 64;
       do
         {
           delta <<= 1;
           if (delta >= target)
             {
               delta = target;
               jumpto(0);
               loc = locate();
               getline(buff);
               break;
             }
           else if (!m_continuousDocument && (target - delta < buffdoc.startSection()))
           {
               delta = target-buffdoc.startSection();
               jumpto(buffdoc.startSection());
               loc = locate();
               getline(buff);
               break;
           }
           jumpto(target-delta);
           do
             {
               getline(buff);
 #ifdef WS
               //printf("Trying:%s\n",buff[0]);
 #endif
               if (locate() > target) continue;
             }
           while (!buffdoc.iseol());
           loc = locate();
           getline(buff);
         }
       while (locate() >= target && delta < 4096);
     }
   else
     {
       jumpto(0);
       loc = locate();
       getline(buff);
     }
   cbptr = 0;
   while (locate() < target)
     {
       loc = locate();
       getline(buff);
     }
   for (int i = numlines; i > 0; i--)
     {
       textarray[i] = textarray[i-1];
       locnarray[i] = locnarray[i-1];
     }
   textarray[0] = buff;
   locnarray[0] = loc;
   int start = numlines;
   int ypos = 0;
   for (int i = 0; i <= numlines; i++)
   {
       ypos += textarray[i]->lineSpacing();
       if (ypos > height())
       {
           start = i;
           ypos -= textarray[i]->lineSpacing();
           break;
       }
   }
   jumpto(locnarray[start]);
   fillbuffer(start, ypos);
   update();
 }
 
 bool QTReader::empty()
 {
     return buffdoc.empty();
 }
 
 MarkupType QTReader::PreferredMarkup()
 {
     MarkupType m = buffdoc.PreferredMarkup();
     if (m == cTEXT)
     {
         int ext = m_lastfile.findRev('.');
         if (ext >= 0)
         {
             QString ft = m_lastfile.right(m_lastfile.length()-ext-1).upper();
             if (ft.left(3) == "HTM")
             {
                 m = cHTML;
             }
         }
     }
     return m;
 }
 
 void QTReader::setstate(const statedata& sd)
 {
     bstripcr = sd.bstripcr;
     btextfmt = sd.btextfmt;
     bautofmt = sd.bautofmt;
     bstriphtml = sd.bstriphtml;
     bpeanut = sd.bpeanut;
     bdehyphen = sd.bdehyphen;
     bonespace = sd.bonespace;
     bunindent = sd.bunindent;
     brepara = sd.brepara;
     bdblspce = sd.bdblspce;
     m_bpagemode = sd.m_bpagemode;
     m_navkeys = sd.m_navkeys;
     m_bMonoSpaced = sd.m_bMonoSpaced;
     bremap = sd.bremap;
     bmakebold = sd.bmakebold;
     m_continuousDocument = sd.Continuous;
 #ifdef REPALM
     brepalm = sd.brepalm;
 #endif
     bindenter = sd.bindenter;
     m_encd = sd.m_charpc;
     m_fontname = sd.m_fontname;
     setContinuous(sd.Continuous);
     ChangeFont(sd.m_textsize);
     refresh();
 }
diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp
index 2044b1d..7333a28 100644
--- a/noncore/apps/opie-reader/QTReaderApp.cpp
+++ b/noncore/apps/opie-reader/QTReaderApp.cpp
@@ -1,2606 +1,2606 @@
 /**********************************************************************
 ** 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 <qclipboard.h>
 #include <qwidgetstack.h>
 #include <qpe/qpemenubar.h>
 //#include <qpe/qpetoolbar.h>
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qpe/menubutton.h>
 #include <qpe/fontdatabase.h>
 #include <qcombobox.h>
 #include <qpopupmenu.h>
 #include <qaction.h>
 #include <qapplication.h>
 #include <qlineedit.h>
 #include <qtoolbutton.h>
 #include <qspinbox.h>
 #include <qobjectlist.h>
 #include <qpe/global.h>
 #include <qpe/applnk.h>
 #include <qfileinfo.h>
 #include <stdlib.h> //getenv
 #include <qprogressbar.h>
 #include <qpe/config.h>
 #include <qbuttongroup.h>
 #include <qradiobutton.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include "QTReader.h"
 #include "GraphicWin.h"
 #include "Bkmks.h"
 #include "cbkmkselector.h"
 #include "infowin.h"
 #include "CAnnoEdit.h"
 #include "QFloatBar.h"
 //#include <qpe/fontdatabase.h>
 
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 
 #include "QTReaderApp.h"
 #include "fileBrowser.h"
 #include "CDrawBuffer.h"
 #include "Filedata.h"
 #include "opie.h"
 #include "name.h"
 #include "StateData.h"
 
 #ifdef OPIE
 #define PICDIR "opie-reader/"
 #else
 #define PICDIR
 #endif
 
 
 unsigned long QTReaderApp::m_uid = 0;
 
 void QTReaderApp::setScrollState(bool _b) { m_scrollButton->setOn(_b); }
 
 #include <unistd.h>
 #include <stddef.h>
 #include <dirent.h>
 
 void QTReaderApp::listBkmkFiles()
 {
     bkmkselector->clear();
     bkmkselector->setText("Cancel");
     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);
 
     if (cnt > 0)
       {
 //tjw        menu->hide();
         editBar->hide();
         if (m_fontVisible) m_fontBar->hide();
         if (regVisible)
         {
             Global::hideInputMethod();
             regBar->hide();
         }
         if (searchVisible)
         {
             Global::hideInputMethod();
             searchBar->hide();
         }
         m_nRegAction = cRmBkmkFile;
         editorStack->raiseWidget( bkmkselector );
       }
     else
       QMessageBox::information(this, PROGNAME, "No bookmark files");
 }
 
 QTReaderApp::QTReaderApp( QWidget *parent, const char *name, WFlags f )
     : QMainWindow( parent, name, f ), bFromDocView( FALSE ), m_dontSave(false)
 {
 //  qDebug("Application directory = %s", (const tchar *)QPEApplication::documentDir());
 //  qDebug("Application directory = %s", (const tchar *)Global::applicationFileName("uqtreader","bkmks.xml"));
 
     pBkmklist = NULL;
     pOpenlist = NULL;
 //    doc = 0;
 
         m_fBkmksChanged = false;
     
   QString lang = getenv( "LANG" );
 
         m_autogenstr = "^ *[A-Z].*[a-z] *$";
     setToolBarsMovable( FALSE );
 
     setIcon( Resource::loadPixmap( "uqtreader" ) );
 
 //    QPEToolBar *bar = new QPEToolBar( this );
     QToolBar *bar = new QToolBar( this );
     bar->setHorizontalStretchable( TRUE );
     addToolBar(bar, "tool",QMainWindow::Top, true);
 //tjw    menu = bar;
 
     QPEMenuBar *mb = new QPEMenuBar( bar );
 //    QMenuBar *mb = new QMenuBar( bar );
     QPopupMenu *file = new QPopupMenu( this );
     QPopupMenu *format = new QPopupMenu( this );
     //    QPopupMenu *edit = new QPopupMenu( this );
 
 //    bar = new QToolBar( this );
     editBar = bar;
 
     /*
     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;
 
     pbar = new QProgressBar(this);
     pbar->hide();
 
     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;
 
     ((QPEApplication*)qApp)->setStylusOperation(reader, QPEApplication::RightOnHold);
 
     qDebug("Reading config");
   Config config( APPDIR );
   config.setGroup( "View" );
 
   reader->bstripcr = config.readBoolEntry( "StripCr", true );
   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->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_navkeys = config.readBoolEntry( "CursorNavigation", false );
   reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", 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 );
 #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 );
   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);
   setTwoTouch(m_twoTouch);
 
 
     connect( reader, SIGNAL( OnShowPicture(QPixmap&) ), this, SLOT( showgraphic(QPixmap&) ) );
 
     connect( reader, SIGNAL( OnRedraw() ), this, SLOT( OnRedraw() ) );
     connect( reader, SIGNAL( OnActionPressed() ), this, SLOT( OnActionPressed() ) );
     connect( reader, SIGNAL( OnWordSelected(const QString&, size_t, const QString&) ), this, SLOT( OnWordSelected(const QString&, size_t, const QString&) ) );
     editorStack->addWidget( reader, get_unique_id() );
 
     QAction *a = new QAction( tr( "Open" ), Resource::loadPixmap( "fileopen" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileOpen() ) );
     a->addTo( bar );
     a->addTo( file );
 
     a = new QAction( tr( "Close" ), Resource::loadPixmap( "fileclose" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileClose() ) );
 //    a->addTo( bar );
     a->addTo( file );
 
     /*
     a = new QAction( tr( "Revert" ), Resource::loadPixmap( "close" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileRevert() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Cut" ), Resource::loadPixmap( "cut" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) );
     a->addTo( editBar );
     a->addTo( edit );
     */
 
     a = new QAction( tr( "Info" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( showinfo() ) );
     a->addTo( file );
 
     QActionGroup* ag = new QActionGroup(this);
     QPopupMenu *spacemenu = new QPopupMenu(this);
     file->insertItem( tr( "On Action..." ), spacemenu );
 
     m_buttonAction[0] = new QAction( tr( "Open File" ), QString::null, 0, ag, NULL, true );
 
     m_buttonAction[1] = new QAction( tr( "Autoscroll" ), QString::null, 0, ag, NULL, true );
 
     m_buttonAction[2] = new QAction( tr( "Mark" ), QString::null, 0, ag, NULL, true );
 
     m_buttonAction[3] = new QAction( tr( "Fullscreen" ), QString::null, 0, ag, NULL, true );
 
     ag->addTo(spacemenu);
 
     connect(ag, SIGNAL( selected(QAction*) ), this, SLOT( buttonActionSelected(QAction*) ) );
 
     file->insertSeparator();
 
     ag = new QActionGroup(this);
     ag->setExclusive(false);
     QPopupMenu *encoding = new QPopupMenu(this);
     file->insertItem( tr( "Navigation" ), encoding );
 
     a = m_scrollButton = new QAction( tr( "Scroll" ), Resource::loadPixmap( PICDIR "panel-arrow-down" ), QString::null, 0, ag, 0, true );
 
     a->setOn(false);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( autoScroll(bool) ) );
     a->addTo( bar );
 
     a = new QAction( tr( "Jump" ), QString::null, 0, ag, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( jump() ) );
 
     a = new QAction( tr( "Page/Line Scroll" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( pagemode(bool) ) );
     a->setOn(reader->m_bpagemode);
 
     a = new QAction( tr( "Set Overlap" ), QString::null, 0, ag, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( setoverlap() ) );
 
     a = new QAction( tr( "Use Cursor" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( navkeys(bool) ) );
     a->setOn(reader->m_navkeys);
 
     ag->addTo(encoding);
 
     /*
     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();
 
     a = new QAction( tr( "Set Dictionary" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( settarget() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Two/One Touch" ), QString::null, 0, this, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( setTwoTouch(bool) ) );
     a->setOn(m_twoTouch);
     a->addTo( file );
 
     ag = new QActionGroup(this);
     ag->setExclusive(false);
     encoding = new QPopupMenu(this);
     file->insertItem( tr( "Target" ), encoding );
 
     a = new QAction( tr( "Annotation" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( OnAnnotation(bool) ) );
     a->setOn(m_doAnnotation);
 
     a = new QAction( tr( "Dictionary" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( OnDictionary(bool) ) );
     a->setOn(m_doDictionary);
 
     a = new QAction( tr( "Clipboard" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( OnClipboard(bool) ) );
     a->setOn(m_doClipboard);
 
     ag->addTo(encoding);
 
 
 /*
     a = new QAction( tr( "Import" ), QString::null, 0, this, NULL );
     connect( a, SIGNAL( activated() ), this, SLOT( importFiles() ) );
     a->addTo( file );
 */
     
     a = new QAction( tr( "Up" ), Resource::loadPixmap( "up" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( pageup() ) );
     a->addTo( editBar );
 
     a = new QAction( tr( "Down" ), Resource::loadPixmap( "down" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );
     a->addTo( editBar );
 
     /*
     a = new QAction( tr( "Paste" ), Resource::loadPixmap( "paste" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) );
     a->addTo( editBar );
     a->addTo( edit );
     */
 
 //     a = new QAction( tr( "Find..." ), Resource::loadPixmap( "find" ), QString::null, 0, this, 0 );
      a = new QAction( tr( "Find..." ), QString::null, 0, this, NULL);
      connect( a, SIGNAL( activated() ), this, SLOT( editFind() ) );
      file->insertSeparator();
 //     a->addTo( bar );
      a->addTo( file );
 
 
      m_fullscreen = false;
     a = m_actFullscreen = new QAction( tr( "Fullscreen" ), QString::null, 0, this, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( setfullscreen(bool) ) );
     a->setOn(m_fullscreen);
     a->addTo( file );
 
     a = new QAction( tr( "Continuous" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( setcontinuous(bool) ) );
     a->setOn(reader->m_continuousDocument);
     a->addTo( file );
 
      a = m_bkmkAvail = new QAction( tr( "Annotation" ), Resource::loadPixmap( "find" ), QString::null, 0, this, 0 );
      connect( a, SIGNAL( activated() ), this, SLOT( showAnnotation() ) );
      a->addTo( bar );
 
      m_bkmkAvail->setEnabled(false);
 
 
     ag = new QActionGroup(this);
 //    ag->setExclusive(false);
     encoding = new QPopupMenu(this);
     format->insertItem( tr( "Markup" ), encoding );
 
     a = new QAction( tr( "Auto" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bautofmt);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( autofmt(bool) ) );
 
     a = new QAction( tr( "None" ), QString::null, 0, ag, NULL, true );
     a->setOn(!reader->bautofmt && !(reader->btextfmt || reader->bstriphtml || reader->bpeanut));
 //    connect( a, SIGNAL( toggled(bool) ), this, SLOT( textfmt(bool) ) );
 
     a = new QAction( tr( "Text" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->btextfmt);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( textfmt(bool) ) );
 
     a = new QAction( tr( "HTML" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bstriphtml);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( striphtml(bool) ) );
 
     a = new QAction( tr( "Peanut/PML" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bpeanut);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( peanut(bool) ) );
 
     ag->addTo(encoding);
 
 
 
     ag = new QActionGroup(this);
     ag->setExclusive(false);
     encoding = new QPopupMenu(this);
     format->insertItem( tr( "Layout" ), encoding );
 
     a = new QAction( tr( "Strip CR" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bstripcr);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( stripcr(bool) ) );
 
     a = new QAction( tr( "Dehyphen" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bdehyphen);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( dehyphen(bool) ) );
 //    a->addTo( format );
 
     a = new QAction( tr( "Single Space" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->bonespace);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( onespace(bool) ) );
 
     a = new QAction( tr( "Unindent" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( unindent(bool) ) );
     a->setOn(reader->bunindent);
 //    a->addTo( format );
 
     a = new QAction( tr( "Re-paragraph" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( repara(bool) ) );
     a->setOn(reader->brepara);
 //    a->addTo( format );
 
     a = new QAction( tr( "Double Space" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( dblspce(bool) ) );
     a->setOn(reader->bdblspce);
 //    a->addTo( format );
 
     a = new QAction( tr( "Indent+" ), QString::null, 0, ag, NULL );
     connect( a, SIGNAL( activated() ), this, SLOT( indentplus() ) );
 //    a->addTo( format );
 
     a = new QAction( tr( "Indent-" ), QString::null, 0, ag, NULL );
     connect( a, SIGNAL( activated() ), this, SLOT( indentminus() ) );
 #ifdef REPALM
     a = new QAction( tr( "Repalm" ), QString::null, 0, ag, NULL, true );
     a->setOn(reader->brepalm);
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( repalm(bool) ) );
 #endif
     a = new QAction( tr( "Remap" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( remap(bool) ) );
     a->setOn(reader->bremap);
 
     a = new QAction( tr( "Embolden" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( embolden(bool) ) );
     a->setOn(reader->bmakebold);
 
     ag->addTo(encoding);
 
     //    a = new QAction( tr( "Zoom" ), QString::null, 0, this, NULL, true );
     //    a = new QAction( tr( "Zoom" ), Resource::loadPixmap( "mag" ), QString::null, 0, this, 0 );
      format->insertSeparator();
     a = new QAction( tr( "Zoom In" ), QString::null, 0, this);
     connect( a, SIGNAL( activated() ), this, SLOT( zoomin() ) );
     a->addTo( format );
     a = new QAction( tr( "Zoom Out" ), QString::null, 0, this);
     connect( a, SIGNAL( activated() ), this, SLOT( zoomout() ) );
     a->addTo( format );
     //    a->addTo( editBar );
      format->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( format );
 
     a = new QAction( tr( "Set width" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( setspacing() ) );
     a->addTo( format );
 
     encoding = new QPopupMenu(this);
 //     format->insertSeparator();
     format->insertItem( tr( "Encoding" ), encoding );
 
     ag = new QActionGroup(this);
 
     m_EncodingAction[0] = new QAction( tr( "Ascii" ), QString::null, 0, ag, NULL, true );
 
     m_EncodingAction[1] = new QAction( tr( "UTF-8" ), QString::null, 0, ag, NULL, true );
 
     m_EncodingAction[2] = new QAction( tr( "UCS-2(BE)" ), QString::null, 0, ag, NULL, true );
 
     m_EncodingAction[3] = new QAction( tr( "USC-2(LE)" ), QString::null, 0, ag, NULL, true );
 
     m_EncodingAction[4] = new QAction( tr( "Palm" ), QString::null, 0, ag, NULL, true );
 
     m_EncodingAction[5] = new QAction( tr( "Windows(1252)" ), QString::null, 0, ag, NULL, true );
 
     ag->addTo(encoding);
 
     connect(ag, SIGNAL( selected(QAction*) ), this, SLOT( encodingSelected(QAction*) ) );
 
     a = new QAction( tr( "Set Font" ), QString::null, 0, this);
     connect( a, SIGNAL( activated() ), this, SLOT( setfont() ) );
      format->insertSeparator();
     a->addTo( format );
 
     QPopupMenu *marks = new QPopupMenu( this );
 
     a = new QAction( tr( "Mark" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( addbkmk() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Annotate" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( addanno() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Goto" ), QString::null, 0, this, NULL, false );
     connect( a, SIGNAL( activated() ), this, SLOT( do_gotomark() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Delete" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( do_delmark() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Autogen" ), QString::null, 0, this, NULL, false );
     connect( a, SIGNAL( activated() ), this, SLOT( do_autogen() ) );
      marks->insertSeparator();
     a->addTo( marks );
 
     a = new QAction( tr( "Clear" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( clearBkmkList() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Save" ), QString::null, 0, this, NULL );
     connect( a, SIGNAL( activated() ), this, SLOT( savebkmks() ) );
     a->addTo( marks );
 
     a = new QAction( tr( "Tidy" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( listBkmkFiles() ) );
      marks->insertSeparator();
     a->addTo( marks );
 
     a = new QAction( tr( "Start Block" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( editMark() ) );
     marks->insertSeparator();
     a->addTo( marks );
 
     a = new QAction( tr( "Copy Block" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( editCopy() ) );
     a->addTo( marks );
 
 
     mb->insertItem( tr( "File" ), file );
     //    mb->insertItem( tr( "Edit" ), edit );
     mb->insertItem( tr( "Format" ), format );
     mb->insertItem( tr( "Marks" ), marks );
 
     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
      a = new QAction( tr( "Find Next" ), Resource::loadPixmap( "next" ), QString::null, 0, this, 0 );
      connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );
      a->addTo( searchBar );
 
     a = new QAction( tr( "Close Find" ), Resource::loadPixmap( "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" ), Resource::loadPixmap( "enter" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( do_regaction() ) );
     a->addTo( regBar );
 
     a = new QAction( tr( "Close Edit" ), Resource::loadPixmap( "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 );
     {
         FontDatabase f;
         QStringList flist = f.families();
         m_fontSelector->insertStringList(flist);
 
         bool realfont = false;
         for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)
         {
             if (reader->m_fontname == *nm)
             {
                 realfont = true;
             }
             if (*nm == "courier") reader->m_fontControl.hasCourier(true);
         }
         if (!realfont) reader->m_fontname = flist[0];
     } // delete the FontDatabase!!!
 
     connect( m_fontSelector, SIGNAL( activated(const QString& ) ),
              this, SLOT( do_setfont(const QString&) ) );
 
     m_fontBar->hide();
     m_fontVisible = false;
 
     connect(qApp, SIGNAL( appMessage(const QCString&, const QByteArray& ) ),
              this, SLOT( msgHandler(const QCString&, const QByteArray&) ) );
 
     qDebug("Initing");
   reader->init();
     qDebug("Inited");
     m_EncodingAction[reader->m_encd]->setOn(true);
     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");
                 openfrombkmk(p);
             }
             else
             {
         qDebug("openfile");
                 openFile( reader->m_lastfile );
             }
         }
         else
         {
             qDebug("Openfile 2");
             if (!reader->m_lastfile.isNull())
                 openFile( reader->m_lastfile );
         }
     }
     qApp->processEvents();
     reader->bDoUpdates = true;
     reader->update();
     qDebug("finished update");
 }
 
 void QTReaderApp::suspend() { reader->suspend(); }
 
 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 == "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 == "File/Open(QString)" )
     {
         QString info;
         stream >> info;
         openFile( info );
     }
     else if ( msg == "File/Info()" )
     {
         showinfo();
     }
     else if ( msg == "File/Start Block()" )
     {
         editMark();
     }
     else if ( msg == "File/Copy Block()" )
     {
         editCopy();
     }
     else if ( msg == "File/Scroll(int)" )
     {
         int info;
         stream >> info;
         autoScroll(info);
     }
     else if ( msg == "File/Jump(int)" )
     {
         int info;
         stream >> info;
         reader->locate(info);
     }
     else if ( msg == "File/Page/Line Scroll(int)" )
     {
         int info;
         stream >> info;
         pagemode(info);
     }
     else if ( msg == "File/Set Overlap(int)" )
     {
         int info;
         stream >> info;
         reader->m_overlap = info;
     }
     else if ( msg == "File/Set Dictionary(QString)" )
     {
         QString info;
         stream >> info;
         do_settarget(info);
     }
     else if ( msg == "File/Two/One Touch(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->buffdoc.getline(&test,reader->width());
         while (arg.match(toQString(test.data())) == -1)
         {
             pos = reader->locate();
             if (!reader->buffdoc.getline(&test,reader->width()))
             {
                 QMessageBox::information(this, PROGNAME, QString("Can't find\n")+info);
                 pos = start;
                 break;
             }
         }
         reader->locate(pos);
     }
     else if ( msg == "Layout/Strip CR(int)" )
     {
         int info;
         stream >> info;
         stripcr(info);
     }
     else if ( msg == "Layout/Single Space" )
     {
         int info;
         stream >> info;
         onespace(info);
     }
 #ifdef REPALM
     else if ( msg == "Layout/Repalm(int)" )
     {
         int info;
         stream >> info;
         repalm(info);
     }
 #endif
     else if ( msg == "Markup/Auto(int)" )
     {
         int info;
         stream >> info;
         autofmt(info);
     }
     else if ( msg == "Markup/Text(int)" )
     {
         int info;
         stream >> info;
         textfmt(info);
     }
     else if ( msg == "Markup/HTML(int)" )
     {
         int info;
         stream >> info;
         striphtml(info);
     }
     else if ( msg == "Markup/Peanut(int)" )
     {
         int info;
         stream >> info;
         peanut(info);
     }
     else if ( msg == "Layout/Dehyphen(int)" )
     {
         int info;
         stream >> info;
         dehyphen(info);
     }
     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/Double Space(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/Set width(int)" )
     {
         int info;
         stream >> info;
         reader->m_charpc = info;
         reader->setfont();
         reader->refresh();
     }
     else if ( msg == "Format/Encoding(QString)" )
     {
         QString info;
         stream >> info;
         reader->setencoding(EncNameToInt(info));
     }
     else if ( msg == "Format/Set Font(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);
     }
 }
 
 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::setcontinuous(bool sfs)
 {
     reader->setContinuous(sfs);
     reader->refresh();
 }
 
 int QTReaderApp::EncNameToInt(const QString& _enc)
 {
     for (int i = 0; i < MAX_ENCODING; i++)
     {
         if (m_EncodingAction[i]->text() == _enc) return i;
     }
     return 0;
 /*
     if (_enc == "Ascii") return 0;
     if (_enc == "UTF-8") return 1;
     if (_enc == "UCS-2(BE)") return 2;
     if (_enc == "USC-2(LE)") return 3;
 */
 }
 
 void QTReaderApp::encodingSelected(QAction* _a)
 {
 //    qDebug("es:%x : %s", _a, (const char *)(_a->text()));
     reader->setencoding(EncNameToInt(_a->text()));
 }
 
 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()
 {
     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);
         switch (QMessageBox::information ( this , PROGNAME, "What do you want to delete?", "Nothing", "Marks", "Marks\nFile", 1, 0 ))
         {
             case 0:
             default:
                 break;
             case 2:
                 unlink((const char*)reader->m_lastfile);
             case 1:
                 unlink((const char *)Global::applicationFileName(APPDIR, reader->m_string));
         }
     }
     
     fileOpen2();
 }
 
 void QTReaderApp::updatefileinfo()
 {
     if (reader->m_string.isNull()) return;
     if (reader->m_lastfile.isNull()) 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();
     editBar->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();
 */
     if (pOpenlist != NULL)
     {
         m_nRegAction = cOpenFile;
         listbkmk(pOpenlist, "Browse");
     }
     else
     {
         QString fn = usefilebrowser();
         if (!fn.isEmpty() && QFileInfo(fn).isFile())
         {
             openFile(fn);
         }
         reader->setFocus();
     }
 }
 
 QString QTReaderApp::usefilebrowser()
 {
     fileBrowser* fb = new fileBrowser(this,"QTReader",TRUE,
                                       0,
         //                            WStyle_Customize | WStyle_NoBorderEx,
                                       "*", QFileInfo(reader->m_lastfile).dirPath(true));
 
 
     QString fn;
     if (fb->exec())
     {
         fn = fb->fileList[0];
     }
     qDebug("Selected %s", (const char*)fn);
     delete fb;
     return fn;
 }
 
 void QTReaderApp::showgraphic(QPixmap& pm)
 {
     m_graphicwin->setPixmap(pm);
     editorStack->raiseWidget( m_graphicwin );
     m_graphicwin->setFocus();
 }
 
 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 );
         Global::showInputMethod();
         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();
         reader->jumpto(m_savedpos);
         while (reader->explocate() < endpos && (ch = reader->getch()) != UEOF)
         {
             text += ch;
         }
         cb->setText(text);
         reader->locate(currentpos);
 }
 
 void QTReaderApp::pageup()
 {
     reader->NavUp();
 }
 
 void QTReaderApp::pagedn()
 {
     reader->NavDown();
 }
 
 void QTReaderApp::stripcr(bool _b)
 {
     reader->setstripcr(_b);
 }
 void QTReaderApp::onespace(bool _b)
 {
     reader->setonespace(_b);
 }
 #ifdef REPALM
 void QTReaderApp::repalm(bool _b)
 {
     reader->setrepalm(_b);
 }
 #endif
 void QTReaderApp::remap(bool _b)
 {
     reader->setremap(_b);
 }
 void QTReaderApp::peanut(bool _b)
 {
     reader->setpeanut(_b);
 }
 void QTReaderApp::embolden(bool _b)
 {
     reader->setmakebold(_b);
 }
 void QTReaderApp::autofmt(bool _b)
 {
     reader->setautofmt(_b);
 }
 void QTReaderApp::textfmt(bool _b)
 {
     reader->settextfmt(_b);
 }
 void QTReaderApp::striphtml(bool _b)
 {
     reader->setstriphtml(_b);
 }
 void QTReaderApp::dehyphen(bool _b)
 {
     reader->setdehyphen(_b);
 }
 void QTReaderApp::unindent(bool _b)
 {
     reader->setunindent(_b);
 }
 void QTReaderApp::repara(bool _b)
 {
     reader->setrepara(_b);
 }
 void QTReaderApp::dblspce(bool _b)
 {
     reader->setdblspce(_b);
 }
 void QTReaderApp::pagemode(bool _b)
 {
     reader->setpagemode(_b);
 }
 void QTReaderApp::navkeys(bool _b)
 {
     reader->m_navkeys = _b;
 }
 void QTReaderApp::monospace(bool _b)
 {
     reader->setmono(_b);
 }
 
 void QTReaderApp::setspacing()
 {
     m_nRegAction = cMonoSpace;
     char lcn[20];
     sprintf(lcn, "%lu", reader->m_charpc);
     regEdit->setText(lcn);
     do_regedit();
 }
 
 void QTReaderApp::setoverlap()
 {
     m_nRegAction = cOverlap;
     char lcn[20];
     sprintf(lcn, "%lu", reader->m_overlap);
     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_overlap(const QString& lcn)
 {
     bool ok;
     unsigned long ulcn = lcn.toULong(&ok);
     if (ok)
     {
         reader->m_overlap = ulcn;
     }
     else
         QMessageBox::information(this, PROGNAME, "Must be a number");
 }
 
 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
   Global::showInputMethod();
   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->buffdoc.getline(&test,reader->width());
   dosearch(start, test, arg);
 }
 
 void QTReaderApp::findClose()
 {
   searchVisible = FALSE;
   searchEdit->setText("");
   Global::hideInputMethod();
   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();
   Global::hideInputMethod();
   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();
   reader->buffdoc.getline(&test,reader->width());
   pbar->show();
   pbar->resize(width(), editBar->height());
   pbar->reset();
   int lastpc = (100*pos)/ts;
   pbar->setProgress(lastpc);
   qApp->processEvents();
   reader->setFocus();
 #ifdef __ISEARCH
   while (strstr(test.data(),(const tchar*)arg) == NULL)
 #else
 #ifdef _UNICODE
   while (arg.match(toQString(test.data())) == -1)
 #else
   while (arg.match(test.data()) == -1)
 #endif
 #endif
     {
       pos = reader->locate();
       unsigned int lcn = reader->locate();
       int pc = (100*pos)/ts;
       if (pc != lastpc)
       {
         pbar->setProgress(pc);
         qApp->processEvents();
         reader->setFocus();
         lastpc = pc;
       }
 
       if (!reader->buffdoc.getline(&test,reader->width()))
         {
           if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)
             pos = searchStart;
           else
             pos = start;
           ret = false;
           findClose();
           break;
         }
     }
   pbar->hide();
   reader->locate(pos);
   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()");
 
         if (fm.extension( FALSE ) == "desktop")
         {
             DocLnk d(f);
             QFileInfo fnew(d.file());
             fm = fnew;
             if (!fm.exists()) return;
         }
 
       clear();
 
       reader->setText(fm.baseName(), fm.absFilePath());
       showEditTools();
       readbkmks();
     }
   else
     {
       QMessageBox::information(this, PROGNAME, "File does not exist");
     }
         
 }
 /*
 void QTReaderApp::resizeEvent(QResizeEvent* e)
 {
     if (m_fullscreen)
     {
         showNormal();
         showFullScreen();
     }
 }
 */
 void QTReaderApp::keyPressEvent(QKeyEvent* e)
 {
     if (m_fullscreen)
     {
         switch(e->key())
         {
             case Key_Escape:
                 m_actFullscreen->setOn(false);
                 if (m_fullscreen)
                 {
                     qDebug("Fullscreen already set - remove this!");
                 }
                 else
                 {
                     m_fullscreen = false;
                     reader->bDoUpdates = false;
                     showEditTools();
                     qApp->processEvents();
                     reader->bDoUpdates = true;
                     reader->update();
                 }
                 e->accept();
                 break;
             default:
                 e->ignore();
         }
     }
     else
     {
         e->ignore();
     }
 }
 
 void QTReaderApp::showEditTools()
 {
 //    if ( !doc )
         //close();
     if (m_fullscreen)
     {
         editBar->hide();
         searchBar->hide();
         regBar->hide();
         Global::hideInputMethod();
         m_fontBar->hide();
         //showNormal();
         showFullScreen();
     }
     else
     {
         qDebug("him");
         Global::hideInputMethod();
         qDebug("eb");
         editBar->show();
         if ( searchVisible )
         {
             Global::showInputMethod();
             searchBar->show();
         }
         if ( regVisible )
         {
             Global::showInputMethod();
             regBar->show();
         }
         if (m_fontVisible) m_fontBar->show();
         qDebug("sn");
         showNormal();
         qDebug("sm");
         showMaximized();
         //setCentralWidget(reader);
     }
 
     qDebug("uc");
     updateCaption();
     qDebug("rw");
     editorStack->raiseWidget( reader );
     qDebug("sf");
     reader->setFocus();
 }
 /*
 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(SHORTPROGNAME) );
 //    }
 }
 
 void QTReaderApp::setDocument(const QString& fileref)
 {
     bFromDocView = TRUE;
 //QMessageBox::information(0, "setDocument", fileref);
     openFile(fileref);
 //    showEditTools();
 }
 
 void QTReaderApp::closeEvent( QCloseEvent *e )
 {
     if (m_fullscreen)
     {
         m_fullscreen = false;
         showEditTools();
         e->accept();
     }
     else if (m_dontSave)
     {
         e->accept();
     }
     else
     {
         if (editorStack->visibleWidget() == reader)
         {
             if (m_fontVisible)
             {
                 m_fontBar->hide();
                 m_fontVisible = false;
             }
             if (regVisible)
             {
                 regBar->hide();
                 Global::hideInputMethod();
                 regVisible = false;
                 return;
             }
             if (searchVisible)
             {
                 searchBar->hide();
                 Global::hideInputMethod();
                 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();
         }
     }
 }
 
 void QTReaderApp::do_gotomark()
 {
     m_nRegAction = cGotoBkmk;
     listbkmk(pBkmklist);
 }
 
 void QTReaderApp::do_delmark()
 {
     m_nRegAction = cDelBkmk;
     listbkmk(pBkmklist);
 }
 
 void QTReaderApp::listbkmk(CList<Bkmk>* plist, const QString& _lab)
 {
     bkmkselector->clear();
     if (_lab.isNull())
         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)
       {
 //tjw        menu->hide();
         editBar->hide();
         if (m_fontVisible) m_fontBar->hide();
         if (regVisible)
         {
             Global::hideInputMethod();
             regBar->hide();
         }
         if (searchVisible)
         {
             Global::hideInputMethod();
             searchBar->hide();
         }
         editorStack->raiseWidget( bkmkselector );
       }
     else
       QMessageBox::information(this, PROGNAME, "No bookmarks in memory");
 }
 
 void QTReaderApp::do_autogen()
 {
   m_nRegAction = cAutoGen;
   regEdit->setText(m_autogenstr);
   do_regedit();
 }
 
 void QTReaderApp::do_regedit()
 {
 //    editBar->hide();
     reader->bDoUpdates = false;
     qDebug("Showing regbar");
   regBar->show();
     qDebug("Showing kbd");
   Global::showInputMethod();
   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");
             reader->locate(bk->value());
         }
         return true;
     }
     else
     {
         return false;
     }
 }
 
 void QTReaderApp::gotobkmk(int ind)
 {
     switch (m_nRegAction)
     {
         case cOpenFile:
         {
             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:
             unlink((const char *)Global::applicationFileName(APPDIR,bkmkselector->text(ind)));
             break;
     }
   showEditTools();
 }
 
 void QTReaderApp::cancelbkmk()
 {
     if (m_nRegAction == 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();
   Global::hideInputMethod();
   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 cOverlap:
           do_overlap(regEdit->text());
           break;
       case cSetTarget:
           do_settarget(regEdit->text());
           break;
   }
   reader->restore();
 //    editBar->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::setfont()
 {
     for (int i = 1; i <= m_fontSelector->count(); i++)
     {
         if (m_fontSelector->text(i) == reader->m_fontname)
         {
             m_fontSelector->setCurrentItem(i);
             break;
         }
     }
     m_fontBar->show();
     m_fontVisible = true;
 }
 
-void QTReaderApp::setfontHelper(const QString& lcn, int size = 0)
+void QTReaderApp::setfontHelper(const QString& lcn, int size)
 {
     if (size == 0) size = reader->m_fontControl.currentsize();
     QFont f(lcn, 10 /*, QFont::Bold*/);
     qDebug("bs");
     bkmkselector->setFont( f );
     qDebug("re");
     regEdit->setFont( f );
     qDebug("se");
     searchEdit->setFont( f );
     qDebug("aw");
     m_annoWin->setFont( f );
     reader->m_fontname = lcn;
     qDebug("cf1");
     if (!reader->ChangeFont(size))
     {
     qDebug("cf2");
         reader->ChangeFont(size);
     }
     qDebug("ref");
     reader->refresh();
     m_fontBar->hide();
     m_fontVisible = false;
     qDebug("showedit");
     if (reader->isVisible()) showEditTools();
     qDebug("showeditdone");
 }
 
 void QTReaderApp::do_setfont(const QString& lcn)
 {
     setfontHelper(lcn);
 }
 
 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->show();
 pbar->resize(width(), editBar->height());
   pbar->reset();
   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();
 }
 
 void QTReaderApp::saveprefs()
 {
 //  reader->saveprefs("uqtreader");
     Config config( APPDIR );
     config.setGroup( "View" );
     
     reader->m_lastposn = reader->pagelocate();
     
     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( "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( "CursorNavigation", reader->m_navkeys );
     config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced );
     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( "TargetApp", m_targetapp );
     config.writeEntry( "TargetMsg", m_targetmsg );
     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);
 #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 );
 
     savefilelist();
 }
 
 void QTReaderApp::indentplus()
 {
   reader->indentplus();
 }
 
 void QTReaderApp::indentminus()
 {
   reader->indentminus();
 }
 
 /*
 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)
     {
         BkmkFile bf((const char *)Global::applicationFileName(APPDIR, reader->m_string), true);
         bf.write(*pBkmklist);
     }
         m_fBkmksChanged = false;
 }
 
 void QTReaderApp::readfilelist()
 {
     BkmkFile bf((const char *)Global::applicationFileName(APPDIR, ".openfiles"));
     qDebug("Reading open files");
     pOpenlist = bf.readall();
     if (pOpenlist != NULL) qDebug("...with success");
     else qDebug("...without success!");
 }
 
 void QTReaderApp::savefilelist()
 {
     if (pOpenlist != NULL)
     {
         BkmkFile bf((const char *)Global::applicationFileName(APPDIR, ".openfiles"), true);
         qDebug("Writing open files");
         bf.write(*pOpenlist);
     }
 }
 
 void QTReaderApp::readbkmks()
 {
     if (pBkmklist != NULL)
     {
             delete pBkmklist;
     }
     struct stat fnstat;
     struct stat bkstat;
     if (
         stat((const char *)reader->m_lastfile, &fnstat) == 0
         &&
         stat((const char *)Global::applicationFileName(APPDIR, reader->m_string), &bkstat) == 0
         )
     {
         if (bkstat.st_mtime < fnstat.st_mtime)
         {
             unlink((const char *)Global::applicationFileName(APPDIR, reader->m_string));
         }
     }
 
     BkmkFile bf((const char *)Global::applicationFileName(APPDIR, reader->m_string));
 
     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)
     {
         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;
     Global::showInputMethod();
     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);
         if (wrd.length() > 10)
         {
             Global::statusMessage(wrd.left(8) + "..");
         }
         else
         {
             Global::statusMessage(wrd);
         }
     }
     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;
         Global::showInputMethod();
         editorStack->raiseWidget( m_annoWin );
     }
     if (m_doDictionary)
     {
         if (!m_targetapp.isEmpty() && !m_targetmsg.isEmpty())
         {
             QCopEnvelope e(("QPE/Application/"+m_targetapp).utf8(), (m_targetmsg+"(QString)").utf8());
             e << wrd;
         }
     }
 }
 
 void QTReaderApp::OnActionPressed()
 {
     switch (m_spaceTarget)
     {
         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(true);
         }
         break;
         default:
         {
             qDebug("Unknown ActionType:%u", m_spaceTarget);
         }
         break;
     }
 }
 
 void QTReaderApp::setTwoTouch(bool _b) { reader->setTwoTouch(_b); }
 void QTReaderApp::restoreFocus() { reader->setFocus(); } 
 
 /*
 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->bonespace = reader->bonespace;
     sd->bunindent = reader->bunindent;
     sd->brepara = reader->brepara;
     sd->bdblspce = reader->bdblspce;
     sd->m_bpagemode = reader->m_bpagemode;
     sd->m_navkeys = reader->m_navkeys;
     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());
 }
 */
diff --git a/noncore/apps/opie-reader/infowin.cpp b/noncore/apps/opie-reader/infowin.cpp
index 30adebf..459b648 100644
--- a/noncore/apps/opie-reader/infowin.cpp
+++ b/noncore/apps/opie-reader/infowin.cpp
@@ -1,43 +1,43 @@
 #include "name.h"
 #include "infowin.h"
 #include "version.h"
 #include <stdio.h>
 
-infowin::infowin( QWidget *parent=0, const char *name=0, WFlags f = 0) :
+infowin::infowin( QWidget *parent, const char *name, WFlags f ) :
     QWidget(parent, name, f)
 {
     grid = new QGridLayout(this, 6, 2);
     QLabel* l;
     l = new QLabel("Compressed file size", this);
     grid->addWidget(l, 0, 0);
     fileSize = new QLabel("0", this);
     fileSize->setAlignment( AlignVCenter | AlignRight );
     grid->addWidget(fileSize, 0, 1);
     l = new QLabel("Original text size", this);
     grid->addWidget(l, 1, 0);
     textSize = new QLabel("0", this);
     textSize->setAlignment( AlignVCenter | AlignRight );
     grid->addWidget(textSize, 1, 1);
     l = new QLabel("Compression Ratio", this);
     grid->addWidget(l, 2, 0);
     ratio = new QLabel("0", this);
     grid->addWidget(ratio, 2, 1);
     ratio->setAlignment( AlignVCenter | AlignRight );
     l = new QLabel("Current location", this);
     grid->addWidget(l, 3, 0);
     location = new QLabel("0", this);
     location->setAlignment( AlignVCenter | AlignRight );
     grid->addWidget(location, 3, 1);
     l = new QLabel("Per centage read", this);
     grid->addWidget(l, 4, 0);
     read = new QLabel("0", this);
     read->setAlignment( AlignVCenter | AlignRight );
     grid->addWidget(read, 4, 1);
     char vstr[128];
     sprintf(vstr, PROGNAME " v%u.%u%c (%s)\nA small e-text reader", MAJOR, BKMKTYPE, MINOR, RELEASE_TYPE);
     l = new QLabel(vstr, this);
     grid->addWidget(l, 5, 0);
     QPushButton* exitbutton = new QPushButton("Cancel", this);
     connect( exitbutton, SIGNAL( released() ), this, SLOT( infoClose() ) );
     grid->addWidget(exitbutton, 5, 1);
 }