code change by tim: ask the user to confirm the remapping of the ESC key

1 files changed, 6 insertions, 1 deletions

diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp
index 6753698..8ef0674 100644
--- a/noncore/apps/opie-reader/QTReaderApp.cpp
+++ b/noncore/apps/opie-reader/QTReaderApp.cpp
@@ -2137,2049 +2137,2054 @@ void QTReaderApp::showprefs()
         m_twoTouch = prefwin->twotouch();
         reader->setTwoTouch(m_twoTouch);
         m_touch_action->setOn(m_twoTouch);
 
         reader->bstripcr = prefwin->StripCR();
         reader->bNoInlineTables = !prefwin->InlineTables();
         reader->bdehyphen = prefwin->Dehyphen();
         reader->bonespace = prefwin->SingleSpace();
         reader->bunindent = prefwin->Unindent();
         reader->brepara = prefwin->Reparagraph();
         reader->bdblspce = prefwin->DoubleSpace();
         reader->bremap = prefwin->Remap();
         reader->bmakebold = prefwin->Embolden();
         reader->bfulljust = prefwin->FullJustify();
                 //if (reader->bInverse != prefwin->Inverse()) reader->setInverse(prefwin->Inverse());
                 //if (reader->bNegative != prefwin->Negative()) reader->setNegative();
         reader->m_fontControl.FixGraphics(prefwin->FixGraphics());
 
         reader->setextraspace(prefwin->ParaLead());
         reader->setlead(prefwin->LineLead());
         reader->m_abstopmargin = prefwin->TopMargin();
         reader->m_absbottommargin = prefwin->BottomMargin();
         reader->m_absleft_border = prefwin->LeftMargin();
         reader->m_absright_border = prefwin->RightMargin();
         reader->bindenter = prefwin->Indent();
         reader->bautofmt = reader->btextfmt = reader->bstriphtml = reader->bpeanut = false;
         switch (prefwin->Markup())
         {
             case 0:
                 reader->bautofmt = true;
                 break;
             case 1:
                 break;
             case 2:
                 reader->btextfmt = true;
                 break;
             case 3:
                 reader->bstriphtml = true;
                 break;
             case 4:
                 reader->bpeanut = true;
                 break;
             default:
                 qDebug("Format out of range");
         }
         reader->bdepluck = prefwin->Depluck();
         reader->bdejpluck = prefwin->Dejpluck();
         reader->setContinuous(prefwin->Continuous());
         reader->setDoubleBuffer(prefwin->DoubleBuffer());
 
         /*
         m_leftScroll = prefwin->leftScroll();
         m_rightScroll = prefwin->rightScroll();
         m_upScroll = prefwin->upScroll();
         m_downScroll = prefwin->downScroll();
         */
         m_targetapp = prefwin->dictApplication();
         m_targetmsg = prefwin->dictMessage();
 
         m_doAnnotation = prefwin->miscannotation();
         m_doDictionary = prefwin->miscdictionary();
         m_doClipboard = prefwin->miscclipboard();
         m_doOutput = prefwin->miscoutput();
         reader->m_swapmouse = prefwin->SwapMouse();
         reader->setBaseSize(prefwin->gfxsize());
         reader->m_overlap = prefwin->pageoverlap();
         reader->m_bMonoSpaced = prefwin->ideogram();
         m_setmono_action->setOn(reader->m_bMonoSpaced);
         reader->m_encd = prefwin->encoding();
         reader->m_charpc = prefwin->ideogramwidth();
 
         if (
             reader->m_fontname != prefwin->Font()
             ||
             m_propogatefontchange != prefwin->propfontchange())
         {
             m_propogatefontchange = prefwin->propfontchange();
             setfontHelper(prefwin->Font());
         }
         if (m_bgtype != (bground)prefwin->bgtype())
           {
             m_bgtype = (bground)prefwin->bgtype();
             setBackgroundBitmap();
           }
         qDebug("OutCodec:%s", (const char*)prefwin->outcodec());
         if (reader->m_outputName != prefwin->outcodec())
           {
             if (reader->m_output != NULL)
               {
                 QMessageBox::warning(this, PROGNAME, "Change of output codec\nrequires a restart");
               }
             reader->m_outputName = prefwin->outcodec();
           }
         delete prefwin;
         reader->setfilter(reader->getfilter());
         reader->refresh();
     }
     else
     {
         delete prefwin;
     }
 }
 
 void QTReaderApp::showtoolbarprefs()
 {
 #ifdef USEQPE
     CBarPrefs* prefwin = new CBarPrefs(APPDIR, !m_bFloatingDialog, this);
 #else
         QFileInfo fi;
     QDir d = QDir::home();                      // "/"
         if ( !d.cd(APPDIR) )
         {                       // "/tmp"
                 qWarning( "Cannot find the \"~/%s\" directory", APPDIR );
                 d = QDir::home();
                 d.mkdir(APPDIR);
                 d.cd(APPDIR);
         }
         fi.setFile(d, INIFILE);
     CBarPrefs* prefwin = new CBarPrefs(fi.absFilePath(), !m_bFloatingDialog, this);
 #endif
     prefwin->tbpolicy(m_tbpolsave);
     prefwin->tbposition(m_tbposition-2);
     prefwin->tbmovable(m_tbmovesave);
     prefwin->floating(m_bFloatingDialog);
     prefwin->qtscroll(m_qtscroll);
     prefwin->localscroll(m_localscroll);
     if (prefwin->exec())
     {
         m_bFloatingDialog = prefwin->floating();
         if (
             m_tbpolsave != (ToolbarPolicy)prefwin->tbpolicy()
             ||
             m_tbposition != (ToolBarDock)(prefwin->tbposition()+2)
             ||
             m_tbmovesave != prefwin->tbmovable()
             ||
             m_qtscroll != prefwin->qtscroll()
                     //    ||
                     //    m_localscrollbar != prefwin->scrollonleft()
             )
         {
             QMessageBox::warning(this, PROGNAME, "Some changes won't take effect\nuntil the next time the\napplication is started");
         }
         m_tbpolsave = (ToolbarPolicy)prefwin->tbpolicy();
         m_tbposition = (ToolBarDock)(prefwin->tbposition()+2);
         m_tbmovesave = prefwin->tbmovable();
         reader->m_scrollpos = m_localscroll = prefwin->localscroll();
         if (m_qtscroll != prefwin->qtscroll())
           {
             m_qtscroll = prefwin->qtscroll();
             setrotated(reader->m_rotated);
           }
         if (m_scrollbar == NULL || m_scrollbar->isHidden())
           {
             reader->m_scrollpos = m_localscroll;
           }
         else
           {
             reader->m_scrollpos = (m_qtscroll == 0) ? m_localscroll : 0;
           }
         bool isChanged = prefwin->isChanged();
         delete prefwin;
 #ifdef USEQPE
         Config config( APPDIR );
 #else
         QFileInfo fi;
     QDir d = QDir::home();                      // "/"
         if ( !d.cd(APPDIR) )
         {                       // "/tmp"
                 qWarning( "Cannot find the \"~/%s\" directory", APPDIR );
                 d = QDir::home();
                 d.mkdir(APPDIR);
                 d.cd(APPDIR);
         }
         fi.setFile(d, INIFILE);
         Config config( fi.absFilePath() );
 #endif
         if (isChanged) addtoolbars(&config);
     }
     else
     {
         delete prefwin;
     }
 }
 
 void QTReaderApp::showinfo()
 {
     unsigned long ds, fs, ts, pl, dl;
     if (reader->empty())
     {
         QMessageBox::information(this, PROGNAME, "No file loaded", 1);
     }
     else
     {
         reader->sizes(fs,ts);
         ds = reader->buffdoc.endSection() - reader->buffdoc.startSection();
         pl = reader->pagelocate();
         dl = pl - reader->buffdoc.startSection();
         m_infoWin->setFileSize(fs);
         m_infoWin->setTextSize(ts);
         if (fs > UINT_MAX/100)
           {
             unsigned long t1 = (ts+50)/100;
             m_infoWin->setRatio(100-(fs + (t1 >> 1))/t1);
           }
         else
           {
             m_infoWin->setRatio(100-(100*fs + (ts >> 1))/ts);
           }
         m_infoWin->setLocation(pl);
         if (pl > UINT_MAX/100)
           {
             unsigned long t1 = (ts+50)/100;
             m_infoWin->setRead((pl + (t1 >> 1))/t1);
           }
         else
           {
             m_infoWin->setRead((100*pl + (ts >> 1))/ts);
           }
         m_infoWin->setDocSize(ds);
         m_infoWin->setDocLocation(dl);
         if (dl > UINT_MAX/100)
           {
             unsigned long d1 = (ds+50)/100;
             m_infoWin->setDocRead((dl + (d1 >> 1))/d1);
           }
         else
           {
             m_infoWin->setDocRead((100*dl + (ds >> 1))/ds);
           }
         m_infoWin->setZoom(reader->m_fontControl.currentsize()*10);
         m_infoWin->setAbout(QString("\nApplication (c) Tim Wentford\n")+reader->about());
         editorStack->raiseWidget( m_infoWin );
         hidetoolbars();
         m_infoWin->setFocus();
     }
 }
 
 void QTReaderApp::addAnno(const QString& name, const QString& text, size_t posn, size_t posn2)
 {
     if (pBkmklist == NULL) reader->pBkmklist = 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;
     Bkmk b(buff.data(), buff2.data(), posn, posn2);
         QColor c = m_annoWin->getColor();
         int red,green,blue;
         c.rgb(&red, &green, &blue);
         b.red(red);
         b.green(green);
         b.blue(blue);
     pBkmklist->push_front(b);
 #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(), m_annoWin->getPosn2());
         }
         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());
         }
         QColor c = m_annoWin->getColor();
         int red,green,blue;
         c.rgb(&red, &green, &blue);
         m_anno->red(red);
         m_anno->green(green);
         m_anno->blue(blue);
         bool found = findNextBookmark(m_anno->value()+1);
         if (found)
         {
             m_annoWin->setName(toQString(m_anno->name()));
             m_annoWin->setAnno(toQString(m_anno->anno()));
             m_annoWin->setColor(QColor(m_anno->red(), m_anno->green(), m_anno->blue()));
         }
         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 );
         hidetoolbars();
 #ifdef USEQPE
         Global::showInputMethod();
 #endif
         m_annoWin->setFocus();
     }
 }
 
 void QTReaderApp::infoClose()
 {
   m_debounce = m_buttonprefs->Debounce();
   if (m_kmapchanged)
     {
       m_kmapchanged = false;
 #ifndef USEQPE
       QDir d = QDir::home();                      // "/"
       d.cd(APPDIR);
       QFileInfo fi(d, ".keymap");
       FILE* f = fopen((const char *)fi.absFilePath(), "w");
 #else /* USEQPE */
       FILE* f = fopen((const char *)Global::applicationFileName(APPDIR,".keymap"), "w");
 #endif /* USEQPE */
       if (f != NULL)
         {
           uint cnt = KEYMAPVERSION;
           fwrite(&cnt, sizeof(cnt), 1, f);
           cnt = kmap.count();
           fwrite(&cnt, sizeof(cnt), 1, f);
           for (QMap<orKey,int>::Iterator i = kmap.begin(); i != kmap.end(); i++)
             {
               orKey key = i.key();
               int data = i.data();
               fwrite(&key, sizeof(key), 1, f);
               fwrite(&data, sizeof(data), 1, f);
               qDebug("Saved %s as %u", (const char*)key.text(), data);
             }
           fclose(f);
         }
     }
     showEditTools();
 }
 
 /*
 void QTReaderApp::fileRevert()
 {
     clear();
     fileOpen();
 }
 
 void QTReaderApp::editCut()
 {
 #ifndef QT_NO_CLIPBOARD
     editor->cut();
 #endif
 }
 */
 void QTReaderApp::editMark()
 {
     m_savedpos = reader->pagelocate();
 }
 
 void QTReaderApp::editCopy()
 {
         QClipboard* cb = QApplication::clipboard();
         QString text;
         int ch;
         unsigned long currentpos = reader->pagelocate();
         unsigned long endpos = reader->locate();
         if (m_savedpos == 0xffffffff)
         {
             m_savedpos = currentpos;
         }
         reader->jumpto(m_savedpos);
         while (reader->explocate() < endpos && (ch = reader->getch()) != UEOF)
         {
             text += ch;
         }
         cb->setText(text);
         reader->locate(currentpos);
         m_savedpos = 0xffffffff;
 }
 
 void QTReaderApp::gotoStart()
 {
     reader->locate(reader->buffdoc.startSection());
 }
 
 void QTReaderApp::gotoEnd()
 {
     reader->dopageup(reader->buffdoc.endSection());
 }
 
 void QTReaderApp::pageup()
 {
     reader->NavUp();
 }
 
 void QTReaderApp::pagedn()
 {
     reader->NavDown();
 }
 
 void QTReaderApp::pagemode(bool _b)
 {
     reader->setpagemode(_b);
 }
 
 /*
 void QTReaderApp::setspacing()
 {
     m_nRegAction = cMonoSpace;
     char lcn[20];
     sprintf(lcn, "%lu", reader->m_charpc);
     regEdit->setText(lcn);
     do_regedit();
 }
 */
 void QTReaderApp::settarget()
 {
     m_nRegAction = cSetTarget;
     QString text = ((m_targetapp.isEmpty()) ? QString("") : m_targetapp)
         + "/"
         + ((m_targetmsg.isEmpty()) ? QString("") : m_targetmsg);
     regEdit->setText(text);
     do_regedit();
 }
 
 /*
 void QTReaderApp::do_mono(const QString& lcn)
 {
     bool ok;
     unsigned long ulcn = lcn.toULong(&ok);
     if (ok)
     {
         reader->m_charpc = ulcn;
         reader->setfont();
         reader->refresh();
         //reader->setmono(true);
     }
     else
         QMessageBox::information(this, PROGNAME, "Must be a number");
 }
 */
 /*
 void QTReaderApp::editPaste()
 {
 #ifndef QT_NO_CLIPBOARD
     editor->paste();
 #endif
 }
 */
 
 void QTReaderApp::editFind()
 {
   searchStart = reader->pagelocate();
 #ifdef __ISEARCH
   searchStack = new QStack<searchrecord>;
 #endif
 #ifdef USEQPE
   Global::showInputMethod();
 #endif
   searchBar->show();
   searchVisible = TRUE;
   searchEdit->setFocus();
 #ifdef __ISEARCH
   searchStack->push(new searchrecord("",reader->pagelocate()));
 #endif
 }
 
 void QTReaderApp::findNext()
 {
 //  //  qDebug("findNext called\n");
 #ifdef __ISEARCH
   QString arg = searchEdit->text();
 #else
   QRegExp arg = searchEdit->text();
 #endif
   CDrawBuffer test(&(reader->m_fontControl));
   size_t start = reader->pagelocate();
   reader->jumpto(start);
   reader->getline(&test);
   dosearch(start, test, arg);
 }
 
 void QTReaderApp::findClose()
 {
   searchVisible = FALSE;
   searchEdit->setText("");
 #ifdef USEQPE
   Global::hideInputMethod();
 #endif
   searchBar->hide();
 #ifdef __ISEARCH
 //  searchStack = new QStack<searchrecord>;
   while (!searchStack->isEmpty())
     {
       delete searchStack->pop();
     }
   delete searchStack;
 #endif
   reader->setFocus();
 }
 
 void QTReaderApp::regClose()
 {
   regVisible = FALSE;
   regEdit->setText("");
   regBar->hide();
 #ifdef USEQPE
   Global::hideInputMethod();
 #endif
   reader->setFocus();
 }
 
 #ifdef __ISEARCH
 bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QString& arg)
 #else
 bool QTReaderApp::dosearch(size_t start, CDrawBuffer& test, const QRegExp& arg)
 #endif
 {
   bool ret = true;
     unsigned long fs, ts;
     reader->sizes(fs,ts);
   size_t pos = reader->locate();
   pbar->setGeometry(searchBar->x(),searchBar->y(),searchBar->width(), searchBar->height());
   pbar->show();
   pbar->raise();
   pbar->reset();
   int offset;
   int lastpc = (100*pos)/ts;
   pbar->setProgress(lastpc);
 //  qApp->processEvents();
   if (reader->buffdoc.getpara(test) >= 0)
   {
       reader->setFocus();
 #ifdef __ISEARCH
       while (strstr(test.data(),(const tchar*)arg) == NULL)
 #else
 #ifdef _UNICODE
       while ((offset = arg.match(toQString(test.data()))) == -1)
 #else
       while (arg.match(test.data()) == -1)
 #endif
 #endif
       {
           pos = reader->locate();
           int pc = (100*pos)/ts;
           if (pc != lastpc)
           {
               pbar->setProgress(pc);
               qApp->processEvents();
               reader->setFocus();
               lastpc = pc;
           }
           
           if (reader->buffdoc.getpara(test) < 0)
           {
               if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)
                   pos = searchStart;
               else
                   pos = start;
               findClose();
               pbar->hide();
               reader->locate(pos);
               return false;
           }
       }
 //      qDebug("Found it at %u:%u", pos, offset);
       pbar->hide();
 //      qDebug("Hid");
       reader->locate(pos+offset);
 //      qDebug("Loacted");
 //      qDebug("page up");
       ret = true;
   }
   else
   {
               if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2)
                   pos = searchStart;
               else
                   pos = start;
               ret = false;
               findClose();
   }
   return ret;
 }
 
 #ifdef __ISEARCH
 void QTReaderApp::search(const QString & arg)
 {
   searchrecord* ss = searchStack->top();
   CBuffer test;
   size_t start = reader->pagelocate();
   bool haspopped = false;
   while (arg.left(ss->s.length()) != ss->s)
   {
       haspopped = true;
       start = ss->pos;
 //      reader->locate(start);
       searchStack->pop();
       delete ss;
   }
   if (haspopped) reader->locate(start);
 /*
   if (arg.length() < ss->len)
     {
       start = ss->pos;
       reader->locate(start);
       searchStack->pop();
       delete ss;
     }
 */
   else
     {
       start = reader->pagelocate();
       reader->jumpto(start);
       searchStack->push(new searchrecord(arg,start));
     }
     dosearch(start, test, arg);
 }
 #else
 void QTReaderApp::search()
 {
     findNext();
 }
 #endif
 
 void QTReaderApp::openFile( const QString &f, unsigned int loc )
 {
 //    qDebug("File:%s", (const char*)f);
 //    openFile(DocLnk(f));
 //}
 //
 //void QTReaderApp::openFile( const DocLnk &f )
 //{
   clear();
   QFileInfo fm(f);
   if ( fm.exists() )
     {
 //      QMessageBox::information(0, "Progress", "Calling fileNew()");
 #ifdef USEQPE
         if (fm.extension( FALSE ) == "desktop")
         {
             DocLnk d(f);
             QFileInfo fnew(d.file());
             fm = fnew;
             if (!fm.exists()) return;
         }
 #endif
       clear();
       reader->setText(fm.baseName(), fm.absFilePath(), loc);
       m_loadedconfig = readconfig(APPDIR "/configs", reader->m_string, false);
       qDebug("Showing tools");
       showEditTools();
       qDebug("Shown tools");
       readbkmks();
       qDebug("read markss");
       m_savedpos = 0xffffffff;
     }
   else
     {
       QString msg = f;
        msg += "\nFile does not exist";
       QMessageBox::information(this, PROGNAME, msg);
       reader->m_lastfile = QString::null;
     }
         
 }
 /*
 void QTReaderApp::resizeEvent(QResizeEvent* e)
 {
     if (m_fullscreen)
     {
         showNormal();
         showFullScreen();
     }
 }
 */
 void QTReaderApp::handlekey(QKeyEvent* e)
 {
 //    qDebug("Keypress event");
     timeb now;
     ftime(&now);
     unsigned long etime = (1000*(now.time - m_lastkeytime.time) + now.millitm)-m_lastkeytime.millitm;
     if (etime < m_debounce)
     {
         return;
     }
     switch(e->key())
     {
         case Key_Escape:
             qDebug("escape event");
             if (m_disableesckey)
             {
                 m_disableesckey = false;
             }
             else
             {
                 m_bcloseDisabled = true;
                 if (m_fullscreen)
                 {
                     m_actFullscreen->setOn(false);
                     e->accept();
                 }
                 else
                 {
         //      qDebug("escape action");
                     doAction(e);
                 }
             }
             break;
             /*
         case Key_Left:
         {
             if (reader->m_autoScroll)
             {
                 reader->reduceScroll();
             }
             else
             {
                 doAction(e);
             }
         }
         break;
         case Key_Right:
         {
             if (reader->m_autoScroll)
             {
                 reader->increaseScroll();
             }
             else
             {
                 doAction(e);
             }
         }
         break;
         case Key_Up:
         {
             if (reader->m_autoScroll)
             {
                 reader->increaseScroll();
             }
             else
             {
                 doAction(e);
             }
         }
         break;
         case Key_Down:
         {
             if (reader->m_autoScroll)
             {
                 reader->reduceScroll();
             }
             else
             {
                 doAction(e);
             }
         }
         break;
             */
         default:
         {
           doAction(e);
         }
         
 /*
         QString msg("Key press was:");
         QString key;
         msg += key.setNum(e->key());
         QMessageBox::information(this, PROGNAME, msg);
 */
     }
     ftime(&m_lastkeytime);
 }
 
 #if defined(USEQPE) && defined(USENEWFULLSCREEN)
 void QTReaderApp::focusInEvent(QFocusEvent *)
 {
   if (m_usenewfullscreen && m_fullscreen && (editorStack->visibleWidget() == reader))
     {
       m_usenewfullscreen = false;
       reader->bDoUpdates = false;
       showEditTools();
       reader->bDoUpdates = true;
       reader->update();
       m_usenewfullscreen = true;
     }
 }
 
 void QTReaderApp::resizeEvent(QResizeEvent *)
 {
   if (m_usenewfullscreen && m_fullscreen && (editorStack->visibleWidget() == reader))
     {
       m_usenewfullscreen = false;
       reader->bDoUpdates = false;
       showEditTools();
       reader->bDoUpdates = true;
       reader->update();
       m_usenewfullscreen = true;
     }
 }
 #endif
 
 void QTReaderApp::showEditTools()
 {
 //    if ( !doc )
         //close();
     if (m_fullscreen)
     {
 #if defined(USEQPE)
         if (menubar != NULL) menubar->hide();
 #endif
         if (fileBar != NULL) fileBar->hide();
         if (viewBar != NULL) viewBar->hide();
         if (navBar != NULL) navBar->hide();
         if (markBar != NULL) markBar->hide();
         if (m_prog != NULL) 
           {
                     //    qDebug("Hiding status");
             m_prog->hide();
           }
         searchBar->hide();
         regBar->hide();
 #ifdef USEQPE
         Global::hideInputMethod();
 #endif
         if (m_scrollbar != NULL) m_scrollbar->hide();
         m_fontBar->hide();
         //showNormal();
         showFullScreen();
   }
     else
     {
         //qDebug("him");
 #ifdef USEQPE
         Global::hideInputMethod();
 #endif
         //qDebug("eb");
         if (m_scrollbar != NULL)
           {
             if (m_scrollishidden)
               {
                 m_scrollbar->hide();
               }
             else
               {
                 m_scrollbar->show();
               }
           }
         if (!m_hidebars)
           {
 #if defined(USEQPE)
             menubar->show();
 #endif
             if (fileBar != NULL) fileBar->show();
             if (viewBar != NULL) viewBar->show();
             if (navBar != NULL) navBar->show();
             if (markBar != NULL) markBar->show();
             if (m_prog != NULL && !m_statusishidden) 
               {
                         //      qDebug("Showing status");
                 m_prog->show();
                         //      qDebug("Shown status");
               }
                     //    qDebug("Showing mb");
             mb->show();
           }
         if ( searchVisible )
         {
 #ifdef USEQPE
             Global::showInputMethod();
 #endif
                 searchBar->show();
         }
         if ( regVisible )
         {
 #ifdef USEQPE
             Global::showInputMethod();
 #endif
                 regBar->show();
         }
         if (m_fontVisible) m_fontBar->show();
         //qDebug("sn");
         showNormal();
         //qDebug("sm");
 #if defined(USEQPE) && !defined(SIMPAD) 
         showMaximized();
 #endif
         //setCentralWidget(reader);
     }
 
     //    qDebug("uc");
     updateCaption();
     //    qDebug("rw");
     editorStack->raiseWidget( reader );
     //    qDebug("sf");
     reader->setFocus();
     //    qDebug("ref");
     //reader->refresh(true);
     //    qDebug("done");
 }
 /*
 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)
 {
 //QMessageBox::information(0, "setDocument", fileref);
     openFile(fileref);
 //    showEditTools();
 }
 
 void QTReaderApp::closeEvent( QCloseEvent *e )
 {
 //    qDebug("Close event");
     if (m_fullscreen)
     {
         m_fullscreen = false;
         showEditTools();
         e->ignore();
     }
     else if (editorStack->visibleWidget() == m_buttonprefs)
       {
-        m_buttonprefs->mapkey(Qt::NoButton, Key_Escape);
+        int ret = QMessageBox::warning(this, PROGNAME,
+tr("Do you wish to map this key?\n\nIf you proceed you will map\nthe escape key and you will\nneed to press the close box\ntwice to exit this program\n\nContinue?"), tr("Yes"), tr("No"), QString::null, 0, 1);
+        if (ret == 0)
+          {
+            m_buttonprefs->mapkey(Qt::NoButton, Key_Escape);
+          }
         e->ignore();
       }
     else if (m_dontSave)
     {
         e->accept();
     }
     else
     {
         if (editorStack->visibleWidget() == reader)
         {
             if ((kmap.find(orKey(Qt::NoButton,Key_Escape,false)) != kmap.end()) && m_bcloseDisabled)
             {
         //qDebug("Close disabled");
                 m_bcloseDisabled = false;
                 e->ignore();
             }
             else
             {
                 if (m_fontVisible)
                 {
                     m_fontBar->hide();
                     m_fontVisible = false;
                     e->ignore();
                     return;
                 }
                 if (regVisible)
                 {
                     regBar->hide();
 #ifdef USEQPE
                     Global::hideInputMethod();
 #endif
                     regVisible = false;
                     e->ignore();
                     return;
                 }
                 if (searchVisible)
                 {
                     searchBar->hide();
 #ifdef USEQPE
                     Global::hideInputMethod();
 #endif
                     searchVisible = false;
                     e->ignore();
                     return;
                 }
                 if (m_fBkmksChanged && pBkmklist != NULL)
                 {
                     if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)
                         savebkmks();
                     delete pBkmklist;
                     reader->pBkmklist = pBkmklist = NULL;
                     m_fBkmksChanged = false;
                 }
                 updatefileinfo();
                 saveprefs();
                 e->accept();
             }
         }
         else
         {
             showEditTools();
             m_disableesckey = true;
         }
     }
 }
 
 void QTReaderApp::do_gotomark()
 {
     m_nBkmkAction = cGotoBkmk;
     if (!listbkmk(pBkmklist))
         QMessageBox::information(this, PROGNAME, "No bookmarks in memory");
 }
 
 void QTReaderApp::do_delmark()
 {
     m_nBkmkAction = cDelBkmk;
     if (!listbkmk(pBkmklist))
         QMessageBox::information(this, PROGNAME, "No bookmarks in memory");
 }
 
 bool QTReaderApp::listbkmk(CList<Bkmk>* plist, const QString& _lab, bool presel)
 {
     bkmkselector->clear();
     if (_lab.isEmpty())
         bkmkselector->setText("Cancel");
     else
         bkmkselector->setText(_lab);
     int cnt = 0;
     int slt = -1;
     if (plist != NULL)
       {
         for (CList<Bkmk>::iterator i = plist->begin(); i != plist->end(); i++)
           {
             if (presel)
               {
                 Bkmk* p = i.pContent();
                 if (toQString(CFiledata(p->anno()).name()) == reader->m_lastfile)
                   {
                     slt = cnt;
                   }
               }
 #ifdef _UNICODE
         //      qDebug("Item:%s", (const char*)toQString(i->name()));
             bkmkselector->insertItem(toQString(i->name()), cnt++);
 #else
             bkmkselector->insertItem(i->name(), cnt++);
 #endif
 
           }
       }
     if (cnt > 0)
       {
           hidetoolbars();
         editorStack->raiseWidget( bkmkselector );
         if (slt != -1) bkmkselector->setCurrentItem(slt);
         return true;
       }
     else
         return false;
 }
 
 void QTReaderApp::do_autogen()
 {
   m_nRegAction = cAutoGen;
   regEdit->setText(m_autogenstr);
   do_regedit();
 }
 
 void QTReaderApp::do_regedit()
 {
 //    fileBar->hide();
     reader->bDoUpdates = false;
 //    qDebug("Showing regbar");
   regBar->show();
 //    qDebug("Showing kbd");
 #ifdef USEQPE
   Global::showInputMethod();
 #endif
   regVisible = true;
   regEdit->setFocus();
 //  qApp->processEvents();
     reader->bDoUpdates = true;
     reader->update();
 }
 
 bool QTReaderApp::openfrombkmk(Bkmk* bk)
 {
     QString fn = toQString(
         CFiledata(bk->anno()).name()
         );
         //qDebug("fileinfo");
     if (!fn.isEmpty() && QFileInfo(fn).isFile())
     {
         //qDebug("Opening");
         struct stat fnstat;
         stat((const char *)fn, &fnstat);
         
         if (CFiledata(bk->anno()).date()
             != fnstat.st_mtime)
         {
             CFiledata fd(bk->anno());
             fd.setdate(fnstat.st_mtime);
             bk->value(0);
             reader->m_lastposn = 0;
             openFile(fn);
         }
         else
         {
             unsigned short svlen = bk->filedatalen();
             unsigned char* svdata = bk->filedata();
             openFile(fn, bk->value());
             reader->putSaveData(svdata, svlen);
         //    setstate(svdata, svlen);
             if (svlen != 0)
             {
                 QMessageBox::warning(this, PROGNAME, "Not all file data used\nNew version?");
             }
         //    qDebug("updating");
         //    showEditTools();
         }
         return true;
     }
     else
     {
         return false;
     }
 }
 
 void QTReaderApp::gotobkmk(int ind)
 {
   qDebug("gbkmk");
     showEditTools();
     switch (m_nBkmkAction)
     {
         case cOpenFile:
         {
         //    qApp->processEvents();
             if (!openfrombkmk((*pOpenlist)[ind]))
             {
                 pOpenlist->erase(ind);
                 QMessageBox::information(this, PROGNAME, "Can't find file");
             }
         }
         break;
         case cGotoBkmk:
             reader->buffdoc.saveposn(reader->m_lastfile, reader->pagelocate());
             reader->locate((*pBkmklist)[ind]->value());
             break;
         case cDelBkmk:
         ////    qDebug("Deleting:%s\n",(*pBkmklist)[ind]->name());
             pBkmklist->erase(ind);
             m_fBkmksChanged = true;
             reader->refresh(true);
         //    pBkmklist->sort();
             break;
         case cRmBkmkFile:
                 {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 d.remove(bkmkselector->text(ind));
 #else /* USEQPE */
                 unlink((const char *)Global::applicationFileName(APPDIR,bkmkselector->text(ind)));
 #endif /* USEQPE */
                 }
             break;
         case cLdConfig:
             readconfig(APPDIR "/configs", bkmkselector->text(ind), false);
             break;
         case cLdTheme:
           m_themename = bkmkselector->text(ind);
           readconfig(QString(APPDIR "/Themes/")+m_themename , "config", false);
           setBackgroundBitmap();
             break;
         case cRmConfig:
                 {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR "/configs");
                 d.remove(bkmkselector->text(ind));
 #else /* USEQPE */
                 unlink((const char *)Global::applicationFileName(APPDIR "/configs",bkmkselector->text(ind)));
 #endif /* USEQPE */
                 }
             break;
         case cExportLinks:
         {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
             d.cd(APPDIR "/urls");
             QFileInfo fi(d, bkmkselector->text(ind));
             if (fi.exists())
             {
                 QString outfile( QFileDialog::getSaveFileName( QString::null, QString::null, this ) );
                 if (!outfile.isEmpty())
                 {
                     FILE* fout = fopen((const char *)outfile, "w");
                     if (fout != NULL)
                     {
                         FILE* fin = fopen((const char *)fi.absFilePath(), "r");
                         if (fin != NULL)
                         {
                             fprintf(fout, "<html><body>\n");
                             int ch = 0;
                             while ((ch = fgetc(fin)) != EOF)
                             {
                                 fputc(ch, fout);
                             }
                             fclose(fin);
                             fprintf(fout, "</html></body>\n");
                             d.remove(bkmkselector->text(ind));
                         }
                         fclose(fout);
                     }
                     else
                         QMessageBox::information(this, PROGNAME, "Couldn't open output");
                 }
             }
 #else /* USEQPE */
             FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");
             if (fin != NULL)
             {
                 bool allok = false;
 #if defined(OPIE) && defined(OPIEFILEDIALOG)
                 QString outfile = OFileDialog::getSaveFileName(OFileSelector::EXTENDED_ALL, QString::null, QString::null, MimeTypes(), 0, "OpieReader");
                 if (!outfile.isEmpty())
                 {
                     FILE* fout = fopen((const char *)outfile, "w");
                     if (fout != NULL)
                     {
                         fprintf(fout, "<html><body>\n");
                         int ch = 0;
                         while ((ch = fgetc(fin)) != EOF)
                         {
                             fputc(ch, fout);
                         }
                         fprintf(fout, "</html></body>\n");
                         fclose(fout);
                         allok = true;
                     }
                     else
                         QMessageBox::information(this, PROGNAME, "Couldn't open output");
                 }
                 fclose(fin);
                 if (allok) unlink((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)));
 #else
                 fileBrowser* fb = new fileBrowser(true, this,"OpieReader",!m_bFloatingDialog, 0, "*", QString::null);
                 if (fb->exec())
                 {
                     QString outfile = fb->getCurrentFile();
                     FILE* fout = fopen((const char *)outfile, "w");
                     if (fout != NULL)
                     {
                         fprintf(fout, "<html><body>\n");
                         int ch = 0;
                         while ((ch = fgetc(fin)) != EOF)
                         {
                             fputc(ch, fout);
                         }
                         fprintf(fout, "</html></body>\n");
                         fclose(fout);
                         allok = true;
                     }
                     else
                         QMessageBox::information(this, PROGNAME, "Couldn't open output");
                 }
                 delete fb;
                 fclose(fin);
                 if (allok) unlink((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)));
 #endif
             }
             else
             {
                 QMessageBox::information(this, PROGNAME, "Couldn't open input");
             }
 
 /*
             CFileSelector *f = new CFileSelector("text/html", this, NULL, !m_bFloatingDialog, TRUE, TRUE );
             int ret = f->exec();
             qDebug("Return:%d", ret);
             DocLnk* doc = f->getDoc();
             if (doc != NULL)
             {
                 FILE* fin = fopen((const char *)Global::applicationFileName(APPDIR "/urls",bkmkselector->text(ind)), "r");
                 QString rt;
                 rt = "<html><body>\n";
                 int ch = 0;
                 while ((ch = fgetc(fin)) != EOF)
                 {
                     rt += (char)ch;
                 }
                 fclose(fin);
                 rt += "</html></body>\n";
                 if ( doc->name().isEmpty() )
                 {
                     doc->setName(bkmkselector->text(ind));
                 }
                 FileManager fm;
                 fm.saveFile( *doc, rt );
                 qDebug("YES");
             }
             else
             {
                 qDebug("NO");
             }
             delete f;
 */
 
 #endif /* USEQPE */
         }
         break;
     }
 }
 
 void QTReaderApp::cancelbkmk()
 {
     if (m_nBkmkAction == cOpenFile)
     {
         QString fn = usefilebrowser();
         if (!fn.isEmpty() && QFileInfo(fn).isFile()) openFile(fn);
     }
   showEditTools();
 }
 
 void QTReaderApp::reparastring()
 {
   m_nRegAction = cRepara;
   regEdit->setText(reader->m_reparastring);
   do_regedit();
 }
 
 void QTReaderApp::do_reparastring(const QString& _lcn)
 {
   reader->m_reparastring = _lcn;
   if (reader->brepara)
     {
       reader->bDoUpdates = true;
       reader->setfilter(reader->getfilter());
     }
 }
 
 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;
     QString lcn = _lcn.stripWhiteSpace();
     unsigned long ulcn = lcn.toULong(&ok);
     if (!ok)
       {
         double pc = 0.0;
 #ifdef _WINDOWS
         if (lcn.at(lcn.length()-1) == '%')
 #else
         if (lcn[lcn.length()-1] == '%')
 #endif
         {
             lcn = lcn.left(lcn.length()-1);
             pc = lcn.toDouble(&ok);
           }
         else
           {
             pc = lcn.toDouble(&ok);
           }
         if (ok && 0 <= pc && pc <= 100)
           {
             ulcn = (pc*(reader->buffdoc.endSection()-reader->buffdoc.startSection()))/100 + reader->buffdoc.startSection();
           }
         else
           {
             ok = false;
           }
       }
     if (ok)
         reader->locate(ulcn);      
     else
         QMessageBox::information(this, PROGNAME, "Must be a number\nor a percentage");
 }
 
 void QTReaderApp::do_regaction()
 {
     reader->bDoUpdates = false;
   regBar->hide();
 #ifdef USEQPE
   Global::hideInputMethod();
 #endif
   regVisible = false;
   switch(m_nRegAction)
   {
       case cAutoGen:
           do_autogen(regEdit->text());
           break;
       case cAddBkmk:
           do_addbkmk(regEdit->text());
           break;
       case cRepara:
         do_reparastring(regEdit->text());
         break;
       case cJump:
           do_jump(regEdit->text());
           break;
 /*
       case cMonoSpace:
           do_mono(regEdit->text());
           break;
 */
       case cSetTarget:
           do_settarget(regEdit->text());
           break;
 #ifdef _SCROLLPIPE
       case cSetPipeTarget:
           do_setpipetarget(regEdit->text());
           break;
 #endif
       case cSetConfigName:
         //  qDebug("Saving config");
           do_saveconfig(regEdit->text(), false);
           break;
   }
 //  reader->restore();
 //    fileBar->show();
   reader->setFocus();
 //    qApp->processEvents();
     reader->bDoUpdates = true;
     reader->update();
 }
 
 void QTReaderApp::do_settarget(const QString& _txt)
 {
     int ind = _txt.find('/');
     if (ind == -1)
     {
         m_targetapp = "";
         m_targetmsg = "";
         QMessageBox::information(this, PROGNAME, "Format is\nappname/messagename");
     }
     else
     {
         m_targetapp = _txt.left(ind);
         m_targetmsg = _txt.right(_txt.length()-ind-1);
     }
 }
 
 void QTReaderApp::chooseencoding()
 {
     m_fontSelector->clear();
     m_fontSelector->insertItem("Ascii");
     m_fontSelector->insertItem("UTF-8");
     m_fontSelector->insertItem("UCS-2(BE)");
     m_fontSelector->insertItem("USC-2(LE)");
     m_fontSelector->insertItem("Palm");
     for (unicodetable::iterator iter = unicodetable::begin(); iter != unicodetable::end(); iter++)
     {
         m_fontSelector->insertItem(iter->mime);
     } // delete the FontDatabase!!!
     m_fontSelector->setCurrentItem (reader->m_encd);
     m_fontAction = cChooseEncoding;
     m_fontBar->show();
     m_fontVisible = true;
 }
 
 void QTReaderApp::setfont()
 {
     m_fontSelector->clear();
     {
         QFontDatabase f;
         QStringList flist = f.families();
         m_fontSelector->insertStringList(flist);
     } // delete the FontDatabase!!!
 
     for (int i = 1; i <= m_fontSelector->count(); i++)
     {
         if (m_fontSelector->text(i) == reader->m_fontname)
         {
             m_fontSelector->setCurrentItem(i);
             break;
         }
     }
     m_fontAction = cChooseFont;
     m_fontBar->show();
     m_fontVisible = true;
 }
 
 void QTReaderApp::setfontHelper(const QString& lcn, int size)
 {
     if (size == 0) size = reader->m_fontControl.currentsize();
     if (m_propogatefontchange)
     {
         QFont f(lcn, 10);
         bkmkselector->setFont( f );
         regEdit->setFont( f );
         searchEdit->setFont( f );
         m_annoWin->setFont( f );
     }
     reader->m_fontname = lcn;
     if (!reader->ChangeFont(size))
     {
         reader->ChangeFont(size);
     }
 }
 
 void QTReaderApp::do_setencoding(int i)
 {
     qDebug("setencoding:%d", i);
     if (m_fontAction == cChooseEncoding)
     {
         reader->setencoding(i);
     }
     reader->refresh();
     m_fontBar->hide();
     m_fontVisible = false;
 //    qDebug("showedit");
     if (reader->isVisible()) showEditTools();
 //    qDebug("showeditdone");
 }
 
 void QTReaderApp::do_setfont(const QString& lcn)
 {
     if (m_fontAction == cChooseFont)
     {
         setfontHelper(lcn);
     }
     reader->refresh();
     m_fontBar->hide();
     m_fontVisible = false;
     //    qDebug("setfont");
     //if (reader->isVisible())
     showEditTools();
 //    qDebug("showeditdone");
 }
 
 void QTReaderApp::do_autogen(const QString& regText)
 {
     unsigned long fs, ts;
     reader->sizes(fs,ts);
 //  //  qDebug("Reg:%s\n", (const tchar*)(regEdit->text()));
   m_autogenstr = regText;
   QRegExp re(regText);
   CBuffer buff;
   if (pBkmklist != NULL) delete pBkmklist;
   reader->pBkmklist = pBkmklist = new CList<Bkmk>;
   m_fBkmksChanged = true;
 
   pbar->setGeometry(regBar->x(),regBar->y(),regBar->width(), regBar->height());
   pbar->show();
   pbar->raise();
   pbar->reset();
   reader->update();
   qApp->processEvents();
   reader->setFocus();
   reader->jumpto(0);
   int lastpc = 0;
   int i = 0;
   unsigned int llcn = reader->locate();
   while (i >= 0)
     {
       unsigned int lcn = llcn;
       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));
       /*
       llcn = reader->locate();
       if ((i == 0) && (llcn+1 < ts))
         {
           reader->jumpto(++llcn);
           i = 1;
         }
       */
     }
   pBkmklist->sort();
   pbar->setProgress(100);
   qApp->processEvents();
   pbar->hide();
   reader->refresh();
 }
 
 void QTReaderApp::saveprefs()
 {
   do_saveconfig( APPDIR, true );
   savefilelist();
 }
 
 /*
 void QTReaderApp::oldFile()
 {
 //  qDebug("oldFile called");
   reader->setText(true);
 //  qDebug("settext called");
   showEditTools();
 //  qDebug("showedit called");
 }
 */
 
 /*
 void info_cb(Fl_Widget* o, void* _data)
 {
 
     if (infowin == NULL)
     {
         
         infowin = new Fl_Window(160,240);
         filename = new Fl_Output(45,5,110,14,"Filename");
         filesize = new Fl_Output(45,25,110,14,"Filesize");
         textsize = new Fl_Output(45,45,110,14,"Textsize");
         comprat = new CBar(45,65,110,14,"Ratio %");
         posn = new Fl_Output(45,85,110,14,"Location");
         frcn = new CBar(45,105,110,14,"% Read");
         about = new Fl_Multiline_Output(5,125,150,90);
         about->value("TWReader - $Name$\n\nA file reader program for the Agenda\n\nReads text, PalmDoc and ppms format files");
         Fl_Button *jump_accept = new Fl_Button(62,220,35,14,"Okay");
         infowin->set_modal();
     }
     if (((reader_ui *)_data)->g_filename[0] != '\0')
     {
         unsigned long fs,ts;
         tchar sz[20];
         ((reader_ui *)_data)->input->sizes(fs,ts);
         unsigned long pl = ((reader_ui *)_data)->input->locate();
 
         filename->value(((reader_ui *)_data)->g_filename);
 
         sprintf(sz,"%u",fs);
         filesize->value(sz);
 
         sprintf(sz,"%u",ts);
         textsize->value(sz);
 
         comprat->value(100-(100*fs + (ts >> 1))/ts);
 
         sprintf(sz,"%u",pl);
         posn->value(sz);
 
         frcn->value((100*pl + (ts >> 1))/ts);
     }
     infowin->show();
 }
 */
 
 void QTReaderApp::savebkmks()
 {
     if (pBkmklist != NULL)
     {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 QFileInfo fi(d, reader->m_string);
         BkmkFile bf((const char *)fi.absFilePath(), true, true);
 #else /* USEQPE */
         BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string), true, true);
 #endif /* USEQPE */
         bf.write(*pBkmklist);
     }
         m_fBkmksChanged = false;
 }
 
 void QTReaderApp::readfilelist()
 {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 QFileInfo fi(d, ".openfiles");
     BkmkFile bf((const char *)fi.absFilePath(), false, false);
 #else /* USEQPE */
     BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"), false, false);
 #endif /* USEQPE */
 //    qDebug("Reading open files");
     pOpenlist = bf.readall();
 //    if (pOpenlist != NULL) qDebug("...with success");
 //    else qDebug("...without success!");
 }
 
 void QTReaderApp::savefilelist()
 {
     if (pOpenlist != NULL)
     {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 QFileInfo fi(d, ".openfiles");
         BkmkFile bf((const char *)fi.absFilePath(), true, false);
 #else /* USEQPE */
         BkmkFile bf((const char *)Global::applicationFileName(APPDIR,".openfiles"), true, false);
 #endif /* USEQPE */
         //qDebug("Writing open files");
         bf.write(*pOpenlist);
     }
 }
 
 void QTReaderApp::readbkmks()
 {
     if (pBkmklist != NULL)
     {
             delete pBkmklist;
     }
     struct stat fnstat;
     struct stat bkstat;
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 QFileInfo fi(d, reader->m_string);
 #endif /* ! USEQPE */
     if (
         stat((const char *)reader->m_lastfile, &fnstat) == 0
         &&
 #ifndef USEQPE
         stat((const char *)fi.absFilePath(), &bkstat) == 0
 #else /* USEQPE */
         stat((const char *)Global::applicationFileName(APPDIR,reader->m_string), &bkstat) == 0
 #endif /* USEQPE */
         )
     {
         if (bkstat.st_mtime < fnstat.st_mtime)
         {
 #ifndef USEQPE
             unlink((const char *)fi.absFilePath());
 #else /* USEQPE */
             unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));
 #endif /* USEQPE */
         }
     }
 
 #ifndef USEQPE
     BkmkFile bf((const char *)fi.absFilePath(), false, true);
 #else /* USEQPE */
     BkmkFile bf((const char *)Global::applicationFileName(APPDIR,reader->m_string), false, true);
 #endif /* USEQPE */
 
     reader->pBkmklist = pBkmklist = bf.readall();
     m_fBkmksChanged = bf.upgraded();
     if (pBkmklist == NULL)
     {
         reader->pBkmklist = 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) reader->pBkmklist = 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();
                 reader->refresh(true);
         }
 }
 
 void QTReaderApp::UpdateStatus()
 {
   QString status;
   for (int i = 0; i < m_statusstring.length(); i++)
     {
       if (m_statusstring[i].unicode() == '%')
         {
           i++;
           if (i < m_statusstring.length())
             {
               switch (m_statusstring[i].unicode())
                 {
                 case 'F':
                   {
                     unsigned long fs,ts;
                     reader->sizes(fs,ts);
                     status += filesize(ts);
                   }
                   break;
                 case 'f':
                   {
                     status += filesize(reader->pagelocate());
                   }
                   break;
                 case 'D':
                   {
                     status += filesize(reader->buffdoc.endSection()-reader->buffdoc.startSection());
                   }
                   break;
                 case 'd':
                   {
                     status += filesize(reader->pagelocate()-reader->buffdoc.startSection());
                   }
                   break;
                 case 'P':
                   {
                     unsigned long fs,ts;
                     reader->sizes(fs,ts);
                     status += percent(reader->pagelocate(),ts);
                   }
                   break;
                 case 'p':
                   {
                     status += percent(reader->pagelocate()-reader->buffdoc.startSection(),reader->buffdoc.endSection()-reader->buffdoc.startSection());
                   }
                   break;
                 case 'z':
                   {
                             //    qDebug("case d");
                     status += QString().setNum(reader->m_fontControl.currentsize()*10);
                   }
                   break;
                 default:
                   status += m_statusstring[i];
                 }
             }
         }
       else
         {
           status += m_statusstring[i];
         }
     }
   m_prog->setText(status);
 }
 
 void QTReaderApp::OnRedraw()
 {
   if ((pBkmklist != NULL) && (m_bkmkAvail != NULL))
     {
       bool found = findNextBookmark(reader->pagelocate());
       m_bkmkAvail->setEnabled(found);
     }
   if (m_scrollbar != NULL)
     {
       //qDebug("OnRedraw:[%u, %u]", reader->buffdoc.startSection(), reader->buffdoc.endSection());
       scrollbar->setRange(reader->buffdoc.startSection(), reader->buffdoc.endSection()-1);
       scrollbar->setPageStep(reader->locate()-reader->pagelocate());
       scrollbar->setValue((reader->m_rotated) ? 
                           (reader->buffdoc.endSection() - reader->locate()+reader->buffdoc.startSection()) :
                           reader->pagelocate());
     }
   if (m_prog->isVisible())
     {
       //      qDebug("updating status");
       UpdateStatus();
       //      qDebug("updated status");
     }
 }
 
 void QTReaderApp::showAnnotation()
 {
     m_annoWin->setName(toQString(m_anno->name()));
     m_annoWin->setAnno(toQString(m_anno->anno()));
     m_annoWin->setColor(QColor(m_anno->red(), m_anno->green(), m_anno->blue()));
     m_annoIsEditing = false;
 #ifdef USEQPE
     Global::showInputMethod();
 #endif
     editorStack->raiseWidget( m_annoWin );
     hidetoolbars();
     m_annoWin->setFocus();
 }
 
 void QTReaderApp::OnWordSelected(const QString& wrd, size_t posn, size_t posn2, const QString& line)
 {
 ////    qDebug("OnWordSelected(%u):%s", posn, (const char*)wrd);
 
     if (m_doOutput && reader->checkoutput())
       {
         reader->doOutput(wrd);
       }
     if (m_doClipboard)
     {
         QClipboard* cb = QApplication::clipboard();
         cb->setText(wrd);
 #ifdef USEQPE
         if (wrd.length() > 10)
         {
             Global::statusMessage(wrd.left(8) + "..");
         }
         else
         {
             Global::statusMessage(wrd);
         }
 #endif
     }
     if (m_doAnnotation)
     {
         //addAnno(wrd, "Need to be able to edit this", posn);
         m_annoWin->setName(line);
         m_annoWin->setAnno("");
         m_annoWin->setPosn(posn);
         m_annoWin->setPosn2(posn2);
         m_annoIsEditing = true;
 #ifdef USEQPE
         Global::showInputMethod();
 #endif
         editorStack->raiseWidget( m_annoWin );
         hidetoolbars();
     }
 #ifdef USEQPE
     if (m_doDictionary)
     {
         if (!m_targetapp.isEmpty() && !m_targetmsg.isEmpty())
         {
             QCopEnvelope e(("QPE/Application/"+m_targetapp).utf8(), (m_targetmsg+"(QString)").utf8());
             e << wrd;
         }
     }
 #endif
 }
 
 void QTReaderApp::doAction(QKeyEvent* e)
 {
   QMap<orKey,int>::Iterator f = kmap.end();
 
   if (reader->m_autoScroll)
     {
       f = kmap.find(orKey(e->state(), e->key(), true));
     }
   if (f == kmap.end())
     {
       f = kmap.find(orKey(e->state(), e->key(), false));
     }
 
     if (f == kmap.end())
     {
       qDebug("doaction (no action) : %d %d %d", e->key(), e->state(), f.data());
         e->ignore();
     }
     else
     {
       qDebug("doaction (some action) : %d %d %d", e->key(), e->state(), f.data());