Resource -> OResource

3 files changed, 6 insertions, 5 deletions

diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp
index 8ef0674..b985094 100644
--- a/noncore/apps/opie-reader/QTReaderApp.cpp
+++ b/noncore/apps/opie-reader/QTReaderApp.cpp
@@ -1,3378 +1,3378 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  Allrights reserved.
 **
 ** This file is part of Qt Palmtop Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qregexp.h>
 #include <qclipboard.h>
 #include <qwidgetstack.h>
 #ifdef USEQPE
 #include <qpe/qpemenubar.h>
 #include <qpe/qpetoolbar.h>
 #endif
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #ifdef USEQPE
 #include <qpe/menubutton.h>
 #endif
 #include <qcombobox.h>
 #include <qpopupmenu.h>
 #include <qaction.h>
 #include <qapplication.h>
 #include <qlineedit.h>
 #include <qtoolbutton.h>
 #include <qspinbox.h>
 #include <qobjectlist.h>
 #include <qstatusbar.h>
 #ifdef USEQPE
 #include <qpe/global.h>
 #include <qpe/applnk.h>
 #endif
 #include <qfileinfo.h>
 #include <stdlib.h> //getenv
 #include <qprogressbar.h>
 #ifdef USEQPE
 #include <qpe/config.h>
 #endif
 #include <qbuttongroup.h>
 #include <qradiobutton.h>
 #ifdef USEQPE
 #include <qpe/qcopenvelope_qws.h>
 #endif
 #include "QTReader.h"
 #include "GraphicWin.h"
 #include "Bkmks.h"
 #include "cbkmkselector.h"
 #include "infowin.h"
 #include "ToolbarPrefs.h"
 #include "Prefs.h"
 #include "CAnnoEdit.h"
 #include "QFloatBar.h"
 #include "FixedFont.h"
 #include "URLDialog.h"
 #include "util.h"
 #include <qfontdatabase.h>
 
 #ifdef USEQPE
-#include <qpe/resource.h>
+#include <opie2/oresource.h>
 #ifdef OPIE
 #if defined(OPIEFILEDIALOG)
 #include <qpe/applnk.h>
 #include <opie2/ofiledialog.h>
 using namespace Opie::Ui;
 #else
 #include "fileBrowser.h"
 #endif
 #else
 #include "fileBrowser.h"
 #endif
 #else
 #include "qfiledialog.h"
 #endif
 
 #include "QTReaderApp.h"
 #include "CDrawBuffer.h"
 #include "Filedata.h"
 #include "names.h"
 #include "CEncoding_tables.h"
 #include "CloseDialog.h"
 
 #include "ButtonPrefs.h"
 
 bool CheckVersion(int&, int&, char&, QWidget*);
 
 #ifdef _WINDOWS
 #define PICDIR "c:\\uqtreader\\pics\\"
 #else
 #ifdef USEQPE
 #define USEMSGS
 #define PICDIR "opie-reader/"
 #else
 //#define PICDIR "/home/tim/uqtreader/pics/"
 QString picdir()
 {
   QString hd(getenv("READERDIR"));
   return hd + "/pics";
 }
 #define PICDIR picdir()
 #endif
 #endif
 
 unsigned long QTReaderApp::m_uid = 0;
 
 void QTReaderApp::setScrollState(bool _b) { m_scrollButton->setOn(_b); }
 
 #ifdef USEQPE
-#define geticon(iconname) Resource::loadPixmap( iconname )
-#define getmyicon(iconname) Resource::loadPixmap( PICDIR iconname )
+#define geticon(iconname) Opie::Core::OResource::loadPixmap( iconname, Opie::Core::OResource::SmallIcon )
+#define getmyicon(iconname) Opie::Core::OResource::loadPixmap( PICDIR iconname, Opie::Core::OResource::SmallIcon )
 #else
 //#define geticon(iconname) QPixmap(PICDIR iconname ".png")
 #define geticon(iconname) QPixmap(PICDIR +"/"+iconname+".png")
 #define getmyicon(iconname) geticon(iconname)
 //#define geticon(iconname) QIconSet( QPixmap(PICDIR iconname) )
 #endif
 
 #ifndef _WINDOWS
 #include <unistd.h>
 #endif
 #include <stddef.h>
 #ifndef _WINDOWS
 #include <dirent.h>
 #endif
 
 void QTReaderApp::listBkmkFiles()
 {
     bkmkselector->clear();
     bkmkselector->setText("Cancel");
 #ifndef USEQPE
     int cnt = 0;
 
     QDir d = QDir::home();                      // "/"
     if ( !d.cd(APPDIR) ) {                       // "/tmp"
         qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
 		d = QDir::home();
 		d.mkdir(APPDIR);
 		d.cd(APPDIR);
     }
 
 
   
 		
         d.setFilter( QDir::Files | QDir::NoSymLinks );
 //        d.setSorting( QDir::Size | QDir::Reversed );
 
         const QFileInfoList *list = d.entryInfoList();
         QFileInfoListIterator it( *list );      // create list iterator
         QFileInfo *fi;                          // pointer for traversing
         while ( (fi=it.current()) ) {           // for each file...
   
 		    bkmkselector->insertItem(fi->fileName(), cnt++);
 			
 			//qDebug( "%10li %s", fi->size(), fi->fileName().data() );
             ++it;                               // goto next list element
         }
  
 #else /* USEQPE */
     int cnt = 0;
     DIR *d;
     d = opendir((const char *)Global::applicationFileName(APPDIR,""));
 
     while(1)
     {
 	struct dirent* de;
 	struct stat buf;
 	de = readdir(d);
 	if (de == NULL) break;
 
 	if (lstat((const char *)Global::applicationFileName(APPDIR,de->d_name),&buf) == 0 && S_ISREG(buf.st_mode))
 	{
 	    bkmkselector->insertItem(de->d_name, cnt++);
 	}
     }
 
     closedir(d);
 #endif
     if (cnt > 0)
       {
 //tjw        menu->hide();
 
 
         editorStack->raiseWidget( bkmkselector );
         hidetoolbars();
 	m_nBkmkAction = cRmBkmkFile;
       }
     else
       QMessageBox::information(this, PROGNAME, "No bookmark files");
 }
 
 void QTReaderApp::hidetoolbars()
 {
   if (m_scrollbar != NULL) m_scrollbar->hide();
   if (m_prog != NULL) m_prog->hide();
 
 #if defined(USEQPE)
     menubar->hide();
 #endif
 
     if (m_scrollbar != NULL) m_scrollbar->hide();
 
     if (fileBar != NULL) fileBar->hide();
     if (viewBar != NULL) viewBar->hide();
     if (navBar != NULL) navBar->hide();
     if (markBar != NULL) markBar->hide();
     if (m_fontVisible) m_fontBar->hide();
     if (regVisible)
     {
 #ifdef USEQPE
 		Global::hideInputMethod();
 #endif
 	regBar->hide();
     }
     if (searchVisible)
     {
 #ifdef USEQPE
 		Global::hideInputMethod();
 #endif
 	searchBar->hide();
     }
 }
 
 QTReaderApp::QTReaderApp( QWidget *parent, const char *name, WFlags f )
     : QMainWindow( parent, name, f ), m_dontSave(false),
       fileBar(NULL), navBar(NULL), viewBar(NULL), markBar(NULL), m_scrollbar(NULL), m_localscroll(2), m_hidebars(false), m_kmapchanged(false)
 {
   {
     setKeyCompression ( true );
 #ifndef USEQPE
   QDir d = QDir::home();                      // "/"
   d.cd(APPDIR);
   QFileInfo fi(d, ".keymap");
   FILE* f = fopen((const char *)fi.absFilePath(), "r");
 #else /* USEQPE */
   FILE* f = fopen((const char *)Global::applicationFileName(APPDIR,".keymap"), "r");
 #endif /* USEQPE */
   if (f != NULL)
     {
       uint cnt;
       if ((fread(&cnt, sizeof(cnt), 1, f) != 0) && (cnt == KEYMAPVERSION))
 	{
 	  if (fread(&cnt, sizeof(cnt), 1, f) == 0) cnt = 0;
 	  for (uint i = 0; i != cnt; i++)
 	    {
 	      orKey key;
 	      int data;
 	      fread(&key, sizeof(key), 1, f);
 	      fread(&data, sizeof(data), 1, f);
 	      kmap[key] = data;
 	    }
 	}
       fclose(f);
     }
   }
 
 	m_url_clipboard = false;
 	m_url_localfile = false;
 	m_url_globalfile = false;
 		ftime(&m_lastkeytime);
 ////  qDebug("Application directory = %s", (const tchar *)QPEApplication::documentDir());
 ////  qDebug("Application directory = %s", (const tchar *)Global::applicationFileName("uqtreader","bkmks.xml"));
 
     m_bcloseDisabled = true;
     m_disableesckey = false;
     pBkmklist = NULL;
     pOpenlist = NULL;
 //    doc = 0;
 
 	m_fBkmksChanged = false;
     
   QString lang = getenv( "LANG" );
   QString rot = getenv( "QWS_DISPLAY" );
 
 /*
   int m_rot = 0;
   if (rot.contains("Rot90"))
   {
       m_rot = 90;
   }
   else if (rot.contains("Rot180"))
   {
       m_rot = 180;
   }
   else if (rot.contains("Rot270"))
   {
       m_rot = 270;
   }
 
 //  qDebug("Initial Rotation(%d):%s", m_rot, (const char*)rot);
 */
   m_autogenstr = "^ *[A-Z].*[a-z] *$";
 
 #ifdef USEQPE
-    setIcon( Resource::loadPixmap( PICDIR  "uqtreader") );
+    setIcon( Opie::Core::OResource::loadPixmap( PICDIR  "uqtreader", Opie::Core::OResource::SmallIcon ) );
 #else
     setIcon( QPixmap (PICDIR  + "/uqtreader.png") );
 #endif /* USEQPE */
 
 //    QPEToolBar *bar = new QPEToolBar( this );
 //    menubar = new QPEToolBar( this );
 #ifdef USEQPE
   Config config( APPDIR );
 #else
     QDir d = QDir::home();                      // "/"
     if ( !d.cd(APPDIR) ) {                       // "/tmp"
         qWarning( "Cannot find the \"~/" APPDIR "\" directory" );
 		d = QDir::home();
 		d.mkdir(APPDIR);
 		d.cd(APPDIR);
     }
     QFileInfo fi(d, INIFILE);
 //    qDebug("Path:%s", (const char*)fi.absFilePath());
     Config config(fi.absFilePath());
 #endif
     config.setGroup("Toolbar");
     m_tbmovesave = m_tbmove = config.readBoolEntry("Movable", false);
     m_tbpolsave = m_tbpol = (ToolbarPolicy)config.readNumEntry("Policy", 1);
     m_tbposition = (ToolBarDock)config.readNumEntry("Position", 2);
     m_qtscroll = config.readNumEntry("QTScrollBar", false);
     m_localscroll = config.readNumEntry("LocalScrollBar", false);
 
 //    fileBar = new QToolBar("File", this);
 //    QToolBar* viewBar = new QToolBar("File", this);
 //    QToolBar* navBar = new QToolBar("File", this);
 //    QToolBar* markBar = new QToolBar("File", this);
 
 #if defined(USEQPE)
     menubar = new QToolBar("Menus", this, m_tbposition);
     mb = new QPEMenuBar( menubar );
 #else
     mb = new QMenuBar( this );
 #endif
 
 #if defined(USEQPE)
     QPopupMenu* tmp = new QPopupMenu(mb);
     mb->insertItem( geticon( "AppsIcon" ), tmp );
 #else
     QMenuBar* tmp = mb;
 #endif
 
     QPopupMenu *file = new QPopupMenu( mb );
     tmp->insertItem( tr( "File" ), file );
 
     QPopupMenu *navigation = new QPopupMenu(mb);
     tmp->insertItem( tr( "Navigation" ), navigation );
 
     QPopupMenu *view = new QPopupMenu( mb );
     tmp->insertItem( tr( "View" ), view );
 
     QPopupMenu *marks = new QPopupMenu( this );
     tmp->insertItem( tr( "Marks" ), marks );
 
     QPopupMenu *settings = new QPopupMenu( this );
     tmp->insertItem( tr( "Settings" ), settings );
 
 //    addToolBar(menubar, "Menus",QMainWindow::Top);
 //    addToolBar(fileBar, "Toolbar",QMainWindow::Top);
 
     //    QPopupMenu *edit = new QPopupMenu( this );
 
     /*
     QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) );
     a->addTo( bar );
     a->addTo( file );
     */
     QWidget* widge = new QWidget(this);
     setCentralWidget( widge );
     QVBoxLayout* vlayout = new QVBoxLayout(widge);
     m_layout = new QBoxLayout(QBoxLayout::LeftToRight);
     m_prog = new QLabel(widge);
     vlayout->addLayout(m_layout, 1);
     vlayout->addWidget(m_prog);
 
     editorStack = new QWidgetStack( widge );
     //    setCentralWidget( editorStack );
 
     searchVisible = FALSE;
     regVisible = FALSE;
     m_fontVisible = false;
 
     m_buttonprefs = new CButtonPrefs(&kmap, this);
     editorStack->addWidget(m_buttonprefs, get_unique_id());
     connect( m_buttonprefs, SIGNAL( Closed() ), this, SLOT( infoClose() ) );
 
 
     m_annoWin = new CAnnoEdit(editorStack);
     editorStack->addWidget(m_annoWin, get_unique_id());
     connect( m_annoWin, SIGNAL( finished(const QString&, const QString&) ), this, SLOT( addAnno(const QString&, const QString&) ) );
     connect( m_annoWin, SIGNAL( cancelled() ), this, SLOT( infoClose() ) );
 
     m_infoWin = new infowin(editorStack);
     editorStack->addWidget(m_infoWin, get_unique_id());
     connect( m_infoWin, SIGNAL( Close() ), this, SLOT( infoClose() ) );
 
     m_graphicwin = new GraphicWin(editorStack);
     editorStack->addWidget(m_graphicwin, get_unique_id());
     connect( m_graphicwin, SIGNAL( Closed() ), this, SLOT( infoClose() ) );
 
 //    bkmkselector = new QListBox(editorStack, "Bookmarks");
     bkmkselector = new CBkmkSelector(editorStack, "Bookmarks");
     //    connect(bkmkselector, SIGNAL( selected(const QString&) ), this, SLOT( gotobkmk(const QString&) ) );
     connect(bkmkselector, SIGNAL( selected(int) ), this, SLOT( gotobkmk(int) ) );
     connect(bkmkselector, SIGNAL( cancelled() ), this, SLOT( cancelbkmk() ) );
     editorStack->addWidget( bkmkselector, get_unique_id() );
 
 /*
     importSelector = new FileSelector( "*", editorStack, "importselector", false );
     connect( importSelector, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( importFile( const DocLnk & ) ) );
 
     editorStack->addWidget( importSelector, get_unique_id() );
 
     // don't need the close visible, it is redundant...
     importSelector->setCloseVisible( FALSE );
 */    
 //    qDebug("Reading file list");
     readfilelist();
 
     reader = new QTReader( editorStack );
 
     reader->setDoUpdates(false);
 
 #ifdef USEQPE
     ((QPEApplication*)qApp)->setStylusOperation(reader, QPEApplication::RightOnHold);
 #endif
 
 //    qDebug("Reading config");
 //  Config config( APPDIR );
   config.setGroup( "View" );
 #if defined(USEQPE) && defined(USENEWFULLSCREEN)
   m_usenewfullscreen = config.readBoolEntry("NewFullScreen", false);
 #endif
   m_debounce = config.readNumEntry("Debounce", 0);
   m_buttonprefs->Debounce(m_debounce);
 #ifdef USEQPE
   m_bFloatingDialog = config.readBoolEntry("FloatDialogs", false);
 #else
   m_bFloatingDialog = config.readBoolEntry("FloatDialogs", true);
 #endif
   reader->setStripCR(config.readBoolEntry( "StripCr", true ));
   reader->bfulljust = config.readBoolEntry( "FullJust", false );
   /*
   bool btmp = config.readBoolEntry("Negative", false);
   if (btmp) reader->setNegative();
   */
   reader->bInverse = config.readBoolEntry("Inverse", false);
   reader->m_fontControl.FixGraphics(config.readBoolEntry( "FixGraphics", false ));
   reader->setextraspace(config.readNumEntry( "ExtraSpace", 0 ));
   reader->setlead(config.readNumEntry( "ExtraLead", 0 ));
   reader->btextfmt = config.readBoolEntry( "TextFmt", false );
   reader->bautofmt = config.readBoolEntry( "AutoFmt", true );
   reader->bstriphtml = config.readBoolEntry( "StripHtml", false );
   reader->bNoInlineTables = config.readBoolEntry( "NoInlineTables", false );
   reader->bpeanut = config.readBoolEntry( "Peanut", false );
   reader->bdehyphen = config.readBoolEntry( "Dehyphen", false );
   reader->bdepluck = config.readBoolEntry( "Depluck", false );
   reader->bdejpluck = config.readBoolEntry( "Dejpluck", false );
   reader->bonespace = config.readBoolEntry( "OneSpace", false );
   reader->bunindent = config.readBoolEntry( "Unindent", false );
   reader->brepara = config.readBoolEntry( "Repara", false );
   reader->m_reparastring = config.readEntry( "ReparaString", "\\n{[\\n \\t]}");
   m_bgtype = (bground)config.readNumEntry( "BackgroundType" , 0 );
   m_themename = config.readEntry("Theme", QString::null );
   reader->bdblspce = config.readBoolEntry( "DoubleSpace", false );
   reader->bindenter = config.readNumEntry( "Indent", 0 );
   reader->m_textsize = config.readNumEntry( "FontSize", 12 );
   reader->m_delay = config.readNumEntry( "ScrollDelay", 5184);
   reader->m_scrollstep = config.readNumEntry( "ScrollStep", 1);
   reader->m_outputName = config.readEntry( "OutputCodec", "");
 
 
   reader->m_lastfile = config.readEntry( "LastFile", QString::null );
   reader->m_lastposn = config.readNumEntry( "LastPosn", 0 );
   reader->m_bpagemode = config.readBoolEntry( "PageMode", true );
   reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false);
   reader->m_rotated = config.readBoolEntry( "IsRotated", false );
   reader->m_scrolltype = config.readNumEntry( "ScrollType", 0 );
   m_statusstring = config.readEntry("StatusContent", "%P%% Doc:%d/%D %p%% %z%%");
   m_statusishidden = config.readBoolEntry("StatusHidden", false);
   m_background = config.readNumEntry( "Background", 0 );
   reader->setBackground(getcolour(m_background));
   m_foreground = config.readNumEntry( "Foreground", 1 );
   reader->setForeground(getcolour(m_foreground));
   m_scrollcolor = config.readNumEntry( "ScrollColour", 5 );
   setscrollcolour();
   m_scrollbarcolor = config.readNumEntry( "ScrollBarColour", 5 );
   setscrollbarcolour();
   reader->hyphenate = config.readBoolEntry( "Hyphenate", false );
   reader->m_swapmouse = config.readBoolEntry( "SwapMouse", false);
   reader->m_fontname = config.readEntry( "Fontname", "helvetica" );
   reader->m_encd = config.readNumEntry( "Encoding", 0 );
   reader->m_charpc = config.readNumEntry( "CharSpacing", 100 );
   reader->m_overlap = config.readNumEntry( "Overlap", 0 );
   reader->m_abstopmargin = config.readNumEntry( "Top Margin", 100 );
   reader->m_absbottommargin = config.readNumEntry( "Bottom Margin", 100 );
   reader->m_absleft_border = config.readNumEntry( "Left Margin", 100 );
   reader->m_absright_border = config.readNumEntry( "Right Margin", 100 );
 
   m_scrollishidden = config.readBoolEntry( "HideScrollBar", false );
   m_hidebars = config.readBoolEntry( "HideToolBar", false );
 
   reader->brepalm = config.readBoolEntry( "Repalm", false );
   reader->bunderlineLink = config.readBoolEntry( "UnderlineLink", true );
   reader->bkern = config.readBoolEntry( "Kern", false );
   reader->bremap = config.readBoolEntry( "Remap", true );
   reader->bmakebold = config.readBoolEntry( "MakeBold", false );
   reader->setContinuous(config.readBoolEntry( "Continuous", true ));
   reader->setDoubleBuffer(config.readBoolEntry("DoubleBuffer", true));
   m_targetapp = config.readEntry( "TargetApp", QString::null );
   m_targetmsg = config.readEntry( "TargetMsg", QString::null );
 #ifdef _SCROLLPIPE
   reader->m_pipetarget = config.readEntry( "PipeTarget", QString::null );
   reader->m_pauseAfterEachPara = config.readBoolEntry( "PauseAfterPara", true );
 #endif
   m_twoTouch = config.readBoolEntry( "TwoTouch", false);
   m_doAnnotation = config.readBoolEntry( "Annotation", false);
   m_doDictionary = config.readBoolEntry( "Dictionary", false);
   m_doClipboard = config.readBoolEntry( "Clipboard", false);
   m_doOutput = config.readBoolEntry( "OutputTgt", false);
   /*
   m_spaceTarget = (ActionTypes)config.readNumEntry("SpaceTarget", cesAutoScroll);
   m_escapeTarget = (ActionTypes)config.readNumEntry("EscapeTarget", cesNone);
   m_returnTarget = (ActionTypes)config.readNumEntry("ReturnTarget", cesFullScreen);
   m_leftTarget = (ActionTypes)config.readNumEntry("LeftTarget", cesZoomOut);
   m_rightTarget = (ActionTypes)config.readNumEntry("RightTarget", cesZoomIn);
   m_upTarget = (ActionTypes)config.readNumEntry("UpTarget", cesPageUp);
   m_downTarget = (ActionTypes)config.readNumEntry("DownTarget", cesPageDown);
 
   m_leftScroll = config.readBoolEntry("LeftScroll", false);
   m_rightScroll = config.readBoolEntry("RightScroll", false);
   m_upScroll = config.readBoolEntry("UpScroll", true);
   m_downScroll = config.readBoolEntry("DownScroll", true);
   */
   m_propogatefontchange = config.readBoolEntry( "RequestorFontChange", false);
   reader->setBaseSize(config.readNumEntry( "Basesize", 10 ));
   reader->setHyphenThreshold(config.readNumEntry( "HyphenThreshold", 50 ));
   //  reader->buffdoc.setCustomHyphen(config.readBoolEntry( "CustomHyphen", false ));
 #ifndef USEQPE
 	config.setGroup( "Geometry" );
 	setGeometry(0,0,
 	config.readNumEntry( "width", QApplication::desktop()->width()/2 ),
 	config.readNumEntry( "height", QApplication::desktop()->height()/2 ));
 	move(
 	config.readNumEntry( "x", 20 ),
 	config.readNumEntry( "y", 20 ));
 #else
 	m_grabkeyboard = config.readBoolEntry( "GrabKeyboard", false);
 #endif
 
 
 
   setTwoTouch(m_twoTouch);
 
     connect( reader, SIGNAL( OnShowPicture(QImage&) ), this, SLOT( showgraphic(QImage&) ) );
 
     connect( reader, SIGNAL( OnRedraw() ), this, SLOT( OnRedraw() ) );
     connect( reader, SIGNAL( OnWordSelected(const QString&, size_t, size_t, const QString&) ), this, SLOT( OnWordSelected(const QString&, size_t, size_t, const QString&) ) );
     connect( reader, SIGNAL( OnURLSelected(const QString&, const size_t) ), this, SLOT( OnURLSelected(const QString&, const size_t) ) );
     connect( reader, SIGNAL( NewFileRequest(const QString&) ), this, SLOT( forceopen(const QString&) ) );
     connect( reader, SIGNAL( HandleKeyRequest(QKeyEvent*) ), this, SLOT( handlekey(QKeyEvent*) ) );
     connect( reader, SIGNAL( SetScrollState(bool) ), this, SLOT( setScrollState(bool) ) );
     connect( reader, SIGNAL(RefreshBitmap()), this, SLOT(setBackgroundBitmap()));
     editorStack->addWidget( reader, get_unique_id() );
 
     m_preferences_action = new QAction( tr( "Configuration" ), geticon( "SettingsIcon" ), QString::null, 0, this, NULL);
     connect( m_preferences_action, SIGNAL( activated() ), this, SLOT( showprefs() ) );
     m_preferences_action->addTo( settings );
 
     m_saveconfig_action = new QAction( tr( "Save Config" ), QString::null, 0, this, NULL);
     connect( m_saveconfig_action, SIGNAL( activated() ), this, SLOT( SaveConfig() ) );
     m_saveconfig_action->addTo( settings );
 
     m_loadconfig_action = new QAction( tr( "Load Config" ), QString::null, 0, this, NULL);
     connect( m_loadconfig_action, SIGNAL( activated() ), this, SLOT( LoadConfig() ) );
     m_loadconfig_action->addTo( settings );
 
     m_tidyconfig_action = new QAction( tr( "Delete Config" ), QString::null, 0, this, NULL);
     connect( m_tidyconfig_action, SIGNAL( activated() ), this, SLOT( TidyConfig() ) );
     m_tidyconfig_action->addTo( settings );
 
     settings->insertSeparator();
     m_toolbarprefs_action = new QAction( tr( "Toolbars" ), QString::null, 0, this, NULL);
     connect( m_toolbarprefs_action, SIGNAL( activated() ), this, SLOT( showtoolbarprefs() ) );
     m_toolbarprefs_action->addTo( settings );
 
     m_buttonprefs_action = new QAction( tr( "Buttons" ), QString::null, 0, this, NULL);
     connect( m_buttonprefs_action, SIGNAL( activated() ), this, SLOT( showbuttonprefs() ) );
     m_buttonprefs_action->addTo( settings );
 
     m_loadtheme_action = new QAction( tr( "Load Theme" ), QString::null, 0, this, NULL);
     connect( m_loadtheme_action, SIGNAL( activated() ), this, SLOT( LoadTheme() ) );
     m_loadtheme_action->addTo( settings );
 
     m_repara_action = new QAction( tr( "EOP Marker" ),  QString::null, 0, this, NULL);
     connect( m_repara_action, SIGNAL( activated() ), this, SLOT( reparastring() ) );
     m_repara_action->addTo(settings);
 
 #ifdef USEQPE
     m_grab_action = new QAction( tr( "Grab Buttons" ), QString::null, 0, this, NULL, true );
     connect( m_grab_action, SIGNAL( toggled(bool) ), this, SLOT( setgrab(bool) ) );
     m_grab_action->setOn(m_grabkeyboard);
     m_grab_action->addTo( settings );
 #endif
 
     m_open_action = new QAction( tr( "Open" ), geticon( "fileopen" ), QString::null, 0, this, 0 );
     connect( m_open_action, SIGNAL( activated() ), this, SLOT( fileOpen() ) );
     m_open_action->addTo( file );
 
     m_close_action = new QAction( tr( "Close" ), geticon( "close" ), QString::null, 0, this, 0 );
     connect( m_close_action, SIGNAL( activated() ), this, SLOT( fileClose() ) );
     m_close_action->addTo( file );
 
 #ifdef _SCRIPT
     a = new QAction( tr( "Run Script" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( RunScript() ) );
     a->addTo( file );
 #endif
     /*
     a = new QAction( tr( "Revert" ), geticon( "close" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( fileRevert() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Cut" ), geticon( "cut" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) );
     a->addTo( filebar() );
     a->addTo( edit );
     */
 
     m_info_action = new QAction( tr( "Info" ), geticon( "UtilsIcon" ), QString::null, 0, this, NULL);
     connect( m_info_action, SIGNAL( activated() ), this, SLOT( showinfo() ) );
     m_info_action->addTo( file );
 
     m_touch_action = new QAction( tr( "Two/One Touch" ), geticon( "1to1" ), QString::null, 0, this, NULL, true );
     connect( m_touch_action, SIGNAL( toggled(bool) ), this, SLOT( setTwoTouch(bool) ) );
     m_touch_action->setOn(m_twoTouch);
     m_touch_action->addTo( file );
 
     m_find_action = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, NULL);
      connect( m_find_action, SIGNAL( activated() ), this, SLOT( editFind() ) );
      file->insertSeparator();
 //     a->addTo( bar );
      m_find_action->addTo( file );
 
     m_exportlinks_action = new QAction( tr( "Export Links" ), QString::null, 0, this, NULL);
     connect( m_exportlinks_action, SIGNAL( activated() ), this, SLOT( ExportLinks() ) );
     m_exportlinks_action->addTo( file );
 
     m_scrollButton = new QAction( tr( "Scroll" ), getmyicon( "panel-arrow-down" ), QString::null, 0, this, 0, true );
     connect( m_scrollButton, SIGNAL( toggled(bool) ), this, SLOT( autoScroll(bool) ) );
     m_scrollButton->addTo(navigation);
     m_scrollButton->setOn(false);
 
     m_start_action = new QAction( tr( "Goto Start" ), geticon( "start" ), QString::null, 0, this, NULL);
     connect( m_start_action, SIGNAL( activated() ), this, SLOT( gotoStart() ) );
     m_start_action->addTo(navigation);
 
     m_end_action = new QAction( tr( "Goto End" ), geticon( "finish" ), QString::null, 0, this, NULL);
     connect( m_end_action, SIGNAL( activated() ), this, SLOT( gotoEnd() ) );
     m_end_action->addTo(navigation);
 
     m_jump_action = new QAction( tr( "Jump" ), geticon( "rotate" ), QString::null, 0, this, NULL);
     connect( m_jump_action, SIGNAL( activated() ), this, SLOT( jump() ) );
     m_jump_action->addTo(navigation);
 
     m_pageline_action = new QAction( tr( "Page/Line Scroll" ), geticon( "pass" ), QString::null, 0, this, NULL, true );
     connect( m_pageline_action, SIGNAL( toggled(bool) ), this, SLOT( pagemode(bool) ) );
     m_pageline_action->addTo(navigation);
     m_pageline_action->setOn(reader->m_bpagemode);
 
     m_pageup_action = new QAction( tr( "Up" ), geticon( "up" ), QString::null, 0, this, 0 );
     connect( m_pageup_action, SIGNAL( activated() ), this, SLOT( pageup() ) );
     m_pageup_action->addTo( navigation );
     
     m_pagedn_action = new QAction( tr( "Down" ), geticon( "down" ), QString::null, 0, this, 0 );
     connect( m_pagedn_action, SIGNAL( activated() ), this, SLOT( pagedn() ) );
     m_pagedn_action->addTo( navigation );
 
     m_back_action = new QAction( tr( "Back" ), geticon( "back" ), QString::null, 0, this, 0 );
     connect( m_back_action, SIGNAL( activated() ), reader, SLOT( goBack() ) );
     m_back_action->addTo( navigation );
 
     m_home_action = new QAction( tr( "Home" ), geticon( "home" ), QString::null, 0, this, 0 );
     connect( m_home_action, SIGNAL( activated() ), reader, SLOT( goHome() ) );
     m_home_action->addTo( navigation );
 
     m_forward_action = new QAction( tr( "Forward" ), geticon( "forward" ), QString::null, 0, this, 0 );
     connect( m_forward_action, SIGNAL( activated() ), reader, SLOT( goForward() ) );
     m_forward_action->addTo( navigation );
 
     /*
     a = new QAction( tr( "Find" ), QString::null, 0, this, NULL, true );
     //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Find Again" ), QString::null, 0, this, NULL, true );
     //    connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) );
     a->addTo( file );
     */
 
 //    file->insertSeparator();
 
 #ifdef _SCROLLPIPE
 
     QActionGroup* ag = new QActionGroup(this);
     ag->setExclusive(false);
     spacemenu = new QPopupMenu(this);
     file->insertItem( tr( "Scrolling" ), spacemenu );
 
     a = new QAction( tr( "Set Target" ), QString::null, 0, ag, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( setpipetarget() ) );
 
     a = new QAction( tr( "Pause Paras" ), QString::null, 0, ag, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( setpause(bool) ) );
     a->setOn(reader->m_pauseAfterEachPara);
 
     ag->addTo(spacemenu);
 //    file->insertSeparator();
 
 #endif
 
 /*
     a = new QAction( tr( "Import" ), QString::null, 0, this, NULL );
     connect( a, SIGNAL( activated() ), this, SLOT( importFiles() ) );
     a->addTo( file );
 */
 
     /*
     a = new QAction( tr( "Paste" ), geticon( "paste" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) );
     a->addTo( fileBar );
     a->addTo( edit );
     */
 
 //     a = new QAction( tr( "Find..." ), geticon( "find" ), QString::null, 0, this, 0 );
 
      m_fullscreen = false;
     m_actFullscreen = new QAction( tr( "Fullscreen" ), geticon( "fullscreen" ), QString::null, 0, this, NULL, true );
     connect( m_actFullscreen, SIGNAL( toggled(bool) ), this, SLOT( setfullscreen(bool) ) );
     m_actFullscreen->setOn(m_fullscreen);
     m_actFullscreen->addTo( view );
 
     m_rotate_action = new QAction( tr( "Rotate" ), geticon( "repeat" ), QString::null, 0, this, NULL, true );
     connect( m_rotate_action, SIGNAL( toggled(bool) ), this, SLOT( setrotated(bool) ) );
     m_rotate_action->setOn(reader->m_rotated);
     m_rotate_action->addTo( view );
 
     m_inverse_action = new QAction( tr( "Invert" ), getmyicon( "invert" ), QString::null, 0, this, NULL, true );
     connect( m_inverse_action, SIGNAL( toggled(bool) ), this, SLOT( setinverted(bool) ) );
     m_inverse_action->setOn(reader->bInverse);
     m_inverse_action->addTo( view );
 
     view->insertSeparator();
 
     m_zoomin_action = new QAction( tr( "Zoom In" ), geticon( "zoom" ), QString::null, 0, this);
     connect( m_zoomin_action, SIGNAL( activated() ), this, SLOT( zoomin() ) );
     m_zoomin_action->addTo( view );
 
     m_zoomout_action = new QAction( tr( "Zoom Out" ), geticon( "mag" ), QString::null, 0, this);
     connect( m_zoomout_action, SIGNAL( activated() ), this, SLOT( zoomout() ) );
     m_zoomout_action->addTo( view );
 
     view->insertSeparator();
     m_setfont_action = new QAction( tr( "Set Font" ), getmyicon( "font" ), QString::null, 0, this);
     connect( m_setfont_action, SIGNAL( activated() ), this, SLOT( setfont() ) );
     m_setfont_action->addTo( view );
 
     view->insertSeparator();
     m_setenc_action = new QAction( tr( "Set Encoding" ), getmyicon( "charset" ), QString::null, 0, this);
     connect( m_setenc_action, SIGNAL( activated() ), this, SLOT( chooseencoding() ) );
     m_setenc_action->addTo( view );
 
     m_setmono_action = new QAction( tr( "Ideogram" ), getmyicon( "ideogram" ), QString::null, 0, this, NULL, true);
     connect( m_setmono_action, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );
     m_setmono_action->addTo( view );
     m_setmono_action->setOn(reader->m_bMonoSpaced);
 
 
     //    a = new QAction( tr( "Zoom" ), QString::null, 0, this, NULL, true );
     //    a = new QAction( tr( "Zoom" ), geticon( "mag" ), QString::null, 0, this, 0 );
 
 
 
     //    a->addTo( filebar() );
 //     view->insertSeparator();
 
 /*
     a = new QAction( tr( "Ideogram/Word" ), QString::null, 0, this, NULL, true );
     connect( a, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) );
     a->setOn(reader->m_bMonoSpaced);
     a->addTo( view );
 */
 /*
     a = new QAction( tr( "Set Width" ), QString::null, 0, this, NULL);
     connect( a, SIGNAL( activated() ), this, SLOT( setspacing() ) );
     a->addTo( view );
 */
 
     m_mark_action = new QAction( tr( "Bookmark" ), getmyicon( "bookmark" ), QString::null, 0, this, NULL);
     connect( m_mark_action, SIGNAL( activated() ), this, SLOT( addbkmk() ) );
     m_mark_action->addTo( marks );
 
     m_annotate_action = new QAction( tr( "Annotate" ), getmyicon( "annotate" ), QString::null, 0, this, NULL);
     connect( m_annotate_action, SIGNAL( activated() ), this, SLOT( addanno() ) );
     m_annotate_action->addTo( marks );
 
     m_goto_action = new QAction( tr( "Goto" ), getmyicon( "bookmark_goto" ), QString::null, 0, this, NULL, false );
     connect( m_goto_action, SIGNAL( activated() ), this, SLOT( do_gotomark() ) );
     m_goto_action->addTo( marks );
 
     m_delete_action = new QAction( tr( "Delete" ), getmyicon( "bookmark_delete" ), QString::null, 0, this, NULL);
     connect( m_delete_action, SIGNAL( activated() ), this, SLOT( do_delmark() ) );
     m_delete_action->addTo( marks );
 
     m_autogen_action = new QAction( tr( "Autogen" ), geticon( "exec" ), QString::null, 0, this, NULL, false );
     connect( m_autogen_action, SIGNAL( activated() ), this, SLOT( do_autogen() ) );
      marks->insertSeparator();
     m_autogen_action->addTo( marks );
 
     m_clear_action = new QAction( tr( "Clear" ), getmyicon( "bookmark_clear" ), QString::null, 0, this, NULL);
     connect( m_clear_action, SIGNAL( activated() ), this, SLOT( clearBkmkList() ) );
     m_clear_action->addTo( marks );
 
     m_save_action = new QAction( tr( "Save" ), getmyicon( "bookmark_save" ), QString::null, 0, this, NULL );
     connect( m_save_action, SIGNAL( activated() ), this, SLOT( savebkmks() ) );
     m_save_action->addTo( marks );
 
     m_tidy_action = new QAction( tr( "Tidy" ), getmyicon( "bookmark_tidy" ), QString::null, 0, this, NULL);
     connect( m_tidy_action, SIGNAL( activated() ), this, SLOT( listBkmkFiles() ) );
      marks->insertSeparator();
     m_tidy_action->addTo( marks );
 
     m_startBlock_action = new QAction( tr( "Start Block" ), geticon( "new" ), QString::null, 0, this, NULL);
     connect( m_startBlock_action, SIGNAL( activated() ), this, SLOT( editMark() ) );
     marks->insertSeparator();
     m_startBlock_action->addTo( marks );
 
     m_endBlock_action = new QAction( tr( "Copy Block" ), geticon( "copy" ), QString::null, 0, this, NULL);
     connect( m_endBlock_action, SIGNAL( activated() ), this, SLOT( editCopy() ) );
     m_endBlock_action->addTo( marks );
 
     m_bkmkAvail = NULL;
 
 
     setToolBarsMovable(m_tbmove);
     addtoolbars(&config);
     if (m_hidebars)
       {
 #if defined(USEQPE)
 	menubar->hide();
 #endif
 	if (fileBar != NULL) fileBar->hide();
 	if (viewBar != NULL) viewBar->hide();
 	if (navBar != NULL) navBar->hide();
 	if (markBar != NULL) markBar->hide();
 	mb->hide();
       }
 
 
     pbar = new QProgressBar(this);
     pbar->hide();
 
     searchBar = new QFloatBar( "Search", this, QMainWindow::Top, TRUE );
 
     searchBar->setHorizontalStretchable( TRUE );
 
     connect(searchBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));
 
     searchEdit = new QLineEdit( searchBar, "searchEdit" );
 //      QFont f("unifont", 16 /*, QFont::Bold*/);
 //      searchEdit->setFont( f );
     searchBar->setStretchableWidget( searchEdit );
 
 
 #ifdef __ISEARCH
     connect( searchEdit, SIGNAL( textChanged( const QString & ) ),
 	     this, SLOT( search( const QString& ) ) );
 #else
     connect( searchEdit, SIGNAL( returnPressed( ) ),
 	     this, SLOT( search( ) ) );
 #endif
      QAction*a = new QAction( tr( "Find Next" ), geticon( "next" ), QString::null, 0, this, 0 );
      connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );
      a->addTo( searchBar );
 
     a = new QAction( tr( "Close Find" ), geticon( "close" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) );
     a->addTo( searchBar );
 
     searchBar->hide();
 
     regBar = new QFloatBar( "Autogen", this, QMainWindow::Top, TRUE );
     connect(regBar, SIGNAL( OnHide() ), this, SLOT( restoreFocus() ));
 
     regBar->setHorizontalStretchable( TRUE );
 
     regEdit = new QLineEdit( regBar, "regEdit" );
 //    regEdit->setFont( f );
 
     regBar->setStretchableWidget( regEdit );
 
     connect( regEdit, SIGNAL( returnPressed( ) ),
 	     this, SLOT( do_regaction() ) );
 
     a = new QAction( tr( "Do Reg" ), geticon( "enter" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( do_regaction() ) );
     a->addTo( regBar );
 
     a = new QAction( tr( "Close Edit" ), geticon( "close" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), this, SLOT( regClose() ) );
     a->addTo( regBar );
 
     regBar->hide();
 
     m_fontBar = new QToolBar( "Autogen", this, QMainWindow::Top, TRUE );
 
     m_fontBar->setHorizontalStretchable( TRUE );
 
 //    qDebug("Font selector");
     m_fontSelector = new QComboBox(false, m_fontBar);
     m_fontBar->setStretchableWidget( m_fontSelector );
     {
 	QFontDatabase f;
 	QStringList flist = f.families();
 	bool realfont = false;
 	for (QStringList::Iterator nm = flist.begin(); nm != flist.end(); nm++)
 	{
 	    if (reader->m_fontname == *nm)
 	    {
 		realfont = true;
 	    }
 	    if ((*nm).contains(FIXEDFONT,false)) reader->m_fontControl.hasCourier(true, *nm);
 	}
 	if (!realfont) reader->m_fontname = flist[0];
     } // delete the FontDatabase!!!
     connect( m_fontSelector, SIGNAL( activated(const QString& ) ),
 	     this, SLOT( do_setfont(const QString&) ) );
     connect( m_fontSelector, SIGNAL( activated(int ) ),
 	     this, SLOT( do_setencoding(int) ) );
 
     m_fontBar->hide();
     m_fontVisible = false;
 #ifdef USEMSGS
     connect(qApp, SIGNAL( appMessage(const QCString&, const QByteArray& ) ),
 	     this, SLOT( msgHandler(const QCString&, const QByteArray&) ) );
 #endif
 //    qDebug("Initing");
 
     m_layout->addWidget(editorStack);
     if (m_qtscroll != 0)
       {
 	/*
 	m_scrollbar = new QToolBar( "Autogen", this, (m_localscrollbar) ? QMainWindow::Left : QMainWindow::Right, TRUE );
 
 	m_scrollbar->setVerticalStretchable( TRUE );
 	*/
 	scrollbar = m_scrollbar = new QScrollBar(QScrollBar::Vertical, widge);
 	m_layout->addWidget(scrollbar);
 	scrollbar->setTracking(false);
 	//	connect(scrollbar, SIGNAL(sliderMoved(int)), this, SLOT(actionscroll(int)) );
 	//	m_scrollbar->setStretchableWidget( scrollbar );
 	if (m_scrollishidden)
 	  {
 	    m_scrollbar->hide();
 	  }
 	else
 	  {
 	    m_scrollbar->show();
 	  }
 
 	setrotated(reader->m_rotated);
       }
     else
       {
 	m_scrollbar = NULL;
       }
     setBackgroundBitmap();
     m_inverse_action->setOn(reader->bInverse);
     reader->init();
 
 //    qDebug("Inited");
 //    m_buttonAction[m_spaceTarget]->setOn(true);
 //    qDebug("fonting");
     do_setfont(reader->m_fontname);
     //    qDebug("fonted");
     QFont progfont(reader->m_fontname, reader->m_fontControl.getsize(0));
     m_prog->setFont( progfont );
     if (m_statusishidden) m_prog->hide();
     showEditTools();
     if (!reader->m_lastfile.isEmpty())
     {
 //	qDebug("doclnk");
 //	doc = new DocLnk(reader->m_lastfile);
 //	qDebug("doclnk done");
 	if (pOpenlist != NULL)
 	{
 
 /*
 	    int ind = 0;
 	    Bkmk* p = (*pOpenlist)[ind];
 	    while (p != NULL && toQString(CFiledata(p->anno()).name()) != reader->m_lastfile)
 	    {
 		p = (*pOpenlist)[++ind];
 	    }
 */
 	    Bkmk* p = NULL;
 	    for (CList<Bkmk>::iterator iter = pOpenlist->begin(); iter != pOpenlist->end(); iter++)
 	    {
 		p = iter.pContent();
 		if (toQString(CFiledata(p->anno()).name()) == reader->m_lastfile)
 		{
 		    break;
 		}
 //		qDebug("Item:%s", (const char*)toQString(CFiledata(p->anno()).name()));
 		p = NULL;
 	    }
 	    if (p != NULL)
 	    {
 		if (!openfrombkmk(p))
 		  {
 		    showEditTools();
 		  }
 	    }
 	    else
 	    {
 		openFile( reader->m_lastfile );
 	    }
 	}
 	else
 	{
 	    if (!reader->m_lastfile.isEmpty())
 	      {
 		openFile( reader->m_lastfile );
 	      }
 	}
     }
     else
     {
       showEditTools();
     }
 //    qApp->processEvents();
     if (m_scrollbar == NULL || m_scrollbar->isHidden())
       {
 	reader->m_scrollpos = m_localscroll;
       }
     else
       {
 	reader->m_scrollpos = (m_qtscroll == 0) ? m_localscroll : 0;
       }
     //    reader->bDoUpdates = true;
     //    reader->update();
     config.setGroup("Version");
     int major = config.readNumEntry("Major", 0);
     int bkmktype = config.readNumEntry("BkmkType", 0);
     char minor = config.readNumEntry("Minor", 0);
     if (CheckVersion(major, bkmktype, minor, this))
     {
 	config.writeEntry("Major", major);
 	config.writeEntry("BkmkType", bkmktype);
 	config.writeEntry("Minor", (int)minor);
     }
 //    qDebug("finished update");
     if (kmap.isEmpty())
       {
 	QMessageBox::warning(this, PROGNAME, "You haven't mapped any keys yet!\n\nYou will be taken to the key\nmapping dialog.\nA few defaults are provided\nbut you can change then to\nsuit yourself.\n\nYou can change the key\nmapping at any time by\nselecting the Settings/Button\noption on the menu.");
 
 	m_buttonprefs->mapkey(Qt::NoButton, Key_Up, cesPageUp);
 	m_buttonprefs->mapkey(Qt::NoButton, Key_Down, cesPageDown);
 
 	m_buttonprefs->mapkey(Qt::NoButton, Key_Right, cesZoomIn);
 	m_buttonprefs->mapkey(Qt::NoButton, Key_Left, cesZoomOut);
 
 	showbuttonprefs();
       }
 }
 
 void QTReaderApp::addtoolbars(Config* config)
 {
     config->setGroup("Toolbar");
 
     if (fileBar != NULL)
     {
 #if defined(USEQPE)
 	if (fileBar != menubar)
 	{
 	    fileBar->clear();
 	}
 	else
 	{
 	    m_preferences_action->removeFrom( filebar() );
 	    m_open_action->removeFrom( filebar() );
 	    m_close_action->removeFrom( filebar() );
 	    m_info_action->removeFrom( filebar() );
 	    m_touch_action->removeFrom( filebar() );
 	    m_find_action->removeFrom( filebar() );
 	}
 #else
 	fileBar->clear();
 #endif
     }
 
     m_preferences_action->addTo( filebar() );
     addfilebar(config, "Open", m_open_action);
     addfilebar(config, "Close", m_close_action);
     addfilebar(config, "Info", m_info_action);
     addfilebar(config, "Two/One Touch", m_touch_action);
     addfilebar(config, "Find", m_find_action);
 
     if (navBar != NULL)
     {
 #if defined(USEQPE)
 	if ((navBar == fileBar) && (fileBar == menubar))
 #else
 	if (navBar == fileBar)
 #endif
 	{
 	    m_scrollButton->removeFrom( navbar() );
 	    m_start_action->removeFrom( navbar() );
 	    m_end_action->removeFrom( navbar() );
 	    m_jump_action->removeFrom( navbar() );
 	    m_pageline_action->removeFrom( navbar() );
 	    m_pageup_action->removeFrom( navbar() );
 	    m_pagedn_action->removeFrom( navbar() );
 	    m_back_action->removeFrom( navbar() );
 	    m_home_action->removeFrom( navbar() );
 	    m_forward_action->removeFrom( navbar() );
 	}
 	else if (navBar != fileBar)
 	{
 	    navBar->clear();
 	}
     }
 
     addnavbar(config, "Scroll", m_scrollButton);
     addnavbar(config, "Goto Start", m_start_action);
     addnavbar(config, "Goto End", m_end_action);
 
     addnavbar(config, "Jump", m_jump_action);
     addnavbar(config, "Page/Line Scroll", m_pageline_action);
 
     addnavbar(config, "Page Up", m_pageup_action);
     addnavbar(config, "Page Down", m_pagedn_action);
 
     addnavbar(config, "Back", m_back_action);
     addnavbar(config, "Home", m_home_action);
     addnavbar(config, "Forward", m_forward_action);
 
     if (viewBar != NULL)
     {
 #if defined(USEQPE)
 	if ((viewBar == fileBar) && (fileBar == menubar))
 #else
 	if (viewBar == fileBar)
 #endif
 	{
 	    m_actFullscreen->removeFrom( filebar() );
 	    m_rotate_action->removeFrom( viewbar() );
 	    m_inverse_action->removeFrom( viewbar() );
 	    m_zoomin_action->removeFrom( viewbar() );
 	    m_zoomout_action->removeFrom( viewbar() );
 	    m_setfont_action->removeFrom( viewbar() );
 	    m_setenc_action->removeFrom( viewbar() );
 	    m_setmono_action->removeFrom( viewbar() );
 	}
 	else if (viewBar != fileBar)
 	{
 	    viewBar->clear();
 	}
     }
 
     addviewbar(config, "Fullscreen", m_actFullscreen);
     addviewbar(config, "Rotate", m_rotate_action);
     addviewbar(config, "Invert Action", m_inverse_action);
     addviewbar(config, "Zoom In", m_zoomin_action);
     addviewbar(config, "Zoom Out", m_zoomout_action);
     addviewbar(config, "Set Font", m_setfont_action);
     addviewbar(config, "Encoding Select", m_setenc_action);
     addviewbar(config, "Ideogram Mode", m_setmono_action);
 
     if (markBar != NULL)
     {
 #if defined(USEQPE)
 	if ((markBar == fileBar) && (fileBar == menubar))
 #else
 	if (markBar == fileBar)
 #endif
 	{
 	    m_mark_action->removeFrom( markbar() );
 	    m_annotate_action->removeFrom( markbar());
 	    m_goto_action->removeFrom( markbar() );
 	    m_delete_action->removeFrom( markbar() );
 	    m_autogen_action->removeFrom( markbar() );
 	    m_clear_action->removeFrom( markbar() );
 	    m_save_action->removeFrom( markbar() );
 	    m_tidy_action->removeFrom( markbar() );
 	    m_startBlock_action->removeFrom( markbar() );
 	    m_endBlock_action->removeFrom( markbar() );
 	}
 	else if (markBar != fileBar)
 	{
 	    markBar->clear();
 	}
     }
     addmarkbar(config, "Mark", m_mark_action);
     addmarkbar(config, "Annotate", m_annotate_action);
     addmarkbar(config, "Goto", m_goto_action);
     addmarkbar(config, "Delete", m_delete_action);
     addmarkbar(config, "Autogen", m_autogen_action);
     addmarkbar(config, "Clear", m_clear_action);
     addmarkbar(config, "Save", m_save_action);
     addmarkbar(config, "Tidy", m_tidy_action);
     addmarkbar(config, "Start Block", m_startBlock_action);
     addmarkbar(config, "Copy Block", m_endBlock_action);
     if (checkbar(config, "Annotation indicator"))
     {
 	if (m_bkmkAvail == NULL)
 	{
 	    m_bkmkAvail = new QAction( tr( "Annotation" ), geticon( "find" ), QString::null, 0, this, 0 );
 	    connect( m_bkmkAvail, SIGNAL( activated() ), this, SLOT( showAnnotation() ) );
 	
 	    m_bkmkAvail->setEnabled(false);
 	}
 	QLabel *spacer = new QLabel(markBar, "");
 	markbar()->setStretchableWidget(spacer);
 	m_bkmkAvail->removeFrom( markbar() );
 	m_bkmkAvail->addTo( markbar() );
     }
     else
     {
 	if (m_bkmkAvail != NULL)
 	{
 	    m_bkmkAvail->removeFrom( markbar() );
 	    delete m_bkmkAvail;
 	    m_bkmkAvail = NULL;
 	}
     }
 }
 
 bool QTReaderApp::checkbar(Config* _config, const QString& key)
 {
     return _config->readBoolEntry(key, false);
 }
 
 
 QToolBar* QTReaderApp::filebar()
 {
     if (fileBar == NULL)
     {
 	switch (m_tbpol)
 	{
 #if defined(USEQPE)
 	    case cesSingle:
 //		qDebug("Setting filebar to menubar");
 		fileBar = menubar;
 		break;
 #endif
 	    default:
 		qDebug("Incorrect toolbar policy set");
 	    case cesMenuTool:
 	    case cesMultiple:
 //		qDebug("Creating new file bar");
 		fileBar = new QToolBar("File", this, m_tbposition);
 		break;
 	}
 //	fileBar->setHorizontalStretchable( true );
     }
     return fileBar;
 }
 QToolBar* QTReaderApp::viewbar()
 {
     if (viewBar == NULL)
     {
 	switch (m_tbpol)
 	{
 	    case cesMultiple:
 		viewBar = new QToolBar("View", this, m_tbposition);
 		break;
 	    default:
 		qDebug("Incorrect toolbar policy set");
 #ifdef USEQPE
 	    case cesSingle:
 #endif
 	    case cesMenuTool:
 		viewBar = fileBar;
 		break;
 	}
     }
     return viewBar;
 }
 QToolBar* QTReaderApp::navbar()
 {
     if (navBar == NULL)
     {
 	switch (m_tbpol)
 	{
 	    case cesMultiple:
 //		qDebug("Creating new nav bar");
 		navBar = new QToolBar("Navigation", this, m_tbposition);
 		break;
 	    default:
 		qDebug("Incorrect toolbar policy set");
 #ifdef USEQPE
 	    case cesSingle:
 #endif
 	    case cesMenuTool:
 		navBar = fileBar;
 //		qDebug("Setting navbar to filebar");
 		break;
 	}
     }
     return navBar;
 }
 QToolBar* QTReaderApp::markbar()
 {
     if (markBar == NULL)
     {
 	switch (m_tbpol)
 	{
 	    case cesMultiple:
 		markBar = new QToolBar("Marks", this, m_tbposition);
 		break;
 	    default:
 		qDebug("Incorrect toolbar policy set");
 #ifdef USEQPE
 	    case cesSingle:
 #endif
 	    case cesMenuTool:
 		markBar = fileBar;
 		break;
 	}
     }
     return markBar;
 }
 
 void QTReaderApp::addfilebar(Config* _config, const QString& key, QAction* a)
 {
     if (_config->readBoolEntry(key, false)) a->addTo( filebar() );
 }
 void QTReaderApp::addnavbar(Config* _config, const QString& key, QAction* a)
 {
     if (_config->readBoolEntry(key, false)) a->addTo( navbar() );
 }
 void QTReaderApp::addmarkbar(Config* _config, const QString& key, QAction* a)
 {
     if (_config->readBoolEntry(key, false)) a->addTo( markbar() );
 }
 void QTReaderApp::addviewbar(Config* _config, const QString& key, QAction* a)
 {
     if (_config->readBoolEntry(key, false)) a->addTo( viewbar() );
 }
 
 void QTReaderApp::suspend() { reader->suspend(); }
 
 void QTReaderApp::msgHandler(const QCString& _msg, const QByteArray& _data)
 {
 #ifndef USEMSGS
   return;
 #else
     QString msg = QString::fromUtf8(_msg);
 
     qDebug("Received:%s", (const char*)msg);
     QDataStream stream( _data, IO_ReadOnly );
     if ( msg == "suspend()" )
     {
       qDebug("Suspending");
       suspend();
       qDebug("Suspendedb");
     }
     return;
     /*
     QDataStream stream( _data, IO_ReadOnly );
     if ( msg == "info(QString)" )
     {
 	QString info;
 	stream >> info;
 	QMessageBox::information(this, PROGNAME, info);
     }
     else if ( msg == "Update(int)" )
     {
 	int info;
 	stream >> info;
 	if (info)
 	{
 	    reader->bDoUpdates = true;
 	    reader->refresh();
 	}
 	else
 	{
 	    reader->bDoUpdates = false;
 	}
     }
     else if ( msg == "warn(QString)" )
     {
 	QString info;
 	stream >> info;
 	QMessageBox::warning(this, PROGNAME, info);
     }
     else if ( msg == "exit()" )
     {
 	m_dontSave = true;
 	close();
     }
     else if ( msg == "pageDown()" )
     {
 	reader->dopagedn();
     }
     else if ( msg == "pageUp()" )
     {
 	reader->dopageup();
     }
     else if ( msg == "lineDown()" )
     {
 	reader->lineDown();
     }
     else if ( msg == "lineUp()" )
     {
 	reader->lineUp();
     }
     else if ( msg == "showText()" )
     {
 	showEditTools();
     }
     else if ( msg == "home()" )
     {
 	reader->goHome();
     }
     else if ( msg == "back()" )
     {
 	reader->goBack();
     }
     else if ( msg == "forward()" )
     {
 	reader->goForward();
     }
     else if ( msg == "File/Open(QString)" )
     {
 	QString info;
 	stream >> info;
 	openFile( info );
     }
     else if ( msg == "File/Info()" )
     {
 	showinfo();
     }
     else if ( msg == "File/Action(QString)" )
     {
 	QString info;
 	stream >> info;
 	m_spaceTarget = ActNameToInt(info);
     }
     else if ( msg == "Navigation/Scroll(int)" )
     {
 	int info;
 	stream >> info;
 	autoScroll(info);
     }
 
     else if ( msg == "Navigation/GotoStart()" )
     {
 	gotoStart();
     }
     else if ( msg == "Navigation/GotoEnd()" )
     {
 	gotoEnd();
     }
     else if ( msg == "Navigation/Jump(int)" )
     {
 	int info;
 	stream >> info;
 	reader->locate(info);
     }
     else if ( msg == "Navigation/Page/LineScroll(int)" )
     {
 	int info;
 	stream >> info;
 	pagemode(info);
     }
     else if ( msg == "Navigation/SetOverlap(int)" )
     {
 	int info;
 	stream >> info;
 	reader->m_overlap = info;
     }
     else if ( msg == "Navigation/SetMargin(int)" )
     {
 	int info;
 	stream >> info;
 	do_margin(info);
     }
     else if ( msg == "File/SetDictionary(QString)" )
     {
 	QString info;
 	stream >> info;
 	do_settarget(info);
     }
 #ifdef _SCROLLPIPE
     else if ( msg == "File/SetScrollTarget(QString)" )
     {
 	QString info;
 	stream >> info;
 	reader->m_pipetarget = info;
     }
 #endif
     else if ( msg == "File/Two/OneTouch(int)" )
     {
 	int info;
 	stream >> info;
 	setTwoTouch(info);
     }
     else if ( msg == "Target/Annotation(int)" )
     {
 	int info;
 	stream >> info;
 	OnAnnotation(info);
     }
     else if ( msg == "Target/Dictionary(int)" )
     {
 	int info;
 	stream >> info;
 	OnDictionary(info);
     }
     else if ( msg == "Target/Clipboard(int)" )
     {
 	int info;
 	stream >> info;
 	OnClipboard(info);
     }
     else if ( msg == "File/Find(QString)" )
     {
 	QString info;
 	stream >> info;
 	QRegExp arg(info);
 	size_t pos = reader->pagelocate();
 	size_t start = pos;
 	CDrawBuffer test(&(reader->m_fontControl));
 	reader->getline(&test);
 	while (arg.match(toQString(test.data())) == -1)
 	{
 	    pos = reader->locate();
 	    if (!reader->getline(&test))
 	    {
 		QMessageBox::information(this, PROGNAME, QString("Can't find\n")+info);
 		pos = start;
 		break;
 	    }
 	}
 	reader->locate(pos);
     }
     else if ( msg == "File/Fullscreen(int)" )
     {
 	int info;
 	stream >> info;
 	setfullscreen(info);
     }
     else if ( msg == "File/Continuous(int)" )
     {
 	int info;
 	stream >> info;
 	setcontinuous(info);
     }
     else if ( msg == "Markup(QString)" )
     {
 	QString info;
 	stream >> info;
 	if (info == "Auto")
 	{
 	    autofmt(true);
 	}
 	if (info == "None")
 	{
 	    autofmt(false);
 	    textfmt(false);
 	    striphtml(false);
 	    peanut(false);
 	}
 	if (info == "Text")
 	{
 	    textfmt(true);
 	}
 	if (info == "HTML")
 	{
 	    striphtml(true);
 	}
 	if (info == "Peanut/PML")
 	{
 	    peanut(true);
 	}
     }
     else if ( msg == "Layout/StripCR(int)" )
     {
 	int info;
 	stream >> info;
 	stripcr(info);
     }
     else if ( msg == "Layout/Dehyphen(int)" )
     {
 	int info;
 	stream >> info;
 	dehyphen(info);
     }
     else if ( msg == "Layout/Depluck(int)" )
     {
 	int info;
 	stream >> info;
 	depluck(info);
     }
     else if ( msg == "Layout/Dejpluck(int)" )
     {
 	int info;
 	stream >> info;
 	dejpluck(info);
     }
     else if ( msg == "Layout/SingleSpace(int)" )
     {
 	int info;
 	stream >> info;
 	onespace(info);
     }
     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;
 	}
 	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;
diff --git a/noncore/apps/opie-reader/opie-reader.control b/noncore/apps/opie-reader/opie-reader.control
index 60976b2..d53f70d 100644
--- a/noncore/apps/opie-reader/opie-reader.control
+++ b/noncore/apps/opie-reader/opie-reader.control
@@ -1,10 +1,10 @@
 Package: opie-reader
 Files: bin/reader lib/libreader* plugins/reader/* apps/Applications/opie-reader.desktop pics/opie-reader/*
 Priority: optional
 Section: opie/applications
 Maintainer: Tim Wentford <timwentford@hotmail.com>
 Architecture: arm
-Depends: task-opie-minimal
+Depends: task-opie-minimal, libopiecore2
 License: GPL
 Description: E-Book reader
 Version: $QPE_VERSION$EXTRAVERSION
diff --git a/noncore/apps/opie-reader/opie-reader.pro b/noncore/apps/opie-reader/opie-reader.pro
index 47980e1..da39154 100644
--- a/noncore/apps/opie-reader/opie-reader.pro
+++ b/noncore/apps/opie-reader/opie-reader.pro
@@ -1,24 +1,25 @@
 TEMPLATE        = subdirs
 SUBDIRS         = pluckerbaselib \
                   codeclib \
                   pdblib \
                   PluckerCodec \
                   AportisCodec \
                   CHM \
                   HTMLFilter \
                   WeaselCodec \
                   iSiloCodec \
                   ppmsCodec \
                   FliteCmd \
                   pluckerdecompress \
                   ArriereCodec \
                   RebCodec \
                   reader
+LIBS            += -lopiecore2
 
 # these are added only built if enabled in "make menuconfig"
 #                  FliteDyn
 #                  FliteDyn16
 
 include( $(OPIEDIR)/include.pro )