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,828 +1,828 @@
 /****************************************************************************
 ** $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 )
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
@@ -1404,1203 +1404,1203 @@ void QTReaderApp::pageup()
 
 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);
 }