Fix copying unicode block to clipboard. See bug #1766. Patch from polyonymous.

1 files changed, 1 insertions, 1 deletions

diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp
index b985094..4f0f0a1 100644
--- a/noncore/apps/opie-reader/QTReaderApp.cpp
+++ b/noncore/apps/opie-reader/QTReaderApp.cpp
@@ -1537,2049 +1537,2049 @@ void QTReaderApp::msgHandler(const QCString& _msg, const QByteArray& _data)
         OnClipboard(info);
     }
     else if ( msg == "File/Find(QString)" )
     {
         QString info;
         stream >> info;
         QRegExp arg(info);
         size_t pos = reader->pagelocate();
         size_t start = pos;
         CDrawBuffer test(&(reader->m_fontControl));
         reader->getline(&test);
         while (arg.match(toQString(test.data())) == -1)
         {
             pos = reader->locate();
             if (!reader->getline(&test))
             {
                 QMessageBox::information(this, PROGNAME, QString("Can't find\n")+info);
                 pos = start;
                 break;
             }
         }
         reader->locate(pos);
     }
     else if ( msg == "File/Fullscreen(int)" )
     {
         int info;
         stream >> info;
         setfullscreen(info);
     }
     else if ( msg == "File/Continuous(int)" )
     {
         int info;
         stream >> info;
         setcontinuous(info);
     }
     else if ( msg == "Markup(QString)" )
     {
         QString info;
         stream >> info;
         if (info == "Auto")
         {
             autofmt(true);
         }
         if (info == "None")
         {
             autofmt(false);
             textfmt(false);
             striphtml(false);
             peanut(false);
         }
         if (info == "Text")
         {
             textfmt(true);
         }
         if (info == "HTML")
         {
             striphtml(true);
         }
         if (info == "Peanut/PML")
         {
             peanut(true);
         }
     }
     else if ( msg == "Layout/StripCR(int)" )
     {
         int info;
         stream >> info;
         stripcr(info);
     }
     else if ( msg == "Layout/Dehyphen(int)" )
     {
         int info;
         stream >> info;
         dehyphen(info);
     }
     else if ( msg == "Layout/Depluck(int)" )
     {
         int info;
         stream >> info;
         depluck(info);
     }
     else if ( msg == "Layout/Dejpluck(int)" )
     {
         int info;
         stream >> info;
         dejpluck(info);
     }
     else if ( msg == "Layout/SingleSpace(int)" )
     {
         int info;
         stream >> info;
         onespace(info);
     }
     else if ( msg == "Layout/Repalm(int)" )
     {
         int info;
         stream >> info;
         repalm(info);
     }
     else if ( msg == "Layout/Unindent(int)" )
     {
         int info;
         stream >> info;
         unindent(info);
     }
     else if ( msg == "Layout/Re-paragraph(int)" )
     {
         int info;
         stream >> info;
         repara(info);
     }
     else if ( msg == "Layout/DoubleSpace(int)" )
     {
         int info;
         stream >> info;
         dblspce(info);
     }
     else if ( msg == "Layout/Indent(int)" )
     {
         int info;
         stream >> info;
         reader->bindenter = info;
         reader->setfilter(reader->getfilter());
     }
     else if ( msg == "Layout/Remap(int)" )
     {
         int info;
         stream >> info;
         remap(info);
     }
     else if ( msg == "Layout/Embolden(int)" )
     {
         int info;
         stream >> info;
         embolden(info);
     }
     else if ( msg == "Format/Ideogram/Word(int)" )
     {
         int info;
         stream >> info;
         monospace(info);
     }
     else if ( msg == "Format/SetWidth(int)" )
     {
         int info;
         stream >> info;
         reader->m_charpc = info;
         reader->setfont();
         reader->refresh();
     }
     else if ( msg == "Format/SetFont(QString,int)" )
     {
         QString fontname;
         int size;
         stream >> fontname;
         stream >> size;
         setfontHelper(fontname, size);
     }
     else if ( msg == "Marks/Autogen(QString)" )
     {
         QString info;
         stream >> info;
         do_autogen(info);
     }
     else if ( msg == "File/StartBlock()" )
     {
         editMark();
     }
     else if ( msg == "File/CopyBlock()" )
     {
         editCopy();
     }
     */
 #endif
 }
 
 ActionTypes QTReaderApp::ActNameToInt(const QString& _enc)
 {
     for (int i = 0; i < MAX_ACTIONS; i++)
     {
         if (m_buttonAction[i]->text() == _enc) return (ActionTypes)i;
     }
     return cesAutoScroll;
 }
 
 void QTReaderApp::setinverted(bool sfs)
 {
   reader->setInverse(sfs);
   reader->setfilter(reader->getfilter());
   reader->refresh();
 }
 
 void QTReaderApp::setrotated(bool sfs)
 {
     reader->setrotated(sfs);
     if (sfs)
       {
         m_layout->setDirection( (m_qtscroll == 2) ? QBoxLayout::BottomToTop : QBoxLayout::TopToBottom );
         if (m_scrollbar != NULL)
           {
             scrollbar->disconnect();
             m_scrollbar->setOrientation(Qt::Horizontal);
             connect(scrollbar, SIGNAL(nextLine()), reader, SLOT(lineUp()) );
             connect(scrollbar, SIGNAL(prevLine()), reader, SLOT(lineDown()) );
             connect(scrollbar, SIGNAL(nextPage()), reader, SLOT(dopageup()) );
             connect(scrollbar, SIGNAL(prevPage()), reader, SLOT(dopagedn()) );
             connect(scrollbar, SIGNAL(sliderMoved(int)), this, SLOT(actionscroll(int)) );
           }
                 //reader->repaint(0, reader->m_left_border, reader->width(), reader->height()-2*reader->m_border);
       }
     else
       {
         m_layout->setDirection( (m_qtscroll == 2) ? QBoxLayout::RightToLeft : QBoxLayout::LeftToRight );
         if (m_scrollbar != NULL)
           {
             scrollbar->disconnect();
             m_scrollbar->setOrientation(Qt::Vertical);
             connect(scrollbar, SIGNAL(nextLine()), reader, SLOT(lineDown()) );
             connect(scrollbar, SIGNAL(prevLine()), reader, SLOT(lineUp()) );
             connect(scrollbar, SIGNAL(nextPage()), reader, SLOT(dopagedn()) );
             connect(scrollbar, SIGNAL(prevPage()), reader, SLOT(dopageup()) );
             connect(scrollbar, SIGNAL(sliderMoved(int)), this, SLOT(actionscroll(int)) );
           }
                 //reader->repaint(reader->m_border, 0, reader->width()-2*reader->m_border, reader->height());
       }
     reader->refresh();
 }
 
 void QTReaderApp::setgrab(bool sfs)
 {
 #ifdef USEQPE
   m_grabkeyboard = sfs;
   if (m_grabkeyboard)
     {
       ((QPEApplication*)qApp)->grabKeyboard();
     }
   else
     {
       ((QPEApplication*)qApp)->ungrabKeyboard();
     }
 #endif
 }
 
 void QTReaderApp::setfullscreen(bool sfs)
 {
     reader->bDoUpdates = false;
     m_fullscreen = sfs;
     showEditTools();
 //    qApp->processEvents();
     reader->bDoUpdates = true;
     reader->update();
 }
 /*
 void QTReaderApp::buttonActionSelected(QAction* _a)
 {
 ////    qDebug("es:%x : %s (%u)", _a, (const char *)(_a->text()), ActNameToInt(_a->text()));
     m_spaceTarget = ActNameToInt(_a->text());
 }
 */
 QTReaderApp::~QTReaderApp()
 {
 }
 
 void QTReaderApp::autoScroll(bool _b)
 {
     reader->setautoscroll(_b);
     setScrollState(reader->m_autoScroll);
 }
 
 void QTReaderApp::zoomin()
 {
     reader->zoomin();
     QFont f(reader->m_fontname, reader->m_fontControl.getsize(0));
     m_prog->setFont( f );
 }
 
 void QTReaderApp::zoomout()
 {
     reader->zoomout();
     QFont f(reader->m_fontname, reader->m_fontControl.getsize(0));
     m_prog->setFont( f );
 }
 
 void QTReaderApp::clearBkmkList()
 {
         delete pBkmklist;
         reader->pBkmklist = pBkmklist = NULL;
         m_fBkmksChanged = false;
     reader->refresh(true);
 }
 
 void QTReaderApp::fileClose()
 {
     CCloseDialog* cd = new CCloseDialog(reader->m_string, false, this);
     if (cd->exec())
     {
         if (pOpenlist != NULL)
         {
             int ind = 0;
             Bkmk* p = (*pOpenlist)[ind];
             while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)
             {
                 p = (*pOpenlist)[++ind];
             }
             if (p != NULL) pOpenlist->erase(ind);
             if (cd->delFile())
             {
                 unlink((const char*)reader->m_lastfile);
             }
             if (cd->delMarks())
             {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR);
                 d.remove(reader->m_string);
 #else /* USEQPE */
                 unlink((const char *)Global::applicationFileName(APPDIR,reader->m_string));
 #endif /* USEQPE */
             }
             if (cd->delConfig())
             {
 #ifndef USEQPE
             QDir d = QDir::home();                      // "/"
                 d.cd(APPDIR "/configs");
                 d.remove(reader->m_string);
 #else /* USEQPE */
                 unlink((const char *)Global::applicationFileName(APPDIR "/configs",reader->m_string));
 #endif /* USEQPE */
             }
         }
     
         fileOpen2();
     }
     delete cd;
 }
 
 void QTReaderApp::updatefileinfo()
 {
     if (reader->m_string.isEmpty()) return;
     if (reader->m_lastfile.isEmpty()) return;
     tchar* nm = fromQString(reader->m_string);
     tchar* fl = fromQString(reader->m_lastfile);
 //    qDebug("Lastfile:%x", fl);
     bool notadded = true;
     if (pOpenlist == NULL) pOpenlist = new CList<Bkmk>;
     else
     {
         for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)
         {
             if (ustrcmp(CFiledata(iter->anno()).name(), fl) == 0)
             {
                 iter->value(reader->pagelocate());
                 unsigned short dlen;
                 unsigned char* data;
                 CFiledata fd(iter->anno());
                 reader->setSaveData(data, dlen, fd.content(), fd.length());
         //      qDebug("Filedata(1):%u, %u", fd.length(), dlen);
         //      getstate(data, dlen);
                 iter->setAnno(data, dlen);
                 notadded = false;
                 delete [] data;
                 break;
             }
         }
     }
 //    qDebug("Added?:%x", notadded);
     if (notadded)
     {
         struct stat fnstat;
         stat((const char *)reader->m_lastfile, &fnstat);
         CFiledata fd(fnstat.st_mtime, fl);
         unsigned short dlen;
         unsigned char* data;
         reader->setSaveData(data, dlen, fd.content(), fd.length());
         pOpenlist->push_front(Bkmk(nm, data, dlen, reader->pagelocate()));
         //qDebug("Filedata(2):%u, %u", fd.length(), dlen);
         delete [] data;
     }
     delete [] nm;
     delete [] fl;
 }
 
 void QTReaderApp::fileOpen()
 {
 /*
     menu->hide();
     fileBar->hide();
     if (regVisible) regBar->hide();
     if (searchVisible) searchBar->hide();
 */
 //    qDebug("fileOpen");
 //    if (!reader->m_lastfile.isEmpty())
     updatefileinfo();
     fileOpen2();
 }
 
 void QTReaderApp::fileOpen2()
 {
     if (pBkmklist != NULL)
     {
         if (m_fBkmksChanged)
         {
             if (QMessageBox::warning(this, PROGNAME, "Save bookmarks?", "Save", "Don't bother") == 0)
                 savebkmks();
         }     
         delete pBkmklist;
         reader->pBkmklist = pBkmklist = NULL;
         m_fBkmksChanged = false;
     }
     reader->disableAutoscroll();
 /*
     editorStack->raiseWidget( fileSelector );
     fileSelector->reread();
 */
     bool usebrowser = true;
     if (pOpenlist != NULL)
     {
         m_nBkmkAction = cOpenFile;
         if (listbkmk(pOpenlist, "Browse", true)) usebrowser = false;
     }
     if (usebrowser)
     {
         QString fn = usefilebrowser();
         //qApp->processEvents();
         if (!fn.isEmpty() && QFileInfo(fn).isFile())
         {
             openFile(fn);
         }
         reader->setFocus();
     }
 //    reader->refresh();
 //    qDebug("HEIGHT:%d", reader->m_lastheight);
 }
 
 QString QTReaderApp::usefilebrowser()
 {
 #ifndef USEQPE
     QString s( QFileDialog::getOpenFileName( reader->m_lastfile, QString::null, this ) );
     return s;
 #else
     QString fn;
 #if defined(OPIE) && defined(OPIEFILEDIALOG)
     QMap<QString, QStringList> mimeTypes;
     QStringList etypes;
     etypes << "etext/*";
     mimeTypes.insert( tr("eText"), etypes );
     QStringList types;
     types << "text/*";
     mimeTypes.insert( tr("Text"), types );
     mimeTypes.insert( tr("All"), "*/*" );
     fn = OFileDialog::getOpenFileName(OFileSelector::EXTENDED_ALL, QFileInfo(reader->m_lastfile).dirPath(true), QString::null, mimeTypes, 0, "OpieReader");
 #else
     fileBrowser* fb = new fileBrowser(false, this,"OpieReader",!m_bFloatingDialog,
                                       0,
         //                            WStyle_Customize | WStyle_NoBorderEx,
                                       "*", QFileInfo(reader->m_lastfile).dirPath(true));
 
 
     if (fb->exec())
     {
         fn = fb->getCurrentFile();
     }
 //    qDebug("Selected %s", (const char*)fn);
     delete fb;
 #endif
     showEditTools();
     return fn;
 #endif
 }
 
 void QTReaderApp::showgraphic(QImage& pm)
 {
     m_graphicwin->setImage(pm);
     editorStack->raiseWidget( m_graphicwin );
     hidetoolbars();
     m_graphicwin->setFocus();
 }
 
 void QTReaderApp::showbuttonprefs()
 {
     editorStack->raiseWidget( m_buttonprefs );
     hidetoolbars();
     m_buttonprefs->setFocus();
     m_kmapchanged = true;
 }
 
 void QTReaderApp::showprefs()
 {
     CPrefs* prefwin = new CPrefs(reader->width(), !m_bFloatingDialog, this);
 
     //    prefwin->Debounce(m_debounce);
     prefwin->bgtype(m_bgtype);
     prefwin->repalm(reader->brepalm);
     prefwin->UnderlineLink(reader->bunderlineLink);
     prefwin->kern(reader->bkern);
     prefwin->hyphenate(reader->hyphenate);
     //    prefwin->customhyphen(reader->buffdoc.getCustomHyphen());
     prefwin->scrolltype(reader->m_scrolltype);
     prefwin->scrollstep(reader->m_scrollstep);
     prefwin->scrollcolor(m_scrollcolor);
     prefwin->minibarcol(m_scrollbarcolor);
     prefwin->foreground(m_foreground);
     prefwin->background(m_background);
     prefwin->twotouch(m_twoTouch); 
     prefwin->propfontchange(m_propogatefontchange);
     prefwin->StripCR(reader->bstripcr);
     prefwin->InlineTables(!reader->bNoInlineTables);
     prefwin->Dehyphen(reader->bdehyphen);
     prefwin->SingleSpace(reader->bonespace);
     prefwin->Unindent(reader->bunindent);
     prefwin->Reparagraph(reader->brepara);
     prefwin->DoubleSpace(reader->bdblspce);
     prefwin->Remap(reader->bremap);
     prefwin->Embolden(reader->bmakebold);
     prefwin->FullJustify(reader->bfulljust);
     //    prefwin->Inverse(reader->bInverse);
     //    prefwin->Negative(reader->bNegative);
     prefwin->FixGraphics(reader->m_fontControl.FixGraphics());
     prefwin->ParaLead(reader->getextraspace());
     prefwin->LineLead(reader->getlead());
     prefwin->TopMargin(reader->m_abstopmargin);
     prefwin->BottomMargin(reader->m_absbottommargin);
     prefwin->LeftMargin(reader->m_absleft_border);
     prefwin->RightMargin(reader->m_absright_border);
     prefwin->Indent(reader->bindenter);
     if (reader->bautofmt)
     {
         prefwin->Markup(0);
     }
     else if (reader->btextfmt)
     {
         prefwin->Markup(2);
     }
     else if (reader->bstriphtml)
     {
         prefwin->Markup(3);
     }
     else if (reader->bpeanut)
     {
         prefwin->Markup(4);
     }
     else
     {
         prefwin->Markup(1);
     }
     prefwin->Depluck(reader->bdepluck);
     prefwin->Dejpluck(reader->bdejpluck);
     prefwin->Continuous(reader->m_continuousDocument);
     prefwin->DoubleBuffer(reader->m_doubleBuffered);
 
     prefwin->dictApplication(m_targetapp);
     prefwin->dictMessage(m_targetmsg);
 
     /*
     prefwin->leftScroll(m_leftScroll);
     prefwin->rightScroll(m_rightScroll);
     prefwin->upScroll(m_upScroll);
     prefwin->downScroll(m_downScroll);
     */
 
     prefwin->miscannotation(m_doAnnotation);
     prefwin->miscdictionary(m_doDictionary);
     prefwin->miscclipboard(m_doClipboard);
     prefwin->miscoutput(m_doOutput);
 
     prefwin->SwapMouse(reader->m_swapmouse);
 
     prefwin->Font(reader->m_fontname);
 
     prefwin->gfxsize(reader->getBaseSize());
 
     prefwin->pageoverlap(reader->m_overlap);
 
     prefwin->ideogram(reader->m_bMonoSpaced);
 
     prefwin->encoding(reader->m_encd);
 
     prefwin->ideogramwidth(reader->m_charpc);
 
     prefwin->outcodec(reader->m_outputName);
 
     if (prefwin->exec())
     {
       //      m_debounce = prefwin->Debounce();
       reader->brepalm = prefwin->repalm();
       reader->bunderlineLink = prefwin->UnderlineLink();
 
       reader->bkern = prefwin->kern();
       reader->hyphenate = prefwin->hyphenate();
       //      reader->buffdoc.setCustomHyphen(prefwin->customhyphen());
       reader->m_scrolltype = prefwin->scrolltype();
       reader->m_scrollstep = prefwin->scrollstep();
       m_scrollcolor = prefwin->scrollcolor();
       setscrollcolour();
       m_scrollbarcolor = prefwin->minibarcol();
       setscrollbarcolour();
       m_foreground = prefwin->foreground();
       reader->setForeground(getcolour(m_foreground));
       m_background = prefwin->background();
       reader->setBackground(getcolour(m_background));
         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;
+            text += QChar(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)
       {
         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