14 files changed, 56 insertions, 56 deletions

diff --git a/libopie2/opiecore/device/odevice_htc.cpp b/libopie2/opiecore/device/odevice_htc.cpp
index c21e10d..4e5200b 100644
--- a/libopie2/opiecore/device/odevice_htc.cpp
+++ b/libopie2/opiecore/device/odevice_htc.cpp
@@ -1,604 +1,603 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2002-2005 The Opie Team <opie-devel@handhelds.org>
               =.             Copyright (C) 2002-2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include "odevice_htc.h"
 
 /* OPIE */
 #include <opie2/oinputsystem.h>
 #include <opie2/oresource.h>
 
 #include <qpe/config.h>
 #include <qpe/sound.h>
 
 /* QT */
 #include <qapplication.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qwindowsystem_qws.h>
 #include <qcopchannel_qws.h>
 
 /* STD */
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <unistd.h>
 #ifndef QT_NO_SOUND
 #include <linux/soundcard.h>
 #endif
 
 using namespace Opie::Core;
 using namespace Opie::Core::Internal;
 
 struct htc_button htc_buttons [] = {
     { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
     "devicebuttons/z_calendar",
     "datebook", "nextView()",
     "today", "raise()" },
     { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
     "devicebuttons/z_contact",
     "addressbook", "raise()",
     "addressbook", "beamBusinessCard()" },
     { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
     "devicebuttons/z_home",
     "QPE/Launcher", "home()",
     "buttonsettings", "raise()" },
     { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
     "devicebuttons/z_menu",
     "QPE/TaskBar", "toggleMenu()",
     "QPE/TaskBar", "toggleStartMenu()" },
     { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
     "devicebuttons/z_mail",
     "opiemail", "raise()",
     "opiemail", "newMail()" },
 };
 
 struct htc_button htc_buttons_universal [] = {
     { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
     "devicebuttons/z_calendar",
     "datebook", "nextView()",
     "today", "raise()" },
     { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
     "devicebuttons/z_contact",
     "addressbook", "raise()",
     "addressbook", "beamBusinessCard()" },
     { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
     "devicebuttons/z_home",
     "QPE/Launcher", "home()",
     "buttonsettings", "raise()" },
     { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
     "devicebuttons/z_menu",
     "QPE/TaskBar", "toggleMenu()",
     "QPE/TaskBar", "toggleStartMenu()" },
     { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
     "devicebuttons/z_mail",
     "opiemail", "raise()",
     "opiemail", "newMail()" },
 
     { Qt::Key_F15, QT_TRANSLATE_NOOP("Button", "Hinge1"),
     "devicebuttons/z_hinge1",
     "QPE/Rotation", "rotateDefault()",0},
     { Qt::Key_F16, QT_TRANSLATE_NOOP("Button", "Hinge2"),
     "devicebuttons/z_hinge2",
     "QPE/Rotation", "rotateDefault()",0},
     { Qt::Key_F17, QT_TRANSLATE_NOOP("Button", "Hinge3"),
     "devicebuttons/z_hinge3",
     "QPE/Rotation", "rotateDefault()",0},
 };
 
 
 //
 //       HTC-Universal (PXA-model w/ 480x640 3.6" lcd)
 //       HTC-Alpine    (PXA-model w/ 240x320 3.5" lcd)
 //       HTC-Apache    (PXA-model w/ 240x320 2.8" lcd)
 //       HTC-Beetles   (PXA-model w/ 240x240 3.0" lcd)
 //       HTC-Blueangel (PXA-model w/ 240x320 3.5" lcd)
 //       HTC-Himalaya  (PXA-model w/ 240x320 3.5" lcd)
 //       HTC-Magician  (PXA-model w/ 240x320 2.8" lcd)
 
 void HTC::init(const QString& cpu_info)
 {
     qDebug( "HTC::init()" );
     // Set the time to wait until the system is really suspended
     // the delta between apm --suspend and sleeping
     setAPMTimeOut( 15000 );
 
     d->m_vendorstr = "Xanadux Team";
     d->m_systemstr = "Familiar";
     d->m_system = System_Familiar;
 
     // check the HTC model
     QString model;
     int loc = cpu_info.find( ":" );
     if ( loc != -1 )
         model = cpu_info.mid( loc+2 ).simplifyWhiteSpace();
     else
         model = cpu_info;
 
     d->m_model = Model_HTC_Universal;
     d->m_modelstr = "Unknown HTC";
 
     if ( model == "HTC Universal" ) {
         d->m_model = Model_HTC_Universal;
         d->m_modelstr = "HTC Universal";
     }
     if ( model == "HTC Alpine" ) {
         d->m_model = Model_HTC_Alpine;
         d->m_modelstr = "HTC Alpine";
     }
     if ( model == "HTC Apache" ) {
         d->m_model = Model_HTC_Apache;
         d->m_modelstr = "HTC Apache";
     }
     if ( model == "HTC Beetles" ) {
         d->m_model = Model_HTC_Beetles;
         d->m_modelstr = "HTC Beetles";
     }
     if ( model == "HTC Blueangel" ) {
         d->m_model = Model_HTC_Blueangel;
         d->m_modelstr = "HTC Blueangel";
     }
     if ( model == "HTC Himalaya" ) {
         d->m_model = Model_HTC_Himalaya;
         d->m_modelstr = "HTC Himalaya";
     }
     if ( model == "HTC Magician" ) {
         d->m_model = Model_HTC_Magician;
         d->m_modelstr = "HTC Magician";
     }
 
 
     // set path to backlight device
     switch ( d->m_model )
     {
         case Model_HTC_Universal:
         case Model_HTC_Magician:
         case Model_HTC_Alpine:
         case Model_HTC_Beetles:
         case Model_HTC_Apache:
             m_backlightdev = "/sys/class/backlight/pxa2xx-fb/";
         break;
         case Model_HTC_Blueangel:
         case Model_HTC_Himalaya:
             m_backlightdev = "/sys/class/backlight/w100fb/";
         break;
         default:
             m_backlightdev = "/sys/class/backlight/pxafb/";
     }
 
     // set initial rotation
     switch( d->m_model )
     {
         case Model_HTC_Universal:
             initHingeSensor();
             d->m_rotation = rotation();
             d->m_direction = direction();
             break;
         default:
             d->m_rotation = Rot270;
     }
 
     // set default qte driver
     switch( d->m_model )
     {
         default:
             d->m_qteDriver = "Transformed";
     }
 
     m_leds[0] = Led_Off;
 
     qDebug( "HTC::init() - Using the 2.6 Xanadux on a %s", (const char*) d->m_modelstr );
 }
 
 void HTC::initButtons()
 {
     qDebug( "HTC::initButtons()" );
     if ( d->m_buttons )
         return;
 
     d->m_buttons = new QValueList <ODeviceButton>;
 
     struct htc_button * phtc_buttons;
     int buttoncount;
     switch ( d->m_model )
     {
         case Model_HTC_Universal:
             if ( isQWS( ) )
             {
                 addPreHandler(this);
             }
             phtc_buttons = htc_buttons_universal;
             buttoncount = ARRAY_SIZE(htc_buttons_universal);
             break;
         default:
             phtc_buttons = htc_buttons;
             buttoncount = ARRAY_SIZE(htc_buttons);
             break;
     }
 
     for ( int i = 0; i < buttoncount; i++ ) {
         struct htc_button *zb = phtc_buttons + i;
         ODeviceButton b;
 
         b.setKeycode( zb->code );
         b.setUserText( QObject::tr( "Button", zb->utext ));
         b.setPixmap( OResource::loadPixmap( zb->pix ));
         b.setFactoryPresetPressedAction( OQCopMessage( makeChannel ( zb->fpressedservice ), zb->fpressedaction ));
         b.setFactoryPresetHeldAction( OQCopMessage( makeChannel ( zb->fheldservice ), zb->fheldaction ));
         d->m_buttons->append( b );
     }
 
     reloadButtonMapping();
 }
 
 
 
 typedef struct sharp_led_status {
     int which;   /* select which LED status is wanted. */
     int status;  /* set new led status if you call SHARP_LED_SETSTATUS */
 } sharp_led_status;
 
 void HTC::buzzer( int sound )
 {
 #ifndef QT_NO_SOUND
     Sound *snd = 0;
 
     // All devices except SL5500 have a DSP device
     if ( d->m_model == Model_HTC_Universal ) {
 
         switch ( sound ){
         case SHARP_BUZ_TOUCHSOUND: {
             static Sound touch_sound("touchsound");
             snd = &touch_sound;
     }
             break;
         case SHARP_BUZ_KEYSOUND: {
             static Sound key_sound( "keysound" );
             snd = &key_sound;
     }
             break;
         case SHARP_BUZ_SCHEDULE_ALARM:
         default: {
             static Sound alarm_sound("alarm");
             snd = &alarm_sound;
     }
             break;
         }
     }
 
     // If a soundname is defined, we expect that this device has
     // sound capabilities.. Otherwise we expect to have the buzzer
     // device..
     if ( snd && snd->isFinished() ){
         changeMixerForAlarm( 0, "/dev/sound/mixer", snd );
         snd->play();
     } else if( !snd ) {
         int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK );
 
         if ( fd >= 0 ) {
             ::ioctl ( fd, SHARP_BUZZER_MAKESOUND, sound );
             ::close ( fd );
         }
 
     }
 #endif
 }
 
 
 void HTC::playAlarmSound()
 {
     buzzer( SHARP_BUZ_SCHEDULE_ALARM );
 }
 
 void HTC::playTouchSound()
 {
     buzzer( SHARP_BUZ_TOUCHSOUND );
 }
 
 void HTC::playKeySound()
 {
     buzzer( SHARP_BUZ_KEYSOUND );
 }
 
 
 QValueList <OLed> HTC::ledList() const
 {
     QValueList <OLed> vl;
     vl << Led_Mail;
     return vl;
 }
 
 QValueList <OLedState> HTC::ledStateList( OLed l ) const
 {
     QValueList <OLedState> vl;
 
     if ( l == Led_Mail )
         vl << Led_Off << Led_On << Led_BlinkSlow;
     return vl;
 }
 
 OLedState HTC::ledState( OLed which ) const
 {
     if ( which == Led_Mail )
         return m_leds [0];
     else
         return Led_Off;
 }
 
 bool HTC::setLedState( OLed which, OLedState st )
 {
     qDebug( "HTC::setLedState: ODevice handling not yet implemented" );
     return false;
 }
 
 int HTC::displayBrightnessResolution() const
 {
     int res = 1;
 
     int fd = ::open( m_backlightdev + "max_brightness", O_RDONLY|O_NONBLOCK );
 
         if ( fd )
         {
             char buf[100];
             if ( ::read( fd, &buf[0], sizeof buf ) ) ::sscanf( &buf[0], "%d", &res );
             ::close( fd );
         }
 
     return res;
 }
 
 bool HTC::setDisplayBrightness( int bright )
 {
 
     //qDebug( "HTC::setDisplayBrightness( %d )", bright );
     bool res = false;
 
     if ( bright > 255 ) bright = 255;
     if ( bright < 0 ) bright = 0;
 
     int numberOfSteps = displayBrightnessResolution();
     int val = ( bright == 1 ) ? 1 : ( bright * numberOfSteps ) / 255;
 
     int fd = ::open( m_backlightdev + "brightness", O_WRONLY|O_NONBLOCK );
     if ( fd )
     {
       char buf[100];
       int len = ::snprintf( &buf[0], sizeof buf, "%d", val );
       res = ( ::write( fd, &buf[0], len ) == 0 );
       ::close( fd );
     }
     return res;
 }
 
 bool HTC::setDisplayStatus( bool on )
 {
 
     bool res = false;
 
     int fd = ::open( m_backlightdev + "power", O_WRONLY|O_NONBLOCK );
     if ( fd )
     {
      char buf[10];
      buf[0] = on ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
      buf[1] = '\0';
      res = ( ::write( fd, &buf[0], 2 ) == 0 );
      ::close( fd );
     }
     return res;
 }
 
 Transformation HTC::rotation() const
 {
     qDebug( "HTC::rotation()" );
-    Transformation rot;
+    Transformation rot = Rot270;
 
     switch ( d->m_model ) {
         case Model_HTC_Universal:
         {
             OHingeStatus hs = readHingeSensor();
             qDebug( "HTC::rotation() - hinge sensor = %d", (int) hs );
             if ( hs == CASE_PORTRAIT ) rot = Rot0;
             else if ( hs == CASE_UNKNOWN ) rot = Rot270;
-            else rot = Rot270;
         }
         break;
     }
 
     qDebug( "HTC::rotation() - returning '%d'", rot );
     return rot;
 }
 ODirection HTC::direction() const
 {
     ODirection dir;
 
     switch ( d->m_model ) {
         case Model_HTC_Universal: {
                 OHingeStatus hs = readHingeSensor();
                 if ( hs == CASE_PORTRAIT ) dir = CCW;
                 else if ( hs == CASE_UNKNOWN ) dir = CCW;
                 else dir = CW;
             }
             break;
         default: dir = d->m_direction;
             break;
     }
     return dir;
 
 }
 
 bool HTC::hasHingeSensor() const
 {
     return d->m_model == Model_HTC_Universal;
 }
 
 OHingeStatus HTC::readHingeSensor() const
 {
         /*
          * The HTC Universal keyboard is event source 1 in kernel 2.6.
          * Hinge status is reported via Input System Switchs 0 and 1 like that:
          *
          * -------------------------
          * | SW0 | SW1 |    CASE   |
          * |-----|-----|-----------|
          * |  0     0    Unknown   |
          * |  1     0    Portrait  |
          * |  0     1    Closed    |
          * |  1     1    Landscape |
          * -------------------------
          */
         OInputDevice* keyboard = OInputSystem::instance()->device( "event1" );
         bool switch0 = true;
         bool switch1 = false;
         if ( keyboard )
         {
             switch0 = keyboard->isHeld( OInputDevice::Switch0 );
             switch1 = keyboard->isHeld( OInputDevice::Switch1 );
         }
         if ( switch0 )
         {
             return switch1 ? CASE_LANDSCAPE : CASE_PORTRAIT;
         }
         else
         {
             return switch1 ? CASE_CLOSED : CASE_UNKNOWN;
         }
 }
 
 void HTC::initHingeSensor()
 {
     if ( m_embedix ) return;
 
     m_hinge.setName( "/dev/input/event1" );
     if ( !m_hinge.open( IO_ReadOnly ) )
     {
         qWarning( "HTC::init() - Couldn't open /dev/input/event1 for read (%s)", strerror( errno ) );
         return;
     }
 
     QSocketNotifier* sn = new QSocketNotifier( m_hinge.handle(), QSocketNotifier::Read, this );
     QObject::connect( sn, SIGNAL(activated(int)), this, SLOT(hingeSensorTriggered()) );
 
     qDebug( "HTC::init() - Hinge Sensor Initialization successfully completed" );
 }
 
 void HTC::hingeSensorTriggered()
 {
     qDebug( "HTC::hingeSensorTriggered() - got event" );
     struct input_event e;
     if ( ::read( m_hinge.handle(), &e, sizeof e ) > 0 )
     {
         qDebug( "HTC::hingeSensorTriggered() - event has type %d, code %d, value %d", e.type, e.code, e.value );
         if ( e.type != EV_SW ) return;
         if ( readHingeSensor() != CASE_UNKNOWN )
         {
             qDebug( "HTC::hingeSensorTriggered() - got valid switch event, calling rotateDefault()" );
             QCopChannel::send( "QPE/Rotation", "rotateDefault()" );
         }
     }
 }
 
 void HTC::systemMessage( const QCString &msg, const QByteArray & )
 {
     if ( msg == "deviceButtonMappingChanged()" ) {
         reloadButtonMapping();
     }
 }
 
 /*
  * Take code from iPAQ device.
  * That way we switch the cursor directions depending on status of hinge sensor, eg. hardware direction.
  * I hope that is ok - Alwin
  */
 bool HTC::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat )
 {
     int newkeycode = keycode;
 
     if ( !hasHingeSensor() ) return false;
 
     /* map cursor keys depending on the hinge status */
     switch ( keycode ) {
         // Rotate cursor keys
         case Key_Left :
         case Key_Right:
         case Key_Up   :
         case Key_Down :
         {
             if (rotation()==Rot90) {
                 newkeycode = Key_Left + ( keycode - Key_Left + 3 ) % 4;
             }
         }
         break;
 
     }
     if (newkeycode!=keycode) {
         if ( newkeycode != Key_unknown ) {
             QWSServer::sendKeyEvent ( -1, newkeycode, modifiers, isPress, autoRepeat );
         }
         return true;
     }
     return false;
 }
 
 bool HTC::suspend() {
 
 /* MV */
         return false;
 
     if ( !isQWS( ) ) // only qwsserver is allowed to suspend
         return false;
 
     bool res = false;
     QCopChannel::send( "QPE/System", "aboutToSuspend()" );
 
     struct timeval tvs, tvn;
     ::gettimeofday ( &tvs, 0 );
 
     ::sync(); // flush fs caches
     res = ( ::system ( "apm --suspend" ) == 0 );
 
     // This is needed because some apm implementations are asynchronous and we
     // can not be sure when exactly the device is really suspended
     // This can be deleted as soon as a stable familiar with a synchronous apm implementation exists.
     // on non embedix eg. 2.6 kernel line apm is synchronous so we don't need it here.
 
     if ( res && m_embedix) {
         do { // wait at most 1.5 sec: either suspend didn't work or the device resumed
             ::usleep ( 200 * 1000 );
             ::gettimeofday ( &tvn, 0 );
         } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < m_timeOut );
     }
 
     QCopChannel::send( "QPE/System", "returnFromSuspend()" );
 
     return res;
 }
diff --git a/libopie2/opiepim/private/opimeventsortvector.cpp b/libopie2/opiepim/private/opimeventsortvector.cpp
index 4220c63..b85f848 100644
--- a/libopie2/opiepim/private/opimeventsortvector.cpp
+++ b/libopie2/opiepim/private/opimeventsortvector.cpp
@@ -1,134 +1,131 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2004 Stefan Eilers <stefan@eilers-online.net>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include "opimeventsortvector.h"
 #include <opie2/ocontactaccess.h>
 #include <opie2/opimnotifymanager.h>
 #include <opie2/odatebookaccess.h>
 
 #include <qvaluelist.h>
 
 namespace Opie {
 namespace Internal {
 
-namespace{
-
-inline int testAlarmNotifiers( const OPimNotifyManager& leftnotifiers, const OPimNotifyManager& rightnotifiers ){
+int testAlarmNotifiers( const OPimNotifyManager& leftnotifiers, const OPimNotifyManager& rightnotifiers ){
         OPimNotifyManager::Alarms left_alarms = leftnotifiers.alarms();
         OPimNotifyManager::Alarms right_alarms = rightnotifiers.alarms();
         
         // Well.. How could we compare two lists of alarms? I think we should find the most early datetimes
         // and compare them.. (se)
         // Find the first alarm of the left list
         OPimNotifyManager::Alarms::Iterator it;
         QDateTime left_earliest; // This datetime is initialized as invalid!!
         for ( it = left_alarms.begin(); it != left_alarms.end(); ++it ){
                 if ( !left_earliest.isValid() || left_earliest > (*it).dateTime() ){
                         left_earliest = (*it).dateTime();
                 }
         }
         QDateTime right_earliest; // This datetime is initialized as invalid!!
         for ( it = right_alarms.begin(); it != right_alarms.end(); ++it ){
                 if ( !right_earliest.isValid() || right_earliest > (*it).dateTime() ){
                         right_earliest = (*it).dateTime();
                 }
         }
         
-        int ret;
+        int ret = 0;
         
         // Now compare this found alarms
         if ( !left_earliest .isValid() ) ret++;
         if ( !right_earliest.isValid() ) ret--;
         
         if ( left_earliest.isValid() && right_earliest.isValid() ){
-                ret += left_earliest < right_earliest ? -1 : 1;    
+                left_earliest < right_earliest ? ret-- : ret++;
         }
         
         return ret;
         
 }
-}
 
 OPimEventSortVector::OPimEventSortVector( uint size, bool asc, int sort )
     : OPimSortVector<OPimEvent>( size, asc, sort ) {}
 
 int OPimEventSortVector::compareItems( const OPimEvent& left,
                                          const OPimEvent& right ) {
     if ( left.uid() == right.uid() )
         return 0;
 
     int ret = 0;
     bool asc = sortAscending();
 
     switch( sortOrder() ) {
     case ODateBookAccess::SortDescription:
         ret = testString( left.description(), right.description() );
         break;
     case ODateBookAccess::SortLocation:
         ret = testString( left.location(), right.location() );
         break;
     case ODateBookAccess::SortNote:
         ret = testString( left.note(),right.note() );
         break;
     case ODateBookAccess::SortStartTime:
             ret = testTime( left.startDateTime().time(), right.startDateTime().time() );
         break;
     case ODateBookAccess::SortEndTime:
             ret = testTime( left.endDateTime().time(), right.endDateTime().time() );
         break;
     case ODateBookAccess::SortStartDate:
             ret = testDate( left.startDateTime().date(), right.startDateTime().date() );
         break;
     case ODateBookAccess::SortEndDate:
             ret = testDate( left.endDateTime().date(), right.endDateTime().date() );
         break;
     case ODateBookAccess::SortStartDateTime:
             ret = testDateTime( left.startDateTime(), right.startDateTime() );
         break;
     case ODateBookAccess::SortEndDateTime:
             ret = testDateTime( left.endDateTime(), right.endDateTime() );
         break;
     case ODateBookAccess::SortAlarmDateTime:
             ret = testAlarmNotifiers( left.notifiers(), right.notifiers() );
         break;
     default:
             odebug << "OpimEventSortVector: Unknown sortOrder: " << sortOrder() << oendl;
     }
 
     /* twist to honor ascending/descending setting as QVector only sorts ascending */
     if ( !asc )
         ret *= -1;
 
     //  Maybe differentiate as in OPimTodoSortVector ### FIXME
     //  if( ret )
     return ret;
 }
 
 }
 }
diff --git a/noncore/apps/confedit/listviewitemconffile.cpp b/noncore/apps/confedit/listviewitemconffile.cpp
index 2958cf5..a7d6b00 100644
--- a/noncore/apps/confedit/listviewitemconffile.cpp
+++ b/noncore/apps/confedit/listviewitemconffile.cpp
@@ -1,165 +1,170 @@
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 // (c) 2002 Patrick S. Vogt <tille@handhelds.org>
 
 #include "listviewitemconffile.h"
 #include "listviewitemconfigentry.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qmessagebox.h>
 #include <qtextstream.h>
 
 #define tr QObject::tr
 
 ListViewItemConfFile::ListViewItemConfFile(QFileInfo *file, QListView *parent)
    : ListViewItemConf(parent), _valid(false)
 {
   confFileInfo = file;
   //  parseFile();
   displayText();
 }
 
 ListViewItemConfFile::~ListViewItemConfFile()
 {
 }
 
 
 void ListViewItemConfFile::displayText()
 {
           setText(0,(_changed?"*":"")+confFileInfo->fileName());
 }
 
 QString ListViewItemConfFile::fileName()
 {
-        return confFileInfo->fileName();
+  return confFileInfo->fileName();
 }
 
 void ListViewItemConfFile::parseFile()
 {
-        //odebug << "ListViewItemConfFile::parseFile BEGIN" << oendl; 
-        QFile confFile(confFileInfo->absFilePath());
-        if(! confFile.open(IO_ReadOnly))
-                        QMessageBox::critical(0,tr("Could not open"),tr("The file ")+confFileInfo->fileName()+tr(" could not be opened."),1,0);
-        QTextStream t( &confFile );
-         QString s;
+  //odebug << "ListViewItemConfFile::parseFile BEGIN" << oendl;
+  QFile confFile(confFileInfo->absFilePath());
+  if(! confFile.open(IO_ReadOnly))
+    QMessageBox::critical(0,tr("Could not open"),tr("The file ")+confFileInfo->fileName()+tr(" could not be opened."),1,0);
+
+  QTextStream t( &confFile );
+  QString s;
   QString group;
-  ListViewItemConfigEntry *groupItem;
+  ListViewItemConfigEntry *groupItem = 0;
   ListViewItemConfigEntry *item;
   while ( !t.atEnd() )
   {
-          s = t.readLine().stripWhiteSpace();
-                //odebug << "line: >" << s.latin1() << "<\n" << oendl; 
-          if (s.contains("<?xml"))
-           {
-            _valid = false;
-                        break;
-    }else
-    if ( s[0] == '[' && s[s.length()-1] == ']' )
-           {
-  //    odebug << "got group"+s << oendl; 
+    s = t.readLine().stripWhiteSpace();
+    //odebug << "line: >" << s.latin1() << "<\n" << oendl;
+    if (s.contains("<?xml"))
+    {
+      _valid = false;
+      break;
+    }
+    else if ( s[0] == '[' && s[s.length()-1] == ']' )
+    {
+      //odebug << "got group"+s << oendl;
       group = s.mid(1,s.length()-2);
-      if (!groupItem) groupItem = new ListViewItemConfigEntry(this, tr("no group") );
+      if (!groupItem)
+        groupItem = new ListViewItemConfigEntry(this, tr("no group") );
+
       groupItem = new ListViewItemConfigEntry(this, group );
       insertItem( groupItem );
-    } else
-    if ( int pos = s.find('=') )
+    }
+    else if ( int pos = s.find('=') )
     {
-//      odebug << "got key"+s << oendl; 
-             if (!groupItem) odebug << "PANIK NO GROUP! >" << group.latin1() << "<" << oendl; 
-            item = new ListViewItemConfigEntry(this, group, s );
+      //odebug << "got key"+s << oendl;
+      if (!groupItem)
+        odebug << "PANIC! no group >" << group.latin1() << "<" << oendl;
+
+      item = new ListViewItemConfigEntry(this, group, s );
       groupItem->insertItem( item );
     }
           }
-        confFile.close();
-        setExpandable( _valid );
-        //odebug << "ListViewItemConfFile::parseFile END" << oendl; 
+  confFile.close();
+  setExpandable( _valid );
+  //odebug << "ListViewItemConfFile::parseFile END" << oendl;
 }
 
 
 void ListViewItemConfFile::remove()
 {
   QFile::remove(confFileInfo->absFilePath());
   QFile::remove(backupFileName());
   delete this;
 }
 
 void ListViewItemConfFile::revert()
 {
         if (!_changed)
          {
           // read the backup file
                  QFile conf(confFileInfo->absFilePath());
           QFile back(backupFileName());
 
           if (!back.open(IO_ReadOnly)) return;
           if (!conf.open(IO_WriteOnly)) return;
 
           #define SIZE 124
           char buf[SIZE];
           while (int c = back.readBlock(buf, SIZE) ) conf.writeBlock(buf,c);
           conf.close();
           back.close();
   }
   parseFile();
   expand();
 }
 
 void ListViewItemConfFile::save()
 {
         if (!_changed) return;
          QFile conf(confFileInfo->absFilePath());
   QFile back(backupFileName());
 
   if (!conf.open(IO_ReadOnly)) return;
   if (!back.open(IO_WriteOnly)) return;
 
   char buf[SIZE];
   while (int c = conf.readBlock(buf, SIZE) ) back.writeBlock(buf,c);
   conf.close();
   back.close();
 
 
   if (!conf.open(IO_WriteOnly)) return;
          QTextStream *t = new QTextStream( &conf );
   for (QListViewItem *it = firstChild(); it!=0;it = it->nextSibling())
   {
            ((ListViewItemConfigEntry*)it)->save(t);
   }
         conf.close();
          unchanged();
 }
 
 
 bool ListViewItemConfFile::revertable()
 {
          return _changed || QFile(backupFileName()).exists();
 }
 
 QString ListViewItemConfFile::backupFileName()
 {
         return confFileInfo->absFilePath()+"~";
 }
 
 
 void ListViewItemConfFile::expand()
 {
         QListViewItem *subItem = firstChild();
         QListViewItem *toDel;
          while(subItem)
   {
           toDel = subItem;
            subItem = subItem->nextSibling();
            delete toDel;
   }
         parseFile();
 }
diff --git a/noncore/apps/opie-console/io_irda.cpp b/noncore/apps/opie-console/io_irda.cpp
index 9d27c85..a0f72ae 100644
--- a/noncore/apps/opie-console/io_irda.cpp
+++ b/noncore/apps/opie-console/io_irda.cpp
@@ -1,64 +1,65 @@
 #include "io_irda.h"
 
 IOIrda::IOIrda( const Profile &config ) : IOSerial( config ) {
     m_attach = 0;
 }
 
 
 IOIrda::~IOIrda() {
     if ( m_attach ) {
         delete m_attach;
     }
 }
 
 
 void IOIrda::close() {
 
     IOSerial::close();
     // still need error handling
     delete m_attach;
 }
 
 bool IOIrda::open() {
     bool ret;
 
     // irdaattach here
     m_attach = new Opie::Core::OProcess();
     *m_attach << "irattach /dev/ttyS2 -s";
 
     connect( m_attach, SIGNAL( processExited(Opie::Core::OProcess*) ),
              this, SLOT( slotExited(Opie::Core::OProcess*) ) );
 
     if ( m_attach->start() ) {
         ret= IOSerial::open();
     } else {
     // emit error!!!
         delete m_attach;
         m_attach = 0l;
+        ret = false;
     }
     return ret;
 }
 
 void IOIrda::reload( const Profile &config ) {
     m_device = config.readEntry("Device", IRDA_DEFAULT_DEVICE);
     m_baud = config.readNumEntry("Baud", IRDA_DEFAULT_BAUD);
     m_parity = config.readNumEntry("Parity", IRDA_DEFAULT_PARITY);
     m_dbits = config.readNumEntry("DataBits", IRDA_DEFAULT_DBITS);
     m_sbits = config.readNumEntry("StopBits", IRDA_DEFAULT_SBITS);
     m_flow = config.readNumEntry("Flow", IRDA_DEFAULT_FLOW);
 }
 
 
 QString IOIrda::identifier() const {
     return "irda";
 }
 
 QString IOIrda::name() const {
     return "Irda IO Layer";
 }
 
 void IOIrda::slotExited(Opie::Core::OProcess* proc ){
     close();
     delete proc;
 }
 
diff --git a/noncore/apps/opie-console/mainwindow.cpp b/noncore/apps/opie-console/mainwindow.cpp
index aba7244..a884179 100644
--- a/noncore/apps/opie-console/mainwindow.cpp
+++ b/noncore/apps/opie-console/mainwindow.cpp
@@ -1,835 +1,831 @@
 #include "TEmulation.h"
 #include "profileeditordialog.h"
 #include "configdialog.h"
 #include "default.h"
 #include "profilemanager.h"
 #include "mainwindow.h"
 #include "tabwidget.h"
 #include "transferdialog.h"
 #include "function_keyboard.h"
 #include "emulation_handler.h"
 #include "script.h"
 #include "fixit.h"
 
 /* OPIE */
 #include <opie2/ofiledialog.h>
 #include <opie2/oresource.h>
 #include <qpe/filemanager.h>
 using namespace Opie::Ui;
 
 /* QT */
 #include <qaction.h>
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qmessagebox.h>
 #include <qwhatsthis.h>
 #include <qfileinfo.h>
 
 /* STD */
 #include <assert.h>
 
 #include <opie2/oconfig.h>
 
 MainWindow::MainWindow(QWidget *parent, const char *name, WFlags) : QMainWindow(parent, name, WStyle_ContextHelp)  {
 
 #ifdef FSCKED_DISTRI
    FixIt fix;
    fix.fixIt();
 #endif
 
     setCaption(QObject::tr("Opie Console") );
     KeyTrans::loadAll();
     for (int i = 0; i < KeyTrans::count(); i++ ) {
         KeyTrans* s = KeyTrans::find(i );
         assert( s );
     }
     m_factory = new MetaFactory();
     Default def(m_factory);
     m_sessions.setAutoDelete( TRUE );
     m_curSession = 0;
     m_manager = new ProfileManager( m_factory );
     m_manager->load();
     m_scriptsData.setAutoDelete(TRUE);
 
     initUI();
     populateProfiles();
     populateScripts();
 }
 
 void MainWindow::initUI() {
 
     setToolBarsMovable( FALSE  );
 
     /* tool bar for the menu */
     m_tool = new QToolBar( this );
     m_tool->setHorizontalStretchable( TRUE );
 
     m_bar = new QMenuBar( m_tool );
     m_console = new QPopupMenu( this );
     m_scripts = new QPopupMenu( this );
     m_sessionsPop= new QPopupMenu( this );
     m_scriptsPop = new QPopupMenu( this );
     m_scrollbar = new QPopupMenu( this );
 
     /* add a toolbar for icons */
     m_icons = new QToolBar(this);
 
     /*
      * the settings action
      */
     m_setProfiles = new QAction(tr("Configure Profiles"),
                                 Opie::Core::OResource::loadPixmap( "SettingsIcon", Opie::Core::OResource::SmallIcon ),
                                 QString::null, 0, this, 0);
     m_setProfiles->addTo( m_console );
     connect( m_setProfiles, SIGNAL(activated() ),
              this, SLOT(slotConfigure() ) );
 
     m_console->insertSeparator();
     /*
      * new Action for new sessions
      */
     QAction* newCon = new QAction(tr("New Profile"),
                                   Opie::Core::OResource::loadPixmap( "new", Opie::Core::OResource::SmallIcon ),
                                   QString::null, 0, this, 0);
     newCon->addTo( m_console );
     connect( newCon, SIGNAL(activated() ),
             this, SLOT(slotNew() ) );
 
     m_console->insertSeparator();
 
     QAction *saveCon = new QAction( tr("Save Profile" ),
                                     Opie::Core::OResource::loadPixmap( "save", Opie::Core::OResource::SmallIcon ), QString::null,
                                     0, this, 0 );
     saveCon->addTo( m_console );
     connect( saveCon, SIGNAL(activated() ),
             this, SLOT(slotSaveSession() ) );
     m_console->insertSeparator();
 
     /*
      * connect action
      */
     m_connect = new QAction( tr("Connect"), Opie::Core::OResource::loadPixmap("console/connected",
                              Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
     m_connect->addTo( m_console );
     connect(m_connect, SIGNAL(activated() ),
             this, SLOT(slotConnect() ) );
 
     /*
      * disconnect action
      */
     m_disconnect = new QAction( tr("Disconnect"), Opie::Core::OResource::loadPixmap("console/notconnected",
                                 Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
     m_disconnect->addTo( m_console );
     connect(m_disconnect, SIGNAL(activated() ),
             this, SLOT(slotDisconnect() ) );
 
     m_console->insertSeparator();
 
 #ifndef EAST
     m_quickLaunch = new QAction( tr("QuickLaunch"),
                                  Opie::Core::OResource::loadPixmap("console/konsole_mini", Opie::Core::OResource::SmallIcon ),
                                  QString::null,  0,  this, 0 );
     m_quickLaunch->addTo( m_icons );
     connect( m_quickLaunch,  SIGNAL( activated() ),
              this,  SLOT( slotQuickLaunch() ) );
 #endif
 
     QWhatsThis::add( m_icons, tr( "The shell button launches the \"default\" profile. If there is none default values are taken" ) );
 
     m_transfer = new QAction( tr("Transfer file..."), Opie::Core::OResource::loadPixmap("pass", Opie::Core::OResource::SmallIcon ),
                               QString::null, 0, this, 0  );
     m_transfer->addTo( m_console );
     connect(m_transfer, SIGNAL(activated() ),
             this, SLOT(slotTransfer() ) );
 
 
 
     /*
      * immediate change of line wrap policy
      */
     m_isWrapped = true;
     m_wrap = new QAction( tr("Line wrap"), Opie::Core::OResource::loadPixmap( "linewrap", Opie::Core::OResource::SmallIcon ),
                           QString::null, 0, this, 0, true );
     m_wrap->addTo( m_console );
     m_wrap->setOn( true );
     connect( m_wrap, SIGNAL( activated() ), SLOT( slotWrap() ) );
 
     /*
      * fullscreen
      */
     m_isFullscreen = false;
 
     m_fullscreen = new QAction( tr("Full screen"), Opie::Core::OResource::loadPixmap( "fullscreen",
                                 Opie::Core::OResource::SmallIcon ), QString::null, 0, this, 0 );
     m_fullscreen->addTo( m_console );
     connect( m_fullscreen, SIGNAL( activated() ),
              this,  SLOT( slotFullscreen() ) );
 
         /*
          * scrollbar
          */
     sm_none = m_scrollbar->insertItem(tr( "None" ));
     sm_left = m_scrollbar->insertItem(tr( "Left" ));
     sm_right = m_scrollbar->insertItem(tr( "Right" ));
 
     m_console->insertItem(tr("Scrollbar"), m_scrollbar, -1, 0);
     connect( m_scrollbar, SIGNAL(activated(int)),
                          this, SLOT(slotScrollbarSelected(int)));
 
     m_console->insertSeparator();
 
         m_recordLog = new QAction();
         m_recordLog->setText( tr("Start log") );
         m_recordLog->addTo( m_console );
         connect(m_recordLog, SIGNAL(activated() ), 
                         this, SLOT( slotSaveLog() ) );
          m_recordingLog = false;
 
     QAction *a = new QAction();
     a->setText( tr("Save history") );
     a->addTo( m_console );
     connect(a, SIGNAL(activated() ),
             this, SLOT(slotSaveHistory() ) );
     /*
      * terminate action
      */
     m_terminate = new QAction();
     m_terminate->setText( tr("Terminate") );
     m_terminate->addTo( m_console );
     connect(m_terminate, SIGNAL(activated() ),
             this, SLOT(slotTerminate() ) );
 
     m_closewindow = new QAction();
     m_closewindow->setText( tr("Close Window") );
     m_closewindow->addTo( m_console );
     connect( m_closewindow, SIGNAL(activated() ),
             this, SLOT(slotClose() ) );
 
 
     /*
      * script actions
      */
     m_runScript_id = m_scripts->insertItem(tr("Run Script"), m_scriptsPop, -1, 0);
     connect(m_scriptsPop, SIGNAL(activated(int)), this, SLOT(slotRunScript(int)));
 
     m_recordScript = new QAction(tr("Record Script"), QString::null, 0, this, 0);
     m_recordScript->addTo(m_scripts);
     connect(m_recordScript, SIGNAL(activated()), this, SLOT(slotRecordScript()));
 
     m_saveScript = new QAction(tr("Save Script"), QString::null, 0, this, 0);
     m_saveScript->addTo(m_scripts);
     connect(m_saveScript, SIGNAL(activated()), this, SLOT(slotSaveScript()));
    
          
         
         
     /*
      * action that open/closes the keyboard
      */
     m_openKeys = new QAction (tr("Open Keyboard..."),
                               Opie::Core::OResource::loadPixmap( "console/keys/keyboard_icon", Opie::Core::OResource::SmallIcon ),
                              QString::null, 0, this, 0);
     m_openKeys->setToggleAction(true);
     connect (m_openKeys, SIGNAL(toggled(bool)), this, SLOT(slotOpenKeb(bool)));
 
     /* insert the submenu */
     m_console->insertItem(tr("New from Profile"), m_sessionsPop,
                           -1, 0);
 
     /* insert the connection menu */
     m_bar->insertItem( tr("Connection"), m_console );
 
     /* the scripts menu */
 #ifdef EAST
     Opie::Core::OConfig cfg("opie-console");
         cfg.setGroup("10east");
            if( !cfg.readEntry("scripthide",0) ) {
             m_bar->insertItem( tr("Scripts"), m_scripts );
     }
 #endif
 
     /* and the keyboard */
     m_keyBar = new QToolBar(this);
     addToolBar( m_keyBar,  "Keyboard", QMainWindow::Top, TRUE );
     m_keyBar->setHorizontalStretchable( TRUE );
     m_keyBar->hide();
 
     m_kb = new FunctionKeyboard(m_keyBar);
     connect(m_kb, SIGNAL(keyPressed(FKey,ushort,ushort,bool)),
             this, SLOT(slotKeyReceived(FKey,ushort,ushort,bool)));
 
 
     a = new QAction(tr("Copy"),
                     Opie::Core::OResource::loadPixmap("copy", Opie::Core::OResource::SmallIcon ), QString::null,
                     0, this, 0 );
     //a->addTo( m_icons );
     connect( a, SIGNAL(activated() ),
              this, SLOT(slotCopy() ) );
 
     QAction *paste = new QAction(tr("Paste"),
                                  Opie::Core::OResource::loadPixmap("paste", Opie::Core::OResource::SmallIcon ), QString::null,
                     0, this, 0 );
     connect( paste, SIGNAL(activated() ),
              this, SLOT(slotPaste() ) );
 
 
     newCon->addTo( m_icons );
     //m_setProfiles->addTo( m_icons );
     paste->addTo( m_icons );
     m_openKeys->addTo(m_icons);
     m_fullscreen->addTo( m_icons );
 
     m_connect->setEnabled( false );
     m_disconnect->setEnabled( false );
     m_terminate->setEnabled( false );
     m_transfer->setEnabled( false );
     m_scripts->setItemEnabled(m_runScript_id, false);
     m_recordScript->setEnabled( false );
     m_saveScript->setEnabled( false );
     m_fullscreen->setEnabled( false );
     m_closewindow->setEnabled( false );
     m_wrap->setEnabled( false );
 
     /*
      * connect to the menu activation
      */
     connect( m_sessionsPop, SIGNAL(activated(int) ),
              this, SLOT(slotProfile(int) ) );
 
     m_consoleWindow = new TabWidget( this, "blah");
     connect(m_consoleWindow, SIGNAL(activated(Session*) ),
             this, SLOT(slotSessionChanged(Session*) ) );
     setCentralWidget( m_consoleWindow );
 
     slotQuickLaunch();
 }
 
 ProfileManager* MainWindow::manager() {
     return m_manager;
 }
 TabWidget* MainWindow::tabWidget() {
     return m_consoleWindow;
 }
 void MainWindow::populateProfiles() {
     m_sessionsPop->clear();
     Profile::ValueList list = manager()->all();
     for (Profile::ValueList::Iterator it = list.begin(); it != list.end(); ++it ) {
         m_sessionsPop->insertItem( (*it).name() );
     }
 
 }
 
 void MainWindow::populateScripts() {
     m_scriptsPop->clear();
     m_scriptsData.clear();
     DocLnkSet files(QPEApplication::documentDir(), "text/plain");
     QListIterator<DocLnk> dit(files.children());
     for (; dit.current(); ++dit) {
         if (*dit && (*dit)->name().length()>0) {
             QFileInfo info((*dit)->file());
             if (info.extension(false) == "script") {
                 m_scriptsData.append(new DocLnk(**dit));
                 m_scriptsPop->insertItem((*dit)->name());
             }
         }
     }
 
 }
 
 MainWindow::~MainWindow() {
     delete m_factory;
     manager()->save();
 #ifdef FSCKED_DISTRI
     FixIt fix;
     fix.breakIt();
 #endif
 }
 
 MetaFactory* MainWindow::factory() {
     return m_factory;
 }
 
 Session* MainWindow::currentSession() {
     return m_curSession;
 }
 
 QList<Session> MainWindow::sessions() {
     return m_sessions;
 }
 
 void MainWindow::slotNew() {
     ProfileEditorDialog dlg(factory() );
     dlg.setCaption( tr("New Connection") );
     int ret = QPEApplication::execDialog( &dlg );
 
     if ( ret == QDialog::Accepted ) {
         create( dlg.profile() );
     }
 }
 
 void MainWindow::slotRecordScript() {
     if (currentSession()) {
         currentSession()->emulationHandler()->startRecording();
         m_saveScript->setEnabled(true);
         m_recordScript->setEnabled(false);
     }
 }
 
 void MainWindow::slotSaveScript() {
     if (currentSession() && currentSession()->emulationHandler()->isRecording()) {
         QMap<QString, QStringList> map;
         QStringList text;
         text << "text/plain";
         map.insert(tr("Script"), text );
         QString filename = OFileDialog::getSaveFileName(2, QPEApplication::documentDir(), QString::null, map);
         if (!filename.isEmpty()) {
             QFileInfo info(filename);
             if (info.extension(FALSE) != "script")
                 filename += ".script";
             DocLnk nf;
             nf.setType("text/plain");
             nf.setFile(filename);
             nf.setName(info.fileName());
             FileManager fm;
             fm.saveFile(nf, currentSession()->emulationHandler()->script()->script());
             currentSession()->emulationHandler()->clearScript();
             m_saveScript->setEnabled(false);
             m_recordScript->setEnabled(true);
             populateScripts();
         }
     }
 }
 
 void MainWindow::slotRunScript(int id) {
     if (currentSession()) {
         int index = m_scriptsPop->indexOf(id);
         DocLnk *lnk = m_scriptsData.at(index);
         QString filePath = lnk->file();
         Script script(filePath);
         currentSession()->emulationHandler()->runScript(&script);
     }
 }
 
 void MainWindow::slotConnect() {
     if ( currentSession() ) {
         bool ret = currentSession()->layer()->open();
         if(!ret) QMessageBox::warning(currentSession()->widgetStack(),
                                       QObject::tr("Failed"),
                                       QObject::tr("Connecting failed for this session."));
         else {
             m_connect->setEnabled( false );
             m_disconnect->setEnabled( true );
 
             // if it does not support file transfer, disable the menu entry
             if ( ( m_curSession->layer() )->supports()[1] == 0 ) {
                 m_transfer->setEnabled( false );
             } else {
                 m_transfer->setEnabled( true );
             }
 
             m_recordScript->setEnabled( true );
             m_scripts->setItemEnabled(m_runScript_id, true);
         }
     }
 }
 
 void MainWindow::slotDisconnect() {
     if ( currentSession() ) {
         currentSession()->layer()->close();
         m_connect->setEnabled( true );
         m_disconnect->setEnabled( false );
         m_transfer->setEnabled( false );
         m_recordScript->setEnabled( false);
         m_saveScript->setEnabled( false );
         m_scripts->setItemEnabled(m_runScript_id, false);
     }
 }
 
 void MainWindow::slotTerminate() {
     if ( currentSession() )
         currentSession()->layer()->close();
 
     slotClose();
     /* FIXME move to the next session */
 }
 
 
 
 void MainWindow::slotQuickLaunch()  {
 
     Profile prof = manager()->profile(  "default" );
     if ( prof.name() == "default"  )  {
         create( prof );
     } else {
     #ifndef EAST
         Profile newProf =  Profile( "default",  "console", "default" ,  0, 3,  0 );
         newProf.setAutoConnect( true );
         create( newProf );
         slotSaveSession();
     #endif
     }
 }
 
 void MainWindow::slotConfigure() {
     ConfigDialog conf( manager()->all(), factory() );
 
     int ret = QPEApplication::execDialog( &conf );
 
     if ( QDialog::Accepted == ret ) {
         manager()->setProfiles( conf.list() );
         manager()->save();
         populateProfiles();
     }
 }
 /*
  * we will remove
  * this window from the tabwidget
  * remove it from the list
  * delete it
  * and set the currentSession()
  */
 void MainWindow::slotClose() {
     if (!currentSession() )
         return;
 
     Session* ses = currentSession();
     /* set to NULL to be safe, if its needed slotSessionChanged resets it automatically */
     m_curSession = NULL;
     tabWidget()->remove( /*currentSession()*/ses );
     /*it's autodelete */
     m_sessions.remove( ses );
 
     if (!currentSession() ) {
         m_connect->setEnabled( false );
         m_disconnect->setEnabled( false );
         m_terminate->setEnabled( false );
         m_transfer->setEnabled( false );
         m_recordScript->setEnabled( false );
         m_saveScript->setEnabled( false );
         m_scripts->setItemEnabled(m_runScript_id, false);
         m_fullscreen->setEnabled( false );
         m_wrap->setEnabled( false );
         m_closewindow->setEnabled( false );
     }
 
     m_kb->loadDefaults();
 }
 
 /*
  * We will get the name
  * Then the profile
  * and then we will make a profile
  */
 void MainWindow::slotProfile( int id) {
     Profile prof = manager()->profile( m_sessionsPop->text( id)  );
     create( prof );
 }
 
 
 
 void MainWindow::create( const Profile& prof ) {
     char *homeDir = getenv("HOME");
 
     if ( homeDir )
         ::chdir( homeDir );
     
     if(m_curSession)
         if(m_curSession->transferDialog()) m_curSession->transferDialog()->hide();
 
     Session *ses = manager()->fromProfile( prof, tabWidget() );
 
     if((!ses) || (!ses->layer()) || (!ses->widgetStack()))
     {
         QMessageBox::warning(this,
             QObject::tr("Session failed"),
             QObject::tr("<qt>Cannot open session: Not all components were found.</qt>"));
         //if(ses) delete ses;
         return;
     }
 
     m_sessions.append( ses );
     tabWidget()->add( ses );
     tabWidget()->repaint();
     m_curSession = ses;
 
     // dicide if its a local term ( then no connction and no tranfer), maybe make a wrapper method out of it
     m_connect->setEnabled( true );
     m_disconnect->setEnabled( false );
     m_terminate->setEnabled( true );
     m_fullscreen->setEnabled( true );
     m_wrap->setEnabled( true );
     m_closewindow->setEnabled( true );
     m_transfer->setEnabled( false );
     m_recordScript->setEnabled( false );
     m_saveScript->setEnabled( false );
     m_scripts->setItemEnabled(m_runScript_id, false);
 
     // is io_layer wants direct connection, then autoconnect
     //if ( ( m_curSession->layer() )->supports()[0] == 1 ) {
     if (prof.autoConnect()) {
         slotConnect();
     }
 
     QWidget *w = currentSession()->widget();
     if(w) w->setFocus();
 
     if(currentSession()->profile().readNumEntry("Wrap", 80)){
         m_isWrapped = true;
     } else {
         m_isWrapped = false;
     }
 
     m_kb->load(currentSession()->profile());
 }
 
 void MainWindow::slotTransfer()
 {
     if ( currentSession() ) {
     Session *mysession = currentSession();
     TransferDialog dlg(/*mysession->widgetStack()*/this, this);
     mysession->setTransferDialog(&dlg);
     //dlg.reparent(mysession->widgetStack(), QPoint(0, 0));
     //dlg.showMaximized();
     currentSession()->widgetStack()->addWidget(&dlg, -1);
     dlg.show();
     //dlg.exec();
     while(dlg.isRunning()) qApp->processEvents();
     mysession->setTransferDialog(0l);
     }
 }
 
 
 void MainWindow::slotOpenKeb(bool state) {
 
     if (state) m_keyBar->show();
     else m_keyBar->hide();
 
 }
 
 
 void MainWindow::slotOpenButtons( bool state ) {
 
     if ( state ) {
         m_buttonBar->show();
     } else {
         m_buttonBar->hide();
     }
 }
 
 
 
 void MainWindow::slotSessionChanged( Session* ses ) {
     if(m_curSession)
         if(m_curSession->transferDialog()) m_curSession->transferDialog()->hide();
     if(ses)
         if(ses->transferDialog()) ses->transferDialog()->show();
 
     if ( ses ) {
         m_curSession = ses;
         if ( m_curSession->layer()->isConnected() ) {
             m_connect->setEnabled( false );
             m_disconnect->setEnabled( true );
             m_recordScript->setEnabled(!m_curSession->emulationHandler()->isRecording());
             m_saveScript->setEnabled(m_curSession->emulationHandler()->isRecording());
             m_scripts->setItemEnabled(m_runScript_id, true);
         } else {
             m_connect->setEnabled( true );
             m_disconnect->setEnabled( false );
             m_recordScript->setEnabled( false );
             m_saveScript->setEnabled( false );
             m_scripts->setItemEnabled(m_runScript_id, false);
         }
 
                 if ( ( currentSession()->emulationHandler()->isLogging() ) ) {
                          m_recordLog->setText( tr("Stop log") );
                 } else {
                          m_recordLog->setText( tr("Start log") );
                 }
 
         if ( ( m_curSession->layer() )->supports()[1] == 0 ) {
             m_transfer->setEnabled( false );
         } else {
             m_transfer->setEnabled( true );
         }
 
         QWidget *w = m_curSession->widget();
         if(w) w->setFocus();
 
         if(currentSession()->profile().readNumEntry("Wrap", 80)){
             m_isWrapped = true;
         } else {
             m_isWrapped = false;
         }
 
         m_kb->load(currentSession()->profile());
     }
 }
 
 void MainWindow::slotWrap()
 {
     if(m_curSession)
     {
         EmulationHandler *e = m_curSession->emulationHandler();
         if(e)
         {
             e->setWrap( m_isWrapped ? 80:0 );
             m_isWrapped = !m_isWrapped;
         }
     }
 }
 
 void MainWindow::slotFullscreen() {
 
 
 
     if ( m_isFullscreen ) {
         ( m_curSession->widgetStack() )->reparent(  savedParentFullscreen, 0, QPoint(0,0), true );
         ( m_curSession->widgetStack() )->resize( savedParentFullscreen->width(), savedParentFullscreen->height() );
         ( m_curSession->emulationHandler() )->cornerButton()->hide();
         disconnect( ( m_curSession->emulationHandler() )->cornerButton(), SIGNAL( pressed() ), this, SLOT( slotFullscreen() ) );
 
     } else {
         savedParentFullscreen = ( m_curSession->widgetStack() )->parentWidget();
         ( m_curSession->widgetStack() )->setFrameStyle( QFrame::NoFrame );
         ( m_curSession->widgetStack() )->reparent( 0, WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop
                                                    , QPoint(0,0), false );
         ( m_curSession->widgetStack() )->resize( qApp->desktop()->width(), qApp->desktop()->height() );
         ( m_curSession->widgetStack() )->setFocus();
         ( m_curSession->widgetStack() )->show();
 
         ( ( m_curSession->emulationHandler() )->cornerButton() )->show();
 
         connect( ( m_curSession->emulationHandler() )->cornerButton(), SIGNAL( pressed() ), this, SLOT( slotFullscreen() ) );
     }
 
     m_isFullscreen = !m_isFullscreen;
 }
 
 void MainWindow::slotScrollbarSelected(int index)
 {
-        int loc;
+    int loc = 0;
 
     Config cfg( "Konsole" );
     cfg.setGroup("ScrollBar");
-    if(index == sm_none)
-    {
-                loc = 0;
-    }
-    else if(index == sm_left)
+    if(index == sm_left)
     {
                 loc = 1;
     }
     else if(index == sm_right)
     {
                 loc = 2;
     }
         
-        cfg.writeEntry("Position", loc);
+    cfg.writeEntry("Position", loc);
 
     if (currentSession()) {
         currentSession()->emulationHandler()->setScrollbarLocation(loc);
     }
 
     m_scrollbar->setItemChecked(sm_none, index == sm_none);
     m_scrollbar->setItemChecked(sm_left, index == sm_left);
     m_scrollbar->setItemChecked(sm_right, index == sm_right);
 }
 
 void MainWindow::slotKeyReceived(FKey k, ushort, ushort, bool pressed) {
 
     if ( m_curSession ) {
 
         QEvent::Type state;
 
         if (pressed) state = QEvent::KeyPress;
         else state = QEvent::KeyRelease;
 
         QKeyEvent ke(state, k.qcode, k.unicode, 0, QString(QChar(k.unicode)));
 
         // is this the best way to do this? cant figure out any other way to work
         QApplication::sendEvent((QObject *)m_curSession->widget(), &ke);
         ke.ignore();
     }
 }
 void MainWindow::slotCopy() {
     if (!currentSession() ) return;
     currentSession()->emulationHandler()->copy();
 }
 void MainWindow::slotPaste() {
     if (!currentSession() ) return;
     currentSession()->emulationHandler()->paste();
 }
 
 /*
  * Save the session
  */
 
 void MainWindow::slotSaveSession() {
     if (!currentSession() ) {
       QMessageBox::information(this, tr("Save Connection"),
                                           tr("<qt>There is no Connection.</qt>"), 1 );
       return;
     }
     manager()->add( currentSession()->profile() );
     manager()->save();
     populateProfiles();
 }
 
 
 
 void MainWindow::slotSaveLog() {
 
     if( currentSession()->emulationHandler()->isLogging() ) {
       DocLnk nf;
       QString m_logName = currentSession()->emulationHandler()->logFileName();
       QFileInfo info(m_logName);
       nf.setType("text/plain");
       nf.setFile(m_logName);
       nf.setName(info.fileName());
       nf.writeLink();
       m_recordLog->setText( tr("Start log") );
       m_recordingLog = false;
           currentSession()->emulationHandler()->clearLog(); 
     } else {
     QMap<QString, QStringList> map;
     QStringList text;
     text << "text/plain";
     map.insert(tr("Log"), text );
     Opie::Core::OConfig cfg("opie-console");
     cfg.setGroup("defaults");
     QString startDir = cfg.readEntry("defaultlogdir", QPEApplication::documentDir() );
     QString m_logName = OFileDialog::getSaveFileName(2, startDir, QString::null, map, 0, startDir);
     if (m_logName.isEmpty() ) return;
 
     m_recordLog->setText( tr("Stop log") ); 
     m_recordingLog = true;
     currentSession()->emulationHandler()->startLogging(m_logName); 
     }
 }
 
 void MainWindow::slotSaveHistory() {
     QMap<QString, QStringList> map;
     QStringList text;
     text << "text/plain";
     map.insert(tr("History"), text );
     QString filename = OFileDialog::getSaveFileName(2, QPEApplication::documentDir(), QString::null, map);
     if (filename.isEmpty() ) return;
 
     QFileInfo info(filename);
 
     DocLnk nf;
     nf.setType("text/plain");
     nf.setFile(filename);
     nf.setName(info.fileName());
 
 
     QFile file(filename);
     if ( !file.open(IO_WriteOnly ) ) return;
 
     QTextStream str(&file );
     if ( currentSession() )
         currentSession()->emulationHandler()->emulation()->streamHistory(&str);
 
     file.close();
     nf.writeLink();
 }
diff --git a/noncore/apps/opie-reader/CFilter.cpp b/noncore/apps/opie-reader/CFilter.cpp
index 25cdfae..a4ea60a 100644
--- a/noncore/apps/opie-reader/CFilter.cpp
+++ b/noncore/apps/opie-reader/CFilter.cpp
@@ -1,861 +1,861 @@
 #include <qmap.h>
 #include <qfileinfo.h>
 #include <qtextstream.h>
 #include <qdir.h>
 
 #ifdef USEQPE
 #include <qpe/global.h>
 #endif
 #include "CDrawBuffer.h"
 #include "CFilter.h"
 #include "hrule.h"
 
 #include <qregexp.h>
 #include <qimage.h>
 #include <qpixmap.h>
 //#include <qprogressdialog.h>
 //#include <qapplication.h>
 
 void textfmt::mygetch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     if (uselast)
     {
         ch = lastchar;
         uselast = false;
     }
     else
     {
         parent->getch(ch, sty, pos);
     }
 }
 
 void textfmt::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     mygetch(ch, sty, pos);
     do
     {
         sty = currentstyle;
         switch (ch)
         {
             case 10:
                 currentstyle.unset();
                 sty = currentstyle;
                 break;
 // Use this if you want to replace -- by em-dash
             case '-':
         //      parent->getch(ch, sty);
                 mygetch(ch, sty, pos);
                 if (ch == '-')
                 {
                     ch = 0x2014;
                 }
                 else
                 {
                     lastchar = ch;
                     uselast = true;
                     ch = '-';
                 }
                 break;
             case '*':
                 if (currentstyle.isBold())
                 {
 // Already bold - time to turn it off?
 // The next two lines ensure that * follows a character but it works better without
         //          QChar c(lastchar);
         //          if ((lastchar != '*') && (c.isPunct() || c.isLetterOrNumber()))
                     if (lastchar != '*')
                     {
                         currentstyle.unsetBold();
                         CStyle dummy;
         //              parent->getch(ch, dummy);
                         mygetch(ch, dummy, pos);
                     }
                 }
                 else
                 {
 // not bold - time to turn it on?
                     CStyle dummy;
         //          parent->getch(ch, dummy);
                     mygetch(ch, dummy, pos);
                     QChar c(ch);
                     if ((ch != '*') && (c.isPunct() || c.isLetterOrNumber()))
                     {
                         currentstyle.setBold();
                     }
                     else
                     {
                         lastchar = ch;
                         uselast = true;
                         ch = '*';
                     }
                     
                 }
                 break;
             case '_':
                 if (currentstyle.isItalic())
                 {
 // Already bold - time to turn it off?
 // The next two lines ensure that * follows a character but it works better without
         //          QChar c(lastchar);
         //          if ((lastchar != '_') && (c.isPunct() || c.isLetterOrNumber()))
                     if (lastchar != '_')
                     {
                         currentstyle.unsetItalic();
                         CStyle dummy;
         //              parent->getch(ch, dummy);
                         mygetch(ch, dummy, pos);
                     }
                 }
                 else
                 {
 // not bold - time to turn it on?
                     CStyle dummy;
         //          parent->getch(ch, dummy);
                     mygetch(ch, dummy, pos);
                     QChar c(ch);
                     if ((ch != '_') && (c.isPunct() || c.isLetterOrNumber()))
                     {
                         currentstyle.setItalic();
                     }
                     else
                     {
                         lastchar = ch;
                         uselast = true;
                         ch = '_';
                     }
                     
                 }
                 break;
         }
     }
     while (sty != currentstyle);
     if (!uselast) lastchar = ch;
     return;
 }
 
 void remap::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     if (q[offset] != 0)
     {
         q[offset++];
         sty = currentstyle;
         return;
     }
     parent->getch(ch, sty, pos);
     switch (ch)
     {
         case 0x201a:
             ch = '\'';
             break;
         case 0x0192:
             ch = 'f';
             break;
         case 0x201e:
             ch = '"';
             break;
         case 0x2026:
             offset = 0;
             q[0] = '.';
             q[1] = '.';
             q[2] = 0;
             ch = '.'; // should be ...
             break;
         case 0x0160:
             ch = 'S';
             break;
         case 0x2039:
             ch = '<';
             break;
                 case 0x0152:    
             offset = 0;
             q[0] = 'E';
             q[1] = 0;
             ch = 'O';
             break;
         case 0x017d:
             ch = 'Z';
             break;
         case 0x2018:
             ch = '\'';
             break;
         case 0x2019:
             ch = '\'';
             break;
         case 0x201c:
             ch = '"';
             break;
         case 0x201d:
             ch = '"';
             break;
         case 0x2022:
             ch = '>';
             break;
         case 0x2013:
             ch = '-';
             break;
         case 0x2014:
             offset = 0;
             q[0] = '-';
             q[1] = 0;
             ch = '-'; // should be --
             break;
         case 0x02dc:
             ch = '~';
             break;
         case 0x0161:
             ch = 's';
             break;
         case 0x203a:
             ch = '>';
             break;
         case 0x0153:
             offset = 0;
             q[0] = 'e';
             q[1] = 0;
             ch = 'o';// should be oe
             break;
             /*
         case 0x0009: // tab
             offset = 0;
             q[0] = ' ';
             q[1] = 0;
             ch = ' ';
             break;
             */
         case 0x017e:
             ch = 'z';
             break;
         case 0x0178:
             ch = 'Y';
             break;
     }
     currentstyle = sty;
 }
 
 void PeanutFormatter::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     CStyle dummy;
     currentstyle.setColour(0,0,0);
     parent->getch(ch, dummy, pos);
     while (ch == '\\')
     {
         parent->getch(ch, dummy, pos);
         if (ch == '\\') break;
         switch(ch)
         {
             case 'a':
             {
                 int code = 0;
                 for (int i = 0; i < 3; i++)
                 {
                     parent->getch(ch, dummy, pos);
                     code = 10*code + ch - '0';
                 }
                 ch = code;
             }
             break;
             case 'v':
             {
                 while (1)
                 {
                     parent->getch(ch, dummy, pos);
                     if (ch == '\\')
                     {
                         parent->getch(ch, dummy, pos);
                         if (ch == 'v')
                         {
                             parent->getch(ch, dummy, pos);
                             break;
                         }
                     }
                 }
             }
             break;
             case 's':
             case 'n':
                 currentstyle.setFontSize(0);
                 parent->getch(ch,dummy, pos);
                 break;
             case 'p':
                 currentstyle.unset();
         //      parent->getch(ch,dummy);
                 ch = 10;
                 break;
             case 'l':
                 if (currentstyle.getFontSize() == 1)
                 {
                     currentstyle.setFontSize(0);
                 }
                 else
                 {
                     currentstyle.setFontSize(1);
                 }
                 parent->getch(ch, dummy, pos);
                 break;
             case 'x':
                 if (currentstyle.getFontSize() == 0)
                 {
         //          currentstyle.unset();
         //          currentstyle.setBold();
                     currentstyle.setFontSize(1);
                 }
                 else
                 {
                     currentstyle.unset();
                 }
         //      parent->getch(ch, dummy);
                 ch = 10;
                 break;
             case 'i':
                 if (currentstyle.isItalic())
                 {
                     currentstyle.unsetItalic();
                 }
                 else
                 {
                     currentstyle.setItalic();
                 }
                 parent->getch(ch, dummy, pos);
                 break;
             case 'b':
             case 'B':
                 if (currentstyle.isBold())
                 {
                     currentstyle.unsetBold();
                 }
                 else
                 {
                     currentstyle.setBold();
                 }
                 parent->getch(ch, dummy, pos);
                 break;
             case 'c':
                 if (currentstyle.getJustify() == m_AlignCentre)
                 {
                     currentstyle.setLeftJustify();
                 }
                 else
                 {
                     currentstyle.setCentreJustify();
                 }
                 parent->getch(ch, dummy, pos);
                 break;
             case 'r':
                 if (currentstyle.getJustify() == m_AlignRight)
                 {
                     currentstyle.setLeftJustify();
                 }
                 else
                 {
                     currentstyle.setRightJustify();
                 }
                 parent->getch(ch, dummy, pos);
                 break;
             default:
                 currentstyle.setColour(255,0,0);
         }
     }
     sty = currentstyle;
 }
 
 void OnePara::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     parent->getch(ch, sty, pos);
     if (m_lastchar == 10)
     {
         while (ch == 10) parent->getch(ch, sty, pos);
     }
     m_lastchar = ch;
 }
 
 void repalm::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     parent->getch(ch, sty, pos);
     switch (ch)
     {
         case 0x80:
             ch = 0x20ac;
             break;
         case 0x82:
             ch = 0x201a;
             break;
         case 0x83:
             ch = 0x0192;
             break;
         case 0x84:
             ch = 0x201e;
             break;
         case 0x85:
             ch = 0x2026;
             break;
         case 0x86:
             ch = 0x2020;
             break;
         case 0x87:
             ch = 0x2021;
             break;
         case 0x88:
             ch = 0x02c6;
             break;
         case 0x89:
             ch = 0x2030;
             break;
         case 0x8a:
             ch = 0x0160;
             break;
         case 0x8b:
             ch = 0x2039;
             break;
         case 0x8c:
             ch = 0x0152;
             break;
 /*
         case 0x8e:
             ch = 0x017d;
             break;
 */
         case 0x91:
             ch = 0x2018;
             break;
         case 0x92:
             ch = 0x2019;
             break;
         case 0x93:
             ch = 0x201c;
             break;
         case 0x94:
             ch = 0x201d;
             break;
         case 0x95:
             ch = 0x2022;
             break;
         case 0x96:
             ch = 0x2013;
             break;
         case 0x97:
             ch = 0x2014;
             break;
         case 0x98:
             ch = 0x02dc;
             break;
         case 0x99:
             ch = 0x2122;
             break;
         case 0x9a:
             ch = 0x0161;
             break;
         case 0x9b:
             ch = 0x203a;
             break;
         case 0x9c:
             ch = 0x0153;
             break;
         case 0x9e:
             ch = 0x017e;
             break;
         case 0x9f:
             ch = 0x0178;
             break;
         case 0x18:
             ch = 0x2026;
             break;
         case 0x19:
             ch = 0x2007;
             break;
         case 0x8d:
             ch = 0x2662;
             break;
         case 0x8e:
             ch = 0x2663;
             break;
         case 0x8f:
             ch = 0x2661;
             break;
         case 0x90:
             ch = 0x2660;
             break;
         default:
             break;
     }
 }
 
 //static tchar nextpart[] = { 'C','l','i','c','k',' ','h','e','r','e',' ','f','o','r',' ','t','h','e',' ','n','e','x','t',' ','p','a','r','t',0 };
 //static tchar prevpart[] = { 'C','l','i','c','k',' ','h','e','r','e',' ','f','o','r',' ','t','h','e',' ','p','r','e','v','i','o','u','s',' ','p','a','r','t',0 };
 
 void DePluck::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
     if (m_buffed > 0)
     {
         sty = m_laststyle;
         ch = nextpart[m_current++];
         if (m_current == m_buffed)
         {
             m_current = m_buffed = 0;
         }
     }
     else
     {
         if (m_buffer != 0)
         {
             ch = m_buffer;
             m_buffer = 0;
             return;
         }
-        unsigned long lnk, lnkoff;
+        unsigned long lnk = 0, lnkoff = 0;
         do
         {
             if (nextpart[m_buffed] == 0) break;
             parent->getch(ch, sty, pos);
             m_laststyle = sty;
             if (sty.getLink())
               {
                 lnk = sty.getData();
                 lnkoff = sty.getOffset();
               }
         } while (ch == nextpart[m_buffed] && sty.getLink() && ++m_buffed);
         m_current = 0;
         if (nextpart[m_buffed] == 0)
         {
             m_buffed = 0;
             QString dmy, dmy2;
             parent->hyperlink(lnk, lnkoff, dmy, dmy2);
             do
             {
                 parent->getch(ch, sty, pos);
             }
             while (ch != 10);
             parent->getch(ch, sty, pos);
         }
         else if (m_buffed > 0)
         {
             m_buffer = ch;
             ch = nextpart[0];
             if (m_buffed == 1)
             {
                 m_buffed = 0;
             }
             else m_current = 1;
         }
     }
 
     return;
 }
 
 HighlightFilter::HighlightFilter(QTReader* _p) : pReader(_p), lastpos(0), nextpos(0), red(255), green(255), blue(255)
 {
 }
 
 #include "Bkmks.h"
 #include "QTReader.h"
 
 void HighlightFilter::refresh(unsigned long pos)
 {
   bkmks = pReader->Bkmklist();
   
   red = green = blue = 255;
   
   if (bkmks == NULL)
     {
       lastpos = 0;
       nextpos = 0xffffffff;
     }
   else
     {
       lastpos = 0;
       nextpos = 0xffffffff;
       for (CList<Bkmk>::iterator i = bkmks->begin(); i != bkmks->end(); i++)
         {
           if ((*i).value() <= pos && pos < (*i).value2())
             {
               red = i->red();
               green = i->green();
               blue = i->blue();
               lastpos = (*i).value();
               nextpos = (*i).value2();
               break;
             }
           if ((*i).value() > pos)
             {
               nextpos = (*i).value();
               break;
             }
           lastpos = (*i).value();
         }
     }
 }
 
 void HighlightFilter::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
   if (bkmks != pReader->Bkmklist() || pos <= lastpos || pos >= nextpos)
     {
       //      qDebug("Recalc <%lu, %lu, %lu>", lastpos, pos, nextpos);
       refresh(pos);
       //      qDebug("Recalc(2) <%lu, %lu, %lu>", lastpos, pos, nextpos);
     }
    int r = sty.bRed(), g = sty.bGreen(), b = sty.bBlue();
    if (r == 255 && g == 255 && b == 255)
      {
         sty.setBackground(red, green, blue);
      }
 }
 
 void kern::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   if (uselast)
     {
       ch = lastchar;
       sty = laststy;
       uselast = false;
       return;
     }
   else
     {
       parent->getch(ch, sty, pos);
     }
   switch (ch)
     {
     case 'f':
       {
         tchar savedchar = 'f';
         parent->getch(ch, sty, pos);
         switch (ch)
           {
           case 'i':
             ch = (251 << 8) + 1;
             break;
           case 'l':
             ch = (251 << 8) + 2;
             break;
           default:
             lastchar = ch;
             uselast = true;
             laststy = sty;
             ch = savedchar;
           }
       }
       break;
     default:
       break;
     }
 }
 
 class ErrorFilter : public CFilter
 {
   QString error;
   int currentpos;
  public:
   ErrorFilter(const QString& _s) : error(_s), currentpos(0) {}
   ~ErrorFilter() {}
   void getch(tchar& ch, CStyle& sty, unsigned long& pos)
   {
     if (currentpos == error.length())
       {
         ch = UEOF;
         currentpos = 0;
       }
     else
       {
         ch = error[currentpos++].unicode();
       }
   }
   QString about() { return parent->about(); }
 };
 
 #ifndef __STATIC
 ExternFilter::ExternFilter(const QString& nm, const QString& optional) : filt(NULL), handle(NULL)
 {
 #ifdef USEQPE
 #ifdef OPIE
   QString filterpath(getenv("OPIEDIR"));
 #else
   QString filterpath(getenv("QTDIR"));
 #endif
   filterpath += "/plugins/reader/filters/lib";
 #else
   QString filterpath(getenv("READERDIR"));
   filterpath += "/filters/lib";
 #endif
   filterpath += nm;
   filterpath += ".so";
   if (QFile::exists(filterpath))
     {
       qDebug("Filter:%s", (const char*)filterpath);
       handle = dlopen(filterpath, RTLD_LAZY);
       if (handle == 0)
         {
           qDebug("Can't find filter:%s", dlerror());
                   //  status = -10;
           filt = new ErrorFilter(QString("Can't find plugin:")+nm);
           return;
         }
       CFilter* (*newfilter)(const QString&);
       newfilter = (CFilter* (*)(const QString&))dlsym(handle, "newfilter");
       if (newfilter == NULL)
         {
           qDebug("Can't find newfilter");
           filt = new ErrorFilter(QString("Can't find entry point in plugin:")+nm);
           return;
         }
       filt = (*newfilter)(optional);
     }
   else
     {
       qDebug("No filter path:%s", (const char*)filterpath);
       filt = new ErrorFilter(QString("No filter plugins installed:")+nm);
     }
   if (filt == NULL)
     {
       qDebug("Can't do newfilter");
       filt = new ErrorFilter(QString("Filter creation failed:")+nm);
       return;
     }
 }
 #endif
 
 void makeInverse::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
   int r,g,b;
   r = 255 - sty.Red(), g = 255 - sty.Green(), b = 255 - sty.Blue();
   sty.setColour(r,g,b);
   r = 255 - sty.bRed(), g = 255 - sty.bGreen(), b = 255 - sty.bBlue();
   sty.setBackground(r,g,b);
   r = 255 - sty.pRed(), g = 255 - sty.pGreen(), b = 255 - sty.pBlue();
   sty.setPaper(r,g,b);
 }
 /*
 void makeNegative::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
   QColor fg(sty.Red(), sty.Green(), sty.Blue());
   int h,s,v;
   fg.hsv(&h,&s,&v);
   fg.setHsv(h,s,255-v);
   int r,g,b;
   fg.rgb(&r,&g,&b);
   sty.setColour(r,g,b);
   
   fg = QColor(sty.bRed(), sty.bGreen(), sty.bBlue());
   fg.hsv(&h,&s,&v);
   fg.setHsv(h,s,255-v);
   fg.rgb(&r,&g,&b);
   sty.setBackground(r,g,b);
 }
 */
 void setbg::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
  int r = sty.pRed(), g = sty.pGreen(), b = sty.pBlue();
   if (r == 255 && g == 255 && b == 255)
     {
       sty.setPaper(m_r,m_g,m_b);
     }
    else
      {
         qDebug("We have background [%x%x%x]", r, g, b);
      }
    r = sty.bRed(), g = sty.bGreen(), b = sty.bBlue();
   if (r == 255 && g == 255 && b == 255)
     {
       sty.setBackground(m_r,m_g,m_b);
     }
    else
      {
         qDebug("We have background [%x%x%x]", r, g, b);
      }
 }
 
 void setfg::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
   int r = sty.Red(), g = sty.Green(), b = sty.Blue();
   if (r == 0 && g == 0 && b == 0)
     {
       sty.setColour(m_r,m_g,m_b);
     }
 }
 
 #include "CRegExp.h"
 
 repara::repara(const QString& pat) : tch(0)
 {
   //  QString pat("{\\n[A-Z\"]}");
   flt = new CRegExpFilt(pat, false);
   qDebug("Construction done");
 }
 
 repara::~repara()
 {
   delete flt;
 }
 
 void repara::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   if (flt->empty())
     {
       while (flt->empty())
         {
           parent->getch(ch, sty, pos);
           flt->addch(ch);
         }
     }
   ch = flt->pop();
   /*
   parent->getch(ch, sty, pos);
   if (ch == 10 || ch == ' ')
     {
       if (tch == 10)
         {
           tch = ch;
           ch = 10;
           return;
         }
       else
         {
           tch = ch;
           ch = ' ';
           return;
         }
             }
   tch = ch;
   */
   return;
 }
 
 void tableLink::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   if (offset >= (int)text.length())
     {
       offset = -1;
       sty.setColour(m_r, m_g, m_b);
       do
         {
           parent->getch(ch, sty, pos);
         }
       while (sty.isTable());
       return;
     }
   if (offset >= 0)
     {
       ch = text[offset++].unicode();
       return;
     }
   parent->getch(ch, sty, pos);
   if (sty.isTable())
     {
       offset = 1;
       ch = text[0].unicode();
       m_r = sty.Red(), m_g = sty.Green(), m_b = sty.Blue();
       sty.setColour(255, 0, 0);
     }
   return;      
 }
 
 void underlineLink::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   parent->getch(ch, sty, pos);
   if (sty.getLink()) sty.setUnderline();
   //if (isLink && !sty.getLink()) sty.unsetUnderline();
   //isLink = sty.getLink();
 }
diff --git a/noncore/apps/opie-reader/CRegExp.cpp b/noncore/apps/opie-reader/CRegExp.cpp
index 6318d28..e3194df 100644
--- a/noncore/apps/opie-reader/CRegExp.cpp
+++ b/noncore/apps/opie-reader/CRegExp.cpp
@@ -1,599 +1,599 @@
 #include "CRegExp.h"
 
 //#include <stdio.h>
 #include <stdlib.h>
 //#include <string.h>
 
 
 tchar CRegExpFilt::escapedchar(tchar c)
 {
   switch (c)
     {
     case '\\':
       return '\\';
       break;
     case '"':
       return '\"';
       break;
     case 'a':
       return '\a';
       break;
     case 'b':
       return '\b';
       break;
     case 'f':
       return '\f';
       break;
     case 'n':
       return '\n';
       break;
     case 'r':
       return '\r';
       break;
     case 't':
       return '\t';
       break;
     case 'v':
       return '\v';
       break;
     default:
       return c;
       break;
     }
 }
 
 void CRegExpFilt::regchar(tchar c, bool insens)
 {
   if (insens)
     {
       tchar t = upper(c);
       CV[t] = 0;
       t = lower(c);
       CV[t] = 0;
     }
   else
     {
       CV[c] = 0;
     }
 }
 
 void CRegExpFilt::prepreprocessing(const QString& pat, bool insens)
 {
   for (unsigned int p = 0; p < pat.length(); p++)
     {
 #ifdef _WINDOWS
       switch (pat.at(p).unicode())
 #else
       switch (pat[p].unicode())
 #endif
           {
         case '{':
           {
             break;
           }
         case '}':
           {
             break;
           }
         case '^':
           {
             break;
           }
         case '.' :
           {
             break;
           }
         case '#':
           {
             p++;
 #ifdef _WINDOWS
             while ('0' <= pat.at(p).unicode() && pat.at(p).unicode() <= '9')
 #else
                 while ('0' <= pat[p].unicode() && pat[p].unicode() <= '9')
 #endif
               {
               }
             p--;
             break;
           }
         case '\\' :
           {
 #ifdef _WINDOWS
             tchar c = escapedchar(pat.at(++p).unicode());
 #else
             tchar c = escapedchar(pat[++p].unicode());
 #endif
                 regchar(c, insens);
             break;
           }
 
         case '[' :
           {
-            tchar clast;
+            tchar clast = 0;
             bool invert = false;
             tchar c;
 #ifdef _WINDOWS
             if (pat.at(p+1).unicode() == '^')
 #else
             if (pat[p+1].unicode() == '^')
 #endif
                 {
                 p++;
                 invert = true;
               }
 #ifdef _WINDOWS
             while ((c = pat.at(++p).unicode()) != ']')
 #else
             while ((c = pat[++p].unicode()) != ']')
 #endif
                 {
                 if (c == '\\')
                   {
 #ifdef _WINDOWS
                     c = escapedchar(pat.at(++p).unicode());
 #else
                     c = escapedchar(pat[++p].unicode());
 #endif
                         if (c == ']') break;
                   }
                 if (c == '-')
                   {
 #ifdef _WINDOWS
                     c = pat.at(++p).unicode();
 #else
                     c = pat[++p].unicode();
 #endif
                         for (tchar j = clast; j <= c; j++)
                       {
                         regchar(j, insens);
                       }
                   }
                 else
                   {
                     regchar(c, insens);
                   }
                 clast = c;
               }
             break;
           }
         default :
           {
 #ifdef _WINDOWS
             regchar(pat.at(p).unicode(), insens);
 #else
             regchar(pat[p].unicode(), insens);
 #endif
                 break;
           }
         }
     }
   /*
   for (iter i = CV.begin(); i != CV.end(); ++i)
     {
       printf("Pre: [%u]\n", i.first());
     }
   */
   CV[0] = 0;
 }
 
 unsigned int CRegExpFilt::preprocessing(const QString& pat, bool insens)
 {
   prepreprocessing(pat, insens);
   qDebug("PrePreProcessing done");
   unsigned int p, m;
   bool inkeep = false;
   keep = 0;
   replace = 0;
   for (unsigned int j = 0; j < WORD_SIZE; j++)
     {
       bit[j] = (1 << (WORD_SIZE -j -1));
       lfcnt[j] = 0;
     }
 
   for (p = 0, m = 0; p < pat.length(); p++)
     {
       qDebug("m is %u", m);
       if (inkeep) keep |= bit[m];
 #ifdef _WINDOWS
       switch (pat.at(p).unicode())
 #else
       switch (pat[p].unicode())
 #endif
           {
         case '{':
           {
             inkeep = true;
             break;
           }
         case '}':
           {
             keep ^= bit[m];
             inkeep = false;
             break;
           }
         case '^':
           {
             replace |= bit[m];
             lfcnt[m]++;
             break;
           }
         case '.' :
           {
             for (iter j = CV.begin(); j != CV.end(); ++j) CV[j.first()] |= bit[m];
             m++;
             break;
           }
         case '#':
           {
             if (m > 0)
               {
                 p++;
                 int count = 0;
 #ifdef _WINDOWS
                 while ('0' <= pat.at(p).unicode() && pat.at(p).unicode() <= '9')
 #else
                 while ('0' <= pat[p].unicode() && pat[p].unicode() <= '9')
 #endif
                 {
 #ifdef _WINDOWS
                     count = 10*count + pat.at(p++).unicode() - '0';
 #else
                     count = 10*count + pat[p++].unicode() - '0';
 #endif
                   }
                 p--;
                 count = count-1;
                 unsigned int mask = 0;
                 for (unsigned int i = m; i < m+count; i++)
                   {
                     mask |= bit[i];
                   }
                
                 for (iter it = CV.begin(); it != CV.end(); ++it)
                   {
                     if (CV[it.first()] & bit[m-1])
                       {
                         CV[it.first()] |= mask;
                       }
                   }
                 if (keep & bit[m-1]) keep |= mask;
                 m += count;
               }
             else
               {
                 p++;
               }
             break;
           }
         case '\\' :
           {
 #ifdef _WINDOWS
             tchar c = escapedchar(pat.at(++p).unicode());
 #else
             tchar c = escapedchar(pat[++p].unicode());
 #endif
                 if (insens)
               {
                 CV[upper(c)] |= bit[m];
                 CV[lower(c)] |= bit[m];
               }
             else
               {
                 CV[c] |= bit[m];
               }
             m++;
             break;
           }
 
         case '[' :
           {
-            tchar c, clast;
+            tchar c, clast = 0;
             bool invert = false;
 #ifdef _WINDOWS
             if (pat.at(p+1).unicode() == '^')
 #else
             if (pat[p+1].unicode() == '^')
 #endif
                 {
                 p++;
                 invert = true;
               }
 #ifdef _WINDOWS
             while ((c = pat.at(++p).unicode()) != ']')
 #else
             while ((c = pat[++p].unicode()) != ']')
 #endif
                 {
                 if (c == '\\')
                   {
 #ifdef _WINDOWS
                     c = escapedchar(pat.at(++p).unicode());
 #else
                     c = escapedchar(pat[++p].unicode());
 #endif
                         if (c == ']') break;
                   }
                 if (c == '-')
                   {
 #ifdef _WINDOWS
                     c = pat.at(++p).unicode();
 #else
                     c = pat[++p].unicode();
 #endif
                         for (tchar j = clast; j <= c; j++)
                       {
                         if (insens)
                           {
                             iter it;
                             if ((it = CV.find(upper(j))) != CV.end())
                               CV[it] |= bit[m];
                             else
                               CV[0] |= bit[m];
                             if ((it = CV.find(lower(j))) != CV.end())
                               CV[it] |= bit[m];
                             else
                               CV[0] |= bit[m];
                           }
                         else
                           {
                             iter it;
                             if ((it = CV.find(j)) != CV.end())
                               CV[it] |= bit[m];
                             else
                               {
                                 CV[0] |= bit[m];
                               }
                           }
                       }
                   }
                 else
                   {
                     if (insens)
                       {
                         iter it;
                         if ((it = CV.find(upper(c))) != CV.end())
                           CV[it] |= bit[m];
                         else
                           CV[0] |= bit[m];
                         if ((it = CV.find(lower(c))) != CV.end())
                           CV[it] |= bit[m];
                         else
                           CV[0] |= bit[m];
                       }
                     else
                       {
                         iter it;
                         if ((it = CV.find(c)) != CV.end())
                           CV[it] |= bit[m];
                         else
                           CV[0] |= bit[m];
                       }
                   }
                 clast = c;
               }
             if (invert)
               {
                 for (iter i = CV.begin(); i != CV.end(); ++i)
                   {
                     CV[i.first()] ^= bit[m];
                   }
               }
             m++;
             break;
           }
         default :
           {
 #ifdef _WINDOWS
             tchar c = pat.at(p).unicode();
 #else
             tchar c = pat[p].unicode();
 #endif
                 if (insens)
               {
                 CV[upper(c)] |= bit[m];
                 CV[lower(c)] |= bit[m];
               }
             else CV[c] |= bit[m];
             m++;
             break;
           }
         }
     }
   qDebug("Returning:%u",m);
   return m;
 }
 
 bool CRegExpFilt::empty()
 {
   return m_outQueue.empty();
 }
 
 tchar CRegExpFilt::pop()
 {
   return m_outQueue.pop();
 }
 
 bool CRegExpFilt::addch(tchar ch)
 {
   word[cur] = ch;
   cur = (cur+1)%patlength;
   if (len < patlength) len++;
 
   unsigned int cv = 0;
   iter it;
   if ((it = CV.find(ch)) == CV.end())
     {
       cv = CV[0];
     }
   else
     {
       cv = CV[it];
     }
 
   R = ((R >> 1) | bit_0) & cv; /* Exact matches */
   if (R & endpos)
     {
       for (unsigned int i = 0; i < patlength; i++)
         {
           if (replace & bit[i])
             {
               for (unsigned int j = 0; j < lfcnt[i]; j++)
                 {
                   m_outQueue.push(10);
                 }
             }
           if (keep & bit[i])
             {
               m_outQueue.push(word[(cur+i)%patlength]);
                       //        putchar('*');
                       //        putchar(i + '0');
             }
           len = 0;
         }
       return true;
     }
   else
     {
       if (len == patlength)
         {
           tchar ch = word[cur];
           if (ch == 10) ch = ' ';
           m_outQueue.push(ch);
         }
       return false;
     }
 }
 
 void CRegExpFilt::restart()
 {
   R = 0;
   len = 0;
 }
 
 CRegExpFilt::CRegExpFilt(const QString& pat, bool insensflag) : CV(300)
 {
   cur = 0;
   patlength = preprocessing(pat, insensflag);
   qDebug("Preprocesing done:%u", patlength);
   endpos = bit[patlength-1];
   bit_0 = bit[0];
 
   restart();
 
   qDebug("Pattern: %s:%u", (const char*)pat, patlength);
 
 }
 
 
 CRegExpFilt::~CRegExpFilt()
 {
 }
 
 #ifdef NOWAYISTHISDEFINED
 void reportmatch(tchar *line, /*tchar *text,*/ unsigned int mtype, unsigned int lino)
 {
   /*
     tchar *text = line + strlen(line);
 
     tchar *ptr = line;
     if (mtype == 0)
     printf("Exact match at line number %u.\n", lino);
     else
     printf("%u error match at line number %u.\n", mtype, lino);
     while (ptr < text) putchar(*ptr++);
     printf("%c[4m^%c[24m%s\n", 27, 27, ptr);
   */
 }
 
 
 void usage(void)
 {
   printf("Usage: CRegExpFilt [-i] pattern/a file\n");
 }
 
 int getline(tchar *s,int lim,FILE *f)
 {
   int c, i;
     
   for (i = 0; i < lim-1 && (c = getc(f)) != EOF && c != '\n'; )
     {
       s[i++] = (tchar)c;
     }
   s[i] = '\0';
   return ((c == EOF && i == 0) ? -1 : i);
 }
 
         #define BUF_SIZE256
 
 int main(int argc, char **argv)
 {
   unsigned int lino = 0;
   unsigned int blino = 0;
   bool insens = false;
   int len;
   tchar line[BUF_SIZE];
   FILE *inf;
 
   /* Error checking of cmd ln args! */
   if (argc < 3)
     {usage(); return 10; }
   /* Corresponds to requiring a minimum of 3 matches */
   for (len = 1; len < argc-2; len++)
     {
       if (argv[len][0] != '-')
         {usage(); return 10; }
       else switch (argv[len][1])
         {
         case 'i' :
           {
             insens = true;
             break;
           }
         default :
           {usage(); return 10;}
         }
     }
 
   tchar* pattern = new tchar[strlen(argv[argc-2])+1];
 
   for (int i = 0; (pattern[i] = argv[argc-2][i]) != 0; i++);
 
 
 
   CRegExpFilt test(pattern, insens);
 
   delete [] pattern;
 
   inf = fopen(argv[argc-1], "r");
   if (!inf)
     {
       printf("file not found\n");
       return 10;
     }
 
   while ((len = getline(line, BUF_SIZE, inf)) >= 0)
     {
       lino++;
       bool ret = false;
    
       {
         tchar *textend = line+len;
         tchar *text = line;
         while (text < textend)
           {
             ret |= test.addch(*text++);
           }
         ret |= test.addch('\n');
         while (!test.empty())
           {
             putchar(test.pop());
           }
       }
       //    inswt = test.addch(line, len);
       if (ret) reportmatch(line, 0, lino);
     }
   fclose(inf);
           //CloseSTDLIB();
   return 0;
 }
 #endif
diff --git a/noncore/apps/opie-reader/Palm2QImage.cpp b/noncore/apps/opie-reader/Palm2QImage.cpp
index 361755f..09cad1c 100644
--- a/noncore/apps/opie-reader/Palm2QImage.cpp
+++ b/noncore/apps/opie-reader/Palm2QImage.cpp
@@ -1,299 +1,299 @@
 /* -*- mode: c; indent-tabs-mode: nil; -*- */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef _WINDOWS
 #include <unistd.h>     /* for link */
 #endif
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdarg.h>
 
 #include <qimage.h>
 
 /***********************************************************************/
 /***********************************************************************/
 /*****                                                             *****/
 /*****   Code to decode the Palm image format to JPEG              *****/
 /*****                                                             *****/
 /***********************************************************************/
 /***********************************************************************/
 
 #define READ_BIGENDIAN_SHORT(p) (((p)[0] << 8)|((p)[1]))
 #define READ_BIGENDIAN_LONG(p)  (((p)[0] << 24)|((p)[1] << 16)|((p)[2] << 8)|((p)[3]))
 
 #define PALM_IS_COMPRESSED_FLAG        0x8000
 #define PALM_HAS_COLORMAP_FLAG        0x4000
 #define PALM_HAS_TRANSPARENCY_FLAG    0x2000
 #define PALM_DIRECT_COLOR_FLAG        0x0400
 #define PALM_4_BYTE_FIELD_FLAG        0x0200
 
 #define PALM_COMPRESSION_SCANLINE    0x00
 #define PALM_COMPRESSION_RLE        0x01
 #define PALM_COMPRESSION_PACKBITS    0x02
 #define PALM_COMPRESSION_NONE        0xFF
 
 #define PALM_COLORMAP_SIZE 232
 
 typedef struct {
   unsigned char red;
   unsigned char green;
   unsigned char blue;
 } ColorMapEntry;
 
 static ColorMapEntry Palm8BitColormap[] = {
   { 255, 255, 255 }, { 255, 204, 255 }, { 255, 153, 255 }, { 255, 102, 255 }, 
   { 255,  51, 255 }, { 255,   0, 255 }, { 255, 255, 204 }, { 255, 204, 204 }, 
   { 255, 153, 204 }, { 255, 102, 204 }, { 255,  51, 204 }, { 255,   0, 204 }, 
   { 255, 255, 153 }, { 255, 204, 153 }, { 255, 153, 153 }, { 255, 102, 153 }, 
   { 255,  51, 153 }, { 255,   0, 153 }, { 204, 255, 255 }, { 204, 204, 255 },
   { 204, 153, 255 }, { 204, 102, 255 }, { 204,  51, 255 }, { 204,   0, 255 },
   { 204, 255, 204 }, { 204, 204, 204 }, { 204, 153, 204 }, { 204, 102, 204 },
   { 204,  51, 204 }, { 204,   0, 204 }, { 204, 255, 153 }, { 204, 204, 153 },
   { 204, 153, 153 }, { 204, 102, 153 }, { 204,  51, 153 }, { 204,   0, 153 },
   { 153, 255, 255 }, { 153, 204, 255 }, { 153, 153, 255 }, { 153, 102, 255 },
   { 153,  51, 255 }, { 153,   0, 255 }, { 153, 255, 204 }, { 153, 204, 204 },
   { 153, 153, 204 }, { 153, 102, 204 }, { 153,  51, 204 }, { 153,   0, 204 },
   { 153, 255, 153 }, { 153, 204, 153 }, { 153, 153, 153 }, { 153, 102, 153 },
   { 153,  51, 153 }, { 153,   0, 153 }, { 102, 255, 255 }, { 102, 204, 255 },
   { 102, 153, 255 }, { 102, 102, 255 }, { 102,  51, 255 }, { 102,   0, 255 },
   { 102, 255, 204 }, { 102, 204, 204 }, { 102, 153, 204 }, { 102, 102, 204 },
   { 102,  51, 204 }, { 102,   0, 204 }, { 102, 255, 153 }, { 102, 204, 153 },
   { 102, 153, 153 }, { 102, 102, 153 }, { 102,  51, 153 }, { 102,   0, 153 },
   {  51, 255, 255 }, {  51, 204, 255 }, {  51, 153, 255 }, {  51, 102, 255 },
   {  51,  51, 255 }, {  51,   0, 255 }, {  51, 255, 204 }, {  51, 204, 204 },
   {  51, 153, 204 }, {  51, 102, 204 }, {  51,  51, 204 }, {  51,   0, 204 },
   {  51, 255, 153 }, {  51, 204, 153 }, {  51, 153, 153 }, {  51, 102, 153 },
   {  51,  51, 153 }, {  51,   0, 153 }, {   0, 255, 255 }, {   0, 204, 255 },
   {   0, 153, 255 }, {   0, 102, 255 }, {   0,  51, 255 }, {   0,   0, 255 },
   {   0, 255, 204 }, {   0, 204, 204 }, {   0, 153, 204 }, {   0, 102, 204 },
   {   0,  51, 204 }, {   0,   0, 204 }, {   0, 255, 153 }, {   0, 204, 153 },
   {   0, 153, 153 }, {   0, 102, 153 }, {   0,  51, 153 }, {   0,   0, 153 },
   { 255, 255, 102 }, { 255, 204, 102 }, { 255, 153, 102 }, { 255, 102, 102 },
   { 255,  51, 102 }, { 255,   0, 102 }, { 255, 255,  51 }, { 255, 204,  51 },
   { 255, 153,  51 }, { 255, 102,  51 }, { 255,  51,  51 }, { 255,   0,  51 },
   { 255, 255,   0 }, { 255, 204,   0 }, { 255, 153,   0 }, { 255, 102,   0 },
   { 255,  51,   0 }, { 255,   0,   0 }, { 204, 255, 102 }, { 204, 204, 102 },
   { 204, 153, 102 }, { 204, 102, 102 }, { 204,  51, 102 }, { 204,   0, 102 },
   { 204, 255,  51 }, { 204, 204,  51 }, { 204, 153,  51 }, { 204, 102,  51 },
   { 204,  51,  51 }, { 204,   0,  51 }, { 204, 255,   0 }, { 204, 204,   0 },
   { 204, 153,   0 }, { 204, 102,   0 }, { 204,  51,   0 }, { 204,   0,   0 },
   { 153, 255, 102 }, { 153, 204, 102 }, { 153, 153, 102 }, { 153, 102, 102 },
   { 153,  51, 102 }, { 153,   0, 102 }, { 153, 255,  51 }, { 153, 204,  51 },
   { 153, 153,  51 }, { 153, 102,  51 }, { 153,  51,  51 }, { 153,   0,  51 },
   { 153, 255,   0 }, { 153, 204,   0 }, { 153, 153,   0 }, { 153, 102,   0 },
   { 153,  51,   0 }, { 153,   0,   0 }, { 102, 255, 102 }, { 102, 204, 102 },
   { 102, 153, 102 }, { 102, 102, 102 }, { 102,  51, 102 }, { 102,   0, 102 },
   { 102, 255,  51 }, { 102, 204,  51 }, { 102, 153,  51 }, { 102, 102,  51 },
   { 102,  51,  51 }, { 102,   0,  51 }, { 102, 255,   0 }, { 102, 204,   0 },
   { 102, 153,   0 }, { 102, 102,   0 }, { 102,  51,   0 }, { 102,   0,   0 },
   {  51, 255, 102 }, {  51, 204, 102 }, {  51, 153, 102 }, {  51, 102, 102 },
   {  51,  51, 102 }, {  51,   0, 102 }, {  51, 255,  51 }, {  51, 204,  51 },
   {  51, 153,  51 }, {  51, 102,  51 }, {  51,  51,  51 }, {  51,   0,  51 },
   {  51, 255,   0 }, {  51, 204,   0 }, {  51, 153,   0 }, {  51, 102,   0 },
   {  51,  51,   0 }, {  51,   0,   0 }, {   0, 255, 102 }, {   0, 204, 102 },
   {   0, 153, 102 }, {   0, 102, 102 }, {   0,  51, 102 }, {   0,   0, 102 },
   {   0, 255,  51 }, {   0, 204,  51 }, {   0, 153,  51 }, {   0, 102,  51 },
   {   0,  51,  51 }, {   0,   0,  51 }, {   0, 255,   0 }, {   0, 204,   0 },
   {   0, 153,   0 }, {   0, 102,   0 }, {   0,  51,   0 }, {  17,  17,  17 },
   {  34,  34,  34 }, {  68,  68,  68 }, {  85,  85,  85 }, { 119, 119, 119 },
   { 136, 136, 136 }, { 170, 170, 170 }, { 187, 187, 187 }, { 221, 221, 221 },
   { 238, 238, 238 }, { 192, 192, 192 }, { 128,   0,   0 }, { 128,   0, 128 },
   {   0, 128,   0 }, {   0, 128, 128 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 },
   {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }, {   0,   0,   0 }};
 
 static ColorMapEntry Palm1BitColormap[] = {{ 255, 255, 255 }, { 0, 0, 0 }};
 
 static ColorMapEntry Palm2BitColormap[] = {
   { 255, 255, 255 }, { 192, 192, 192 }, { 128, 128, 128 }, { 0, 0, 0 }};
 
 static ColorMapEntry Palm4BitColormap[] = {
   { 255, 255, 255 }, { 238, 238, 238 }, { 221, 221, 221 }, { 204, 204, 204 },
   { 187, 187, 187 }, { 170, 170, 170 }, { 153, 153, 153 }, { 136, 136, 136 },
   { 119, 119, 119 }, { 102, 102, 102 }, {  85,  85,  85 }, {  68,  68,  68 },
   {  51,  51,  51 }, {  34,  34,  34 }, {  17,  17,  17 }, {   0,   0,   0 }};
 
 QImage* Palm2QImage
   (unsigned char *image_bytes_in, int byte_count_in)
 {
   unsigned int width, height, bytes_per_row, flags, next_depth_offset;
   unsigned int bits_per_pixel, version, transparent_index, compression_type, i, j, inval, inbit, mask, incount;
   unsigned int palm_red_bits, palm_green_bits, palm_blue_bits;
-  unsigned char *palm_ptr, *x_ptr, *imagedata, *inbyte, *rowbuf, *lastrow,
+  unsigned char *palm_ptr, *x_ptr, *inbyte, *rowbuf, *lastrow,
   *imagedatastart, *palmimage;
   ColorMapEntry *colormap;
 
   palmimage = image_bytes_in;
   width = READ_BIGENDIAN_SHORT(palmimage + 0);
   height = READ_BIGENDIAN_SHORT(palmimage + 2);
   bytes_per_row = READ_BIGENDIAN_SHORT(palmimage + 4);
   flags = READ_BIGENDIAN_SHORT(palmimage + 6);
   bits_per_pixel = palmimage[8];
   version = palmimage[9];
   next_depth_offset = READ_BIGENDIAN_SHORT(palmimage + 10);
   transparent_index = palmimage[12];
   compression_type = palmimage[13];
   /* bytes 14 and 15 are reserved by Palm and always 0 */
   
 #if 0
 //  qDebug ("Palm image is %dx%d, %d bpp, version %d, flags 0x%x, compression %d", width, height, bits_per_pixel, version, flags, compression_type);
 #endif
 
   if (compression_type == PALM_COMPRESSION_PACKBITS) {
 //    qDebug ("Image uses packbits compression; not yet supported");
     return NULL;
   } else if ((compression_type != PALM_COMPRESSION_NONE) &&
     (compression_type != PALM_COMPRESSION_RLE) &&
       (compression_type != PALM_COMPRESSION_SCANLINE)) {
 //    qDebug ("Image uses unknown compression, code 0x%x", compression_type);
     return NULL;
   }
 
   /* as of PalmOS 4.0, there are 6 different kinds of Palm pixmaps:
      
      1, 2, or 4 bit grayscale
      8-bit StaticColor using the Palm standard colormap
      8-bit PseudoColor using a user-specified colormap
      16-bit DirectColor using 5 bits for red, 6 for green, and 5 for blue
      
      Each of these can be compressed with one of four compression schemes,
      "RLE", "Scanline", "PackBits", or none.
      
      We begin by constructing the colormap.
      */
 
   if (flags & PALM_HAS_COLORMAP_FLAG) {
 //    qDebug("Palm images with custom colormaps are not currently supported.\n");
     return NULL;
   } else if (bits_per_pixel == 1) {
     colormap = Palm1BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 2) {
     colormap = Palm2BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 4) {
     colormap = Palm4BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 8) {
     colormap = Palm8BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 16 && (flags & PALM_DIRECT_COLOR_FLAG)) {
     colormap = NULL;
     palm_red_bits = palmimage[16];
     palm_green_bits = palmimage[17];
     palm_blue_bits = palmimage[18];
 //    qDebug("Bits:%d, %d, %d", palm_red_bits, palm_green_bits, palm_blue_bits);
     if (palm_blue_bits > 8 || palm_green_bits > 8 || palm_red_bits > 8) {
 //      qDebug("Can't handle this format DirectColor image -- too wide in some color (%d:%d:%d)\n", palm_red_bits, palm_green_bits, palm_blue_bits);
       return NULL;
     }
     if (bits_per_pixel > (8 * sizeof(unsigned long))) {
 //      qDebug ("Can't handle this format DirectColor image -- too many bits per pixel (%d)\n", bits_per_pixel);
       return NULL;
     }
     imagedatastart = palmimage + 24;
   } else {
 //    qDebug("Unknown bits-per-pixel of %d encountered.\n", bits_per_pixel);
     return NULL;
   }
 
 #ifndef USEQPE
   QImage* qimage = new QImage(width, height, 32);
 #else
       QImage* qimage = new QImage(width, height, 16);
 #endif
 
   /* row by row, uncompress the Palm image and copy it to the JPEG buffer */
   rowbuf = new unsigned char[bytes_per_row * width];
   lastrow = new unsigned char[bytes_per_row * width];
 
-  for (i=0, palm_ptr = imagedatastart , x_ptr = imagedata;  i < height;  ++i) {
+  for (i=0, palm_ptr = imagedatastart , x_ptr = 0;  i < height;  ++i) {
 //        qDebug("inval:%x palm_ptr:%x x_ptr:%x bpr:%x", inval, palm_ptr, x_ptr, bytes_per_row);
 
     /* first, uncompress the Palm image */
     if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_RLE)) {
       for (j = 0;  j < bytes_per_row;  ) {
         incount = *palm_ptr++;
         inval = *palm_ptr++;
         memset(rowbuf + j, inval, incount);
         j += incount;
       }
     } else if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_SCANLINE)) {
       for (j = 0;  j < bytes_per_row;  j += 8) {
         incount = *palm_ptr++;
         inval = ((bytes_per_row - j) < 8) ? (bytes_per_row - j) : 8;
         for (inbit = 0;  inbit < inval;  inbit += 1) {
           if (incount & (1 << (7 - inbit)))
             rowbuf[j + inbit] = *palm_ptr++;
           else
             rowbuf[j + inbit] = lastrow[j + inbit];
         }
       }
       memcpy (lastrow, rowbuf, bytes_per_row);
     } else if (((flags & PALM_IS_COMPRESSED_FLAG) &&
                 (compression_type == PALM_COMPRESSION_NONE)) ||
                ((flags & PALM_IS_COMPRESSED_FLAG) == 0))
     {
         memcpy (rowbuf, palm_ptr, bytes_per_row);
         palm_ptr += bytes_per_row;
     }
     else {
         qDebug("Case 4");
         qDebug("Is compressed:%s", ((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true");
         qDebug("Has colourmap:%s", ((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true");
         qDebug("Has transparency:%s", ((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true");
         qDebug("Direct colour:%s", ((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true");
         qDebug("four byte field:%s", ((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true");
       memcpy (rowbuf, palm_ptr, bytes_per_row);
       palm_ptr += bytes_per_row;
     }
     /* next, write it to the GDK bitmap */
     if (colormap) {
       mask = (1 << bits_per_pixel) - 1;
       for (inbit = 8 - bits_per_pixel, inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((*inbyte) & (mask << inbit)) >> inbit;
         /* correct for oddity of the 8-bit color Palm pixmap... */
         if ((bits_per_pixel == 8) && (inval == 0xFF)) inval = 231;
         /* now lookup the correct color and set the pixel in the GTK bitmap */
         QRgb colour = qRgb(colormap[inval].red, colormap[inval].green, colormap[inval].blue);
         qimage->setPixel(j, i, colour);
         if (!inbit) {
           ++inbyte;
           inbit = 8 - bits_per_pixel;
         } else {
           inbit -= bits_per_pixel;
         }
       }
     } else if (!colormap &&
       bits_per_pixel == 16) {
       for (inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((unsigned short)inbyte[0] << (unsigned short)8) | inbyte[1];
 
 /*
         qDebug ("pixel is %d,%d (%d:%d:%d)",
                       j, i,
                       ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits),
                       ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
                       ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
 */
         QRgb colour = qRgb(
             ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), 
             ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
             ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
         qimage->setPixel(j, i, colour);
         inbyte += 2;
       }
     }
   }
 
   delete [] rowbuf;
   delete [] lastrow;
 
   return qimage;
 }
diff --git a/noncore/apps/opie-reader/QTReader.cpp b/noncore/apps/opie-reader/QTReader.cpp
index 0c56dd4..75da8ac 100644
--- a/noncore/apps/opie-reader/QTReader.cpp
+++ b/noncore/apps/opie-reader/QTReader.cpp
@@ -1,3492 +1,3492 @@
 /****************************************************************************
 ** $Id$
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of an example program for Qt.  This example
 ** program may be used, distributed and modified without limitation.
 **
 *****************************************************************************/
 
 const int _SBARHEIGHT = 3;
 
 #include <qpainter.h>
 //#include <qdirectpainter_qws.h>
 #include <qimage.h>
 #include <qtimer.h>
 #include "config.h"
 #include "QTReader.h"
 //#include "QTReaderApp.h"
 #include "CDrawBuffer.h"
 #ifdef USEQPE
 #include <qpe/qpeapplication.h>
 #endif
 #include <math.h>
 #include <ctype.h>
 #include <stdio.h> //for sprintf
 #ifdef USEQPE
 #include <qpe/config.h>
 #include <qpe/applnk.h>
 #include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 #endif
 #include <qfileinfo.h>
 #include <qdir.h>
 #include "TableDialog.h"
 #include "outputcodec.h"
 
 /*
 #ifdef _UNICODE
 const char *QTReader::fonts[] = { "unifont", "Courier", "Times", 0 };
 #else
 const char *QTReader::fonts[] = { "Helvetica", "Courier", "Times", 0 };
 #endif
 */
 //const int   QTReader::fontsizes[] = { 8, 10, 12, 14, 18, 24, 30, 40, 50, 60, 70, 80, 90, 100, 0 };
 
 //const tchar *QTReader::fonts[] = { "unifont", "fixed", "micro", "smoothtimes", "Courier", "Times", 0 };
 //const int   QTReader::fontsizes[] = {10,16,17,22,0};
 //const tchar *QTReader::fonts[] = { "verdana", "Courier", "Times", 0 };
 //const int   QTReader::fontsizes[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,0};
 
 tchar QTReader::pluckernextpart[] = { 'C','l','i','c','k',' ','h','e','r','e',' ','f','o','r',' ','t','h','e',' ','n','e','x','t',' ','p','a','r','t',0 };
 tchar QTReader::jplucknextpart[] = { 'N','e','x','t',' ','P','a','r','t',' ','>','>',0 };
 //tchar QTReader::jplucknextpart[] = { 10,'#',10,'N','e','x','t',' ','P','a','r','t',' ','>','>',0 };
 
 QTReader::QTReader( QWidget *parent, const char *name, WFlags f) :
   QWidget(parent, name, f | WRepaintNoErase | WResizeNoErase),
   m_outofdate(true),
   m_default_fg(0,0,0),
   m_default_bg(255,255,255),
   m_bg(255,255,255),
   m_delay(100),
   m_scrolldy1(0),
   m_scrolldy2(0),
   m_totalscroll(0),
   m_autoScroll(false),
   //textarray(NULL),
   //locnarray(NULL),
   numlines(0),
   m_fontname("unifont"),
   m_fm(NULL),
   mouseUpOn(true),
   m_twotouch(true),
   m_touchone(true),
   bDoUpdates(false),
 #ifdef _SCROLLPIPE
   m_pipeout(NULL),
 #endif
   m_left_border(2),
   m_right_border(2),
   m_rotated(true),
   pBkmklist(NULL),
   m_scrollpos(0),
   //  bNegative(false),
   bInverse(false),
   m_highlightfilter(NULL),
   m_bgIsScaled(false),
   m_scrollstep(2),
   m_topmargin(5),
   m_bottommargin(5),
   m_reparastring("{\\n[\\n ]}"),
   m_currentlinkstyle(NULL),
   m_currentlinkoffset(-1),
   m_currentlink(-1)
 {
   m_output = NULL;
     m_overlap = 1;
     setKeyCompression ( true );
 
     dbuff = NULL;
     dbp = NULL;
 }
 
 /*
 QTReader::QTReader( const QString& filename, QWidget *parent=0, const tchar *name=0, WFlags f = 0) :
   QWidget(parent, name, f),
   m_textfont(0),
   m_textsize(1),
   textarray(NULL),
   numlines(0),
   bstripcr(true),
   bunindent(false),
   brepara(false),
   bdblspce(false),
   btight(false),
   bindenter(0),
   m_fm(NULL)
 {
   init();
 //  //  qDeb2ug("Load_file(1)");
   load_file((const tchar*)filename);
 }
 */
 
 /*
 void QTReader::mouseMoveEvent(QMouseEvent* _e)
 {
 
     mouseUpOn = !(_e->pos().x() == -1);
 
     qDebug("MouseMove:[%d, %d]", _e->pos().x(), _e->pos().y());
 }
 */
 long QTReader::real_delay()
 {
     return m_scrollstep*( 8976 + m_delay ) / ( m_linespacing * m_linespacing );
 }
 
 void QTReader::mousePressEvent( QMouseEvent* _e )
 {
   m_drageligible = false;
   qDebug("Mouse pressed at (%u, %u)", _e->x(), _e->y());
   int x, y, ht, wh;
   if (m_rotated)
     {
       x = _e->y();
       y = width()-_e->x();
       ht = width();
       wh = height();
     }
   else
     {
       x = _e->x();
       y = _e->y();
       ht = height();
       wh = width();
     }
   if (x >= m_left_border && x <= wh - m_right_border && y >= m_topmargin && y <= ht-m_bottommargin)
     {
       if (_e->button() == RightButton)
         {
                   //qDebug("MousePress");
           mouseUpOn = false;
           if (m_swapmouse)
             {
               int lineno = 0;
               /*
                 int hgt = textarray[0]->lineSpacing();
                 while ((hgt < y) && (lineno < numlines))
                 {
                 hgt += textarray[++lineno]->lineSpacing();
                 }
               */
               size_t startpos, startoffset, tgt, tgtoffset, pictgt, tabtgt;
               QImage* img;
               getcurrentpos(x, y, wh, ht, lineno, startpos, startoffset, tgt, tgtoffset, pictgt, img, tabtgt);
               processmousewordevent(startpos, startoffset, _e, lineno);
             }
           else
             {
               processmousepositionevent(_e);
             }
         }
     }
   else
     {
       int ln = -1;
       int mp;
       int sectionsize = (buffdoc.endSection()-buffdoc.startSection());
       switch (m_scrollpos)
         {
         case 1:
           {
             if (m_rotated)
               {
                 if (_e->x() < m_bottommargin)
                   {
                     ln = height();
                     mp = _e->y();
                   }
               }
             else
               {
                 if (_e->y() > height()-m_bottommargin)
                   {
                     ln = width();
                     mp = _e->x();
                   }
               }
           }
           break;
         case 2:
           {
             if (m_rotated)
               {
                 if (_e->y() > height() - m_right_border)
                   {
                     ln = width();
                     mp = width()-_e->x();
                   }
               }
             else
               {
                 if (_e->x() > width() - m_right_border)
                   {
                     ln = height();
                     mp = _e->y();
                   }
               }
           }
           break;
         case 3:
           {
             if (m_rotated)
               {
                 if (_e->y() < m_left_border)
                   {
                     ln = width();
                     mp = width()-_e->x();
                   }
               }
             else
               {
                 if (_e->x() < m_left_border)
                   {
                     ln = height();
                     mp = _e->y();
                   }
               }
           }
           break;
         case 0:
         default:
           ln = -1;
           break;
         }
       if (ln >= 0)
         {
           int dp = (sectionsize*mp+ln/2)/ln + buffdoc.startSection();
           int winsize = locnarray[numlines]-locnarray[0];
           int slidersize = 10*(sectionsize+ln/2)/ln;
           if (slidersize > winsize)
             {
               int mid = (locnarray[0] + locnarray[numlines])/2;
               slidersize /= 2;
               if (dp < mid-slidersize)
                 {
                   dopageup();
                 }
               else if (dp > mid+slidersize)
                 {
                   dopagedn();
                 }
               //if (mid-slidersize < dp && dp < mid+slidersize)
               else
                 {
                   m_drageligible = true;
                 }
             }
           else
             {
               if (dp < locnarray[0])
                 {
                   dopageup();
                 }
               else if (dp > locnarray[numlines])
                 {
                   dopagedn();
                 }
                 //if (locnarray[0] < dp && dp < locnarray[numlines])
               else
                 {
                   m_drageligible = true;
                 }
             }
           qDebug("Drag eligible:%s", (m_drageligible) ? "true" : "false");
         }
       else
         {
           if (m_scrollpos == 1)
             {
               if (x < m_left_border)
                 {
                   lineUp();
                 }
               if (y > ht - m_bottommargin)
                 {
                   lineDown();
                 }
             }
           else if (m_scrollpos != 0)
             {
               if (y < m_topmargin)
                 {
                   lineUp();
                 }
               if (y > ht - m_bottommargin)
                 {
                   lineDown();
                 }
             }
         }
     }
 }
 
 void QTReader::processmousepositionevent( QMouseEvent* _e )
 {
   int x, y, ht, wh;
   if (m_rotated)
     {
       x = _e->y();
       y = width()-_e->x();
       ht = width();
       wh = height();
     }
   else
     {
       x = _e->x();
       y = _e->y();
       ht = height();
       wh = width();
     }
     if (buffdoc.hasnavigation())
     {
         if (y > (2*ht)/3)
         {
             goDown();
         }
         else if (y < ht/3)
         {
             goUp();
         }
         else
         {
             if (x < wh/3)
             {
                 goBack();
             }
             else if (x > (2*wh)/3)
             {
                 goForward();
             }
             else
             {
                 goHome();
             }
         }
     }
     else
     {
         if (y > ht/2)
         {
             goDown();
         }
         else
         {
             goUp();
         }
     }
 }
 
 void QTReader::goHome()
 {
     if (buffdoc.hasnavigation())
     {
          size_t current=pagelocate();
          size_t home=buffdoc.getHome();
          if (current!=home)
         {
             buffdoc.saveposn(m_lastfile, current);
             locate(home);
          }
     }
     else
       locate(0);
 }
 
 void QTReader::goBack()
 {
   if (buffdoc.hasnavigation())
     {
       size_t target = pagelocate();
       QString nxt = m_lastfile;
       buffdoc.writeposn(m_lastfile, target);
       linkType lt = buffdoc.back(nxt, target);
       if ((lt & eFile) != 0)
         {
           if (nxt != m_lastfile)
             {
               emit NewFileRequest(nxt);
             }
           locate(target);
         }
       else if ((lt & eLink) != 0)
         {
           locate(target);
         }
     }
 }
 
 void QTReader::goForward()
 {
   if (buffdoc.hasnavigation())
     {
       size_t target = pagelocate();
       QString nxt = m_lastfile;
       linkType lt = buffdoc.forward(nxt, target);
       if ((lt & eFile) != 0)
         {
           if (nxt != m_lastfile)
             {
               emit NewFileRequest(nxt);
             }
           locate(target);
         }
       else if ((lt & eLink) != 0)
         {
           locate(target);
         }
     }
 }
 
 linkType QTReader::getcurrentpos(int x, int y, int w, int h, int& lineno, size_t& start, size_t& offset, size_t& tgt, size_t& tgtoffset, size_t& pictgt, QImage*& img, size_t& tabtgt)
 {
   int ht;
   if (m_scrolldy == m_topmargin)
     {
       lineno = 0;
       ht = textarray[0]->lineSpacing()-m_scrolldy1 + m_topmargin;
     }
   else
     {
       if (y >= m_scrolldy)
         {
           lineno = 0;
           ht = textarray[0]->lineSpacing()-m_scrolldy1+m_scrolldy + m_topmargin;
         }
       else
         {
           lineno = 0;
           ht = textarray[0]->lineSpacing()-m_scrolldy1+m_scrolldy+m_topmargin;
           while ((ht < h) && (lineno < numlines-1))
             {
               ht += textarray[++lineno]->lineSpacing();
             }
           ht = textarray[lineno]->lineSpacing();
         }
     }
   while ((ht < y) && (lineno < numlines-1))
     {
       ht += textarray[++lineno]->lineSpacing();
     }
   if (ht < y && textarray[numlines]->showPartial()) lineno = numlines;
   start = locnarray[lineno];
   int availht = ((m_rotated) ? width() : height()) - m_topmargin - m_bottommargin;
   if (m_bMonoSpaced)
     {
       offset = (x - textarray[lineno]->offset(w, m_left_border, m_right_border, availht))/m_charWidth;
     }
   else
     {
       int i;
       CDrawBuffer* t = textarray[lineno];
       x = x - t->offset(width(), m_left_border, m_right_border, availht);
       for (i = t->length(); i > 0 && t->width(availht, i, true, w, m_left_border, m_right_border) > x; i--);
       offset = i;
     }
   return textarray[lineno]->getLinkType(offset, tgt, tgtoffset, pictgt, img, tabtgt);
 }
 
 void QTReader::suspend()
 {
   buffdoc.suspend();
   /*#ifdef OPIE
     if (memcmp("/mnt/", m_lastfile.latin1(), 5) == 0) buffdoc.suspend();
 #else
     if (memcmp("/usr/mnt.rom/", m_lastfile.latin1(), 13) == 0) buffdoc.suspend();
 #endif
   */
 }
 
 void QTReader::setDoubleBuffer(bool _b)
 {
   m_doubleBuffered = _b;
   if (_b || m_rotated)
     {
       if (dbuff == NULL)
         {
           dbuff = new QPixmap();
           dbp = new QPainter();
         }
       if (m_rotated)
         {
           dbuff->resize(height(), width());
         }
       else
         {
           dbuff->resize(width(), height());
         }
       m_outofdate = true;
     }
   else
     {
       if (dbuff != NULL)
         {
           delete dbuff;
           delete dbp;
         }
       dbuff = NULL;
       dbp = NULL;
     }
 }
 
 void QTReader::setTwoTouch(bool _b)
 {
     setBackgroundColor( m_bg );
     m_twotouch = m_touchone = _b;
 }
 
 void QTReader::setContinuous(bool _b)
 {
     buffdoc.setContinuous(m_continuousDocument = _b);
 }
 
 void QTReader::processmousewordevent(size_t startpos, size_t startoffset, QMouseEvent* _e, int lineno)
 {
-  unsigned long wrdstart, wrdend;
+    unsigned long wrdstart = 0, wrdend = 0;
     QString wrd;
     int availht = ((m_rotated) ? width() : height()) - m_topmargin - m_bottommargin;
     if (m_twotouch)
     {
         if (m_touchone)
         {
             m_touchone = false;
             m_startpos = startpos;
             m_startoffset = startoffset;
             setBackgroundColor( lightGray );
         }
         else
         {
             m_touchone = true;
             setBackgroundColor( m_bg );
             size_t endpos, endoffset;
             endpos = startpos;
             endoffset = startoffset;
             size_t currentpos = locate();
             if (endpos >= m_startpos)
             {
                 jumpto(m_startpos);
                 for (int i = 0; i < m_startoffset; i++)
                 {
                     getch();
                 }
                 wrdstart = buffdoc.explocate();
                 if (m_startpos == endpos)
                 {
                     for (int i = m_startoffset; i <= endoffset; i++)
                     {
                         wrd += QChar(getch());
                     }
                 }
                 else
                 {
                     while (buffdoc.explocate() <= endpos)
                     {
                         wrd += QChar(getch());
                     }
                     for (int i = 0; i < endoffset; i++)
                     {
                         wrd += QChar(getch());
                     }
                 }
                 wrdend = buffdoc.explocate();
                 jumpto(currentpos);
             }
         }
     }
     else if (m_bMonoSpaced)
     {
       int chno = (m_rotated) ?
         (_e->y()-textarray[lineno]->offset(height(), m_left_border, m_right_border, availht))/m_charWidth
         :
         (_e->x()-textarray[lineno]->offset(width(), m_left_border, m_right_border, availht))/m_charWidth;
         if (chno < ustrlen(textarray[lineno]->data()))
         {
             wrd[0] = textarray[lineno]->data()[chno];
         }
     }
     else
     {
         CDrawBuffer* t = textarray[lineno];
         int first = 0;
         int tgt = (m_rotated) ?
           _e->y() - t->offset(height(), m_left_border, m_right_border, availht) :
           _e->x() - t->offset(width(), m_left_border, m_right_border, availht);
         while (1)
         {
             int i = first+1;
             int availht = ((m_rotated) ? width() : height()) - m_topmargin - m_bottommargin;
             while (QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
             if (t->width(availht, i, true, (m_rotated) ? height() : width(), m_left_border, m_right_border) > tgt)
             {
                 wrd = toQString(t->data()+first, i - first);
         //                  qDebug("Got %s", (const char *)wrd);
                 break;
             }
             while (!QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++;
             if ((*t)[i] == 0) break;
             first = i;
                 }       
     }
     if (!wrd.isEmpty())
     {
         qDebug("Selected:%s", (const char*)wrd);
         if (m_twotouch)
           {
             emit OnWordSelected(wrd, wrdstart, wrdend, wrd);
           }
         else
           {
             QString line = toQString(textarray[lineno]->data());
             emit OnWordSelected(wrd, locnarray[lineno], locnarray[lineno]+line.length(), line);
           }
     }
 }
 
 #ifdef USETIMER
 void QTReader::actionDrag()
 {
   if (m_drageligible)
     {
       int fivepages = 5*((2*width()+m_textsize/2)/m_textsize)*((height()+m_textsize/2)/m_textsize);
       if (m_dragtarget > fivepages && locnarray[numlines] < m_dragtarget - fivepages)
         {
           int tgt = m_dragtarget - fivepages/2;
           //qDebug("Jumping to %u (%u)", tgt, fivepages);
           if (tgt < buffdoc.startSection())
             {
               tgt = buffdoc.startSection();
             }
           locate(tgt);
           drawFonts();
         }
       else if (locnarray[0] > m_dragtarget+fivepages)
         {
           int tgt = m_dragtarget + fivepages/2;
           //qDebug("Jumping to %u (%u)", tgt, fivepages);
           if (tgt > buffdoc.endSection())
             {
               dopageup();
             }
           else
             {
               locate(tgt);
               drawFonts();
             }
         }
       else if (locnarray[numlines] <= m_dragtarget)
         {
           dopagedn();
         }
       else if (locnarray[0] > m_dragtarget)
         {
           dopageup();
         }
     }
   else
     {
       m_dragtimer->stop();
     }
 }
 #endif
 
 void QTReader::mouseMoveEvent( QMouseEvent* _e )
 {
   if (m_drageligible)
     {
       int ht;
       int mp;
       int sectionsize = (buffdoc.endSection()-buffdoc.startSection());
       //qDebug("Mouse moved to (%u, %u)", _e->x(), _e->y());
       switch (m_scrollpos)
         {
         case 1:
           {
             if (m_rotated)
               {
                 ht = height();
                 mp = _e->y();
               }
             else
               {
                 ht = width();
                 mp = _e->x();
               }
           }
           break;
         case 2:
         case 3:
           {
             if (m_rotated)
               {
                 ht = width();
                 mp = width()-_e->x();
               }
             else
               {
                 ht = height();
                 mp = _e->y();
               }
           }
           break;
         case 0:
         default:
           ht = -1;
           break;
         }
       if (ht >= 0)
         {
 #ifdef USETIMER
           m_dragtarget = (sectionsize*mp+ht/2)/ht + buffdoc.startSection();
           if (!m_dragtimer->isActive())
             {
               m_dragtimer->start(0, false);
             }
 #else
           int dp = (sectionsize*mp+ht/2)/ht + buffdoc.startSection();
           locate(dp);
 #endif
         }
     }
 }
 
 void QTReader::mouseReleaseEvent( QMouseEvent* _e )
 {
   qDebug("Mouse released at (%u, %u)", _e->x(), _e->y());
   if (m_drageligible)
     {
       m_drageligible = false;
     }
   else
     {
       int x, y, ht, wh;
       if (m_rotated)
         {
           x = _e->y();
           y = width()-_e->x();
           ht = width();
           wh = height();
         }
       else
         {
           x = _e->x();
           y = _e->y();
           ht = height();
           wh = width();
         }
       if (_e->button() == LeftButton)
         {
           if (mouseUpOn)
             {
                       //    qDebug("MouseRelease");
               /*
                 switch(m_scrollpos)
                 {
                 case 1: // Bottom
                 if (y > ht - 5)
                 {
                 locate(buffdoc.startSection()+((buffdoc.endSection()-buffdoc.startSection())*x+wh/2)/wh);
                 return;
                 }
                 break;
                 case 2: // right
                 if (x > wh - m_right_border)
                 {
                 locate(buffdoc.startSection()+((buffdoc.endSection()-buffdoc.startSection())*y+ht/2)/ht);
                 return;
                 }
                 break;
                 case 3: // left
                 if (x < m_left_border)
                 {
                 locate(buffdoc.startSection()+((buffdoc.endSection()-buffdoc.startSection())*y+ht/2)/ht);
                 return;
                 }
                 break;
                 case 0:
                 default:
                 break;
                 }
               */
               if (textarray[0] != NULL)
                 {
                   QString line;
                           //    int lineno = _e->y()/m_linespacing;
                   int lineno = 0;
                   /*
                     int ht = textarray[0]->lineSpacing();
                     while ((ht < y) && (lineno < numlines))
                     {
                     ht += textarray[++lineno]->lineSpacing();
                     }
                   */
                   size_t startpos, startoffset, tgt, tgtoffset, pictgt, tabtgt;
                   QImage* img;
                   if (m_currentlinkstyle != NULL)
                     {
                       textarray[m_currentlink]->invertLink(m_currentlinkoffset);
                       m_currentlinkstyle = NULL;
                       m_currentlink = -1;
                       m_currentlinkoffset = -1;
                     }
                   linkType glt = getcurrentpos(x, y, wh, ht, lineno, startpos, startoffset, tgt, tgtoffset, pictgt, img, tabtgt);
                   if (bNoInlineTables && ((glt & eTable) != 0))
                     {
                       size_t currentpos = locate();
                       QString tabtext = buffdoc.getTableAsHtml(tabtgt);
                       qDebug("TABLE:%u:%u:%s", currentpos, tabtgt, (const char*)tabtext);
                       QFont f(m_fontname, m_fontControl.currentsize());
 #ifdef USEQPE
                       CTableDialog td(f, tabtext, true, this);
 #else
                       CTableDialog td(f, tabtext, false, this);
 #endif
                       td.exec();
                       jumpto(currentpos);
                     }
                   if ((glt & eLink) != 0)
                     {
                       if ((glt & ePicture) != 0)
                         {
                           qDebug("Big Picture:%x", pictgt);
                           if (QMessageBox::warning(this, PROGNAME, "Show picture or goto link?", "Show", "Goto Link") == 0)
                             {
                               QImage* pm = buffdoc.getPicture(pictgt);
                               if (pm != NULL)
                                 {
                                   emit OnShowPicture(*pm);
                                   delete pm;
                                   return;
                                 }
                             }
                         }
                       else if (img != NULL)
                         {
                           if (QMessageBox::warning(this, PROGNAME, "Show picture or goto link?", "Show", "Goto Link") == 0)
                             {
                               emit OnShowPicture(*img);
                               return;
                             }
                         }
                       size_t saveposn = pagelocate();
                       QString href, nm;
                       linkType lt = buffdoc.hyperlink(tgt, tgtoffset, href, nm);
                       qDebug("URL(1):%s", (const char*)href);
                       if ((lt & eFile) != 0)
                         {
                           buffdoc.saveposn(m_lastfile, saveposn);
 #ifdef USEQPE
                           {
                             QCopEnvelope e("QPE/System", "busy()");
                           }
 #endif
                           ResetScroll();
                           if (!href.isEmpty())
                             {
                               if (!buffdoc.getFile(href, nm))
                                 {
                                   emit NewFileRequest(href);
                                 }
                               else
                                 {
                                   qDebug("BEFORE:%u", pagelocate());
                                   buffdoc.resetPos();
                                   ResetScroll();
                                   fillbuffer();
                                   qDebug("AFTER:%u", pagelocate());
                                   m_outofdate = true;
                                   update();
                                 }
                             }
                           if (!nm.isEmpty())
                             {
                               qDebug("QTReader:Finding %s", (const char*)nm);
                               if (buffdoc.findanchor(nm))
                                 {
                                   buffdoc.resetPos();
                                   fillbuffer();
                                   m_outofdate = true;
                                   update();
                                 }
                             }
                           //fillbuffer();
                           //update();
 #ifdef USEQPE
                           {
                             QCopEnvelope e("QPE/System", "notBusy()");
                           }
 #endif
                         }
                       else if ((lt & eLink) != 0)
                         {
                           buffdoc.saveposn(m_lastfile, saveposn);
                           ResetScroll();
                           fillbuffer();
                           m_outofdate = true;
                           update();
                         }
                       else
                         {
                           if ((lt & ePicture) != 0)
                             {
                               QImage* pm = buffdoc.getPicture(tgt);
                               if (pm != NULL)
                                 {
                                   emit OnShowPicture(*pm);
                                   delete pm;
                                 }
                             }
                           else
                             {
                                       //                        QString anchortext = textarray[lineno]->getanchortext(startoffset);
                               if (!href.isEmpty())
                                 {
                                   emit OnURLSelected(href, tgt);
                                 }
                             }
                         }
                       return;
                     }
                   else if ((glt & ePicture) != 0)
                     {
                       qDebug("Big Picture:%x", pictgt);
                       QImage* pm = buffdoc.getPicture(pictgt);
                       if (pm != NULL)
                         {
                           emit OnShowPicture(*pm);
                           delete pm;
                         }
                       else
                         {
                           update();
                         }
                       return;
                     }
                   else if (img != NULL)
                     {
                       emit OnShowPicture(*img);
                       return;
                     }
                   if (m_swapmouse)
                     processmousepositionevent(_e);
                   else
                     processmousewordevent(startpos, startoffset, _e, lineno);
                 }
             }
           else
             {
               mouseUpOn = true;
             }
         }
     }
 }
 
 void QTReader::focusInEvent(QFocusEvent* e)
 {
     if (m_autoScroll && (m_scrolltype != 4)) timer->start(real_delay(), false);
     update();
 }
 
 void QTReader::focusOutEvent(QFocusEvent* e)
 {
     if (m_autoScroll)
     {
       if (m_scrolltype != 4)
         {
           timer->stop();
         }
       else
         {
           m_autoScroll = false;
         }
         //m_scrolldy1 = m_scrolldy2 = 0;
     }
 }
 
 #include <qapplication.h>
 #include <qdrawutil.h>
 #ifndef _WINDOWS
 #include <unistd.h>
 #endif
 
 void QTReader::goDown()
 {
     if (m_bpagemode)
     {
         dopagedn();
     }
     else
     {
         lineDown();
     }
 }
 
 void QTReader::goUp()
 {
     if (m_bpagemode)
     {
         dopageup();
     }
     else
     {
         lineUp();
     }
 }
 
 void QTReader::NavUp()
 {
     if (buffdoc.hasnavigation())
     {
 /*
         size_t target = pagelocate();
         if (buffdoc.back(target))
         {
             locate(target);
         }
 */
         locate(buffdoc.startSection());
     }
     else
     {
         goUp();
     }
 }
 
 void QTReader::NavDown()
 {
     if (buffdoc.hasnavigation())
     {
 /*
         size_t target = pagelocate();
         if (buffdoc.forward(target))
         {
             locate(target);
         }
 */
         dopageup(buffdoc.endSection());
     }
     else
     {
         goDown();
     }
 }
 
 void QTReader::zoomin()
 {
     if (m_fontControl.increasesize())
     {
         bool sc = m_autoScroll;
         setautoscroll(false);
         setfont();
         refresh();
         setautoscroll(sc);
     }
 }
 
 void QTReader::zoomout()
 {
     if (m_fontControl.decreasesize())
     {
         bool sc = m_autoScroll;
         setautoscroll(false);
         setfont();
         refresh();
         setautoscroll(sc);
     }
 }
 
 void QTReader::reduceScroll()
 {
     if (m_delay < 59049)
     {
         m_delay = (3*m_delay)/2;
         timer->changeInterval(real_delay());
     }
     else
     {
         m_delay = 59049;
     }
 }
 
 void QTReader::increaseScroll()
 {
     if (m_delay > 454)
     {
         m_delay = (2*m_delay)/3;
         timer->changeInterval(real_delay());
     }
     else
     {
         m_delay = 454;
     }
 }
 
 void QTReader::keyPressEvent(QKeyEvent* e)
 {
 
    //((QTReaderApp*)parent()->parent())->handlekey(e);
     emit HandleKeyRequest(e);
 //    e->ignore();
     return;
 #ifdef _SCROLLPIPE
     if (m_isPaused)
     {
         m_isPaused = false;
         if (e->key() != Key_Space)
         {
             m_autoScroll = false;
             if (m_pipeout != NULL)
             {
                 pclose(m_pipeout);
                 m_pipeout = NULL;
             }
             //((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll);
             emit SetScrollState(m_autoScroll);
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
         }
         else
         {
             timer->start(real_delay(), false);
         }
         e->accept();
         return;
     }
 #endif
 }
 
 void QTReader::CalculateScrollParameters()
 {
   int bmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
   if (bmargin < m_bottommargin) bmargin = m_bottommargin;
   switch (m_scrolltype)
     {
     case 0:
       {
         if (m_scrolldy == m_topmargin)
           {
             m_scrolldy1 = 0;
             m_scrolldy2 = 0;
             m_totalscroll = 0;
             return;
           }
         if (m_scrolldy < textarray[0]->lineSpacing())
           {
             m_scrolldy2 = m_scrolldy;
             return;
           }
         int ht = m_scrolldy - m_scrolldy1;
         int i;
         for (i = 0; (ht < ((m_rotated) ? width() : height())-bmargin) && (i < numlines); i++)
           {
             ht += textarray[i]->lineSpacing();
           }
         ht = 0;
         int j;
         i--;
         for (j = i; j < numlines; j++)
           {
             ht += textarray[j]->lineSpacing();
           }
         ht -= (
                textarray[i]->lineExtraSpacing()
                +
                (i != 0) ? textarray[numlines-1]->lineExtraSpacing() : 0
                )/2-2;
         
         m_scrolldy2 = m_scrolldy-ht;
       }
       break;
     case 1:
     case 2:
     case 3:
       {
         int ypos = m_topmargin;
         for (int i = 0; i < numlines; i++)
           {
             ypos += textarray[i]->lineSpacing();
           }
         ypos -= (
                  textarray[0]->lineExtraSpacing()
                  +
                  ((numlines > 1) ? textarray[numlines-1]->lineExtraSpacing() : 0)
                  )/2 +
           m_scrolldy1 - 2;
         m_scrolldy2 = ((m_rotated) ? width() : height()) - ypos - bmargin;
       }
       break;
     }
 }
 
 void QTReader::setautoscroll(bool _sc)
 {
   m_outofdate = true;
     if (_sc == m_autoScroll) return;
     if (m_autoScroll)
     {
         m_autoScroll = false;
 #ifdef USEQPE
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
 #ifdef _SCROLLPIPE
         if (m_pipeout != NULL)
         {
             pclose(m_pipeout);
             m_pipeout = NULL;
         }
 #endif
                 //m_scrolldy1 = 0;
         //refresh();
      }
     else
     {
         CDrawBuffer* reusebuffer = textarray[numlines];
         if (reusebuffer == NULL || reusebuffer->eof()) return;
 #ifndef __STATIC
         if ((m_scrolltype == 4) && !checkoutput()) return;
 #endif
         m_autoScroll = true;
         CalculateScrollParameters();
 
 #ifdef _SCROLLPIPE
         if (!m_pipetarget.isEmpty())
         {
         //    qDebug("Opening pipe to %s", (const char*)m_pipetarget);
             m_pipeout = popen((const char*)m_pipetarget, "w");
             m_isPaused = false;
         }
 #endif
         autoscroll();
 #ifdef USEQPE
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Disable; // light is even not dimmed
 #endif
     }
 }
 
 bool QTReader::getline(CDrawBuffer *buff)
 {
     bool bRet;
     int availht = ((m_rotated) ? width() : height()) - m_topmargin - m_bottommargin;
     if (m_bMonoSpaced)
     {
         bRet = buffdoc.getline(buff ,(m_rotated) ? height() : width(), m_charWidth, m_left_border, m_right_border, availht);
     }
     else
     {
         bRet = buffdoc.getline(buff, (m_rotated) ? height() : width(), m_left_border, m_right_border, hyphenate, availht);
     }
     buff->resize(availht);
     return bRet;
 }
 
 void QTReader::doscroll()
 {
     if (!m_autoScroll)
     {
         timer->stop();
         return;
     }
     switch (m_scrolltype)
       {
       case 0:
         doinplacescroll();
         break;
       case 1:
         dorollingscroll(false);
         break;
       case 2:
         dorollingscroll(true);
         break;
       case 3:
         dostaticscroll();
         break;
       }
 }
 
 void QTReader::doinplacescroll()
 {
   QPainter p( this );
   //  p.setBackgroundMode(OpaqueMode);
   int wh, ht;
   int bmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
   if (bmargin < m_bottommargin) bmargin = m_bottommargin;
   if (m_rotated)
     {
       ht = width()-bmargin;
       wh = height();
     }
   else
     {
       ht = height()-bmargin;
       wh = width();
     }
   int lastdy = m_scrolldy;
   m_scrolldy += m_scrollstep;
   if ((m_scrolldy1 = m_scrolldy1+m_scrollstep) >= textarray[0]->lineSpacing())
     {
       int ht = textarray[0]->lineSpacing();
 #ifdef _SCROLLPIPE
       if (m_pipeout != NULL)
         {
           QString outstr = toQString(textarray[0]->data());
           if (!outstr.isEmpty())
             {
               fprintf(m_pipeout, "%s\n", (const char*)outstr);
               fflush(m_pipeout);
             }
           else if (m_pauseAfterEachPara)
             {
               m_isPaused = true;
               timer->stop();
             }
         }
 #endif
       CDrawBuffer* buff = textarray[0];
       for (int i = 1; i <= numlines; i++)
         {
           textarray[i-1] = textarray[i];
           locnarray[i-1] = locnarray[i];
         }
       textarray[numlines] = buff;
       --numlines;
       m_scrolldy1 -= ht;
     }
   if ((m_scrolldy2 = m_scrolldy2+m_scrollstep) >= textarray[numlines]->lineSpacing())
     {
       m_scrolldy2 -= textarray[numlines]->lineSpacing();
       numlines++;
 
       if (textarray[numlines] == NULL)
         {
           textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
       locnarray[numlines] = locate();
       int ch = getline(textarray[numlines]);
       if (m_rotated)
         {
           blitRot(width()-m_scrolldy, 0, height(), -1, textarray[numlines-1]);
         }
       else
         {
           if (m_bgpm.isNull())
             {
               p.fillRect(m_left_border,m_scrolldy-textarray[numlines-1]->lineSpacing(),width()-(m_left_border+m_right_border),textarray[numlines-1]->lineSpacing(),m_bg);
             }
           else
             {
               int h_tmp = textarray[numlines-1]->lineSpacing();
               bitBlt(this, m_left_border, m_scrolldy-h_tmp, dbuff, m_left_border, m_scrolldy-h_tmp, width()-(m_left_border+m_right_border), h_tmp);
             }
           textarray[numlines-1]->render(&p, m_scrolldy -textarray[numlines-1]->lineSpacing()+ textarray[numlines-1]->ascent(), m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg, height()-m_topmargin-m_bottommargin);
         }
       mylastpos = locate();
       if (!ch)
         {
           m_scrolldy = m_topmargin;
           m_autoScroll = false;
 #ifdef _SCROLLPIPE
           for (int i = 0; i < numlines; i++)
             {
               if (m_pipeout != NULL)
                 {
                   QString outstr = toQString(textarray[i]->data());
                   if (!outstr.isEmpty())
                     {
                       fprintf(m_pipeout, "%s\n", (const char*)outstr);
                       fflush(m_pipeout);
                     }
                 }
             }
 #endif
           emit SetScrollState(m_autoScroll);
 #ifdef USEQPE
           QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
         }
       if (m_scrolldy > ht-textarray[numlines]->lineSpacing())
         {
           if (m_rotated)
             {
               if (m_bgpm.isNull())
                 {
                   p.fillRect(bmargin, m_left_border, ht-m_scrolldy, wh-(m_left_border+m_right_border), m_bg);
                 }
               else
                 {
                   blitRot(bmargin, 0,height(), ht-m_scrolldy, NULL);
                 }
             }
           else
               if (m_bgpm.isNull())
                 {
                   p.fillRect(m_left_border,m_scrolldy,width()-(m_left_border+m_right_border),height()-m_scrolldy,m_bg);
                 }
               else
                 {
                   bitBlt(this,m_left_border,m_scrolldy,dbuff,m_left_border,m_scrolldy,width()-(m_left_border+m_right_border), height()-m_scrolldy);
                 }
           m_scrolldy = m_topmargin;
           m_scrolldy2 = 0;
         }
       redrawScroll(&p);
       emitRedraw();
       lastdy = -1;
     }
   //  else
     {
       if (m_rotated)
         {
           if (lastdy >= 0) 
             {
               if (m_bgpm.isNull())
                 {
                   p.fillRect(width()-lastdy, m_left_border, m_scrollstep, wh-(m_left_border+m_right_border),m_bg);
                 }
               else
                 {
                   blitRot(width()-lastdy,m_left_border,wh-(m_left_border+m_right_border), m_scrollstep, NULL);
                 }
             }
           p.fillRect(width()-m_scrolldy, m_left_border, 1,wh-(m_left_border+m_right_border),m_scrollcolor);
         }
       else
         {
           if (lastdy >= 0) 
             {
               if (m_bgpm.isNull())
                 {
                   p.fillRect(m_left_border,lastdy,width()-(m_left_border+m_right_border),m_scrollstep,m_bg);
                 }
               else
                 {
                   bitBlt(this, m_left_border, lastdy, dbuff, m_left_border, lastdy, width()-(m_left_border+m_right_border), m_scrollstep);
                 }
             }
           p.fillRect(m_left_border,m_scrolldy,width()-(m_left_border+m_right_border),1,m_scrollcolor);
         }
     }
 }
 
 void QTReader::dorollingscroll(bool _statbord)
 {
   bool bredrawscroll = false;
     QPainter p( this );
     // 2 = right, 3 = left
     int tmargin = (_statbord) ? m_topmargin : 0;
     int lmargin = (m_scrollpos == 3 || _statbord) ? m_left_border : 0;
     int rmargin = (m_scrollpos == 2 || _statbord) ? m_right_border : 0;
     int hmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
     if (hmargin < m_bottommargin) hmargin = m_bottommargin;
     if (m_rotated)
       {
         m_totalscroll = (m_totalscroll+m_scrollstep) % width();
         bitBlt(this, m_scrollstep+hmargin, lmargin, this, hmargin, lmargin, width()-tmargin-hmargin, height()-(lmargin+rmargin));
         if (!m_bgpm.isNull())
           {
             blitRot(hmargin, tmargin, height(), m_scrollstep, NULL);
           }
         else
           {
             p.fillRect(hmargin, rmargin, m_scrollstep, height()-lmargin-rmargin, m_bg);
           }
       }
     else
       {
         m_totalscroll = (m_totalscroll+m_scrollstep) % height();
         bitBlt(this,lmargin,tmargin,this,lmargin,tmargin+m_scrollstep,width()-(lmargin+rmargin),height() - tmargin - hmargin - m_scrollstep);
         if (m_bgpm.isNull())
           {
             p.fillRect(0, height() - (m_scrollstep+1) - hmargin, width(), (m_scrollstep+1), m_bg);
           }
         else
           {
             int loff = (_statbord) ? 0 : m_totalscroll;
             bitBlt(this,0,height() - (m_scrollstep+1) - hmargin, dbuff, 0, (loff+height() - (m_scrollstep+1) - hmargin) % height(), width(), (m_scrollstep+1));
           }
       }
 
     if ((m_scrolldy1 = m_scrolldy1+m_scrollstep) >= textarray[0]->lineSpacing())
     {
       int ht = textarray[0]->lineSpacing();
       bredrawscroll = true;
 #ifdef _SCROLLPIPE
         if (m_pipeout != NULL)
         {
             QString outstr = toQString(textarray[0]->data());
             if (!outstr.isEmpty())
             {
                 fprintf(m_pipeout, "%s\n", (const char*)outstr);
                 fflush(m_pipeout);
             }
             else if (m_pauseAfterEachPara)
             {
                 m_isPaused = true;
                 timer->stop();
             }
         }
 #endif
         CDrawBuffer* buff = textarray[0];
         for (int i = 1; i <= numlines; i++)
         {
             textarray[i-1] = textarray[i];
             locnarray[i-1] = locnarray[i];
         }
         textarray[numlines] = buff;
         --numlines;
         m_scrolldy1 -= ht;
     }
     if ((m_scrolldy2 = m_scrolldy2+m_scrollstep) >= textarray[numlines]->lineSpacing())
     {
       bredrawscroll = true;
         m_scrolldy2 -= textarray[numlines]->lineSpacing();
         numlines++;
 
         if (textarray[numlines] == NULL)
         {
             textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
         locnarray[numlines] = locate();
         int ch = getline(textarray[numlines]);
         if (m_rotated)
           {
             blitRot(hmargin, 0, height(), -1, textarray[numlines-1]);
           }
         else
           {
                     //    textarray[numlines-1]->render(&p, height() - textarray[numlines-1]->descent() - 2 - hmargin, m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg);
             textarray[numlines-1]->render(&p, height() - textarray[numlines-1]->descent() - textarray[numlines-1]->lineExtraSpacing() - 1 - hmargin, m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg, height()-m_topmargin-m_bottommargin);
 
           }
         mylastpos = locate();
         if (!ch)
         {
           redrawScroll(&p);
           emitRedraw();
             m_autoScroll = false;
 #ifdef _SCROLLPIPE
             for (int i = 0; i < numlines; i++)
             {
                 if (m_pipeout != NULL)
                 {
                     QString outstr = toQString(textarray[i]->data());
                     if (!outstr.isEmpty())
                     {
                         fprintf(m_pipeout, "%s\n", (const char*)outstr);
                         fflush(m_pipeout);
                     }
                 }
             }
 #endif
             emit SetScrollState(m_autoScroll);
 #ifdef USEQPE
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
             return;
         }
     }
     if (!bredrawscroll && ((m_scrolldy2/m_scrollstep) % 10 == 5) && textarray[numlines]->showPartial())
       {
         if (m_rotated)
           {
             blitRot(hmargin + m_scrolldy2 - textarray[numlines]->lineSpacing(), 0, height(), -1, textarray[numlines]);
           }
         else
           {
             textarray[numlines]->render( &p, height() + textarray[numlines]->lineSpacing() - textarray[numlines]->descent() - 2 - hmargin-m_scrolldy2, m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg, height()-m_topmargin-m_bottommargin);
           }
       }
     if (m_scrollpos != 0)
       {
         redrawScroll(&p);
       }
     if (bredrawscroll) emitRedraw();
 }
 
 void QTReader::dostaticscroll()
 {
     redrawall();
   bool bredraw = false;
     if ((m_scrolldy1 = m_scrolldy1+m_scrollstep) >= textarray[0]->lineSpacing())
     {
       int ht = textarray[0]->lineSpacing();
       bredraw = true;
 #ifdef _SCROLLPIPE
         if (m_pipeout != NULL)
         {
             QString outstr = toQString(textarray[0]->data());
             if (!outstr.isEmpty())
             {
                 fprintf(m_pipeout, "%s\n", (const char*)outstr);
                 fflush(m_pipeout);
             }
             else if (m_pauseAfterEachPara)
             {
                 m_isPaused = true;
                 timer->stop();
             }
         }
 #endif
         CDrawBuffer* buff = textarray[0];
         for (int i = 1; i <= numlines; i++)
         {
             textarray[i-1] = textarray[i];
             locnarray[i-1] = locnarray[i];
         }
         textarray[numlines] = buff;
         --numlines;
         m_scrolldy1 -= ht;
     }
     if ((m_scrolldy2 = m_scrolldy2 + m_scrollstep) >= textarray[numlines]->lineSpacing())
     {
       bredraw = true;
         m_scrolldy2 -= textarray[numlines]->lineSpacing();
         numlines++;
 
         if (textarray[numlines] == NULL)
         {
             textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
         locnarray[numlines] = locate();
         int ch = getline(textarray[numlines]);
         mylastpos = locate();
         if (!ch)
         {
           redrawall();
           emitRedraw();
             m_autoScroll = false;
 #ifdef _SCROLLPIPE
             for (int i = 0; i < numlines; i++)
             {
                 if (m_pipeout != NULL)
                 {
                     QString outstr = toQString(textarray[i]->data());
                     if (!outstr.isEmpty())
                     {
                         fprintf(m_pipeout, "%s\n", (const char*)outstr);
                         fflush(m_pipeout);
                     }
                 }
             }
 #endif
             emit SetScrollState(m_autoScroll);
 #ifdef USEQPE
             QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
 #endif
             return;
         }
     }
   if (bredraw) emitRedraw();
 }
 
 void QTReader::redrawScroll(QPainter* p)
 {
   int offset = (m_scrolltype == 1) ? m_totalscroll : 0;
   switch (m_scrollpos)
     {
     case 1:
       {
         int hmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
         if (hmargin < m_bottommargin) hmargin = m_bottommargin;
         if (m_rotated)
           {
             if (m_bgpm.isNull())
               {
                 p->fillRect(0,0,hmargin,height(),m_bg);
               }
             else
               {
                 blitRot(0,0, height(), hmargin, NULL);
               }
           }
         else
           {
             if (m_bgpm.isNull())
               {
                 p->fillRect(0,height() -  hmargin,width(),hmargin,m_bg);
               }
             else
               {
                 int toffset = (offset+height()-hmargin) % height();
                 if (toffset+hmargin > height())
                   {
                     int fp = height()-toffset;
                     bitBlt(this,
                            0,height() -  hmargin,
                            dbuff,
                            0, toffset, width(), fp);
                     bitBlt(this,
                            0,height()-hmargin+fp,
                            dbuff,
                            0, 0, width(), hmargin-fp);
                   }
                 else
                   {
                     bitBlt(this,
                            0,height() - hmargin,
                            dbuff,
                            0, toffset, width(), hmargin);
                   }
               }
           }
       }
       break;
     case 2: //right
           if (m_rotated)
             {
               if (m_bgpm.isNull())
                 {
                   p->fillRect(0,height()-m_right_border,width(),m_right_border,m_bg);
                 }
               else
                 {
                   blitRot(0,height()-m_right_border, m_right_border, width(), NULL);
                 }
             }
           else
             {
               if (m_bgpm.isNull())
                 {
                   p->fillRect(width()-m_right_border,0,m_right_border,height(),m_bg);
                 }
               else
                 {
                   int x = width() - m_right_border;
                   int fp = height()-offset;
                   bitBlt(this, x,  0, dbuff, x, offset, m_right_border, fp);
                   bitBlt(this, x, fp, dbuff, x,      0, m_right_border, height()-fp);
                 }
             }
           break;
     case 3: //left
           if (m_rotated)
             {
               if (m_bgpm.isNull())
                 {
                   p->fillRect(0,0,width(),m_left_border,m_bg);
                 }
               else
                 {
                   blitRot(0,0, m_left_border, width(), NULL);
                 }
             }
           else
             {
               if (m_bgpm.isNull())
                 {
                   p->fillRect(0,0,m_left_border,height(),m_bg);
                 }
               else
                 {
                   int fp = height()-offset;
                   bitBlt(this, 0,  0, dbuff, 0, offset, m_left_border, fp);
                   bitBlt(this, 0, fp, dbuff, 0,      0, m_left_border, height()-fp);
                 }
             }
           break;
     case 0:
     default:
       break;
     }
   if (m_scrollpos != 0) DrawScroll(p, width(), height());
 }
 
 void QTReader::autoscroll()
 {
   if (m_scrolltype == 4)
     {
       readAloud();
     }
   else
     {
       if (dbuff != NULL)
         {
           dbp->begin(dbuff);
           drawBackground(dbp);
           dbp->end();
         }
       timer->start(real_delay(), false);
     }
 }
 
 void QTReader::setfont()
 {
 //    m_fontControl.Change
     m_charWidth = (m_charpc*m_fontControl.currentsize())/100;
     if (m_charWidth <= 0) m_charWidth = 1;
     m_ascent = m_fontControl.ascent();
     m_descent = m_fontControl.descent();
     m_linespacing = m_fontControl.lineSpacing();
 }
 
 void QTReader::DrawStraight(QPainter* p, int w, int h)
 {
   if (m_scrolldy == m_topmargin)
     {
       int ypos = textarray[0]->ascent()-m_scrolldy1+m_topmargin;
       textarray[0]->render( p, ypos, m_bMonoSpaced, m_charWidth, w, m_left_border, m_right_border, m_bg, h-m_topmargin-m_bottommargin);
       int i;
       for (i = 1; i < numlines; i++)
         {
           ypos += (textarray[i-1]->descent() + textarray[i]->ascent())+
             (textarray[i-1]->lineExtraSpacing() + textarray[i]->lineExtraSpacing())/2;
           textarray[i]->render( p, ypos, m_bMonoSpaced, m_charWidth, w, m_left_border, m_right_border, m_bg, h-m_topmargin-m_bottommargin);
         }
       if (textarray[i]->showPartial())
         {
           ypos += (textarray[i-1]->descent() + textarray[i]->ascent())+
             (textarray[i-1]->lineExtraSpacing() + textarray[i]->lineExtraSpacing())/2;
           textarray[i]->render( p, ypos, m_bMonoSpaced, m_charWidth, w, m_left_border, m_right_border, m_bg, h-m_topmargin-m_bottommargin);
         }
     }
   else
     {
       int ypos = textarray[0]->ascent()-m_scrolldy1+m_scrolldy+m_topmargin;
       textarray[0]->render( p, ypos, m_bMonoSpaced, m_charWidth, w, m_left_border, m_right_border, m_bg, h-m_topmargin-m_bottommargin);
       //      p->fillRect(m_border, 0, w-2*m_border, m_scrolldy, m_bg);
       for (int i = 1; i < numlines; i++)
         {
           ypos += (textarray[i-1]->descent() + textarray[i]->ascent())+
             (textarray[i-1]->lineExtraSpacing() + textarray[i]->lineExtraSpacing())/2;
           if (ypos+textarray[i]->descent() > h)
             {
               ypos = textarray[i]->ascent();
             }
           textarray[i]->render( p, ypos, m_bMonoSpaced, m_charWidth, w, m_left_border, m_right_border, m_bg, h-m_topmargin-m_bottommargin);
         }
       p->fillRect(m_left_border,m_scrolldy,w-(m_left_border+m_right_border),1,m_scrollcolor);
     }
   bool wasrotated = m_rotated;
   m_rotated = false;
   DrawScroll(p, w, h);
   m_rotated = wasrotated;
 
 }
 
 void QTReader::redrawall()
 {
   if (m_rotated)
     {
       if (dbuff != NULL)
         {
           dbp->begin(dbuff);
           drawBackground(dbp);
           DrawStraight(dbp, height(), width());
           dbp->end();
           
           QWMatrix m;
           m.rotate(90);
           QPixmap rp = dbuff->xForm(m);
           bitBlt(this, 0,0,&rp,0,0,-1,-1);
         }
       else
         {
           qDebug("This shouldn't happen but it doesn't matter if it does (rotated == double buffered)");
           QPixmap dbuff(height(), width());
           QPainter dbp(&dbuff);
 
           drawBackground(&dbp);
           DrawStraight(&dbp, height(), width());
           
           QWMatrix m;
           m.rotate(90);
           QPixmap rp = dbuff.xForm(m);
           bitBlt(this, 0,0,&rp,0,0,-1,-1);
         }
     }
   else
     {
       if (dbuff != NULL)
         {
           dbp->begin(dbuff);
           drawBackground(dbp);
           DrawStraight(dbp, width(), height());
           dbp->end();
           bitBlt(this, 0,0,dbuff,0,0,-1,-1);
         }
       else
         {
           QPainter p(this);
           drawBackground(&p);
           DrawStraight(&p, width(), height());
         }
     }
 }
 
 void QTReader::drawFonts()
 {
     if (bDoUpdates)
     {
       int hmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
       if (hmargin < m_bottommargin) hmargin = m_bottommargin;
         //qDebug("How refreshing...");
         if (buffdoc.empty())
           {
             if (dbuff != NULL)
               {
                 dbp->begin(dbuff);
                 drawBackground(dbp);
                 dbp->end();
               }
             else
               {
                 QPainter p(this);
                 drawBackground(&p);
               }
             return;
           }
         setfont();
                 //if (!m_autoScroll) m_scrolldy1 = 0;
         if (dbuff != NULL && (dbuff->width() != width() || dbuff->height() != height()))
           {
             qDebug("Oh no! A resize event was missed...");
             if (m_rotated)
               {
                 dbuff->resize(height(), width());
               }
             else
               {
                 dbuff->resize(width(), height());
               }
             m_lastwidth = 0;
           }
         if (m_lastwidth != ((m_rotated) ? height() : width()))
           {
             m_scrolldy = m_topmargin;
                     //    qDebug("Not Optimised %d", m_lastwidth);
             m_lastwidth = ((m_rotated) ? height() : width());
             m_lastheight = ((m_rotated) ? width() : height());
             buffdoc.setwidth(m_lastwidth-(m_left_border+m_right_border));
             buffdoc.locate(pagelocate());
             fillbuffer();
             redrawall();
                     //    qDebug("Not Optimised %d", m_lastwidth);
           }
         else 
           {
             int newht = ((m_rotated) ? width() : height());
             if (m_lastheight > newht)
               {
                         //      qDebug("Optimised < %d %d %d", numlines, m_lastheight, newht);
                 m_scrolldy = m_topmargin;
                 int ypos = m_scrolldy1+m_topmargin;
                 for (int i = 0; i < numlines; i++)
                   {
                             if ((ypos += textarray[i]->lineSpacing()) > newht - hmargin)              
                       {
                         numlines = i;
                         jumpto(mylastpos = locnarray[i+1]);
                         break;
                       }
                   }
                         //      qDebug("Optimised < %d", numlines);
                 m_lastheight = newht;
               }
             else if (m_lastheight < newht)
               {
                 m_scrolldy = m_topmargin;
                         //      qDebug("Optimised > %d", numlines);
                 int ypos = m_scrolldy1+m_topmargin;
                 for (int i = 0; i <= numlines; i++)
                   {
                     ypos += textarray[i]->lineSpacing();
                   }
                 fillbuffer(numlines+1, ypos, newht);
                         //      qDebug("Optimised > %d", numlines);
               }
             if (numlines > 0)
               {
                 redrawall();
               }
           }
         emitRedraw();
     }
 /*
     else
     {
         qDebug("Not so refreshing...");
     }
 */
 }
 
 void QTReader::DrawScroll( QPainter *p, int _w, int _h )
 {
   if (!buffdoc.empty())
     {
       QBrush checkered = QBrush( Dense4Pattern );
       checkered.setColor(m_scrollbarcolor);
       switch (m_scrollpos)
         {
         case 1:
           if (m_rotated)
             {
               p->fillRect(0, 0, 2, _h, checkered);
             }
           else
             {
               p->fillRect(0, _h-2, _w, 2, checkered);
             }
           break;
         case 2:
           if (m_rotated)
             {
               p->fillRect(0, _h-2, _w, 2, checkered);
             }
           else
             {
               p->fillRect(_w-2, 0, 2, _h, checkered);
             }
           break;
         case 3:
           if (m_rotated)
             {
               p->fillRect(0, 0, _w, 2, checkered);
             }
           else
             {
               p->fillRect(0, 0, 2, _h, checkered);
             }
           break;
         case 0:
         default:
           break;
         }
       switch (m_scrollpos)
         {
         case 1:
           {
             int ht;
             if (m_rotated)
               {
                 ht = _h;
               }
             else
               {
                 ht = _w;
               }
             int sectionsize = (buffdoc.endSection()-buffdoc.startSection());
             int mid = (ht*(locnarray[numlines]+locnarray[0]-2*buffdoc.startSection())+sectionsize)/(2*sectionsize);
             int sliderheight = ((locnarray[numlines]-locnarray[0])*ht+sectionsize/2)/sectionsize;
             int sliderpos;
             if (sliderheight < 10)
               {
                 sliderheight = 10;
                 sliderpos = mid-5;
               }
             else
               {
                 sliderpos = (ht*(locnarray[0]-buffdoc.startSection())+sectionsize/2)/sectionsize;
               }
             if (m_rotated)
               {
                 p->fillRect(0, sliderpos, 3, sliderheight, m_scrollbarcolor);
               }
             else
               {
                 p->fillRect(sliderpos, _h-3, sliderheight, 3, m_scrollbarcolor);
               }
           }
           break;
         case 2:
         case 3:
           {
             int ht;
             if (m_rotated)
               {
                 ht = _w;
               }
             else
               {
                 ht = _h;
               }
             int sectionsize = (buffdoc.endSection()-buffdoc.startSection());
             int mid = (ht*(locnarray[numlines]+locnarray[0]-2*buffdoc.startSection())+sectionsize)/(2*sectionsize);
             int sliderheight = ((locnarray[numlines]-locnarray[0])*ht+sectionsize/2)/sectionsize;
             int sliderpos;
             if (sliderheight < 10)
               {
                 sliderheight = 10;
                 sliderpos = mid-5;
               }
             else
               {
                 sliderpos = (ht*(locnarray[0]-buffdoc.startSection())+sectionsize/2)/sectionsize;
               }
             if (m_rotated)
               {
                 int hoff;
                 if (m_scrollpos == 2) //right
                   {
                     hoff = _h-3;
                   }
                 else
                   {
                     hoff = 0;
                   }
                 p->fillRect(ht-sliderpos-sliderheight, hoff, sliderheight, 3, m_scrollbarcolor);
               }
             else
               {
                 int hoff;
                 if (m_scrollpos == 2) //right
                   {
                     hoff = _w-3;
                   }
                 else
                   {
                     hoff = 0;
                   }
                 p->fillRect(hoff, sliderpos, 3, sliderheight, m_scrollbarcolor);
               }
           }
           break;
         case 0:
         default:
           break;
         }
     }
 }
 
 /*
 void QTReader::DrawScroll( QPainter *p )
 {
   if (m_border > 5 && !buffdoc.empty())
     {
       int ht, wh;
       if (m_rotated)
         {
           ht = width();
           wh = height()g;
           p->fillRect(0, wh-2, ht, 2, cyan);
         }
       else
         {
           ht = height();
           wh = width();
           p->fillRect(wh-2, 0, 2, ht, cyan);
         }
       int sectionsize = (buffdoc.endSection()-buffdoc.startSection());
       int mid = (ht*(locnarray[numlines]+locnarray[0]-2*buffdoc.startSection())+sectionsize)/(2*sectionsize);
       if (m_rotated)
         {
           p->fillRect(ht-mid-5, wh-2, 10, 2, yellow);
           p->fillRect(ht-(ht*(locnarray[numlines]-buffdoc.startSection())+sectionsize/2)/sectionsize, wh-2, ((locnarray[numlines]-locnarray[0])*ht+sectionsize/2)/sectionsize, 2, magenta);
         }
       else
         {
           p->fillRect(wh-2, mid-5, 2, 10, yellow);
           p->fillRect(wh-2, (ht*(locnarray[0]-buffdoc.startSection())+sectionsize/2)/sectionsize, 2, ((locnarray[numlines]-locnarray[0])*ht+sectionsize/2)/sectionsize, magenta);
         }
     }
 }
 */
 QString QTReader::firstword()
 {
     if (m_bMonoSpaced)
     {
         return toQString(textarray[0]->data());
     }
     else
     {
         int start, end, len, j;
         for (j = 0; j < numlines; j++)
         {
             len = textarray[j]->length();
             for (start = 0; start < len && !isalpha((*textarray[j])[start]); start++);
             if (start < len) break;
         }
         if (j < numlines)
         {
             QString ret = "";
             for (end = start; end < len && isalpha((*textarray[j])[end]); end++)
                 ret += (*textarray[j])[end];
             if (ret.isEmpty()) ret = "Current position";
             return ret;
         }
         else
             return "Current position";
     }
 }
 
 //
 // Construct the QTReader with buttons.
 //
 
 bool QTReader::ChangeFont(int tgt)
 {
     return m_fontControl.ChangeFont(m_fontname, tgt);
 }
 
 void QTReader::init()
 {
   setBackgroundColor( m_bg );
   buffdoc.setfilter(getfilter());
   ChangeFont(m_textsize);
   setFocusPolicy(QWidget::StrongFocus);
   timer = new QTimer(this);
   connect(timer, SIGNAL(timeout()), this, SLOT(doscroll()));
 #ifdef USETIMER
   m_dragtimer = new QTimer(this);
   connect(m_dragtimer, SIGNAL(timeout()), this, SLOT(actionDrag()));
 #endif
   //  QMessageBox::information(this, "init", m_lastfile, 1);
   setfont();
 }
 
 //
 // Clean up
 //
 QTReader::~QTReader()
 {
   if (m_output != NULL)
     {
       delete m_output;
     }
   if (dbuff != NULL)
     {
       delete dbuff;
       delete dbp;
     }
 #ifdef USEQPE
     if (m_autoScroll)
     {
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
 #endif
 #ifdef _SCROLLPIPE
     if (m_pipeout != NULL)
     {
         fclose(m_pipeout);
     }
 #endif
 }
 
 //
 // Called when the print button is clicked.
 //
 /*
 void QTReader::printIt()
 {
 #ifndef QT_NO_PRINTER
     if ( printer->setup( this ) ) {
         QPainter paint;
         if ( !paint.begin( printer ) )
             return;
         drawIt( &paint );
     }
 #endif
 }
 */
 //
 // Called when the widget needs to be updated.
 //
 
 void QTReader::paintEvent( QPaintEvent * p )
 {
   if ((dbuff != NULL) && !m_outofdate)
     {
       if (m_rotated)
         {
           if ((p->rect().width() != width()) || (p->rect().height() != height()))
             {
               qDebug("Partial paint");
               QRect r;
               r.setTop(width()-p->rect().right()-1);
               r.setLeft(p->rect().top());
               r.setHeight(p->rect().width());
               r.setWidth(p->rect().height());
               QPixmap p1(r.width(), r.height());
               bitBlt(&p1, QPoint(0, 0), dbuff, r);
               QWMatrix m;
               m.rotate(90);
               QPixmap p2 = p1.xForm(m);
               bitBlt(this, p->rect().left(), p->rect().top(), &p2, 0, 0, -1, -1);
             }
           else
             {
               qDebug("Full paint");
               QWMatrix m;
               m.rotate(90);
               QPixmap rp = dbuff->xForm(m);
               bitBlt(this, 0,0,&rp,0,0,-1,-1);
             }
         }
       else
         {
           //bitBlt(this, 0,0,dbuff,0,0,-1,-1);
           bitBlt(this,p->rect().topLeft(),dbuff,p->rect());
         }
     }
   else
     {
       drawFonts();
     }
   m_outofdate = false;
 }
 
 //
 // Called when the widget has been resized.
 // Moves the button group to the upper right corner
 // of the widget.
 
 /*
 void QTReader::resizeEvent( QResizeEvent * )
 {
 //  //  qDebug("resize:(%u,%u)", width(), height());
   //    bgroup->move( width()-bgroup->width(), 0 );
 }
 */
 
 //
 // Create and display our widget.
 //
 /*
 int main( int argc, tchar **argv )
 {
     QApplication app( argc, argv );
     QTReader   draw;
     app.setMainWidget( &draw );
     draw.setCaption("Qt Example - Drawdemo");
     draw.show();
     return app.exec();
 }
 */
 
 
 bool QTReader::locate(unsigned long n)
 {
   m_outofdate = true;
   m_lastwidth = 0;
   locnarray[0] = n;
   ResetScroll();
   update();
   return true;
 }
 /*
 bool QTReader::locate(unsigned long n) {
   //printf("Locate\n");
   buffdoc.locate(n);
 //  //  qDebug("&buffdoc.located");
   ResetScroll();
   fillbuffer();
   m_outofdate = true;
 //  //  qDebug("&Buffer filled");
   update();
 //  //  qDebug("&Located");
   emitRedraw();
   return true;
 }
 */
 unsigned int QTReader::screenlines()
 {
   //  int linespacing = (tight) ? m_ascent : m_ascent+m_descent;
   //  return (height()-m_descent)/(m_linespacing);
   return (height()-2)/(m_linespacing);
 };
 
 bool QTReader::fillbuffer(int reuse, int ht, int newht)
 {
     int hmargin = ((m_scrollpos == 1) ? _SBARHEIGHT : 0);
     if (hmargin < m_bottommargin) hmargin = m_bottommargin;
     if (ht < 0) ht = m_topmargin;
     if (buffdoc.empty()) return false;
     if (newht < 0)
       m_lastheight = (m_rotated) ? width() : height();
     else
       m_lastheight = newht;
     int ch;
     bool ret = false;
     unsigned int oldpagepos = locnarray[reuse];
     int lastypos = ht, ypos = ht;
     numlines = reuse;
     while (ypos < m_lastheight - hmargin || numlines < 2)
     {
         lastypos = ypos;
         if (textarray[numlines] == NULL)
         {
             textarray[numlines] = new CDrawBuffer(&m_fontControl);
         }
         locnarray[numlines] = locate();
         int ch = getline(textarray[numlines]);
         ypos += textarray[numlines]->lineSpacing();
         /*
         QString tmp = toQString(textarray[numlines]->data());
         printf("[%u, %u, %u](%s):%s\n", lastypos, m_lastheight-hmargin, ypos,
                ((textarray[numlines]->showPartial()) ? "TRUE" : "FALSE"),
                (const char*)tmp);
         */
         numlines++;
         if (!ch)
         {
           if (numlines - reuse == 1 /*&& locnarray[numlines] == buffdoc.locate()*/)
             {
               qDebug("FALSE");
               if (oldpagepos < buffdoc.endSection())
                 locate(oldpagepos);
               else
                 dopageup(buffdoc.endSection());
               return false;
             }
             else
             {
               qDebug("TRUE");
                 --numlines;
                 mylastpos = locate();
                 return true;
             }
         }
         if (numlines > 1 && textarray[numlines-2]->isBop())
         {
           --numlines;
           mylastpos = locate();
           return true;
         }
     }
     
     --numlines;
     mylastpos = locate();
     m_scrollpart = m_lastheight - lastypos - hmargin;
     if (m_autoScroll)
       {
         CalculateScrollParameters();
       }
     return true;
 }
 
 void QTReader::dopagedn()
 {
 //    qDebug("HEIGHT(2):%d", m_lastheight);
     ResetScroll();
     int skip = 0, ypos = m_topmargin;
     if (locate() != mylastpos)
     {
         jumpto(mylastpos);
     }
     CDrawBuffer* reusebuffer = textarray[numlines];
     if (reusebuffer != NULL)
     {
       if (reusebuffer->eof()) return;
         for (int i = 0; i <= m_overlap; i++)
         {
             int offset = numlines - m_overlap + i;
             reusebuffer = textarray[offset];
             size_t reuselocn = locnarray[offset];
             textarray[offset] = textarray[i];
             textarray[i] = reusebuffer;
         //    reusebuffer->empty();
             locnarray[offset] = locnarray[i];
             locnarray[i] = reuselocn;
             ypos += textarray[i]->lineSpacing();
             skip++;
         }
     }
     if (numlines <= 1)
       {
         skip = 0;
         ypos = 0;
         qDebug("Doing extra skip");
       }
     if (fillbuffer(skip, ypos))
     {
         drawFonts();
     }
 }
 
 void QTReader::dopageup()
 {
   dopageup(locnarray[(m_overlap < numlines) ? m_overlap : numlines/2]);
 }
 
 bool QTReader::synch(size_t start, size_t end)
 {
     jumpto(start);
     while (start++ < end)
     {
         tchar ch = getch();
         if (ch == 10) return true;
         if ((ch == UEOF) || (ch == 6))
         {
           return false;
         }
     }
     return false;
 }
 
 void QTReader::dopageup(unsigned int target)
 {
     ResetScroll();
     CBufferFace<CDrawBuffer*> buff;
     CBufferFace<size_t> loc;
     size_t delta, guess = 2*(locate()-pagelocate()), lastdelta = 0;
     qDebug("dopageup:: locate():%u pagelocate():%u guess:%u", locate(), pagelocate(), guess);
   bool ch = true;
   int nbfl, ypos = m_topmargin;
   if (guess < 128) guess = 128;
   while (1)
   {
     //      qDebug("Guess:%u", guess);
 
       ch = true;
       if (target < guess)
       {
           delta = 0; // 0 is a flag to say don't guess any more
           jumpto( (m_continuousDocument) ? 0 : buffdoc.startSection() );
       }
       else if (!m_continuousDocument && (target - guess < buffdoc.startSection()))
       {
           delta = 0; // 0 is a flag to say don't guess any more
           qDebug("Jumping to startsection:%d", buffdoc.startSection());
           jumpto(buffdoc.startSection());
       }
       else
       {
           delta = guess;
           if (!synch(target-delta, target-lastdelta))
           {
             lastdelta = delta;
             if (guess < 4000)
               {
                 guess <<= 1;
                 continue;
               }
             else
               {
                 jumpto(target-delta);
               }
           }
       }
       
       nbfl = 0;
       ypos = m_topmargin;
 
       while (locate() < target) 
       {
           if (buff[nbfl] == NULL) buff[nbfl] = new CDrawBuffer(&m_fontControl);
           loc[nbfl] = locate();
           ch = getline(buff[nbfl]);
           ypos += buff[nbfl]->lineSpacing();
           nbfl++;
           if (!ch) break;
       }
       if (guess < 4000 && ypos < ((m_rotated) ? width() : height())-(m_bottommargin) && (delta != 0))
       {
           for (int i = 0; i < nbfl; i++)
           {
               delete buff[i];
               buff[i] = NULL;
           }
           guess <<= 1;
           continue;
       }
       break;
   }
   if (ch)
   {
       if (buff[nbfl] == NULL) buff[nbfl] = new CDrawBuffer(&m_fontControl);
       loc[nbfl] = locate();
       int ch = getline(buff[nbfl]);
       nbfl++;
   }
 /*
   ypos = 0;
   numlines = 0;
   while (ypos < height() && numlines <= nbfl-1)
   {
       ypos += buff[nbfl - numlines - 1]->lineSpacing();
       numlines++;
   }
   --numlines;
 */
 
   ypos = m_topmargin;
   numlines = 0;
   while (ypos < ((m_rotated) ? width() : height())-m_bottommargin && numlines+2 <= nbfl)
   {
       ypos += buff[nbfl - numlines - 2]->lineSpacing();
       numlines++;
   }
   if (numlines > 0) --numlines;
   if (numlines == 0 && nbfl > 1) numlines = 1;
 
   int offset = nbfl-1;
   offset -= numlines;
   ypos = m_topmargin;
   for (int i = 0; i <= numlines; i++)
   {
       delete textarray[i];
       textarray[i] = buff[offset+i];
       locnarray[i] = loc[offset + i];
       ypos += textarray[i]->lineSpacing();
   }
 #ifdef _WINDOWS
   for (i = 0; i < nbfl - numlines - 1; i++)
 #else
   for (int i = 0; i < nbfl - numlines - 1; i++)
 #endif
   {
       delete buff[i];
   }
 
   while (ypos < ((m_rotated) ? width() : height())-m_bottommargin)
   {
       numlines++;
       locnarray[numlines] = locate();
       if (textarray[numlines] == NULL) textarray[numlines] = new CDrawBuffer(&m_fontControl);
       if (!getline(textarray[numlines])) break;
       ypos += textarray[numlines]->lineSpacing();
   }
 
   mylastpos = locate();
   CalculateScrollParameters();
   drawFonts();
         //  repaint();
 }
 
 bool QTReader::load_file(const char *newfile, unsigned int _lcn)
 {
 //  QMessageBox::information(this, "Name", name, 1);
 //  QMessageBox::information(this, "load_file", newfile, 1);
   int prog = 0;
   bool bRC = false;
   unsigned int lcn = _lcn;
   bDoUpdates = false;
   ResetScroll();
   if (m_lastfile == newfile && lcn == 0)
     {
       lcn = m_lastposn;
     }
   //  QMessageBox::information(0, "Opening...", newfile);
   if (m_rotated)
     {
       m_lastwidth = height();
       m_lastheight = width();
     }
   else
     {
       m_lastwidth = width();
       m_lastheight = height();
     }
   if (buffdoc.openfile(this,newfile) == 0)
   {
       m_lastfile = newfile;
       buffdoc.setwidth(m_lastwidth-(m_left_border+m_right_border));
       bRC = true;
       buffdoc.setContinuous(m_continuousDocument);
       qDebug("buffdoc.openfile done");
     }
   setfilter(getfilter());
   qDebug("Updated");
   bDoUpdates = true;
   locate(lcn);
   return bRC;
 }
 
 void QTReader::lineDown()
 {
     int ypos = m_topmargin;
     ResetScroll();
     int offset = numlines;
 
     for (int i = 0; i <= numlines; i++)
     {
         if ((ypos += textarray[numlines-i]->lineSpacing()) > ((m_rotated) ? width() : height()))
         {
             offset = i-1;
             break;
         }
     }
     offset = numlines - offset;
 #ifdef _WINDOWS
     for (i = offset; i <= numlines; i++)
 #else
     for (int i = offset; i <= numlines; i++)
 #endif
     {
         CDrawBuffer* buff = textarray[i-offset];
         textarray[i-offset] = textarray[i];
         locnarray[i-offset] = locnarray[i];
         textarray[i] = buff;
     }
     numlines = numlines - offset + 1;
     locnarray[numlines] = locate();
     if (textarray[numlines] == NULL)
     {
         textarray[numlines] = new CDrawBuffer(&m_fontControl);
     }
     getline(textarray[numlines]);
     mylastpos = locate();
     m_outofdate = true;
     update();
 }
 /*
 void QTReader::lineUp()
 {
   CBuffer** buff = textarray;
   unsigned int *loc = new unsigned int[numlines];
   int cbptr = 0;
   if (locate() != mylastpos) jumpto(mylastpos);
   unsigned int target = locnarray[numlines-1];
   if (buffdoc.hasrandomaccess())
     {
       unsigned int delta = locate()-pagelocate();
       if (delta < 64) delta = 64;
       do
         {
           delta <<= 1;
           if (delta >= target)
             {
               delta = target;
               jumpto(0);
               for (int i = 0; i < numlines; i++)
                 {
                   loc[i] = locate();
                   getline(buff[i]);
                 }
               break;
             }
           jumpto(target-delta);
           do
             {
               buffdoc.getline(buff[0],width());
 #ifdef WS
               //printf("Trying:%s\n",buff[0]);
 #endif
               if (locate() > target) continue;
             }
           while (!buffdoc.iseol());
           for (int i = 0; i < numlines; i++)
             {
               loc[i] = locate();
               buffdoc.getline(buff[i],width());
 #ifdef WS
               //printf("Filling:%s\n",buff[i]);
 #endif
             }
         }
       while (locate() >= target && delta < 4096);
 #ifdef WS
       //printf("Delta:%u\n",delta);
 #endif
     }
   else
     {
       jumpto(0);
       for (int i = 0; i < numlines; i++)
         {
           loc[i] = locate();
           buffdoc.getline(buff[i],width());
         }
     }
   cbptr = 0;
   while (locate() < target)
     {
       loc[cbptr] = locate();
       buffdoc.getline(buff[cbptr], width());
 #ifdef WS
       //printf("Adding:%s\n",buff[cbptr]->data());
 #endif
       cbptr = (cbptr+1) % numlines;
     }
   pagepos = loc[cbptr];
   textarray = new CBuffer*[numlines];
   for (int i = 0; i < numlines; i++)
     {
       int j = (cbptr+i)%numlines;
       textarray[i] = buff[j];
       locnarray[i] = loc[j];
     }
   delete [] buff;
   delete [] loc;
   mylastpos = locate();
   update();
 }
 */
 
 void QTReader::ResetScroll()
 {
   m_totalscroll = 0;
   m_scrolldy1 = 0;
   m_scrolldy = m_topmargin;
   if (m_autoScroll && ((m_scrolltype == 0) || !m_bgpm.isNull()))
     {
       setautoscroll(false);
     }
 }
 
 void QTReader::lineUp()
 {
   dopageup(locnarray[numlines-1]);
 
   /*
   buffdoc.unsuspend();
   ResetScroll();
 
   CDrawBuffer* buff = textarray[numlines];
   unsigned int loc;
   unsigned int end = locnarray[numlines];
   int cbptr = 0;
   if (locate() != mylastpos) jumpto(mylastpos);
   unsigned int target = locnarray[0];
   if (target == 0) return;
   if (!m_continuousDocument && (target == buffdoc.startSection())) return;
   if (buffdoc.hasrandomaccess())
     {
       unsigned int delta = locate()-pagelocate();
       if (delta < 64) delta = 64;
       do
         {
           delta <<= 1;
           if (delta >= target)
             {
               delta = target;
               jumpto(0);
               loc = locate();
               getline(buff);
               break;
             }
           else if (!m_continuousDocument && (target - delta < buffdoc.startSection()))
           {
               delta = target-buffdoc.startSection();
               jumpto(buffdoc.startSection());
               loc = locate();
               getline(buff);
               break;
           }
           jumpto(target-delta);
           do
             {
               getline(buff);
 #ifdef WS
               //printf("Trying:%s\n",buff[0]);
 #endif
               if (locate() > target) continue;
             }
           while (!buffdoc.iseol());
           loc = locate();
           getline(buff);
         }
       while (locate() >= target && delta < 4096);
     }
   else
     {
       jumpto(0);
       loc = locate();
       getline(buff);
     }
   cbptr = 0;
   while (locate() < target)
     {
       loc = locate();
       getline(buff);
     }
   for (int i = numlines; i > 0; i--)
     {
       textarray[i] = textarray[i-1];
       locnarray[i] = locnarray[i-1];
     }
   textarray[0] = buff;
   locnarray[0] = loc;
   int start = numlines;
   int ypos = m_topmargin;
 #ifdef _WINDOWS
   for (i = 0; i <= numlines; i++)
 #else
         for (int i = 0; i <= numlines; i++)
 #endif
   {
       ypos += textarray[i]->lineSpacing();
       if (ypos > ((m_rotated) ? width() : height()))
       {
           start = i;
           ypos -= textarray[i]->lineSpacing();
           break;
       }
   }
   jumpto(locnarray[start]);
   fillbuffer(start, ypos);
   repaint();
   */
 }
 
 bool QTReader::empty()
 {
     return buffdoc.empty();
 }
 
 MarkupType QTReader::PreferredMarkup()
 {
     MarkupType m = buffdoc.PreferredMarkup();
     if (m == cTEXT)
     {
         int ext = m_lastfile.findRev('.');
         if (ext >= 0)
         {
             QString ft = m_lastfile.right(m_lastfile.length()-ext-1).upper();
             if (ft.left(3) == "HTM")
             {
                 m = cHTML;
             }
         }
     }
     return m;
 }
 
 void QTReader::resizeEvent( QResizeEvent * p )
 {
   qDebug("Resizing");
   m_outofdate = true;
   if (dbuff != NULL)
     {
       if (m_rotated)
         {
           dbuff->resize(p->size().height(),p->size().width());
         }
       else
         {
           dbuff->resize(p->size());
         }
     }
   m_bgIsScaled = false;
   if (m_bgtype == bgStretched)
     {
       emit RefreshBitmap();
     }
 
   {
     int h, w;
     if (m_rotated)
       {
         h = p->size().width();
         w = p->size().height();
       }
     else
       {
         w = p->size().width();
         h = p->size().height();
       }
     m_topmargin = (h*m_abstopmargin+500)/1000;
     m_bottommargin = (h*m_absbottommargin+500)/1000;
     m_left_border = (w*m_absleft_border+500)/1000;
     m_right_border = (w*m_absright_border+500)/1000;
   }
   if (dbuff != NULL && buffdoc.empty())
     {
       dbp->begin(dbuff);
       drawBackground(dbp);
       dbp->end();
     }
 }
 
 void QTReader::setrotated(bool sfs)
 {
   qDebug("Rotating");
   m_rotated = sfs;
   setDoubleBuffer(m_doubleBuffered);
   m_bgIsScaled = false;
   m_outofdate = true;
   /*
     int h, w;
     if (m_rotated)
       {
         h = width();
         w = height();
       }
     else
       {
         w = width();
         h = height();
       }
     m_topmargin = (h*m_abstopmargin+500)/1000;
     m_bottommargin = (h*m_absbottommargin+500)/1000;
     m_left_border = (w*m_absleft_border+500)/1000;
     m_right_border = (w*m_absright_border+500)/1000;
     
     qDebug("Top margin:%u", m_topmargin );
     qDebug("Bottom margin:%u", m_bottommargin );
     qDebug("Left margin:%u", m_left_border );
     qDebug("Right margin:%u", m_right_border );
   */
 }
 
 void QTReader::drawBackground(QPainter *p)
 {
   //  p->setBackgroundMode(OpaqueMode);
   p->setBackgroundColor(m_bg);
   if (dbuff != NULL)
     {
       p->eraseRect(dbuff->rect());
     }
   else
     {
       if (m_rotated)
         {
           p->eraseRect(0,0,height(),width());
         }
       else
         {
           p->eraseRect(rect());
         }
     }
   if (!m_bgpm.isNull())
     {
       //      p->setBackgroundMode(TransparentMode);
       switch (m_bgtype)
         {
         case bgCentred:
           {
             if (dbuff == NULL)
               {
                 p->drawPixmap(width(),height(),m_bgpm);
               }
             else
               {
                 int w = (dbuff->rect().width()-m_bgpm.width())/2;
                 int h = (dbuff->rect().height()-m_bgpm.height())/2;
                 p->drawPixmap(w,h,m_bgpm);
               }
           }
           break;
         case bgTiled:
           {
             if (dbuff == NULL)
               {
                 p->drawTiledPixmap(0,0,width(),height(),m_bgpm);
               }
             else
               {
                 p->drawTiledPixmap(0,0,dbuff->rect().width(),dbuff->rect().height(),m_bgpm);
               }
           }
           break;
         case bgStretched:
           {
             if (!m_bgIsScaled)
               {
                 m_bgIsScaled = true;
                 QImage im = m_bgpm.convertToImage();
                 if (dbuff == NULL)
                   {
                     m_bgpm.convertFromImage(im.smoothScale(width(),height()));
                   }
                 else
                   {
                     m_bgpm.convertFromImage(im.smoothScale(dbuff->rect().width(), dbuff->rect().height()));
                   }
               }
             p->drawPixmap(0,0,m_bgpm);
           }
           break;
         default:
           qDebug("Unknown background type");
         }
       //      p->setBackgroundMode(OpaqueMode);
     } 
 }
 
 void QTReader::blitRot(int dx, int dy, int sw, int sh, CDrawBuffer* txt)
 {
   if (txt != NULL)
     {
       sh = txt->lineSpacing();
     }
   int sy = width()-dx-sh;
   if (m_autoScroll && !(m_scrolltype == 0))
     {
       sy = (sy+m_totalscroll+1)%width();
     }
 
   QPixmap pm(sw, sh);
  
   QPainter pd(&pm, this);
   if (m_bgpm.isNull())
     {
       pd.eraseRect(pm.rect());
     }
   else
     {
       if (sy+pm.height() > dbuff->height())
         {
                   //  pd.eraseRect(pm.rect());
           int fh = dbuff->height() - sy;
           if (sy+fh > dbuff->height())
             {
               qDebug("Oh no!");
             }
           
           if (fh > pm.height())
             {
               qDebug("Oh no! - 2");
             }
           
           bitBlt(&pm,0,0,dbuff,dy,sy,pm.width(),fh);
           bitBlt(&pm,0,fh,dbuff,dy,0,pm.width(),pm.height()-fh);
         }
       else
         {
           bitBlt(&pm,0,0,dbuff,dy,sy,pm.width(),pm.height());
         }
     }
   if (txt != NULL)
     {
       //      txt->render(&pd, txt->lineSpacing() - txt->descent() - txt->lineExtraSpacing(), m_bMonoSpaced, m_charWidth, sw, m_left_border, m_right_border, m_bg);
       txt->render(&pd, txt->lineSpacing() - txt->descent() - txt->lineExtraSpacing(), m_bMonoSpaced, m_charWidth, sw, m_left_border, m_right_border, m_bg, width()-m_topmargin-m_bottommargin);
     }
   QWMatrix m;
   m.rotate(90);
   QPixmap rp = pm.xForm(m);
   /*
   p.drawPixmap(QPoint(dx, dy), rp);
   */
   bitBlt(this, dx, dy, &rp, 0, 0, -1, -1, CopyROP);
 }
 
 QString QTReader::about()
 {
   QString ab = QString("QTReader widget (c) Tim Wentford\n")+buffdoc.about() + "\nMini-scrollbar by Markus Gritsch\nNavigation History fixes by Frantisek Dufka";
   if (m_output != NULL)
     {
       ab += QString("\n") + m_output->about();
     }
   return ab;
 }
 
 void QTReader::getNextLink()
 {
   if (m_scrolldy != 0)
     {
       setautoscroll(false);
       ResetScroll();
       redrawall();
     }
   bool redraw = false;
   bool found = false;
   if (m_currentlink >= 0)
     {
       m_currentlinkoffset = textarray[m_currentlink]->invertLink(m_currentlinkoffset);
       if ((m_currentlinkstyle = textarray[m_currentlink]->getNextLink(m_currentlinkoffset)) != NULL)
         {
           qDebug("Found a link at %u", m_currentlinkoffset);
           int offset = textarray[m_currentlink]->invertLink(m_currentlinkoffset);
           qDebug("Finishes at %u", offset);
           found = true;
         }
       redraw = true;
       drawSingleLine(m_currentlink);
       //      if (found) return;
     }
   if (!found)
     {
       m_currentlinkoffset = -1;
       for (int i = m_currentlink+1; i < numlines; ++i)
         {
           if ((m_currentlinkstyle = textarray[i]->getNextLink(m_currentlinkoffset)) != NULL)
             {
               m_currentlink = i;
               qDebug("Found a link at %u", m_currentlinkoffset);
               int offset = textarray[m_currentlink]->invertLink(m_currentlinkoffset);
               qDebug("Finishes at %u", offset);
               //drawSingleLine(i);
               redraw = true;
               found = true;
               drawSingleLine(m_currentlink);
               break;
             }
         }
     }
   if (redraw)
     {
       //      redrawall();
     }
   if (!found)
     {
       m_currentlink = -1;
       m_currentlinkstyle = NULL;
       m_currentlinkoffset = -1;
       dopagedn();
     }
 }
 
 void QTReader::emitRedraw()
 {
   m_currentlinkstyle = NULL;
   m_currentlink = -1;
   m_currentlinkoffset = -1;
   emit OnRedraw();
 };
 
 void QTReader::drawSingleLine(int lineno)
 {
   QPainter p( this );
   int ypos = textarray[0]->ascent()+m_topmargin;
   if (lineno == 0)
     {
       if (m_rotated)
         {
           blitRot(width()-(ypos+textarray[lineno]->descent()+textarray[lineno]->lineExtraSpacing()), 0, height(), -1, textarray[lineno]);
         }
       else
         {
           if (m_bgpm.isNull())
             {
               p.fillRect(m_left_border,ypos-textarray[lineno]->ascent(),width()-(m_left_border+m_right_border),textarray[lineno]->lineSpacing(),m_bg);
             }
           else
             {
               bitBlt(this, m_left_border, ypos-textarray[lineno]->ascent(), dbuff, m_left_border, ypos-textarray[lineno]->ascent(), width()-(m_left_border+m_right_border), textarray[lineno]->lineSpacing());
             }
           textarray[lineno]->render( &p, ypos, m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg, height()-m_topmargin-m_bottommargin);
         }
     }
   for (int i = 1; i < numlines; i++)
     {
       ypos += (textarray[i-1]->descent() + textarray[i]->ascent())+
         (textarray[i-1]->lineExtraSpacing() + textarray[i]->lineExtraSpacing())/2;
       if (i == lineno)
         {
           if (m_rotated)
             {
               blitRot(width()-(ypos+textarray[i]->descent()+textarray[i]->lineExtraSpacing()), 0, height(), -1, textarray[i]);
             }
           else
             {
               if (m_bgpm.isNull())
                 {
                   p.fillRect(m_left_border,ypos-textarray[lineno]->ascent(),width()-(m_left_border+m_right_border),textarray[lineno]->lineSpacing(),m_bg);
                 }
               else
                 {
                   bitBlt(this, m_left_border, ypos-textarray[lineno]->ascent(), dbuff, m_left_border, ypos-textarray[lineno]->ascent(), width()-(m_left_border+m_right_border), textarray[lineno]->lineSpacing());
                 }
               textarray[i]->render( &p, ypos, m_bMonoSpaced, m_charWidth, width(), m_left_border, m_right_border, m_bg, height()-m_topmargin-m_bottommargin);
             }
         }
     }
 }
 
 
 void QTReader::gotoLink()
 {
   if (m_currentlinkstyle == NULL) return;
   textarray[m_currentlink]->invertLink(m_currentlinkoffset);
   size_t saveposn = pagelocate();
   QString href, nm;
   unsigned long tgt = m_currentlinkstyle->getData();
   unsigned long tgtoffset = m_currentlinkstyle->getOffset();
   linkType lt = buffdoc.hyperlink(tgt, tgtoffset, href, nm);
   qDebug("URL(1):%s", (const char*)href);
   if ((lt & eFile) != 0)
     {
       buffdoc.saveposn(m_lastfile, saveposn);
 #ifdef USEQPE
       {
         QCopEnvelope e("QPE/System", "busy()");
       }
 #endif
       ResetScroll();
       if (!href.isEmpty())
         {
           if (!buffdoc.getFile(href, nm))
             {
               emit NewFileRequest(href);
             }
           else
             {
               ResetScroll();
               fillbuffer();
               m_outofdate = true;
               update();
             }
         }
       if (!nm.isEmpty())
         {
           qDebug("QTReader:Finding %s", (const char*)nm);
           if (buffdoc.findanchor(nm))
             {
               buffdoc.resetPos();
               fillbuffer();
               m_outofdate = true;
               update();
             }
         }
       //fillbuffer();
       //update();
 #ifdef USEQPE
       {
         QCopEnvelope e("QPE/System", "notBusy()");
       }
 #endif
     }
   else if ((lt & eLink) != 0)
     {
       buffdoc.saveposn(m_lastfile, saveposn);
       ResetScroll();
       fillbuffer();
       m_outofdate = true;
       update();
     }
   else
     {
       if ((lt & ePicture) != 0)
         {
           QImage* pm = buffdoc.getPicture(tgt);
           if (pm != NULL)
             {
               emit OnShowPicture(*pm);
               delete pm;
             }
         }
       else
         {
                   //                    QString anchortext = textarray[lineno]->getanchortext(startoffset);
           if (!href.isEmpty())
             {
               emit OnURLSelected(href, tgt);
               refresh();
             }
         }
     }
   m_currentlinkstyle = NULL;
   m_currentlink = -1;
   m_currentlinkoffset = -1;
 }
 
 void QTReader::refresh(bool full)
 {
   qDebug("Refreshing");
   int h, w;
   if (m_rotated)
     {
       h = width();
       w = height();
     }
   else
     {
       w = width();
       h = height();
     }
   m_topmargin = (h*m_abstopmargin+500)/1000;
   m_bottommargin = (h*m_absbottommargin+500)/1000;
   m_left_border = (w*m_absleft_border+500)/1000;
   m_right_border = (w*m_absright_border+500)/1000;
   
   qDebug("Top margin:%u", m_topmargin );
   qDebug("Bottom margin:%u", m_bottommargin );
   qDebug("Left margin:%u", m_left_border );
   qDebug("Right margin:%u", m_right_border );
   if (full && m_highlightfilter) m_highlightfilter->refresh(pagelocate());
   m_outofdate = true;
   locate(pagelocate());
 }
 
 #include "striphtml.h"
 
 CFilterChain* QTReader::getfilter()
 {
   CFilterChain * filt = new CFilterChain(getencoding());
   if (bstripcr) filt->addfilter(new stripcr);
   
   if (btextfmt || (bautofmt && (PreferredMarkup() == cTEXT))) filt->addfilter(new textfmt);
   if (bpeanut || (bautofmt && (PreferredMarkup() == cPML))) filt->addfilter(new PeanutFormatter);
   //    if (bstriphtml || (bautofmt && (PreferredMarkup() == cHTML))) filt->addfilter(new striphtml(m_lastfile));
   
 #ifdef __STATIC
   if (bstriphtml || (bautofmt && (PreferredMarkup() == cHTML))) filt->addfilter(new striphtml(m_lastfile));
   if (bautofmt && (PreferredMarkup() == cCHM))
     {
       striphtml* f = new striphtml(m_lastfile);
       f->setchm(true);
       filt->addfilter(f);
     }
 #else
   if (bstriphtml || (bautofmt && (PreferredMarkup() == cHTML))) filt->addfilter(new ExternFilter("HTMLfilter", m_lastfile));
   if (bautofmt && (PreferredMarkup() == cCHM))
     {
       ExternFilter* f = new ExternFilter("HTMLfilter",m_lastfile);
       ((striphtml*)f->filter())->setchm(true);
       filt->addfilter(f);
     }
 #endif
   m_highlightfilter = new HighlightFilter(this);
   filt->addfilter(m_highlightfilter);
   
   if (bdehyphen) filt->addfilter(new dehyphen);
   if (bunindent) filt->addfilter(new unindent);
   if (brepara) filt->addfilter(new repara(m_reparastring));
   if (bonespace) filt->addfilter(new OnePara);
   if (bindenter) filt->addfilter(new indenter(bindenter));
   if (bdblspce) filt->addfilter(new dblspce);
   if (bdepluck) filt->addfilter(new DePluck(pluckernextpart));
   if (bdejpluck) filt->addfilter(new DePluck(jplucknextpart));
   if (brepalm) filt->addfilter(new repalm);
   if (bunderlineLink) filt->addfilter(new underlineLink);
   if (bkern) filt->addfilter(new kern);
   if (bremap) filt->addfilter(new remap);
   if (bmakebold) filt->addfilter(new embolden);
   if (bfulljust) filt->addfilter(new FullJust);
   int r,g,b;
   m_default_bg.rgb(&r, &g, &b);
   if (r != 255 || g != 255 || b != 255)
     filt->addfilter(new setbg(r,g,b));
   m_default_fg.rgb(&r, &g, &b);
   if (r != 0 || g != 0 || b != 0)
     filt->addfilter(new setfg(r,g,b));
   //    if (bNegative) filt->addfilter(new makeNegative);
   if (bInverse) filt->addfilter(new makeInverse);
   if (bNoInlineTables) filt->addfilter(new tableLink);
   return filt;
 }
 
 void QTReader::readAloud()
 {
 #ifdef __STATIC
   return;
 #else
   CBuffer para;
   jumpto(pagelocate());
   while (m_autoScroll && (buffdoc.getpara(para) != -1))
     {
       if (para.length() > 0)
         {
           unsigned long lastpos = buffdoc.explocate();
           while (lastpos > mylastpos)
             {
               dopagedn();
               qApp->processEvents();
             }
           jumpto(lastpos);
           QString txt = toQString(para.data());
 
           doOutput(txt);
         }
       qApp->processEvents();
     }
 #endif
 }
 
 bool QTReader::doOutput(const QString& wrd)
 {
   if (m_output != NULL)
     {
       m_output->output(wrd);
       return true;
     }
   else
     {
       return false;
     }
 }
 
 bool QTReader::checkoutput()
 {
   if (m_output == NULL)
     {
       m_output = new outputcodec(m_outputName);
       if (reinterpret_cast<outputcodec*>(m_output)->getStatus() != 0)
         {
           delete m_output;
           m_output = NULL;
           QMessageBox::warning(this, PROGNAME, QString("Couldn't find output codec\n")+m_outputName);
           return false;
         }
     }
   return true;
 }
diff --git a/noncore/apps/opie-reader/plucker_base.cpp b/noncore/apps/opie-reader/plucker_base.cpp
index 849edfc..302ac73 100644
--- a/noncore/apps/opie-reader/plucker_base.cpp
+++ b/noncore/apps/opie-reader/plucker_base.cpp
@@ -1,1531 +1,1531 @@
 #include <stdio.h>
 #include <string.h>
 #include <qmessagebox.h>
 #include <qpixmap.h>
 #ifdef USEQPE
 #include <qpe/qcopenvelope_qws.h>
 #endif /* USEQPE */
 #ifdef LOCALPICTURES
 #include <qscrollview.h>
 #endif
 #ifdef USEQPE
 #include <qpe/global.h>
 #endif /* USEQPE */
 #include <qclipboard.h>
 #ifndef USEQPE
 #include <qapplication.h>
 #else /* USEQPE */
 #include <qpe/qpeapplication.h>
 #endif /* USEQPE */
 #include <qimage.h>
 
 #include "plucker_base.h"
 #include "Aportis.h"
 #include "hrule.h"
 #include "decompress.h"
 
 const UInt8 CPlucker_base::continuation_bit = 1;
 
 CPlucker_base::CPlucker_base() :
 #ifdef LOCALPICTURES
   m_viewer(NULL),
   m_picture(NULL),
 #endif
   expandedtextbuffer(NULL),
   compressedtextbuffer(NULL),
   bufferrec(-1),
   m_offset(0)
   //,    urls(NULL)
 { /*printf("constructing:%x\n",fin);*/ }
 
 
 void CPlucker_base::Expand(UInt32 reclen, UInt8 type, UInt8* buffer, UInt32 buffersize)
 {
 unsuspend();
   if ((type%2 == 0) && (type != 14))
     {
       size_t bytes_read = fread(buffer, reclen, sizeof(char), fin);
       buffer[bytes_read] = '\0';
     }
   else
     {
       UInt8* readbuffer = NULL;
       if (reclen > compressedbuffersize)
         {
           readbuffer = new UInt8[reclen];
         }
       else
         {
           readbuffer = compressedtextbuffer;
         }
       if (readbuffer != NULL)
         {
           fread(readbuffer, reclen, sizeof(char), fin);
           size_t bytes_read = (*m_decompress)(readbuffer, reclen, buffer, buffersize);
           buffer[bytes_read] = '\0';
           if (reclen > compressedbuffersize)
             {
               delete [] readbuffer;
             }
         }
     }
 }
 
 void CPlucker_base::sizes(unsigned long& _file, unsigned long& _text)
 {
   _file = file_length;
   if (textlength == 0)
     {
       for (int recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
         {
           gotorecordnumber(recptr);
           UInt16 thishdr_uid, thishdr_nParagraphs;
           UInt32 thishdr_size;
           UInt8 thishdr_type, thishdr_reserved;
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           if (thishdr_type < 2) textlength += thishdr_size;
         }
     }
   _text = textlength;
   //ntohl(hdr0.size);
 }
 
 char* CPlucker_base::geturl(UInt16 tgt)
 {
   char * pRet = NULL;
   gotorecordnumber(0);
   fread(&hdr0, 1, 6, fin);
   unsigned int nrecs = ntohs(hdr0.nRecords);
   //qDebug("Version %u, no. recs %u", ntohs(hdr0.version), nrecs);
   UInt16 urlid = 0;
   bool urlsfound = false;
   char* urls = NULL;
   size_t urlsize = 0;
   for (unsigned int i = 0; i < nrecs; i++)
     {
       UInt16 id, name;
       fread(&name, 1, sizeof(name), fin);
       fread(&id, 1, sizeof(id), fin);
       //qDebug("N:%d, I:%d", ntohs(name), ntohs(id));
       if (ntohs(name) == 2)
         {
           urlsfound = true;
           urlid = id;
           //qDebug("Found url index:%d", ntohs(urlid));
         }
               ////qDebug("%x", id);
     }
   if (urlsfound)
     {
       unsigned short recptr = finduid(ntohs(urlid));
       if (recptr != 0)
         {
           gotorecordnumber(recptr);
           UInt16 thishdr_uid, thishdr_nParagraphs;
           UInt32 thishdr_size;
           UInt8 thishdr_type, thishdr_reserved;
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           UInt16 urlctr = 0;
           while (1)
             {
               UInt16 tctr;
               fread(&tctr, 1, sizeof(tctr), fin);
               fread(&urlid, 1, sizeof(urlid), fin);
               tctr = ntohs(tctr);
               //qDebug("tgt:%u urlctr:%u tctr:%u", tgt, urlctr, tctr);
               if (tctr >= tgt)
                 {
                   break;
                 }
               urlctr = tctr;
             }
           //qDebug("urls are in %d", ntohs(urlid));
           recptr = finduid(ntohs(urlid));
           if (recptr != 0)
             {
               UInt32 reclen = recordlength(recptr) - HeaderSize();
               gotorecordnumber(recptr);
               GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
               //qDebug("Found urls:%x",thishdr_type);
               urlsize = thishdr_size;
               urls = new char[urlsize];
               Expand(reclen, thishdr_type, (UInt8*)urls, urlsize);
               char* ptr = urls;
               int rn = urlctr+1;
               while (ptr - urls < urlsize)
                 {
                   if (rn == tgt)
                     {
                       //qDebug("URL:%s", ptr);
                       int len = strlen(ptr)+1;
                       pRet = new char[len];
                       memcpy(pRet, ptr, len);
                       break;
                     }
                   ptr += strlen(ptr)+1;
                   rn++;
                 }
               delete [] urls;
             }
         }
     }
   else
     {
       pRet = NULL;
     }
   return pRet;
 }
 
 CPlucker_base::~CPlucker_base()
 {
   if (expandedtextbuffer != NULL) delete [] expandedtextbuffer;
   if (compressedtextbuffer != NULL) delete [] compressedtextbuffer;
 #ifdef LOCALPICTURES
   if (m_viewer != NULL) delete m_viewer;
 #endif
 }
 
 int CPlucker_base::getch() { return getch(false); }
 
 void CPlucker_base::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   pos = locate();
   ch = getch(false);
   sty = mystyle;
 }
 
 unsigned int CPlucker_base::locate()
 {
   return currentpos;
   /*
     UInt16 thisrec = 1;
     unsigned long locpos = 0;
     gotorecordnumber(thisrec);
     UInt16 thishdr_uid, thishdr_nParagraphs;
     UInt32 thishdr_size;
     UInt8 thishdr_type, thishdr_reserved;
     while (thisrec < bufferrec)
     {
     GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
     if (thishdr_type < 2) locpos += thishdr_size;
     thisrec++;
     gotorecordnumber(thisrec);
     }
     return locpos+bufferpos;
   */
 }
 
 void CPlucker_base::locate(unsigned int n)
 {
 
   //    clock_t start = clock();
   if (n >= currentpos-bufferpos && n < currentpos - bufferpos + buffercontent)
     {
       currentpos -= bufferpos;
       expand(bufferrec);
       while (currentpos < n && bufferpos < buffercontent) getch_base(true);
       return;
     }
   /*
 
   UInt32 textlength = currentpos - bufferpos;
   UInt16 recptr = bufferrec;
   if (n < textlength/2)
     {
       textlength = 0;
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size = buffercontent;
       UInt8 thishdr_type, thishdr_reserved;
       for (recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
         {
           gotorecordnumber(recptr);
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           if (thishdr_type < 2)
             {
               textlength += thishdr_size;
               if (textlength > n)
                 {
                   textlength -= thishdr_size;
                   break;
                 }
             }
         }
     }
   else if (n < textlength)
     {
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size;
       UInt8 thishdr_type, thishdr_reserved;
       while (n < textlength && recptr > 1)
         {
           recptr--;
           gotorecordnumber(recptr);
           //qDebug("recptr:%u", recptr);
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           if (thishdr_type < 2)
             {
               textlength -= thishdr_size;
             }
         }
     }
   else
     {
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size = buffercontent;
       UInt8 thishdr_type, thishdr_reserved;
       while (n > textlength + thishdr_size && recptr < ntohs(head.recordList.numRecords)-1)
         {
           textlength += thishdr_size;
           recptr++;
           gotorecordnumber(recptr);
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           if (!(thishdr_type < 2))
             {
               thishdr_size = 0;
             }
         }
     }
 
   */
   UInt16 thisrec = 0;
   unsigned long locpos = 0;
   unsigned long bs = 0;
   unsigned int np1 = n+1;
   UInt16 thishdr_uid, thishdr_nParagraphs;
   UInt32 thishdr_size;
   UInt8 thishdr_type, thishdr_reserved;
   do
     {
       thisrec++;
       locpos += bs;
       gotorecordnumber(thisrec);
       GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
       if (thishdr_type < 2)
         {
           bs = thishdr_size;
         }
       else
         {
           bs = 0;
         }
     } while (locpos + bs < np1);
 
   //    qDebug("Time(2): %u", clock()-start);
   /*
   if (recptr != thisrec)
     {
       qDebug("Disaster:recptr:%u thisrec:%u", recptr, thisrec);
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size = buffercontent;
       UInt8 thishdr_type, thishdr_reserved;
       for (recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
         {
           gotorecordnumber(recptr);
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
                   //    qDebug("UID:%u Paras:%u Size:%u Type:%u Reserved:%u", thishdr_uid, thishdr_nParagraphs, thishdr_size, (unsigned int)thishdr_type, (unsigned int)thishdr_reserved);
         }
               //QApplication::exit ( 100 );
     }
   */
   currentpos = locpos;
   expand(thisrec);
   while (currentpos < n && bufferpos < buffercontent) getch_base(true);
 
   /*  // This is faster but the alignment attribute doesn't get set 8^(
       bufferpos = n-locpos;
       currentpos = n;
       while (bufferpos >= m_nextPara && m_nextPara >= 0)
       {
       UInt16 attr = m_ParaAttrs[m_nextParaIndex];
       m_nextParaIndex++;
       if (m_nextParaIndex == m_nParas)
       {
       m_nextPara = -1;
       }
       else
       {
       m_nextPara += m_ParaOffsets[m_nextParaIndex];
       }
       }
   */
 }
 
 bool CPlucker_base::expand(int thisrec)
 {
   mystyle.unset();
   if (bufferrec != thisrec)
     {
       size_t reclen = recordlength(thisrec);
       gotorecordnumber(thisrec);
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size;
       UInt8 thishdr_type, thishdr_reserved;
       while (1)
         {
           GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
           //qDebug("This (%d) type is %d, uid is %u", thisrec, thishdr_type, thishdr_uid);
           if (thishdr_type < 2) break;
           //qDebug("Skipping paragraph of type %d", thishdr_type);
           if (++thisrec >= ntohs(head.recordList.numRecords) - 1) return false;
           reclen = recordlength(thisrec);
           gotorecordnumber(thisrec);
         }
       m_nParas = thishdr_nParagraphs;
       m_bufferisreserved = (thishdr_reserved != 0);
       //qDebug("It has %u paragraphs and is %u bytes", thishdr_nParagraphs, thishdr_size);
       uid = thishdr_uid;
       //    gotorecordnumber(thisrec);
       //    fread(expandedtextbuffer,1,10,fin);
       for (int i = 0; i < m_nParas; i++)
         {
           UInt16 ubytes, attrs;
           fread(&ubytes, 1, sizeof(ubytes), fin);
           fread(&attrs, 1, sizeof(attrs), fin);
           m_ParaOffsets[i] = ntohs(ubytes);
           m_ParaAttrs[i] = ntohs(attrs);
                   ////qDebug("Bytes %u, Attr %x", ntohs(ubytes), ntohs(attrs));
         }
 
       reclen -= HeaderSize()+4*m_nParas;
 
       buffercontent = thishdr_size;
 
       if (thishdr_size > buffersize)
         {
           delete [] expandedtextbuffer;
           buffersize = thishdr_size;
           expandedtextbuffer = new UInt8[buffersize];
         }
       Expand(reclen, thishdr_type, expandedtextbuffer, buffercontent);
       bufferrec = thisrec;
     }
 
 
   if (m_nParas > 0)
     {
       m_nextPara = m_ParaOffsets[0];
       //qDebug("First offset = %u", m_nextPara);
       m_nextParaIndex = 0;
     }
   else
     {
       m_nextPara = -1;
     }
   bufferpos = 0;
   //qDebug("BC:%u, HS:%u", buffercontent, thishdr_size);
   return true;
 }
 /*
 void CPlucker_base::UnZip(UInt8* compressedbuffer, size_t reclen, UInt8* tgtbuffer, size_t bsize)
 {
   z_stream zstream;
   memset(&zstream,sizeof(zstream),0);
   zstream.next_in = compressedbuffer;
   zstream.next_out = tgtbuffer;
   zstream.avail_out = bsize;
   zstream.avail_in = reclen;
 
   int keylen = 0;
 
   zstream.zalloc = Z_NULL;
   zstream.zfree = Z_NULL;
   zstream.opaque = Z_NULL;
   
   //  printf("Initialising\n");
   
   inflateInit(&zstream);
   int err = 0;
   do {
     if ( zstream.avail_in == 0 && 0 < keylen ) {
       zstream.next_in   = compressedbuffer + keylen;
       zstream.avail_in  = reclen - keylen;
       keylen      = 0;
     }
     zstream.next_out  = tgtbuffer;
     zstream.avail_out = bsize;
 
     err = inflate( &zstream, Z_SYNC_FLUSH );
 
             ////qDebug("err:%d - %u", err, zstream.avail_in);
 
   } while ( err == Z_OK );
 
   inflateEnd(&zstream);
 }
 */
 size_t CPlucker_base::UnDoc(UInt8* compressedbuffer, size_t reclen, UInt8* tgtbuffer, size_t bsize)
 {
   //    UInt16      headerSize;
   UInt16      docSize;
   UInt16      i;
   UInt16      j;
   UInt16      k;
 
   UInt8 *inBuf = compressedbuffer;
   UInt8 *outBuf = tgtbuffer;
 
   //    headerSize  = sizeof( Header ) + record->paragraphs * sizeof( Paragraph );
   docSize     = reclen;
 
   j               = 0;
   k               = 0;
   while ( j < docSize ) {
     i = 0;
     while ( i < bsize && j < docSize ) {
       UInt16 c;
 
       c = (UInt16) inBuf[ j++ ];
       if ( 0 < c && c < 9 ) {
         while ( 0 < c-- )
           outBuf[ i++ ] = inBuf[ j++ ];
       }
       else if ( c < 0x80 )
         outBuf[ i++ ] = c;
       else if ( 0xc0 <= c ) {
         outBuf[ i++ ] = ' ';
         outBuf[ i++ ] = c ^ 0x80;
       }
       else {
         Int16 m;
         Int16 n;
 
         c <<= 8;
         c  += inBuf[ j++ ];
 
         m   = ( c & 0x3fff ) >> COUNT_BITS;
         n   = c & ( ( 1 << COUNT_BITS ) - 1 );
         n  += 2;
 
         do {
           outBuf[ i ] = outBuf[ i - m ];
           i++;
         } while ( 0 < n-- );
       }
     }
     k += bsize;
   }
   return i;
 }
 
 void CPlucker_base::home()
 {
   currentpos = 0;
   expand(1);
 }
 
 CList<Bkmk>* CPlucker_base::getbkmklist()
 {
   /*
     UInt16 thishdr_uid, thishdr_nParagraphs;
     UInt32 thishdr_size;
     UInt8 thishdr_type, thishdr_reserved;
 
     for (int i = 1; i < ntohs(head.recordList.numRecords); i++)
     {
     gotorecordnumber(i);
     GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
     if (thishdr_type == 8)
     {
     UInt16 n;
     fread(&n, 1, sizeof(n), fin);
     n = ntohs(n);
     //qDebug("Found %u bookmarks", n);
     }
     //qDebug("Found:%d, %u", i , thishdr_type);
     }
   */
   return NULL;
 }
 
 #include <qnamespace.h>
 
 QImage* CPlucker_base::expandimg(UInt16 tgt, bool border)
 {
   QImage* qimage = getimg(tgt);
   QImage* ret;
   if (qimage == NULL) return NULL;
   if (border)
     {
       QPixmap* image = new QPixmap(0,0);
       image->convertFromImage(*qimage);
       delete qimage;
       QPixmap* pret = new QPixmap(image->width()+4, image->height()+4);
       pret->fill(Qt::red);
       bitBlt(pret, 2, 2, image, 0, 0, -1, -1);//, Qt::RasterOp::CopyROP);
       delete image;
       ret = new QImage(pret->convertToImage());
     }
   else
     {
       ret = qimage;
     }
   return ret;
 }
 
 #ifdef _BUFFERPICS
 #include <qmap.h>
 #endif
 
 QImage* CPlucker_base::getPicture(unsigned long tgt)
 {
 #ifdef _BUFFERPICS
   static QMap<unsigned long, QPixmap> pix;
   QMap<unsigned long, QPixmap>::Iterator t = pix.find(tgt);
   if (t == pix.end())
     {
       pix[tgt] = *expandimg(tgt);
       return &pix[tgt];
     }
   else
     return &(t.data());
 #else
   return expandimg(tgt >> 16);
 #endif
 }
 
 #ifdef LOCALPICTURES
 #include <unistd.h>
 #include <qpe/global.h>
 void CPlucker_base::showimg(UInt16 tgt)
 {
   //qDebug("Crassssssh!");
   QPixmap* qimage = expandimg(tgt);
   m_picture->setFixedSize(qimage->size());
   m_picture->setBackgroundPixmap(*qimage);
   delete qimage;
   m_viewer->show();
 
   /*
     char tmp[] = "uqtreader.XXXXXX";
     QImage* qimage = getimg(tgt);
     QPixmap* image = new QPixmap(0,0);
     //    //qDebug("New image");
     image->convertFromImage(*qimage);
     delete qimage;
     char tmpfile[sizeof(tmp)+1];
     strcpy(tmpfile,tmp);
     int f = mkstemp(tmpfile);
     close(f);
     //qDebug("TMPFILE:%s", tmpfile);
     if (image->save(tmpfile,"PNG"))
     {
     QCopEnvelope e("QPE/Application/showimg", "setDocument(QString)");
     e << QString(tmpfile);
     }
     Global::statusMessage("Opening image");
     sleep(5);
     delete image;
     unlink(tmpfile);
   */
 }
 
 #endif
 
 unsigned short CPlucker_base::finduid(unsigned short urlid)
 {
   //    //qDebug("Finding %u", urlid);
   unsigned short jmin = 1, jmax = ntohs(head.recordList.numRecords);
   unsigned short jmid = (jmin+jmax) >> 1;
   while (jmax - jmin > 1)
     {
       gotorecordnumber(jmid);
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size;
       UInt8 thishdr_type, thishdr_reserved;
       GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
       unsigned short luid = thishdr_uid;
               ////qDebug("%u %u %u : %u", jmin, jmid, jmax, urlid);
       if (luid == urlid)
         {
           return jmid;
         }
       if (luid < urlid)
         {
           jmin = jmid;
         }
       else
         {
           jmax = jmid;
         }
       jmid = (jmin+jmax) >> 1;
     }
   gotorecordnumber(jmin);
   UInt16 thishdr_uid, thishdr_nParagraphs;
   UInt32 thishdr_size;
   UInt8 thishdr_type, thishdr_reserved;
   GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
   unsigned short luid = thishdr_uid;
   //qDebug("jmin at end:%u,%u", jmin, luid);
   if (luid == urlid)
     {
       return jmin;
     }
   gotorecordnumber(jmax);
   GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
   luid = thishdr_uid;
   //qDebug("jmax at end:%u,%u", jmax, luid);
   if (luid == urlid)
     {
       return jmax;
     }
   //qDebug("Couldn't find %u", urlid);
   return 0; // Not found!
 }
 
 #include <qnamespace.h>
 
 void CPlucker_base::setSaveData(unsigned char*& data, unsigned short& len, unsigned char* src, unsigned short srclen)
 {
   unsigned short sz = 0;
   for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
     {
       sz++;
     }
   size_t newlen = srclen+sizeof(sz)+sz*sizeof(unsigned long);
   unsigned char* newdata = new unsigned char[newlen];
   unsigned char* pdata = newdata;
   memcpy(newdata, src, srclen);
   newdata += srclen;
   memcpy(newdata, &sz, sizeof(sz));
   newdata += sizeof(sz);
 #ifdef _WINDOWS
   for (it = visited.begin(); it != visited.end(); it++)
 #else
     for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
 #endif
       {
         unsigned long t = *it;
                 //qDebug("[%u]", t);
         memcpy(newdata, &t, sizeof(t));
         newdata += sizeof(t);
       }
   m_nav.setSaveData(data, len, pdata, newlen);
   delete [] pdata;
 }
 
 void CPlucker_base::putSaveData(unsigned char*& src, unsigned short& srclen)
 {
-  unsigned short sz;
+  unsigned short sz = 0;
   if (srclen >= sizeof(sz))
     {
       memcpy(&sz, src, sizeof(sz));
       src += sizeof(sz);
       srclen -= sizeof(sz);
     }
   for (int i = 0; i < sz; i++)
     {
       unsigned long t;
       if (srclen >= sizeof(t))
         {
           memcpy(&t, src, sizeof(t));
                   //    qDebug("[%u]", t);
           visited.push_front(t);
           src += sizeof(t);
           srclen -= sizeof(t);
         }
       else
         {
           QMessageBox::warning(NULL, PROGNAME, "File data mismatch\nMight fix itself");
           break;
         }
     }
   m_nav.putSaveData(src, srclen);
 }
 
 int CPlucker_base::OpenFile(const char *src)
 {
   qDebug("plucker openfile:%s", src);
   m_lastBreak = 0;
   if (!Cpdb::openpdbfile(src))
     {
       return -1;
     }
 
   if (!CorrectDecoder()) return -1;
 
   gotorecordnumber(0);
   fread(&hdr0, 1, 6, fin);
   qDebug("Compression type:%u", ntohs(hdr0.version));
  
  
   switch (ntohs(hdr0.version))
     {
     case 2:
       m_decompress = UnZip;
       break;
     case 1:
       m_decompress = UnDoc;
       break;
 #ifdef USENEF
     case 3:
       m_decompress = getdecompressor("PluckerDecompress3");
       break;
     case 4:
       m_decompress = getdecompressor("PluckerDecompress4");
       break;
 #endif
     default:
       m_decompress = NULL;
     }
   if (m_decompress == NULL) return -1;
 
   setbuffersize();
   compressedtextbuffer = new UInt8[compressedbuffersize];
   expandedtextbuffer = new UInt8[buffersize];
 
   unsigned int nrecs = ntohs(hdr0.nRecords);
   qDebug("Version %u, no. reserved recs %u", ntohs(hdr0.version), nrecs);
   textlength = ntohl(head.sortInfoID);
   qDebug("Textlength at startup:%u", textlength);
   UInt16 homerecid = 1;
   for (unsigned int i = 0; i < nrecs; i++)
     {
       UInt16 id, name;
       fread(&name, 1, sizeof(name), fin);
       fread(&id, 1, sizeof(id), fin);
       //qDebug("N:%d, I:%d", ntohs(name), ntohs(id));
       if (ntohs(name) == 0) homerecid = ntohs(id);
     }
 
   textlength = 0;
   for (int recptr = 1; recptr < ntohs(head.recordList.numRecords); recptr++)
     {
       gotorecordnumber(recptr);
       UInt16 thishdr_uid, thishdr_nParagraphs;
       UInt32 thishdr_size;
       UInt8 thishdr_type, thishdr_reserved;
       GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
       if (thishdr_uid == homerecid)
         {
           m_homepos = textlength;
           break;
         }
       if (thishdr_type < 2) textlength += thishdr_size;
     }
   qDebug("Found home");
   textlength = 0;
   home();
   qDebug("Gone home");
 #ifdef LOCALPICTURES
   if (m_viewer == NULL)
     {
       m_viewer = new QScrollView(NULL);
       m_picture = new QWidget(m_viewer->viewport());
       m_viewer->addChild(m_picture);
     }
 #endif
   return 0;
 
 }
 
 QImage* CPlucker_base::getimg(UInt16 tgt)
 {
   size_t reclen;
   UInt16 thisrec = finduid(tgt);
   qDebug("getimg:Found %u from uid:%u", thisrec, tgt);
   reclen = recordlength(thisrec);
   gotorecordnumber(thisrec);
   UInt16 thishdr_uid, thishdr_nParagraphs;
   UInt32 thishdr_size;
   UInt8 thishdr_type, thishdr_reserved;
   GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
   if (thishdr_type == 15)
     {
       char *buffer = new char[thishdr_size];
       fread(buffer, thishdr_size, sizeof(char), fin);
       unsigned short tmp;
       memcpy(&tmp, buffer, sizeof(tmp));
       unsigned short cols = ntohs(tmp);
       memcpy(&tmp, buffer+sizeof(tmp), sizeof(tmp));
       unsigned short rows = ntohs(tmp);
       qDebug("Found a picture of type:%u [%u,%u]", thishdr_type, rows, cols);
       QImage*** images;
       images = new QImage**[rows];
 #ifdef _WINDOWS
       int i;
       for (i = 0; i < rows; i++)
 #else
         for (int i = 0; i < rows; i++)
 #endif
           {
             images[i] = new QImage*[cols];
           }
       int height = 0;
       int width = 0;
 #ifdef _WINDOWS
       for (i = 0; i < rows; i++)
 #else
         for (int i = 0; i < rows; i++)
 #endif
           {
             width = 0;
             for (int j = 0; j < cols; j++)
               {
                 memcpy(&tmp, buffer+(i*cols+j+2)*sizeof(tmp), sizeof(tmp));
                 unsigned short uid = ntohs(tmp);
                 images[i][j] = getimg(uid);
                 width += images[i][j]->width();
               }
             height += images[i][0]->height();
           }
       delete [] buffer;
       QPixmap pm(width, height);
       int hoffset = 0;
 #ifdef _WINDOWS
       for (i = 0; i < rows; i++)
 #else
         for (int i = 0; i < rows; i++)
 #endif
           {
             int woffset = 0;
             int delht = images[i][0]->height();
             for (int j = 0; j < cols; j++)
               {
                 QPixmap pm2;
                 pm2.convertFromImage(*(images[i][j]));
                 delete images[i][j];
                 bitBlt(&pm, woffset, hoffset, &pm2, 0, 0, pm2.width(), pm2.height());
                 woffset += pm2.width();
               }
             hoffset += delht;
           }
 #ifdef _WINDOWS
       for (i = 0; i < rows; i++)
 #else
         for (int i = 0; i < rows; i++)
 #endif
           {
             delete [] images[i];
           }
       delete [] images;
       return new QImage(pm.convertToImage());
     }
   else
     {
       qDebug("Found a picture of type:%u", thishdr_type);
       reclen -= HeaderSize();
 
       UInt32 imgsize = thishdr_size;
       UInt8* imgbuffer = new UInt8[imgsize];
     
       Expand(reclen, thishdr_type, imgbuffer, imgsize);
 
       return imagefromdata(imgbuffer, imgsize);
     }
 }
 
 linkType CPlucker_base::hyperlink(unsigned int n, unsigned int offset, QString& wrd, QString&)
 {
   visited.push_front(n);
   UInt16 tuid = (n >> 16);
   n &= 0xffff;
   char *turl = geturl(tuid);
   if (turl != NULL)
     {
       qDebug("URL in PB:%s", turl);
       wrd = turl;
       delete [] turl;
     }
   else
     {
       wrd.truncate(0);
     }
   qDebug("Hyper: UID:%u, Para:%u, Offset:%u", tuid, n, offset);
   UInt16 thisrec = 1;
   currentpos = 0;
   gotorecordnumber(thisrec);
   UInt16 thishdr_uid, thishdr_nParagraphs;
   UInt32 thishdr_size;
   UInt8 thishdr_type, thishdr_reserved;
   while (1)
     {
       GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
       if (tuid == thishdr_uid) break;
       if (thishdr_type < 2) currentpos += thishdr_size;
               ////qDebug("hyper-cp:%u", currentpos);
       thisrec++;
       if (thisrec >= ntohs(head.recordList.numRecords))
         {
           if (wrd.isEmpty())
             {
               QMessageBox::information(NULL,
                                        QString(PROGNAME),
                                        QString("Couldn't find link")
                                        );
             }
           else
             {
 #ifdef USEQPE
               if (wrd.length() > 10)
                 {
                   Global::statusMessage(wrd.left(8) + "..");
                 }
               else
                 {
                   Global::statusMessage(wrd);
                 }
 #else
 #endif /* USEQPE */
               //qDebug("Link:%s", (const char*)wrd);
                       //        setlink(fn, wrd);
             }
           return eNone;
         }
       gotorecordnumber(thisrec);
     }
   if (thishdr_type > 1)
     {
       if (thishdr_type == 4)
         {
           QMessageBox::information(NULL,
                                    QString(PROGNAME),
                                    QString("Mailto links\nnot yet supported (2)"));
         }
       else
         {
           if (thishdr_type > 3 && thishdr_type != 15)
             {
               QMessageBox::information(NULL,
                                        QString(PROGNAME),
                                        QString("External links\nnot yet supported (2)")
                                        );
               return eNone;
             }
           else
             {
 #ifdef LOCALPICTURES
               showimg(tuid);
 #else
               return ePicture;
 #endif
             }
         }
       return eNone;
     }
   /*
     if (thishdr_type == 2 || thishdr_type == 3)
     {
     expandimg(thisrec);
 
     }
   */
   else
     {
       expand(thisrec);
       unsigned int paraoffset = offset;
       //      unsigned int noff = 0;
       if (n != 0) 
         {
           if (n >= m_nParas)
             {
               QMessageBox::information(NULL,
                                        QString(PROGNAME),
                                        QString("Error in link\nPara # too big")
                                        );
               return eNone;
             }
           unsigned int noff = 0;
           for (unsigned int i = 0; i < n; i++) noff += m_ParaOffsets[i];
 
           paraoffset += noff;
         }
       if (paraoffset > thishdr_size)
         {
           QMessageBox::information(NULL,
                                    QString(PROGNAME),
                                    QString("Error in link\nOffset too big")
                                    );
           return eNone;
         }
       while (bufferpos < paraoffset && bufferpos < buffercontent) getch_base(true);
       //qDebug("Hyper:<%u,%u,%u>", paraoffset, bufferpos, currentpos);
       /*      // This is faster but the alignment doesn't get set
               mystyle.unset();
               bufferpos = n;
               currentpos += n;
               while (bufferpos >= m_nextPara && m_nextPara >= 0)
               {
               UInt16 attr = m_ParaAttrs[m_nextParaIndex];
               m_nextParaIndex++;
               if (m_nextParaIndex == m_nParas)
               {
               m_nextPara = -1;
               }
               else
               {
               m_nextPara += m_ParaOffsets[m_nextParaIndex];
               }
               }
       */
     }
   return eLink;
 }
 QString CPlucker_base::getTableAsHtml(unsigned long tgt)
 {
   qDebug("CPlucker_base::getTableAsHtml:%u", tgt);
   size_t reclen;
   UInt16 thisrec = finduid(tgt);
   qDebug("getimg:Found %u from uid:%u", thisrec, tgt);
   reclen = recordlength(thisrec);
   gotorecordnumber(thisrec);
   UInt16 thishdr_uid, thishdr_nParagraphs;
   UInt32 thishdr_size;
   UInt8 thishdr_type, thishdr_reserved;
   GetHeader(thishdr_uid, thishdr_nParagraphs, thishdr_size, thishdr_type, thishdr_reserved);
   qDebug("Found a table of type:%u", thishdr_type);
   reclen -= HeaderSize();
   UInt32 imgsize = thishdr_size;
   UInt8* imgbuffer = new UInt8[imgsize];
   Expand(reclen, thishdr_type, imgbuffer, imgsize);
 
   QString ret;
 
   UInt16 size, columns, rows;
   UInt8 depth, border;
   UInt32 borderColour, linkColour;
   UInt8* dp(imgbuffer);
 
   memcpy(&size, dp, sizeof(size));
   size = ntohs(size);
   dp += sizeof(size);
   memcpy(&columns, dp, sizeof(columns));
   columns = ntohs(columns);
   dp += sizeof(columns);
   memcpy(&rows, dp, sizeof(rows));
   rows = ntohs(rows);
   dp += sizeof(rows);
   qDebug("Rows:%u Cols:%u", rows, columns);
 
   memcpy(&depth, dp, sizeof(depth));
   dp += sizeof(depth);
   memcpy(&border, dp, sizeof(border));
   dp += sizeof(border);
 
   qDebug("Depth:%u, Border:%u", depth, border);
 
   memcpy(&borderColour, dp, sizeof(borderColour));
   dp += sizeof(borderColour);
   memcpy(&linkColour, dp, sizeof(linkColour));
   dp += sizeof(linkColour);
 
   qDebug("Colours: border:%x, link:%x", borderColour, linkColour);
 
   if (border)
     {
       ret = "<table border>";
     }
   else
     {
       ret = "<table>";
     }
   bool firstrow = true;
   bool firstcol = true;
   while (dp < imgbuffer+imgsize)
     {
       UInt8 ch = *dp++;
       if (ch == 0x00)
         {
           ch = *dp++;
           if (ch == 0x90)
             {
               if (firstrow)
                 {
                   ret += "<tr>";
                   firstrow = false;
                   firstcol = true;
                 }
               else
                 {
                   ret += "</tr><tr>";
                 }
             }
           else if (ch == 0x97)
             {
               if (firstcol)
                 {
                   ret += "<td";
                   firstcol = false;
                 }
               else
                 {
                   ret += "</td><td";
                 }
               UInt8 align;
               UInt16 imgid;
               UInt8 cols, rows;
               UInt16 len;
               memcpy(&align, dp, sizeof(align));
               dp += sizeof(align);
               memcpy(&imgid, dp, sizeof(imgid));
               dp += sizeof(imgid);
               imgid = ntohs(imgid);
               memcpy(&cols, dp, sizeof(cols));
               dp += sizeof(cols);
               memcpy(&rows, dp, sizeof(rows));
               dp += sizeof(rows);
               memcpy(&len, dp, sizeof(len));
               dp += sizeof(len);
               len = ntohs(len);
               switch (align)
                 {
                 case 1:
                   ret += " align=right";
                   break;
                 case 2:
                   ret += " align=center";
                   break;
                 case 3:
                   ret += " align=justify";
                   break;
                 case 0:
                   break;
                 default:
                   qDebug("Unknown table cell alignment:%u", align);
                 }
               if (cols != 1)
                 {
                   QString num;
                   num.setNum(cols);
                   ret += " colspan=";
                   ret += num;
                 }
               if (rows != 1)
                 {
                   QString num;
                   num.setNum(rows);
                   ret += " rowspan=";
                   ret += num;
                 }
               ret += ">";
             }
           else
             {
               dp += (ch & 7);
             }
         }
       else
         {
           ret += QChar(ch);
         }
     }
 
   ret += "</td></tr></table>";
   delete [] imgbuffer;
   return ret;
 }
 
 tchar CPlucker_base::getch_base(bool fast)
 {
   mystyle.setTable(0xffffffff);
   int ch = bgetch();
   while (ch == 0)
     {
       ch = bgetch();
               ////qDebug("Function:%x", ch);
       switch (ch)
         {
         case 0x38:
                   //    //qDebug("Break:%u", locate());
           if (m_lastBreak == locate())
             {
               ch = bgetch();
             }
           else
             {
               ch = 10;
             }
           m_lastBreak = locate();
           break;
         case 0x0a:
         case 0x0c:
           {
             unsigned long ln = 0;
             int skip = ch & 7;
             for (int i = 0; i < 2; i++)
               {
                 int ch = bgetch();
                 ln = (ln << 8) + ch;
                         //          //qDebug("ch:%d, ln:%u", ch, ln);
               }
             if (skip == 2)
               {
                 ln <<= 16;
               }
             else
               {
                 for (int i = 0; i < 2; i++)
                   {
                     int ch = bgetch();
                     ln = (ln << 8) + ch;
                             //          //qDebug("ch:%d, ln:%u", ch, ln);
                   }
               }
                     //  //qDebug("ln:%u", ln);
             mystyle.setLink(true);
             mystyle.setData(ln);
                     //  mystyle.setColour(255, 0, 0);
             bool hasseen = false;
             for (CList<unsigned long>::iterator it = visited.begin(); it != visited.end(); it++)
               {
                 if (*it == ln)
                   {
                     hasseen = true;
                     break;
                   }
               }
             if (hasseen)
               {
                 mystyle.setStrikethru();
               }
             mystyle.setOffset(m_offset);
             m_offset = 0;
             ch = bgetch();
           }
           break;
         case 0x08:
           ch = bgetch();
                   //    mystyle.setColour(0, 0, 0);
           mystyle.unsetUnderline();
           mystyle.unsetStrikethru();
           mystyle.setLink(false);
           mystyle.setData(0);
           break;
         case 0x40:
           mystyle.setItalic();
           ch = bgetch();
           break;
         case 0x48:
           mystyle.unsetItalic();
           ch = bgetch();
           break;
         case 0x11:
           {
             ch = bgetch();
                     //  //qDebug("Font:%d",ch);
             mystyle.setVOffset(0);
             mystyle.unsetMono();
             mystyle.unsetBold();
             switch (ch)
               {
               case 0:
                 mystyle.setFontSize(0);
                 break;
               case 1:
                 mystyle.setFontSize(3);
                 mystyle.setBold();
                 break;
               case 2:
                 mystyle.setFontSize(2);
                 mystyle.setBold();
                 break;
               case 3:
                 mystyle.setFontSize(1);
                 mystyle.setBold();
                 break;
               case 4:
                 mystyle.setFontSize(0);
                 mystyle.setBold();
                 break;
               case 5:
                 mystyle.setFontSize(0);
                 mystyle.setBold();
                 break;
               case 6:
                 mystyle.setFontSize(0);
                 mystyle.setBold();
                 break;
               case 7:
                 mystyle.setFontSize(0);
                 mystyle.setBold();
                 break;
               case 8: // should be fixed width
                 //qDebug("Trying fixed width");
                 mystyle.setFontSize(0);
                 mystyle.setMono();
                 break;
               case 9:
                         //      mystyle.setFontSize(mystyle.getFontSize());
                 mystyle.setFontSize(-1);
                 break;
               case 10:
                 mystyle.setFontSize(-2);
                 mystyle.setVOffset(1);
                 break;
               case 11:
                 mystyle.setFontSize(-2);
                 mystyle.setVOffset(-1);
                 break;
               default:
                 qDebug("Unrecognised font");
                 break;
               }
             ch = bgetch();
           }
           break;
         case 0x29:
           ch = bgetch();
           switch (ch)
             {
             case 0:
               mystyle.setLeftJustify();
                       //                //qDebug("left");
               break;
             case 1:
               mystyle.setRightJustify();
                       //                //qDebug("right");
               break;
             case 2:
               mystyle.setCentreJustify();
                       //                //qDebug("centre");
               break;
             case 3:
               mystyle.setFullJustify();
                       //                //qDebug("full");
               break;
 
             }
           ch = bgetch();
           break;
         case 0x53:
           {
             int r = bgetch();
             int g = bgetch();
             int b = bgetch();
             mystyle.setColour(r,g,b);
             ch = bgetch();
           }
           break;
         case 0x1a:
         case 0x5c:
           {
             bool hasalternate = (ch == 0x5c);
             UInt16 ir = bgetch();
             ir = (ir << 8) + bgetch();
             if (hasalternate)
               {
                 //qDebug("Alternate image:%x", ir);
                 UInt16 ir2 = bgetch();
                 ir2 = (ir2 << 8) + bgetch();
                 if (!fast) mystyle.setPicture(true, expandimg(ir2, true), true, ir << 16);
 #ifdef LOCALPICTURES
                 UInt32 ln = ir;
                 ln <<= 16;
                 mystyle.setLink(true);
                 mystyle.setData(ln);
 #endif
               }
             else
               {
                 if (!fast) mystyle.setPicture(true, expandimg(ir));
               }
                     //  if (mystyle.getLink()) qDebug("Picture link!");
             ch = '#';
           }
                   //    ch = bgetch();
           break;
         case 0x33:
           {
             UInt8 h = bgetch();
             UInt8 wc = bgetch();
             UInt8 pc = bgetch();
             UInt16 w = wc;
                     //  //qDebug("h,w,pc [%u, %u, %u]", h, w, pc);
             if (w == 0)
               {
                 w = (m_scrWidth*(unsigned long)pc)/100;
               }
             if (w == 0) w = m_scrWidth;
             mystyle.setPicture(false, hRule(w,h,mystyle.Red(),mystyle.Green(),mystyle.Blue()));
                     //  if (mystyle.getLink()) //qDebug("hRule link!");
             ch = '#';
           }
           break;
         case 0x60:
           mystyle.setUnderline();
           ch = bgetch();
           break;
         case 0x68:
           mystyle.unsetUnderline();
           ch = bgetch();
           break;
         case 0x22:
           ch = bgetch();
           mystyle.setLeftMargin(ch);
                   //    //qDebug("Left margin:%d", ch);
           ch = bgetch();
           mystyle.setRightMargin(ch);
                   //    //qDebug("Right margin:%d", ch);
           ch = bgetch();
           break;
         case 0x70:
           mystyle.setStrikethru();
           ch = bgetch();
           break;
         case 0x78:
           mystyle.unsetStrikethru();
           ch = bgetch();
           break;
         case 0x83:
           {
             int tlen = bgetch();
             ch = bgetch();
             ch <<= 8;
             ch |= (tchar)bgetch();
             for (int i = 0; i < tlen; i++) bgetch();
             //qDebug("Function 83");
           }
           break;
         case 0x9a:
           {
             m_offset = 255*bgetch();
             m_offset += bgetch();
             qDebug("Found offset:%u", m_offset);
             ch = bgetch();
           }
           break;
         case 0x92:
           {
             ch = bgetch();
             ch <<= 8;
             ch |= (tchar)bgetch();
             mystyle.setTable(ch);
             ch = 0x16e5;
           }
           break;
         case 0x85:
         default:
           qDebug("Function:%x NOT IMPLEMENTED", ch);
           {
             int skip = ch & 7;
             for (int i = 0; i < skip; i++)
               {
                 ch = bgetch();
                 //qDebug("Arg %d, %d", i, ch);
               }
             ch = bgetch();
           }
         }
     }
 
   if (m_lastIsBreak && !mystyle.isMono())
     {
       while (ch == ' ')
         {
           ch = getch(false);
         }
     }
 
   m_lastIsBreak = (ch == 10);
 
   return (ch == EOF) ? UEOF : ch;
 }
 
 QString CPlucker_base::about()
 {
   QString abt = "Plucker base codec (c) Tim Wentford";
   if (m_decompress != UnDoc && m_decompress != UnZip)
     {
       abt += "\nSpecial decompression (c) Tim Wentford (ppmd by Dmitry Shkarin";
     }
   return abt;
 }
diff --git a/noncore/apps/opie-reader/striphtml.cpp b/noncore/apps/opie-reader/striphtml.cpp
index c434dbb..a2ad56b 100644
--- a/noncore/apps/opie-reader/striphtml.cpp
+++ b/noncore/apps/opie-reader/striphtml.cpp
@@ -1,1414 +1,1414 @@
 #include <qmap.h>
 #include <qfileinfo.h>
 #include <qtextstream.h>
 #include <qdir.h>
 #ifdef USEQPE
 #include <qpe/global.h>
 #endif
 #include "CDrawBuffer.h"
 #include "striphtml.h"
 #include "hrule.h"
 
 #include <qregexp.h>
 #include <qimage.h>
 #include <qpixmap.h>
 //#include <qprogressdialog.h>
 //#include <qapplication.h>
 
 static unsigned char h2i(unsigned char c)
 {
   unsigned char ret = 0;
   if ('0' <= c && c <= '9')
     {
       ret = c - '0';
     }
   else if ('a' <= c && c <= 'f')
     {
       ret = c - 'a' + 10;
     }
   return ret;
 }
 
 static void parse_color(const QString& attr, unsigned char& r, unsigned char& g, unsigned char& b)
 {
   r = g = b = 0;
   if (attr.length() >= 7 && attr[0] == '#')
     {
       r = h2i(attr[1].unicode());
       r = 16*r + h2i(attr[2].unicode());
       g = h2i(attr[3].unicode());
       g = 16*g + h2i(attr[4].unicode());
       b = h2i(attr[5].unicode());
       b = 16*b + h2i(attr[6].unicode());
     }
   else if (attr == "red")
     {
       r = 255;
     }
   else if (attr == "green")
     {
       g = 255;
     }
   else if (attr == "blue")
     {
       b = 255;
     }
   else if (attr == "white")
     {
       r = g = b = 255;
     }
   else if (attr == "black")
     {
       r = g = b = 0;
     }
   else
     {
       qDebug("Don't understand colour \"%s\"", (const char*)attr);
     }
 }
 
 CNavigation_base<htmlmark> striphtml::m_nav;
 
 void striphtml::skipblock(const QString& _ent)
 {
   tchar ch = '>';
   CStyle dummy;
   QString ent;
   unsigned long pos;
   do 
     {
       while (ch != '<' && ch != UEOF)
         {
           mygetch(ch, dummy, pos);
         }
       
       ch = skip_ws();
       
       ent = getname(ch, " >").lower();
       qDebug("Skipblock:%s", (const char*)ent);
     } while (ent != _ent && ch != UEOF);
 }
 
 void striphtml::reset()
 {
   m_inblock = false;
   text_q = "";
   q = "";
   tablenesteddepth = 0;
   forcecentre = false;
   ignorespace = false;
   indent = 0;
   while (!stylestack.isEmpty()) stylestack.pop();
   currentstyle.unset();
 }
 
 void striphtml::locate(unsigned int n)
 {
   qDebug("striphtml:locating:%u", n);
   reset();
   parent->locate(n);
 }
 
 int striphtml::getpara(CBuffer& buff, unsigned long& startpos)
 {
   tchar ch;
   CStyle sty;
   unsigned long pos;
   int i = 0;
   parent->getch(ch, sty, startpos);
   pos = startpos;
   while (1)
     {
       if (ch == 10 && !isPre)
         {
           ch = ' ';
         }
       if (ch == UEOF)
         {
                   //  qDebug("EOF:%d:%u", i, pos);
           buff[i] = 0;
           if (i == 0)
             {
               i = -1;
             }
           return i;
         }
       else if (ch == '<')
         {
           tchar ch2 = skip_ws();
           QString ent = getname(ch2, " >");
           ent = ent.lower();
                   //  qDebug("ent:%s", (const char*)ent);
           if (ent == "a")
             {
               buff[i++] = '<';
               buff[i++] = 'a';
               buff[i++] = ch2;
                       //      buff[i] = 0; qDebug("ANCHOR:%s", (const char*)toQString(buff.data()));
             }
           else if (ent == "/a")
             {
               buff[i++] = '<';
               buff[i++] = '/';
               buff[i++] = 'a';
               buff[i++] = ch2;
                       //      buff[i] = 0; qDebug("/ANCHOR:%s", (const char*)toQString(buff.data()));
             }
           else if (ent == "div")
             {
                       //      buff[i] = 0; qDebug("DIV:%s", (const char*)toQString(buff.data()));
               if (i == 0)
                 {
                   buff[i++] = '<';
                   buff[i++] = 'd';
                   buff[i++] = 'i';
                   buff[i++] = 'v';
                   buff[i++] = ' ';
                   buff[i++] = ch2;
                   while (ch2 != '>' && ch2 != UEOF && i < 2048)
                     {
                       parent->getch(ch2, sty, pos);
                       buff[i++] = ch2;
                     }
                 }
               else
                 {
                   locate(pos);
                 }
               buff[i++] = 0;
                       //      qDebug("DIV:%s", (const char*)toQString(buff.data()));
               return i;
             }
           else if (ent == "p" || (ent[0] == 'h' && ent.length() == 2 && QString("123456789").find(ent[1]) != -1))
             {
               buff[i++] = 0;
               while (ch2 != '>' && ch2 != UEOF)
                 {
                   parent->getch(ch2, sty, pos);
                 }
               return i;
             }
           else
             {
               while (ch2 != '>' && ch2 != UEOF)
                 {
                   parent->getch(ch2, sty, pos);
                 }
             }
         }
       else
         {
           buff[i++] = ch;
         }
       parent->getch(ch, sty, pos);
     }
 }
 
 QString striphtml::dehtml(const QString& _info)
 {
   QString info;
   for (int i = 0; i < _info.length(); i++)
   {
     tchar ch = _info[i];
     if (ch == '%')
       {
         ch = 0;
         for (int j = 0; j < 2; j++)
           {
             ch <<= 4;
             tchar ch1 = _info[++i];
             if ('0' <= ch1 && ch1 <= '9')
               {
                 ch += ch1 - '0';
               }
             else if ('a' <= ch1 && ch1 <= 'f')
               {
                 ch += ch1 - 'a' + 10;
               }
             else if ('A' <= ch1 && ch1 <= 'F')
               {
                 ch += ch1 - 'A' + 10;
               }
           }
       }
     info += ch;
   }
   return info;
 }
 
 bool striphtml::findanchor(const QString& _info)
 {
   //  QProgressDialog dlg("Finding link...", QString::null, 0, NULL, "progress", true);
   //  QProgressBar dlg(0);
   if (parent->findanchor(_info))
     {
       reset();
       return true;
     }
   qDebug("Using html find");
   parent->locate(parent->startSection());
 #if defined(USEQPE) || defined(_WINDOWS) 
   QString info;
   for (int i = 0; i < _info.length(); i++)
   {
     tchar ch = _info[i];
     if (QString(".^$[]*+?").find(ch) != -1)
       {
         info += '\\';
       }
     info += ch;
   }
 #else
   QString info = QRegExp::escape(_info);
 #endif
   qDebug("Adjusted searchstring:%s", (const char*)info);
   QString sname("<[Aa][^>]*[ \t]+[Nn][Aa][Mm][Ee][ \t]*=[ \t]*\"?");
   sname += info + "\"?[ \t>]";
   QString sid("<[A-Za-z][^>]*[ \t]+[Ii][Dd][ \t]*=[ \t]*\"?");
   sid += info+"\"?[ \t>]";
 #ifdef USEQPE
   QRegExp name(sname);
   QRegExp id(sid);
 #else
   QRegExp name(sname+"|"+sid);
 #endif
   bool ret = true;
   locate(0);
   unsigned long pos = 0;
   unsigned long startpos = 0;
   int offset;
   CBuffer test;
   qDebug("striphtml::findanchor");
   //  dlg.show();
   if (getpara(test, pos) >= 0)
     {
       while (1)
         {
                   //  qApp->processEvents();
           if ((offset = name.match(toQString(test.data()))) != -1) break;
 #ifdef USEQPE
           if ((offset = id.match(toQString(test.data()))) != -1) break;
 #endif
           if (getpara(test, pos) < 0)
             {
               locate(startpos);
               qDebug("Not found");
               return false;
             }
         }
       locate(pos);
       qDebug("Found");
       ret = true;
     }
   else
     {
       locate(startpos);
       qDebug("Not found");
       ret = false;
     }
   return ret;
 }
 
 striphtml::striphtml(const QString& _s) : entmap(NULL), isPre(false), currentid(0), lastch(0), currentfile(_s), indent(0), forcecentre(false), m_inblock(false), m_bchm(false), ignorespace(false), tablenesteddepth(0)
 {
   href2filepos = new QMap<QString, unsigned long>;
   id2href = new QMap<unsigned long, QString>;
 }
 
 striphtml::~striphtml()
 {
   if (entmap != NULL) delete entmap;
   delete href2filepos;
   delete id2href;
 }
 
 void striphtml::initentmap()
 {
   entmap = new QMap<QString, tchar>;
 #ifdef USEQPE
 #ifdef OPIE
   QString fname(getenv("OPIEDIR"));
 #else
   QString fname(getenv("QTDIR"));
 #endif
   fname += "/plugins/reader/data";
 #else
   QString fname(getenv("READERDIR"));
   fname += "/data";
 #endif  
   QFileInfo fi;
   fi.setFile(fname, "HTMLentities");
   if (fi.exists())
     {
       fname = fi.absFilePath();
 
       QFile fl(fname);
       if (fl.open(IO_ReadOnly))
         {
           QTextStream t(&fl);
           QString key, value;
           while (!t.eof())
             {
               QString data = t.readLine();
               int colon = data.find(':');
               if (colon > 0)
                 {
                   QString key = data.left(colon);
                   QString value = data.right(data.length()-colon-1);
                   bool ok;
                   int ret = value.toInt(&ok);
                   if (ok)
                     {
                       (*entmap)[key] = ret;
                     }
                 }
             }
           fl.close();
         }
     }
 }
 
 unsigned short striphtml::skip_ws()
 {
     tchar ch;
     CStyle sty;
     unsigned long dummy;
     do
     {
         mygetch(ch, sty, dummy);
     }
     while (ch < 33 && ch != UEOF);
     return ch;
 }
 
 unsigned short striphtml::skip_ws_end()
 {
     unsigned long dummy;
     return skip_ws_end(dummy);
 }
 
 unsigned short striphtml::skip_ws_end(unsigned long& pos)
 {
     tchar ch;
     CStyle sty;
     do
       {
         mygetch(ch, sty, pos);
       }
     while (ch != '>' && ch != UEOF);
     return ch;
 }
 
 QString striphtml::getname(tchar& ch, const QString& nd)
 {
   QString nm = "";
   //  nm += ch;
   CStyle sty;
   unsigned long dummy;
   while (1)
     {
       //      if ( QChar(ch).isLetterOrNumber() )
       if (ch != UEOF && nd.find(ch, 0, false) == -1 && nm.length() < 2048)
         {
           nm += ch;
         }
       else
         {
           break;
         }
       mygetch(ch, sty, dummy);
     }
   return nm;
 }
 
 QString striphtml::getattr(tchar& ch)
 {
   QString ref;
   CStyle sty;
   unsigned long pos;
   if (ch == ' ') ch = skip_ws();
   if (ch == '=')
     {
       ch = skip_ws();
       if (ch == '"')
         {
           mygetch(ch, sty, pos);
           ref = getname(ch, "\"");
           ch = skip_ws();
         }
       else if (ch == '\'')
         {
           mygetch(ch, sty, pos);
           ref = getname(ch, "\'");
           ch = skip_ws();
         }
       else
         {
           ref = getname(ch, " >");
           if (ch == ' ') ch = skip_ws();
         }
     }
   return ref;
 }
 
 linkType striphtml::hyperlink(unsigned int n, unsigned int, QString& w, QString& nm)
 {
 #if defined(USEQPE) || defined(_WINDOWS)
   QMap<unsigned long, QString>::Iterator hrefit = id2href->find(n);
 #else
   QMap<unsigned long, QString>::iterator hrefit = id2href->find(n);
 #endif
   if (hrefit == id2href->end())
     {
       return eNone;
     }
   QString href = *hrefit;
 #if defined(USEQPE) || defined(_WINDOWS)
   QMap<QString, unsigned long>::Iterator fpit = href2filepos->find(href);
 #else
   QMap<QString, unsigned long>::iterator fpit = href2filepos->find(href);
 #endif
   if (fpit == href2filepos->end())
     {
       if (href == "history.back()")
         {
           QString fc = currentfile;
-          unsigned long loc;
+          unsigned long loc = 0;
           htmlmark m(fc, loc);
           linkType ret = (m_nav.back(m)) ? eFile : eNone;
           if (fc == m.filename())
             {
               if ((ret & eFile) != 0)
                 {
                   locate(m.posn());
                   return eLink;
                 }
             }
           return eNone;
         }
       qDebug("Searching for %s", (const char*)href);
 
 
       QString file, name;
 
       int colon = href.find('#');
       if (colon >= 0)
         {
           file = dehtml(href.left(colon));
           name = dehtml(href.right(href.length()-colon-1));
         }
       else
         {
           file = dehtml(href);
         }
       
       qDebug("File:%s", (const char*)file);
       qDebug("Name:%s", (const char*)name);
       
 
       if (file.isEmpty())
         {
           if (parent->findanchor(name))
             {
               reset();
               return eLink;
             }
           fpit = href2filepos->find(name);
           if (fpit != href2filepos->end())
             {
               locate(*fpit);
               return eLink;
             }
           else
             {
                       //      nm = QString("<a[^>]*name[ \t]*=[ \t]*\"") + name + "\"";
               qDebug("Do a search for:%s", (const char*)name);
               findanchor(name);
               return eLink;
             }
         }
       else
         //      if (href.find('#') == -1)
         {
           if (m_bchm)
             {
               w = file;
               nm = name;
               return eFile;
             }
           else
             {
               QFileInfo f(currentfile);
               QFileInfo f1(f.dir(true), file);
               if (f1.exists())
                 {
                   w = f1.absFilePath();
                   nm = name;
                 }
               else
                 {
                   w = file;
                 }
               return (f1.exists() ? eFile : eNone);
             }
         }
       return eNone;
     }
   locate(*fpit);
   //  parent->locate((*href2filepos)[(*id2href)[n]]);
   return eLink;
 }
 /*
 unsigned short striphtml::parse_m()
 {
     tchar ch;
     CStyle sty;
     unsigned long dummy;
     mygetch(ch, sty, dummy);
     if (ch == 'm' || ch == 'M')
     {
         ch = skip_ws_end();
         if (ch == '>')
         {
             return 0;
         }
     }
     return ch;
 }
 */
 
 void striphtml::mygetch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   if (!text_q.isEmpty() && !m_inblock)
     {
       ch = text_q[0].unicode();
       text_q = text_q.right(text_q.length()-1);
     }
   else
     {
       parent->getch(ch, sty, pos);
       if (ch == '<')
         {
           m_inblock = true;
         }
       if (ch == '>')
         {
           m_inblock = false;
         }
     }
   if (ch == 10 && !isPre)
     {
 #ifdef REMOVE_LF_BEFORE_ENDTAG
       parent->getch(ch, sty, pos);
       if (ch == '<')
         {
           parent->getch(ch, sty, pos);
           if (ch == '/')
             {
               ch = '<';
               text_q += '/';
             }
           else
             {
               text_q += '<';
               text_q += ch;
               ch = ' ';
             }
         }
       else
         {
           text_q += ch;
           ch = ' ';
         }
 #else
       ch = ' ';
 #endif
     }
 }
 
 void striphtml::parse_paragraph(CStyle& currentstyle, tchar& ch, unsigned long pos)
 {
 /*
  int count = 0;
    for (CList<CStyle>::iterator iter = stylestack.begin(); iter != stylestack.end(); ++iter)
      {
         count++;
      }
    qDebug("Currently have %u styles", count);
 */
    if (stylestack.isEmpty())
      {
         currentstyle.unset();
      }
    else
      {
         currentstyle = stylestack.first();
      }
   if (forcecentre)
     {
       currentstyle.setCentreJustify();
     }
   if (ch == ' ') ch = skip_ws();
   while (ch != '>' && ch != UEOF)
     {
       QString ent = getname(ch, " =>").lower();
       QString attr = getattr(ch).lower();
       //qDebug("(Paragraph)Entity:%s Attr:%s", (const char*)ent, (const char*)attr);
       if (ent == "align")
         {
           if (attr == "center")
             {
               currentstyle.setCentreJustify();
             }
           if (attr == "right")
             {
               currentstyle.setRightJustify();
             }
           if (attr == "justify")
             {
               currentstyle.setFullJustify();
             }
         }
       if (ent == "id")
         {
           (*href2filepos)[attr] = pos;
         }
       if (ent == "bgcolor")
         {
           qDebug("Got paper colour:%s", (const char*)attr);
           unsigned char r,g,b;
           parse_color(attr, r, g, b);
           currentstyle.setPaper(r, g, b);
         }
       if (ent == "color")
         {
           qDebug("Got foreground colour:%s", (const char*)attr);
           unsigned char r,g,b;
           parse_color(attr, r, g, b);
           currentstyle.setColour(r, g, b);
         }
       if (ch == ' ') ch = skip_ws();
     }
   ch = 10;
 }
 
 void striphtml::getch(tchar& ch, CStyle& sty, unsigned long& pos)
 {
   currentstyle.clearPicture();
   if (!q.isEmpty())
     {
       ch = q[0].unicode();
       if (ch == '-')
         {
           tchar w = q[1].unicode();
           tchar h = q[2].unicode();
           unsigned char r = q[3].unicode();
           unsigned char g = q[4].unicode();
           unsigned char b = q[5].unicode();
           ch = '#';
           //qDebug("html:hrule<%u, %u>", w, h);
           currentstyle.setPicture(false, hRule(w,h,r,g,b));
           q = q.right(q.length()-6);
         }
       else
         {
           q = q.right(q.length()-1);
         }
       sty = currentstyle;
       lastch = ch;
       return;
     }
   do
     {
       unsigned long npos;
       CStyle dummy;
       mygetch(ch, dummy, pos);
       while (ch == '<' && ch != UEOF)
         {
           ch = skip_ws();
           QString ent = getname(ch, " >").lower();
 
                   //  qDebug("Entity:%s", (const char*)ent);
         
           if (ent == "a"/* || ent == "reference"*/)
             {
               if (ch == ' ') ch = skip_ws();
               bool fileposfound = false;
               bool ishref = false;
               unsigned int filepos = 0;
               QString ref, name;
               while (ch != '>' && ch != UEOF)
                 {
                   QString ent = getname(ch, " =>").lower();
                   QString attr = getattr(ch);
                   //qDebug("<A>Entity:%s Attr:%s", (const char*)ent, (const char*)attr);
                   if (ent == "name")
                     {
                       name = attr;
                     }
                    if (ent == "onclick")
                      {
                         int st = attr.find('\'');
                         int nd = attr.findRev('\'');
                         ref = attr.mid(st+1, nd-st-1);
                         ishref = true;
                         qDebug("Onclick:%s", (const char*)ref);
                      }
                   if (ent == "href")
                     {
                       ishref = true;
                       ref = attr;
                     }
                   if (ent == "filepos")
                     {
                       filepos = attr.toUInt(&fileposfound);
                       if (ref.isEmpty())
                         {
                           ishref = true;
                           ref = attr;
                         }
                     }
                   if (ent == "title")
                     {
                       text_q = attr + "</a><p>";
                     }
                   //qDebug("<a %s=%s>", (const char*)ent, (const char*)ref);
                 }
               if (ishref)
                 {
                   currentstyle.setColour(0,0,255);
                   currentstyle.setLink(true);
                   currentstyle.setData(currentid);
                   if (!text_q.isEmpty())
                     {
                       currentstyle.setBold();
                       currentstyle.setCentreJustify();
                     }
                   (*id2href)[currentid] = ref;
                   currentid++;
                 
                 
                   if (fileposfound)
                     {
                       (*href2filepos)[ref] = filepos;
                     }
                 }
               if (!name.isEmpty())
                 {
                   (*href2filepos)[name] = pos;
                 }
             }
           else if (ent == "p")
             {
               parse_paragraph(currentstyle, ch, pos);
               currentstyle.setExtraSpace(3);
               continue;
             }
           else if (ent == "div")
             {
               parse_paragraph(currentstyle, ch, pos);
               stylestack.push_front(currentstyle);
               currentstyle.setExtraSpace(16);
                   //indent = 0;
               continue;
             }
           else if (ent == "sup")
             {
               currentstyle.setVOffset(-1);
             }
           else if (ent == "sup")
             {
               currentstyle.setVOffset(1);
             }
           else if (ent == "/sup" || ent == "/sub")
             {
               currentstyle.setVOffset(0);
             }
           else if (ent == "span")
             {
               if (ch == ' ') ch = skip_ws();
               while (ch != '>' && ch != UEOF)
                 {
                   QString ent = getname(ch, " =>").lower();
                   QString attr = getattr(ch).lower();
                   if (ent == "bgcolor")
                     {
                       qDebug("Got background colour:%s", (const char*)attr);
                       unsigned char r,g,b;
                       parse_color(attr, r, g, b);
                       currentstyle.setBackground(r, g, b);
                     }
                   if (ent == "color")
                     {
                       qDebug("Got foreground colour:%s", (const char*)attr);
                       unsigned char r,g,b;
                       parse_color(attr, r, g, b);
                       currentstyle.setColour(r, g, b);
                     }
                 }
                stylestack.push_front(currentstyle);
             }
           else if (ent == "/span")
             {
               if (ch != '>') ch = skip_ws_end();
               currentstyle.setBackground(255, 255, 255);
               currentstyle.setColour(0, 0, 0);
                if (!stylestack.isEmpty())
                  {
                     stylestack.pop();
                  }
             }
           else if (ent == "pre")
             {
               isPre = true;
               currentstyle.setNoJustify();
               currentstyle.setMono();
             }
           else if (ent == "tt")
             {
               currentstyle.setMono();
             }
           else if (ent == "b" || ent == "strong")
             {
               currentstyle.setBold();
             }
           else if (ent == "u")
             {
               currentstyle.setUnderline();
             }
           else if (ent == "/u")
             {
               currentstyle.unsetUnderline();
             }
           else if (ent == "blockquote")
             {
               if (ch != '>') ch = skip_ws_end();
               ch = 10;
               currentstyle.setExtraSpace(0);
               currentstyle.setLeftMargin(30);
               currentstyle.setRightMargin(30);
               continue;
             }
           else if (ent == "br" || ent == "br/")
             {
               if (ch != '>') ch = skip_ws_end();
               ch = 10;
               currentstyle.setExtraSpace(0);
               lastch = 0;
               continue;
             }
           else if (ent == "mbp:pagebreak")
             {
               /*
               if (ch != '>') ch = skip_ws_end(pos);
               q += 10;
               q += QChar(UEOF);
               ch = 10;
               continue;
               */
               ch = 6;
                       //      currentstyle.setTop();
               continue;
             }
           else if (ent == "center")
             {
               //forcecentre = true;
               qDebug("setting centre");
               currentstyle.setCentreJustify();
                ch = 10;
                continue;
             }
           else if (ent == "/center")
             {
               qDebug("unsetting centre");
               forcecentre = false;
             }
           else if (ent == "li")
             {
               if (ch != '>') ch = skip_ws_end();
               lastch = 0;
               ch = 10;
               if (m_listtype[indent % m_cmaxdepth] == 1)
                 {
                   q.setNum(m_ctr[indent % m_cmaxdepth]++);
                 }
               else
                 {
                   q += QChar(8226);
                 }
               q += ' ';
               currentstyle.setLeftMargin(6*indent);
               qDebug("Setting indent:%d", indent);
               continue;
             }
           else if (ent == "ul")
             {
               indent++;
               m_listtype[indent % m_cmaxdepth] = 0;
             }
           else if (ent == "/ul")
             {
               indent--;
             }
           else if (ent == "ol")
             {
               indent++;
               m_listtype[indent % m_cmaxdepth] = 1;
               m_ctr[indent % m_cmaxdepth] = 1;
             }
           else if (ent == "/ol")
             {
               indent--;
             }
           else if (ent == "i")
             {
               currentstyle.setItalic();
             }
           else if (ent == "em")
             {
               currentstyle.setItalic();
             }
           else if (ent == "small")
             {
               currentstyle.setFontSize(-2);
             }
           else if (ent == "/small")
             {
               currentstyle.setFontSize(0);
             }
           else if (ent == "big")
             {
               currentstyle.setFontSize(2);
             }
           else if (ent == "/big")
             {
               currentstyle.setFontSize(0);
             }
           else if (ent[0] == '/' && ent[1] == 'h' && ent.length() == 3 && QString("123456789").find(ent[2]) != -1)
             {
               parse_paragraph(currentstyle, ch, pos);
               currentstyle.setExtraSpace(3);
               continue;
             }
           else if (ent[0] == 'h' && ent.length() == 2 && QString("123456789").find(ent[1]) != -1)
             {
               indent = 0;
               if (ent[1] == '1')
                 {
                   parse_paragraph(currentstyle, ch, pos);
                   currentstyle.setFontSize(3);
                   currentstyle.setExtraSpace(8);
                   currentstyle.setBold();
                           //        currentstyle.setExtraSpace(10);
                 }
               else if (ent[1] == '2')
                 {
                   parse_paragraph(currentstyle, ch, pos);
                   currentstyle.setFontSize(2);
                   currentstyle.setExtraSpace(6);
                   currentstyle.setBold();
                           //        currentstyle.setExtraSpace(10);
                 }
               else if (ent[1] == '3')
                 {
                   parse_paragraph(currentstyle, ch, pos);
                   currentstyle.setFontSize(1);
                   currentstyle.setExtraSpace(4);
                   currentstyle.setBold();
                           //        currentstyle.setExtraSpace(10);
                 }
               else
                 {
                   parse_paragraph(currentstyle, ch, pos);
                   currentstyle.setExtraSpace(4);
                   currentstyle.setBold();
                           //        currentstyle.setExtraSpace(10);
                 }
               ch = 10;
               continue;
             }
         
         
           else if (ent == "/a")
             {
               currentstyle.setColour(0,0,0);
               currentstyle.setLink(false);
             }
           else if (ent == "/pre")
             {
               currentstyle.unsetMono();
               isPre = false;
             }
           else if (ent == "/tt")
             {
               currentstyle.unsetMono();
             }
           else if (ent == "/b" || ent == "/strong")
             {
               currentstyle.unsetBold();
             }
           else if (ent == "/i")
             {
               currentstyle.unsetItalic();
             }
           else if (ent == "/em")
             {
               currentstyle.unsetItalic();
             }
           else if (ent == "/div")
             {
               currentstyle.unset();
               if (ch != '>') ch = skip_ws_end();
               ch = 10;
                if (!stylestack.isEmpty())
                  {
                     stylestack.pop();
                  }
               continue;
             }
           else if (ent == "tr")
             {
               if (ch != '>') ch = skip_ws_end();
               ch = 10;
               q += '-';
               q += QChar(parent->getwidth());
               q += 2;
               q += '\0';
               q += '\0';
               q += '\0';
               continue;
             }
           else if (ent == "td")
             {
               if (ch != '>') ch = skip_ws_end();
               ignorespace = false;
             }
           else if (ent == "/td")
             {
               ignorespace = true;
                       //      parse_paragraph(currentstyle, ch, pos);
               //stylestack.push_front(currentstyle);
               if (ch != '>') ch = skip_ws_end();
                       //      ch = '|';
               //continue;
               ch = 10;
               q += '-';
               q += QChar(parent->getwidth());
               q += 1;
               q += '\0';
               q += '\0';
               q += '\0';
               continue;
             }
           /*
           else if (ent == "/td")
             {
               currentstyle.unset();
               if (ch != '>') ch = skip_ws_end();
                if (!stylestack.isEmpty())
                  {
                     stylestack.pop();
                  }
                        //       ch = 10;
                continue;
             }
           */
           else if (ent[0] == '/' && ent.length() == 3 && ent[1] == 'h' && QString("123456789").find(ent[2]) != -1)
             {
               currentstyle.unset();
               if (ch != '>') ch = skip_ws_end();
               //ch = 10;
               //continue;
             }
           else if (ent == "table" || ent == "/table")
             {
               currentstyle.unset();
               ignorespace = (ent == "table");
               if (ent == "table")
                 {
                   if (tablenesteddepth++ == 0) currentstyle.setTable(pos);
                 }
               else
                 {
                   if (--tablenesteddepth <= 0)
                     {
                       tablenesteddepth = 0;
                       currentstyle.setTable(0xffffffff);
                     }
                 }
               if (ch == ' ') ch = skip_ws();
               while (ch != '>' && ch != UEOF)
                 {
                   QString ent = getname(ch, " =>").lower();
                   QString attr = getattr(ch);
                   qDebug("<table>Entity:%s Attr:%s", (const char*)ent, (const char*)attr);
                 }
               if (ch != '>') ch = skip_ws_end();
 
               currentstyle.setLeftMargin(6*tablenesteddepth);
 
 
               lastch = 0; // Anything but 10
               ch = 10;
               q += '-';
               q += QChar(parent->getwidth());
               q += 3;
               q += '\0';
               q += '\0';
               q += '\0';
               continue;
             }
           else if (ent == "hr")
             {
               //bool isPageBreak = false;
               if (ch == ' ') ch = skip_ws();
               unsigned char red = 0, green = 0, blue = 0;
               while (ch != '>' && ch != UEOF)
                 {
                   QString ent = getname(ch, " =>").lower();
                   QString attr = getattr(ch);
                   if (ent == "color")
                     {
                       parse_color(attr, red, green, blue);
                     }
                   /*
                   if (ent == "size")
                     {
                       if (attr == "0")
                         {
                           isPageBreak = true;
                         }
                     }
                   */
                   qDebug("<hr>Entity:%s Attr:%s", (const char*)ent, (const char*)attr);
                 }
               if (ch != '>') ch = skip_ws_end();
               /*
               if (isPageBreak)
                 {
                   ch = UEOF;
                 }
               else
                 {
               */
                           //      if (stylestack.isEmpty())
                           //    {
                   currentstyle.unset();
                           //    }
                   /*
                     else
                     {
                     qDebug("Using stack style");
                     currentstyle = stylestack.first();
                     }
                   */
                   lastch = 0; //Anything but 10 or ' '
                   ch = 10;
                   q += '-';
                   q += QChar(parent->getwidth());
                   q += 3;
                   q += red;
                   q += green;
                   q += blue;
 
               continue;
             }
 
 
 
           else if (ent == "img")
             {
               if (ch == ' ') ch = skip_ws();
               while (ch != '>' && ch != UEOF)
                 {
                   QString ent = getname(ch, " =>").lower();
                   QString attr = getattr(ch);
                   qDebug("<img>Entity:%s Attr:%s", (const char*)ent, (const char*)attr);
                   if (ent == "src")
                     {
                       /*
                       if (m_bchm)
                         {
                           QImage* img = parent->getPicture(attr);
                           if (img != NULL)
                             {
                               currentstyle.setPicture(true, img);
                             }
                         }
                       */
 
 
                       QImage* img = parent->getPicture(attr);
                       if (img != NULL)
                         {
                           currentstyle.setPicture(true, img);
                         }
                       else
                         {
                           QFileInfo f(currentfile);
                           QFileInfo f1(f.dir(true), attr);
                           QPixmap pm;
                           if (pm.load(f1.absFilePath()))
                             {
                               QImage* img = new QImage(pm.convertToImage());
                               currentstyle.setPicture(true, img);
                             }
                         }
                     }
                   if (ent == "recindex")
                     {
                       bool ok;
                       unsigned int picindex = attr.toUInt(&ok);
                       qDebug("Looking for image at %u", picindex);
                       QImage* img = parent->getPicture(picindex);
                       if (img != NULL)
                         {
                           currentstyle.setPicture(true, img);
                         }
                       else
                         {
                           qDebug("No image found");
                         }
                     }
                 }
               if (ch != '>') ch = skip_ws_end();
               ch = '#';
               break;
             }
           else if (ent.left(2) == "dc")
             {
               QString nd("/");
               skipblock(nd+ent);
             }
           else if (ent == "metadata")
             {
                       //      skipblock("/metadata");
             }
           else if (ent == "title")
             {
               skipblock("/title");
             }
           else if (ent == "head")
             {
               skipblock("/head");
             }
           /*
           else if (ent == "metadata")
             {
               currentstyle.setFontSize(-2);
             }
           else if (ent == "/metadata")
             {
               currentstyle.unset();
               ch = 10;
               continue;
             }
           */
           else
             {
               if (ent[0] != '/')
                 qDebug("Not handling:%s", (const char*)ent);
             }
 
           if (ch != '>') ch = skip_ws_end();
           if (ent[0] == '/')
             mygetch(ch, dummy, pos);
           else
             mygetch(ch, dummy, npos);
         }
       if (ch == '&')
         {
           mygetch(ch, dummy, npos);
           if (ch == '#')
             {
               int id = 0;
               mygetch(ch, dummy, npos);
               while (ch != ';' && ch != UEOF)
                 {
                   id = 10*id+ch-'0';
                   mygetch(ch, dummy, npos);
                 }
               ch = id;
             }
           else
             {
               QString en;
               en += ch;
               mygetch(ch, dummy, npos);
               while (ch != ';' && ch != UEOF)
                 {
                   en += ch;
                   mygetch(ch, dummy, npos);
                 }
               if (entmap == NULL) initentmap();
 #if defined(USEQPE) || defined(_WINDOWS)
               QMap<QString, tchar>::Iterator it = entmap->find(en);
 #else
               QMap<QString, tchar>::iterator it = entmap->find(en);
 #endif
               if (it != entmap->end())
                 {
                   ch = *it;
                 }
               else
                 {
                   ch = '.';
                 }
             }
         }
       //    sty = (dummy == ucFontBase) ? currentstyle : dummy;
       if (lastch == 10 && ch == 10 && sty.getExtraSpace() > currentstyle.getExtraSpace())
         {
           currentstyle.setExtraSpace(sty.getExtraSpace());
         }
       sty = currentstyle;
     }
   while (!isPre && (((lastch == ' '  || lastch == 10 || ignorespace) && ch == ' ') || ((ch == 10) && (lastch == 10))));
   //  lastch = ch;
   lastch = ch;
   return;
 }
 
 QString striphtml::getTableAsHtml(unsigned long loc)
 {
   qDebug("striphtml::getTableAsHtml");
   QString ret;
   tchar ch(0);
   CStyle sty;
   unsigned long pos;
   locate(loc);
   int endpos(0);
   QString endmarker("</table>");
   QString startmarker("<table");
   int startpos(0);
   int depth(0);
   while (ch != UEOF)
     {
       parent->getch(ch, sty, pos);
       QChar qc(ch);
       ret += qc;
       if (qc.lower() == endmarker[endpos])
         {
           if ((++endpos >= endmarker.length()) && (--depth <= 0)) break;
         }
       else
         {
           endpos = 0;
         }
       if (qc.lower() == startmarker[startpos])
         {
           if (++startpos >= startmarker.length()) ++depth;
         }
       else
         {
           startpos = 0;
         }
     }
   return ret;
 }
 
 
 extern "C"
 {
   CFilter* newfilter(const QString& s) { return new striphtml(s); }
 }
diff --git a/noncore/apps/tinykate/libkate/document/katehighlight.cpp b/noncore/apps/tinykate/libkate/document/katehighlight.cpp
index 89024f7..ee6030f 100644
--- a/noncore/apps/tinykate/libkate/document/katehighlight.cpp
+++ b/noncore/apps/tinykate/libkate/document/katehighlight.cpp
@@ -1,1468 +1,1470 @@
 /*
    Copyright (C) 1998, 1999 Jochen Wilhelmy
                             digisnap@cs.tu-berlin.de
          (C) 2002, 2001 The Kate Team <kwrite-devel@kde.org>
          (C) 2002 Joseph Wenninger <jowenn@kde.org>
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include "katehighlight.h"
 #include "katetextline.h"
 #include "katedocument.h"
 #include "katesyntaxdocument.h"
 
 #include "kglobal.h"
 //#include "kinstance.h"
 //#include "kmimemagic.h"
 #include "klocale.h"
 //#include "kregexp.h"
 #include "kglobalsettings.h"
 #include "kdebug.h"
 #include "kstddirs.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/config.h>
 
 /* QT */
 #include <qtextstream.h>
 
 /* STD */
 #include <string.h>
 
 
 HlManager *HlManager::s_pSelf = 0;
 
 enum Item_styles { dsNormal,dsKeyword,dsDataType,dsDecVal,dsBaseN,dsFloat,dsChar,dsString,dsComment,dsOthers};
 
 static bool trueBool = true;
 static QString stdDeliminator = QString ("!%&()*+,-./:;<=>?[]^{|}~ \t\\");
 
 int getDefStyleNum(QString name)
 {
   if (name=="dsNormal") return dsNormal;
   if (name=="dsKeyword") return dsKeyword;
   if (name=="dsDataType") return dsDataType;
   if (name=="dsDecVal") return dsDecVal;
   if (name=="dsBaseN") return dsBaseN;
   if (name=="dsFloat") return dsFloat;
   if (name=="dsChar") return dsChar;
   if (name=="dsString") return dsString;
   if (name=="dsComment") return dsComment;
   if (name=="dsOthers")  return dsOthers;
 
   return dsNormal;
 }
 
 bool ustrchr(const QChar *s, uint len, QChar c)
 {
   for (int z=0; z < len; z++)
   {
     if (*s == c) return true;
     s++;
   }
 
   return false;
 }
 
 HlItem::HlItem(int attribute, int context)
   : attr(attribute), ctx(context)  {subItems=0;
 }
 
 HlItem::~HlItem()
 {
   //kdDebug(13010)<<"In hlItem::~HlItem()"<<endl;
   if (subItems!=0) {subItems->setAutoDelete(true); subItems->clear(); delete subItems;}
 }
 
 bool HlItem::startEnable(QChar c)
 {
   return true;
 }
 
 HlCharDetect::HlCharDetect(int attribute, int context, QChar c)
   : HlItem(attribute,context), sChar(c) {
 }
 
 const QChar *HlCharDetect::checkHgl(const QChar *str, int len, bool) {
   if (*str == sChar) return str + 1;
   return 0L;
 }
 
 Hl2CharDetect::Hl2CharDetect(int attribute, int context, QChar ch1, QChar ch2)
   : HlItem(attribute,context) {
   sChar1 = ch1;
   sChar2 = ch2;
 }
 
 const QChar *Hl2CharDetect::checkHgl(const QChar *str, int len, bool) {
   if (str[0] == sChar1 && str[1] == sChar2) return str + 2;
   return 0L;
 }
 
 HlStringDetect::HlStringDetect(int attribute, int context, const QString &s, bool inSensitive)
   : HlItem(attribute, context), str(inSensitive ? s.upper():s), _inSensitive(inSensitive) {
 }
 
 HlStringDetect::~HlStringDetect() {
 }
 
 const QChar *HlStringDetect::checkHgl(const QChar *s, int len, bool) {
   if (!_inSensitive) {if (memcmp(s, str.unicode(), str.length()*sizeof(QChar)) == 0) return s + str.length();}
      else
        {
      QString tmp=QString(s,str.length()).upper();
      if (tmp==str) return s+str.length();
        }
   return 0L;
 }
 
 
 HlRangeDetect::HlRangeDetect(int attribute, int context, QChar ch1, QChar ch2)
   : HlItem(attribute,context) {
   sChar1 = ch1;
   sChar2 = ch2;
 }
 
 const QChar *HlRangeDetect::checkHgl(const QChar *s, int len, bool) {
   if (*s == sChar1)
   {
     do
     {
       s++;
       len--;
       if (len == 0) return 0L;
     }
     while (*s != sChar2);
 
     return s + 1;
   }
   return 0L;
 }
 
 HlKeyword::HlKeyword (int attribute, int context,bool casesensitive, const QChar *deliminator, uint deliLen)
   : HlItem(attribute,context), dict (113, casesensitive)
 {
   deliminatorChars = deliminator;
   deliminatorLen = deliLen;
   _caseSensitive=casesensitive;
 }
 
 HlKeyword::~HlKeyword() {
 }
 
 bool HlKeyword::startEnable(QChar c)
 {
   return ustrchr(deliminatorChars, deliminatorLen, c);
 }
 
 // If we use a dictionary for lookup we don't really need
 // an item as such we are using the key to lookup
 void HlKeyword::addWord(const QString &word)
 {
   words.append(word);
   dict.insert(word,&trueBool);
 }
 
 void HlKeyword::addList(const QStringList& list)
 {
 
  words+=list;
  for(uint i=0;i<list.count();i++) dict.insert(list[i], &trueBool);
 }
 
 const QChar *HlKeyword::checkHgl(const QChar *s, int len, bool b)
 {
   if (len == 0) return 0L;
 
   const QChar *s2 = s;
 
   while ( (len > 0) && (!ustrchr(deliminatorChars, deliminatorLen, *s2)) )
   {
     s2++;
     len--;
   }
 
   if (s2 == s) return 0L;
 
   QString lookup = QString(s,s2-s);
 
   if ( dict.find(lookup) ) return s2;
   return 0L;
 }
 
 HlInt::HlInt(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlInt::checkHgl(const QChar *str, int len, bool) {
   const QChar *s,*s1;
 
   s = str;
   while (s->isDigit()) s++;
   if (s > str)
    {
      if (subItems)
        {
      for (HlItem *it=subItems->first();it;it=subItems->next())
           {
             s1=it->checkHgl(s, len, false);
         if (s1) return s1;
           }
        }
      return s;
   }
   return 0L;
 }
 
 HlFloat::HlFloat(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlFloat::checkHgl(const QChar *s, int len, bool) {
   bool b, p;
   const QChar *s1;
 
   b = false;
   while (s->isDigit()){
     s++;
     b = true;
   }
   if (p = (*s == '.')) {
     s++;
     while (s->isDigit()) {
       s++;
       b = true;
     }
   }
   if (!b) return 0L;
   if ((*s&0xdf) == 'E') s++;
     else
       if (!p) return 0L;
     else
     {
           if (subItems)
             {
           for (HlItem *it=subItems->first();it;it=subItems->next())
                 {
                   s1=it->checkHgl(s, len, false);
               if (s1) return s1;
                 }
             }
           return s;
         }
   if ((*s == '-')||(*s =='+'))  s++;
   b = false;
   while (s->isDigit()) {
     s++;
     b = true;
   }
   if (b)
     {
       if (subItems)
         {
           for (HlItem *it=subItems->first();it;it=subItems->next())
             {
               s1=it->checkHgl(s, len, false);
               if (s1) return s1;
             }
         }
       return s;
    }
    else return 0L;
 }
 
 
 HlCInt::HlCInt(int attribute, int context)
   : HlInt(attribute,context) {
 }
 
 const QChar *HlCInt::checkHgl(const QChar *s, int len, bool lineStart) {
 
 //  if (*s == '0') s++; else s = HlInt::checkHgl(s);
   s = HlInt::checkHgl(s, len, lineStart);
   if (s != 0L) {
     int l = 0;
     int u = 0;
     const QChar *str;
 
     do {
       str = s;
       if ((*s&0xdf) == 'L' ) {
         l++;
         if (l > 2) return 0L;
         s++;
       }
       if ((*s&0xdf) == 'U' ){
         u++;
         if (u > 1) return 0L;
         s++;
       }
     } while (s != str);
   }
   return s;
 }
 
 HlCOct::HlCOct(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlCOct::checkHgl(const QChar *str, int len, bool) {
   const QChar *s;
 
   if (*str == '0') {
     str++;
     s = str;
     while (*s >= '0' && *s <= '7') s++;
     if (s > str) {
       if ((*s&0xdf) == 'L' || (*s&0xdf) == 'U' ) s++;
       return s;
     }
   }
   return 0L;
 }
 
 HlCHex::HlCHex(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlCHex::checkHgl(const QChar *str, int len, bool) {
   const QChar *s=str;
 #if 0
   int i;
   for (i=0;(*s)!='\0';s++,i++);
   QString line(str,i);
   QRegExp3 rx("0[xX][a-fA-F\\d]+[UuLl]?"); // this matches but is also matching parenthesis
   int pos=rx.search(line,0);
   if(pos > -1) return str+rx.matchedLength();
   else
     return 0L;
 
 #else
   if (str[0] == '0' && ((str[1]&0xdf) == 'X' )) {
     str += 2;
     s = str;
     while (s->isDigit() || ((*s&0xdf) >= 'A' && (*s&0xdf) <= 'F') /*|| (*s >= 'a' && *s <= 'f')*/) s++;
     if (s > str) {
       if ((*s&0xdf) == 'L' || (*s&0xdf) == 'U' ) s++;
       return s;
     }
   }
   return 0L;
 #endif
 }
 
 HlCFloat::HlCFloat(int attribute, int context)
   : HlFloat(attribute,context) {
 }
 
 const QChar *HlCFloat::checkHgl(const QChar *s, int len, bool lineStart) {
 
   s = HlFloat::checkHgl(s, len, lineStart);
   if (s && ((*s&0xdf) == 'F' )) s++;
   return s;
 }
 
 HlAnyChar::HlAnyChar(int attribute, int context, const QChar* charList, uint len)
   : HlItem(attribute, context) {
   _charList=charList;
   _charListLen=len;
 }
 
 const QChar *HlAnyChar::checkHgl(const QChar *s, int len, bool)
 {
   if (ustrchr(_charList, _charListLen, *s)) return s +1;
   return 0L;
 }
 
 HlRegExpr::HlRegExpr(int attribute, int context,QString regexp)
   : HlItem(attribute, context), Expr(0) {
 
     handlesLinestart=regexp.startsWith("^");
     if(!handlesLinestart) regexp.prepend("^");
     Expr=new QRegExp3(regexp);
 }
 
 HlRegExpr::~HlRegExpr()
 {
     delete Expr;
 }
 
 const QChar *HlRegExpr::checkHgl(const QChar *s, int len, bool lineStart)
 {
   if ((!lineStart) && handlesLinestart) return 0;
 
   QString line(s,len);
   int pos = Expr->search( line, 0 );
   if (pos==-1) return 0L;
     else
      return (s+Expr->matchedLength());
 };
 
 
 HlLineContinue::HlLineContinue(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlLineContinue::checkHgl(const QChar *s, int len, bool) {
 
   if ((s[0].latin1() == '\\') && (len == 1))
     {
            return s + 1;
     }
   return 0L;
 }
 
 
 HlCStringChar::HlCStringChar(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 //checks for hex and oct (for example \x1b or \033)
 const QChar *checkCharHexOct(const QChar *str) {
   const QChar *s;
         s=str;
         int n;
   if (*s == 'x') {
     n = 0;
     do {
       s++;
       n *= 16;
       if (s->isDigit()) n += *s - '0';
       else if ((*s&0xdf) >= 'A' && (*s&0xdf) <= 'F') n += (*s&0xdf) - 'A' + 10;
 //      else if (*s >= 'a' && *s <= 'f') n += *s - 'a' + 10;
       else break;
       if (n >= 256) return 0L;
     } while (true);
     if (s - str == 1) return 0L;
   } else {
     if (!(*s >= '0' && *s <= '7')) return 0L;
     n = *s - '0';
     do {
       s++;
       n *= 8;
       if (*s >= '0' && *s <= '7') n += *s - '0'; else break;
       if (n >= 256) return s;
     } while (s - str < 3);
   }
   return s;
 }
 // checks for C escaped chars \n and escaped hex/octal chars
 const QChar *checkEscapedChar(const QChar *s, int len) {
   int i;
   if (s[0] == '\\' && (len > 1) ) {
         s++;
         switch(*s){
                 case  'a': // checks for control chars
                 case  'b': // we want to fall through
                 case  'e':
                 case  'f':
 
                 case  'n':
                 case  'r':
                 case  't':
                 case  'v':
                 case '\'':
                 case '\"':
                 case '?' : // added ? ANSI C classifies this as an escaped char
                 case '\\': s++;
                            break;
                 case 'x': // if it's like \xff
                         s++; // eat the x
                         // these for loops can probably be
                         // replaced with something else but
                         // for right now they work
                         // check for hexdigits
                         for(i=0;i<2 &&(*s >= '0' && *s <= '9' || (*s&0xdf) >= 'A' && (*s&0xdf) <= 'F');i++,s++);
                         if(i==0) return 0L; // takes care of case '\x'
                         break;
 
                 case '0': case '1': case '2': case '3' :
                 case '4': case '5': case '6': case '7' :
                         for(i=0;i < 3 &&(*s >='0'&& *s<='7');i++,s++);
                         break;
                         default: return 0L;
         }
   return s;
   }
   return 0L;
 }
 
 const QChar *HlCStringChar::checkHgl(const QChar *str, int len, bool) {
   return checkEscapedChar(str, len);
 }
 
 
 HlCChar::HlCChar(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlCChar::checkHgl(const QChar *str, int len, bool) {
   const QChar *s;
 
   if ((len > 1) && (str[0] == '\'') && (str[1] != '\''))
   {
     s = checkEscapedChar(&str[1], len); //try to match escaped char
     if (!s) s = &str[2];           //match single non-escaped char
     if (*s == '\'') return s + 1;
   }
   return 0L;
 }
 
 
 //--------
 ItemStyle::ItemStyle() : selCol(Qt::white), bold(false), italic(false) {
 }
 
 ItemStyle::ItemStyle(const QColor &col, const QColor &selCol,
   bool bold, bool italic)
   : col(col), selCol(selCol), bold(bold), italic(italic) {
 }
 
 ItemData::ItemData(const QString  name, int defStyleNum)
   : name(name), defStyleNum(defStyleNum), defStyle(true) {
 }
 
 ItemData::ItemData(const QString name, int defStyleNum,
   const QColor &col, const QColor &selCol, bool bold, bool italic)
   : ItemStyle(col,selCol,bold,italic), name(name), defStyleNum(defStyleNum),
   defStyle(false) {
 }
 
 HlData::HlData(const QString &wildcards, const QString &mimetypes, const QString &identifier)
   : wildcards(wildcards), mimetypes(mimetypes), identifier(identifier) {
 
 //JW  itemDataList.setAutoDelete(true);
 }
 
 HlContext::HlContext(int attribute, int lineEndContext, int _lineBeginContext)
   : attr(attribute), ctx(lineEndContext),lineBeginContext(_lineBeginContext) {
   items.setAutoDelete(true);
 }
 
 Hl2CharDetect::Hl2CharDetect(int attribute, int context, const QChar *s)
   : HlItem(attribute,context) {
   sChar1 = s[0];
   sChar2 = s[1];
 }
 
 Highlight::Highlight(syntaxModeListItem *def) : refCount(0)
 {
   noHl = false;
 
   if (def == 0)
   {
     noHl = true;
     iName = I18N_NOOP("Normal");
     iSection = "";
   }
   else
   {
     iName = def->name;
     iSection = def->section;
     iWildcards = def->extension;
     iMimetypes = def->mimetype;
     identifier = def->identifier;
   }
   deliminator = stdDeliminator;
   deliminatorChars = deliminator.unicode();
   deliminatorLen = deliminator.length();
 }
 
 Highlight::~Highlight()
 {
 }
 
 int Highlight::doHighlight(int ctxNum, TextLine *textLine)
 {
   if (noHl)
   {
     textLine->setAttribs(0,0,textLine->length());
     textLine->setAttr(0);
     return 0;
   }
 
   HlContext *context;
   const QChar *s2;
   HlItem *item;
 
   context = contextList[ctxNum];
   if (context->lineBeginContext!=-1)
   {
     ctxNum=context->lineBeginContext;
     context=contextList[ctxNum];
   }
 
   QChar lastChar = ' ';
 
   // first char
   const QChar *str = textLine->getText();
 
   // non space char - index of that char
   const QChar *s1 = textLine->firstNonSpace();
   uint z = textLine->firstChar();
 
   // length of textline
   uint len = textLine->length();
 
   bool found = false;
   while (z < len)
   {
     found = false;
 
     for (item = context->items.first(); item != 0L; item = context->items.next())
     {
       if (item->startEnable(lastChar))
       {
         s2 = item->checkHgl(s1, len-z, z==0);
         if (s2 > s1)
         {
         odebug << "An item has been detected" << oendl;
             textLine->setAttribs(item->attr,s1 - str,s2 - str);
             ctxNum = item->ctx;
             context = contextList[ctxNum];
             z = z + s2 - s1 - 1;
             s1 = s2 - 1;
             found = true;
             break;
         }
       }
     }
 
     // nothing found: set attribute of one char
     if (!found)
       textLine->setAttribs(context->attr,s1 - str,s1 - str + 1);
 
     lastChar = *s1;
     s1++;
     z++;
   }
 
   //set "end of line"-properties
   textLine->setAttr(context->attr);
 
   //return new context
   return context->ctx;
 }
 
 KateConfig *Highlight::getKateConfig() {
   KateConfig *config;
   config=KGlobal::config();
   config->setGroup(iName + QString(" Highlight"));
   return config;
 }
 
 QString Highlight::getWildcards() {
   KateConfig *config;
 
   config = getKateConfig();
 
   //if wildcards not yet in config, then use iWildCards as default
   return config->readEntry("Wildcards", iWildcards);
 }
 
 
 QString Highlight::getMimetypes() {
   KateConfig *config;
 
   config = getKateConfig();
 
   return config->readEntry("Mimetypes", iMimetypes);
 }
 
 
 HlData *Highlight::getData() {
   KateConfig *config;
   HlData *hlData;
 
   config = getKateConfig();
 
 //  iWildcards = config->readEntry("Wildcards");
 //  iMimetypes = config->readEntry("Mimetypes");
 //  hlData = new HlData(iWildcards,iMimetypes);
   hlData = new HlData(
     config->readEntry("Wildcards", iWildcards),
     config->readEntry("Mimetypes", iMimetypes),
     config->readEntry("Identifier", identifier));
   getItemDataList(hlData->itemDataList, config);
   return hlData;
 }
 
 void Highlight::setData(HlData *hlData) {
   KateConfig *config;
 
   config = getKateConfig();
 
 //  iWildcards = hlData->wildcards;
 //  iMimetypes = hlData->mimetypes;
 
   config->writeEntry("Wildcards",hlData->wildcards);
   config->writeEntry("Mimetypes",hlData->mimetypes);
 
   setItemDataList(hlData->itemDataList,config);
 }
 
 void Highlight::getItemDataList(ItemDataList &list) {
   KateConfig *config;
 
   config = getKateConfig();
   getItemDataList(list, config);
 }
 
 void Highlight::getItemDataList(ItemDataList &list, KateConfig *config) {
   ItemData *p;
   QString s;
   QRgb col, selCol;
 
   list.clear();
 //JW  list.setAutoDelete(true);
   createItemData(list);
 
   for (p = list.first(); p != 0L; p = list.next()) {
     s = config->readEntry(p->name);
     if (!s.isEmpty()) {
       sscanf(s.latin1(),"%d,%X,%X,%d,%d", &p->defStyle,&col,&selCol,&p->bold,&p->italic);
       p->col.setRgb(col);
       p->selCol.setRgb(selCol);
     }
   }
 }
 
 /*******************************************************************************************
         Highlight - setItemDataList
         saves the ItemData / attribute / style definitions to the apps configfile.
         Especially needed for user overridden values.
 
                         * input: ItemDataList &list             :reference to the list, whose
                         *                                        items should be saved
                         *        KateConfig *config                :Pointer KDE configuration
                         *                                        class, which should be used
                         *                                        as storage
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::setItemDataList(ItemDataList &list, KateConfig *config) {
   ItemData *p;
   QString s;
 
   for (p = list.first(); p != 0L; p = list.next()) {
     s.sprintf("%d,%X,%X,%d,%d",
       p->defStyle,p->col.rgb(),p->selCol.rgb(),p->bold,p->italic);
     config->writeEntry(p->name,s);
   }
 }
 
 
 /*******************************************************************************************
         Highlight - use
         Increase the usage count and trigger initialization if needed
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::use()
 {
   if (refCount == 0) init();
   refCount++;
 }
 
 
 /*******************************************************************************************
         Highlight - release
         Decrease the usage count and trigger a cleanup if needed
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::release()
 {
   refCount--;
   if (refCount == 0) done();
 }
 
 /*******************************************************************************************
         Highlight - init
         If it's the first time a particular highlighting is used create the needed contextlist
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::init()
 {
   if (noHl)
     return;
 
   for (int z = 0; z < nContexts; z++) contextList[z] = 0L;
   makeContextList();
 }
 
 
 /*******************************************************************************************
         Highlight - done
         If the there is no document using the highlighting style free the complete context
         structure.
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::done()
 {
   if (noHl)
     return;
 
   for (int z = 0; z < nContexts; z++) delete contextList[z];
 }
 
 
 /*******************************************************************************************
         Highlight - createItemData
         This function reads the itemData entries from the config file, which specifies the
         default attribute styles for matched items/contexts.
 
                         * input: none
                         *************
                         * output: ItemDataList &list            :A reference to the internal
                                                                 list containing the parsed
                                                                 default config
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::createItemData(ItemDataList &list)
 {
     odebug << "Highlight::createItemData" << oendl;
 
   // If no highlighting is selected we need only one default.
   if (noHl)
   {
      list.append(new ItemData(I18N_NOOP("Normal Text"), dsNormal));
      return;
   }
 
   QString color;
   QString selColor;
   QString bold;
   QString italic;
 
   // If the internal list isn't already available read the config file
   if (internalIDList.count()==0)
   {
     //if all references to the list are destried the contents will also be deleted
     internalIDList.setAutoDelete(true);
     syntaxContextData *data;
 
     odebug << "Trying to read itemData section" << oendl;
 
     //Tell the syntax document class which file we want to parse and which data group
     HlManager::self()->syntax->setIdentifier(identifier);
     data=HlManager::self()->syntax->getGroupInfo("highlighting","itemData");
     //begin with the real parsing
     while (HlManager::self()->syntax->nextGroup(data))
       {
     odebug << "Setting up one itemData element" << oendl;
         // read all attributes
         color=HlManager::self()->syntax->groupData(data,QString("color"));
         selColor=HlManager::self()->syntax->groupData(data,QString("selColor"));
         bold=HlManager::self()->syntax->groupData(data,QString("bold"));
         italic=HlManager::self()->syntax->groupData(data,QString("italic"));
         //check if the user overrides something
         if ( (!color.isEmpty()) && (!selColor.isEmpty()) && (!bold.isEmpty()) && (!italic.isEmpty()))
                 {
                         //create a user defined style
                         internalIDList.append(new ItemData(
                                 HlManager::self()->syntax->groupData(data,QString("name")).simplifyWhiteSpace(),
                                 getDefStyleNum(HlManager::self()->syntax->groupData(data,QString("defStyleNum"))),
                                 QColor(color),QColor(selColor),(bold=="true") || (bold=="1"), (italic=="true") || (italic=="1")
                                 ));
                 }
         else
                 {
                         //assign a default style
                         internalIDList.append(new ItemData(
                                 HlManager::self()->syntax->groupData(data,QString("name")).simplifyWhiteSpace(),
                                 getDefStyleNum(HlManager::self()->syntax->groupData(data,QString("defStyleNum")))));
 
                 }
       }
     //clean up
     if (data) HlManager::self()->syntax->freeGroupInfo(data);
   }
 
   //set the ouput reference
   list=internalIDList;
 }
 
 
 /*******************************************************************************************
         Highlight - lookupAttrName
         This function is  a helper for makeContextList and createHlItem. It looks the given
         attribute name in the itemData list up and returns it's index
 
                         * input: QString &name                  :the attribute name to lookup
                         *        ItemDataList &iDl               :the list containing all
                         *                                         available attributes
                         *************
                         * output: none
                         *************
                         * return value: int                     :The index of the attribute
                         *                                        or 0
 *******************************************************************************************/
 
 int  Highlight::lookupAttrName(const QString& name, ItemDataList &iDl)
 {
     for (int i=0;i<iDl.count();i++)
         {
             if (iDl.at(i)->name==name) return i;
         }
     kdDebug(13010)<<"Couldn't resolve itemDataName"<<endl;
     return 0;
 }
 
 
 /*******************************************************************************************
         Highlight - createHlItem
         This function is  a helper for makeContextList. It parses the xml file for
         information, how single or multi line comments are marked
 
                         * input: syntaxContextData *data : Data about the item read from
                         *                                  the xml file
                         *        ItemDataList &iDl :       List of all available itemData
                         *                                   entries. Needed for attribute
                         *                                   name->index translation
                         *************
                         * output: none
                         *************
                         * return value: HlItem * :          Pointer to the newly created item
                         *                                   object
 *******************************************************************************************/
 
 HlItem *Highlight::createHlItem(syntaxContextData *data, ItemDataList &iDl)
 {
   // No highlighting -> exit
   if (noHl)
     return 0;
 
                 // get the (tagname) itemd type
                 QString dataname=HlManager::self()->syntax->groupItemData(data,QString(""));
 
                 // BEGIN - Translation of the attribute parameter
                 QString tmpAttr=HlManager::self()->syntax->groupItemData(data,QString("attribute")).simplifyWhiteSpace();
                 int attr;
                 if (QString("%1").arg(tmpAttr.toInt())==tmpAttr)
                   attr=tmpAttr.toInt();
                 else
                   attr=lookupAttrName(tmpAttr,iDl);
                 // END - Translation of the attribute parameter
 
                 // Info about context switch
                 int context=((HlManager::self()->syntax->groupItemData(data,QString("context"))).toInt());
 
                 // Get the char parameter (eg DetectChar)
                 char chr;
                 if (! HlManager::self()->syntax->groupItemData(data,QString("char")).isEmpty())
                   chr= (HlManager::self()->syntax->groupItemData(data,QString("char")).latin1())[0];
                 else
                   chr=0;
 
                 // Get the String parameter (eg. StringDetect)
                 QString stringdata=HlManager::self()->syntax->groupItemData(data,QString("String"));
 
                 // Get a second char parameter (char1) (eg Detect2Chars)
                 char chr1;
                 if (! HlManager::self()->syntax->groupItemData(data,QString("char1")).isEmpty())
                   chr1= (HlManager::self()->syntax->groupItemData(data,QString("char1")).latin1())[0];
                 else
                   chr1=0;
 
                 // Will be removed eventuall. Atm used for StringDetect
                 bool insensitive=(HlManager::self()->syntax->groupItemData(data,QString("insensitive"))==QString("TRUE"));
 
 
                 //Create the item corresponding to it's type and set it's parameters
                 if (dataname=="keyword")
                 {
                   HlKeyword *keyword=new HlKeyword(attr,context,casesensitive,
                      deliminatorChars, deliminatorLen);
 
                    //Get the entries for the keyword lookup list
                   keyword->addList(HlManager::self()->syntax->finddata("highlighting",stringdata));
                   return keyword;
                 } else
                 if (dataname=="Float") return (new HlFloat(attr,context)); else
                 if (dataname=="Int") return(new HlInt(attr,context)); else
                 if (dataname=="DetectChar") return(new HlCharDetect(attr,context,chr)); else
                 if (dataname=="Detect2Chars") return(new Hl2CharDetect(attr,context,chr,chr1)); else
                 if (dataname=="RangeDetect") return(new HlRangeDetect(attr,context, chr, chr1)); else
                 if (dataname=="LineContinue") return(new HlLineContinue(attr,context)); else
                 if (dataname=="StringDetect") return(new HlStringDetect(attr,context,stringdata,insensitive)); else
                 if (dataname=="AnyChar") return(new HlAnyChar(attr,context,stringdata.unicode(), stringdata.length())); else
                 if (dataname=="RegExpr") return(new HlRegExpr(attr,context,stringdata)); else
                 if(dataname=="HlCChar") return ( new HlCChar(attr,context));else
                 if(dataname=="HlCHex") return (new HlCHex(attr,context));else
                 if(dataname=="HlCOct") return (new HlCOct(attr,context)); else
                 if(dataname=="HlCStringChar") return (new HlCStringChar(attr,context)); else
 
                   {
                     // oops, unknown type. Perhaps a spelling error in the xml file
                     return 0;
                   }
 
 
 }
 
 
 /*******************************************************************************************
         Highlight - isInWord
 
                         * input: Qchar c       Character to investigate
                         *************
                         * output: none
                         *************
                         * return value: returns true, if c is no deliminator
 *******************************************************************************************/
 
 bool Highlight::isInWord(QChar c)
 {
   return !ustrchr(deliminatorChars, deliminatorLen, c);
 }
 
 
 
 /*******************************************************************************************
         Highlight - readCommentConfig
         This function is  a helper for makeContextList. It parses the xml file for
         information, how single or multi line comments are marked
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 void Highlight::readCommentConfig()
 {
 
   cslStart = "";
   HlManager::self()->syntax->setIdentifier(identifier);
 
   syntaxContextData *data=HlManager::self()->syntax->getGroupInfo("general","comment");
   if (data)
     {
 //      kdDebug(13010)<<"COMMENT DATA FOUND"<<endl;
     while  (HlManager::self()->syntax->nextGroup(data))
       {
 
         if (HlManager::self()->syntax->groupData(data,"name")=="singleLine")
         cslStart=HlManager::self()->syntax->groupData(data,"start");
     if (HlManager::self()->syntax->groupData(data,"name")=="multiLine")
            {
         cmlStart=HlManager::self()->syntax->groupData(data,"start");
         cmlEnd=HlManager::self()->syntax->groupData(data,"end");
            }
       }
     HlManager::self()->syntax->freeGroupInfo(data);
     }
 
 }
 
 /*******************************************************************************************
         Highlight - readGlobalKeyWordConfig
         This function is  a helper for makeContextList. It parses the xml file for
         information, if keywords should be treated case(in)sensitive and creates the keyword
         delimiter list. Which is the default list, without any given weak deliminiators
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 
 void Highlight::readGlobalKeywordConfig()
 {
   // Tell the syntax document class which file we want to parse
   HlManager::self()->syntax->setIdentifier(identifier);
 
   // Get the keywords config entry
   syntaxContextData * data=HlManager::self()->syntax->getConfig("general","keywords");
   if (data)
     {
     kdDebug(13010)<<"Found global keyword config"<<endl;
 
         if (HlManager::self()->syntax->groupItemData(data,QString("casesensitive"))!="0")
         casesensitive=true; else {casesensitive=false; kdDebug(13010)<<"Turning on case insensitiveness"<<endl;}
      //get the weak deliminators
      weakDeliminator=(!HlManager::self()->syntax->groupItemData(data,QString("weakDeliminator")));
 
      // remove any weakDelimitars (if any) from the default list and store this list.
      int f;
      for (int s=0; s < weakDeliminator.length(); s++)
      {
         f = 0;
         f = deliminator.find (weakDeliminator[s]);
 
         if (f > -1)
           deliminator.remove (f, 1);
      }
 
      deliminatorChars = deliminator.unicode();
      deliminatorLen = deliminator.length();
 
     HlManager::self()->syntax->freeGroupInfo(data);
     }
   else
     {
        //Default values
        casesensitive=true;
        weakDeliminator=QString("");
     }
 
 }
 
 /*******************************************************************************************
         Highlight - makeContextList
         That's the most important initialization function for each highlighting. It's called
         each time a document gets a highlighting style assigned. parses the xml file and
         creates a corresponding internal structure
 
                         * input: none
                         *************
                         * output: none
                         *************
                         * return value: none
 *******************************************************************************************/
 
 
 void Highlight::makeContextList()
 {
   if (noHl)
     return;
 
   HlKeyword *keyword=0, *dataType=0;
   syntaxContextData *data, *datasub;
   HlItem *c;
 
   readCommentConfig();
   readGlobalKeywordConfig();
 
   // Let the syntax document class know, which file we'd like to parse
   HlManager::self()->syntax->setIdentifier(identifier);
 
   // This list is needed for the translation of the attribute parameter, if the itemData name is given instead of the index
   ItemDataList iDl;
   createItemData(iDl);
 
   //start the real work
   data=HlManager::self()->syntax->getGroupInfo("highlighting","context");
   int i=0;
   if (data)
     {
       while (HlManager::self()->syntax->nextGroup(data))
         {
 
           // BEGIN - Translation of the attribute parameter
           QString tmpAttr=HlManager::self()->syntax->groupData(data,QString("attribute")).simplifyWhiteSpace();
           int attr;
           if (QString("%1").arg(tmpAttr.toInt())==tmpAttr)
             attr=tmpAttr.toInt();
           else
             attr=lookupAttrName(tmpAttr,iDl);
           // END - Translation of the attribute parameter
 
           contextList[i]=new HlContext(
             attr,
             (HlManager::self()->syntax->groupData(data,QString("lineEndContext"))).toInt(),
             (HlManager::self()->syntax->groupData(data,QString("lineBeginContext"))).isEmpty()?-1:
             (HlManager::self()->syntax->groupData(data,QString("lineBeginContext"))).toInt());
 
 
             //Let's create all items for the context
             while (HlManager::self()->syntax->nextItem(data))
               {
 //      kdDebug(13010)<< "In make Contextlist: Item:"<<endl;
         c=createHlItem(data,iDl);
         if (c)
             {
                                 contextList[i]->items.append(c);
 
                                 // Not supported completely atm and only one level. Subitems.(all have to be matched to at once)
                 datasub=HlManager::self()->syntax->getSubItems(data);
                 bool tmpbool;
                 if (tmpbool=HlManager::self()->syntax->nextItem(datasub))
                     {
                                           c->subItems=new QList<HlItem>;
                       for (;tmpbool;tmpbool=HlManager::self()->syntax->nextItem(datasub))
                                             c->subItems->append(createHlItem(datasub,iDl));
                                         }
                 HlManager::self()->syntax->freeGroupInfo(datasub);
                                 // end of sublevel
             }
 //      kdDebug(13010)<<"Last line in loop"<<endl;
               }
           i++;
         }
       }
 
   HlManager::self()->syntax->freeGroupInfo(data);
 
 
 }
 
 HlManager::HlManager() : QObject(0L)
 {
   syntax = new SyntaxDocument();
   SyntaxModeList modeList = syntax->modeList();
 
   hlList.setAutoDelete(true);
   hlList.append(new Highlight(0));
 
   uint i=0;
   while (i < modeList.count())
   {
     hlList.append(new Highlight(modeList.at(i)));
     i++;
   }
 }
 
 HlManager::~HlManager() {
   if(syntax) delete syntax;
 }
 
 HlManager *HlManager::self()
 {
   if ( !s_pSelf )
     s_pSelf = new HlManager;
   return s_pSelf;
 }
 
 Highlight *HlManager::getHl(int n) {
   if (n < 0 || n >= (int) hlList.count()) n = 0;
   return hlList.at(n);
 }
 
 int HlManager::defaultHl() {
   KateConfig *config;
   config = KGlobal::config();
   config->setGroup("General Options");
 
 #warning fixme  return nameFind(config->readEntry("Highlight"));
 
 }
 
 
 int HlManager::nameFind(const QString &name) {
   int z;
 
   for (z = hlList.count() - 1; z > 0; z--) {
     if (hlList.at(z)->iName == name) break;
   }
   return z;
 }
 
 int HlManager::wildcardFind(const QString &fileName) {
   Highlight *highlight;
   int p1, p2;
   QString w;
   for (highlight = hlList.first(); highlight != 0L; highlight = hlList.next()) {
     p1 = 0;
     w = highlight->getWildcards();
     while (p1 < (int) w.length()) {
       p2 = w.find(';',p1);
       if (p2 == -1) p2 = w.length();
       if (p1 < p2) {
         QRegExp regExp(w.mid(p1,p2 - p1),true,true);
         if (regExp.match(fileName) == 0) return hlList.at();
       }
       p1 = p2 + 1;
     }
   }
   return -1;
 }
 
 
 int HlManager::makeAttribs(Highlight *highlight, Attribute *a, int maxAttribs) {
   ItemStyleList defaultStyleList;
-  ItemStyle *defaultStyle;
+  ItemStyle *defaultStyle = 0;
   ItemDataList itemDataList;
   ItemData *itemData;
   int nAttribs, z;
 
   odebug << "HlManager::makeAttribs" << oendl;
 
   defaultStyleList.setAutoDelete(true);
   getDefaults(defaultStyleList);
 
 //  itemDataList.setAutoDelete(true);
   highlight->getItemDataList(itemDataList);
   nAttribs = itemDataList.count();
   for (z = 0; z < nAttribs; z++) {
-    odebug << "HlManager::makeAttribs: createing one attribute definition" << oendl;
+    odebug << "HlManager::makeAttribs: creating an attribute definition" << oendl;
     itemData = itemDataList.at(z);
     if (itemData->defStyle) {
       // default style
       defaultStyle = defaultStyleList.at(itemData->defStyleNum);
       a[z].col = defaultStyle->col;
       a[z].selCol = defaultStyle->selCol;
       a[z].bold = defaultStyle->bold;
       a[z].italic = defaultStyle->italic;
     } else {
       // custom style
       a[z].col = itemData->col;
       a[z].selCol = itemData->selCol;
       a[z].bold = itemData->bold;
       a[z].italic = itemData->italic;
     }
   }
 
   for (; z < maxAttribs; z++) {
     a[z].col = black;
     a[z].selCol = black;
-    a[z].bold = defaultStyle->bold;
-    a[z].italic = defaultStyle->italic;
+    if (defaultStyle) {
+      a[z].bold = defaultStyle->bold;
+      a[z].italic = defaultStyle->italic;
+    }
   }
   return nAttribs;
 }
 
 int HlManager::defaultStyles() {
   return 10;
 }
 
 QString HlManager::defaultStyleName(int n)
 {
   static QStringList names;
 
   if (names.isEmpty())
   {
     names << i18n("Normal");
     names << i18n("Keyword");
     names << i18n("Data Type");
     names << i18n("Decimal/Value");
     names << i18n("Base-N Integer");
     names << i18n("Floating Point");
     names << i18n("Character");
     names << i18n("String");
     names << i18n("Comment");
     names << i18n("Others");
   }
 
   return names[n];
 }
 
 void HlManager::getDefaults(ItemStyleList &list) {
   KateConfig *config;
   int z;
   ItemStyle *i;
   QString s;
   QRgb col, selCol;
 
   list.setAutoDelete(true);
   //ItemStyle(color, selected color, bold, italic)
   list.append(new ItemStyle(black,white,false,false));     //normal
   list.append(new ItemStyle(black,white,true,false));      //keyword
   list.append(new ItemStyle(darkRed,white,false,false));   //datatype
   list.append(new ItemStyle(blue,cyan,false,false));       //decimal/value
   list.append(new ItemStyle(darkCyan,cyan,false,false));   //base n
   list.append(new ItemStyle(darkMagenta,cyan,false,false));//float
   list.append(new ItemStyle(magenta,magenta,false,false)); //char
   list.append(new ItemStyle(red,red,false,false));         //string
   list.append(new ItemStyle(darkGray,gray,false,true));    //comment
   list.append(new ItemStyle(darkGreen,green,false,false)); //others
 
 #warning fixme
 /*
   config = KateFactory::instance()->config();
   config->setGroup("Default Item Styles");
   for (z = 0; z < defaultStyles(); z++) {
     i = list.at(z);
     s = config->readEntry(defaultStyleName(z));
     if (!s.isEmpty()) {
       sscanf(s.latin1(),"%X,%X,%d,%d",&col,&selCol,&i->bold,&i->italic);
       i->col.setRgb(col);
       i->selCol.setRgb(selCol);
     }
   }
 */
 }
 
 void HlManager::setDefaults(ItemStyleList &list) {
   KateConfig *config;
   int z;
   ItemStyle *i;
   char s[64];
 #warning fixme
 /*
   config =  KateFactory::instance()->config();
   config->setGroup("Default Item Styles");
   for (z = 0; z < defaultStyles(); z++) {
     i = list.at(z);
     sprintf(s,"%X,%X,%d,%d",i->col.rgb(),i->selCol.rgb(),i->bold, i->italic);
     config->writeEntry(defaultStyleName(z),s);
   }
 */
   emit changed();
 }
 
 
 int HlManager::highlights() {
   return (int) hlList.count();
 }
 
 QString HlManager::hlName(int n) {
   return hlList.at(n)->iName;
 }
 
 QString HlManager::hlSection(int n) {
   return hlList.at(n)->iSection;
 }
 
 void HlManager::getHlDataList(HlDataList &list) {
   int z;
 
   for (z = 0; z < (int) hlList.count(); z++) {
     list.append(hlList.at(z)->getData());
   }
 }
 
 void HlManager::setHlDataList(HlDataList &list) {
   int z;
 
   for (z = 0; z < (int) hlList.count(); z++) {
     hlList.at(z)->setData(list.at(z));
   }
   //notify documents about changes in highlight configuration
   emit changed();
 }
diff --git a/noncore/net/ftplib/ftplib.c b/noncore/net/ftplib/ftplib.c
index addf9d2..ce4c05f 100644
--- a/noncore/net/ftplib/ftplib.c
+++ b/noncore/net/ftplib/ftplib.c
@@ -1,1354 +1,1354 @@
 /***************************************************************************/
 /* ftplib.c - callable ftp access routines           */
 /* Copyright (C) 1996-2000 Thomas Pfau, pfau@cnj.digex.net       */
 /*  73 Catherine Street, South Bound Brook, NJ, 08880      */
 /*                     */
 /* This library is free software; you can redistribute it and/or     */
 /* modify it under the terms of the GNU Library General Public       */
 /* License as published by the Free Software Foundation; either      */
 /* version 2 of the License, or (at your option) any later version.    */
 /*                     */
 /* This library is distributed in the hope that it will be useful,     */
 /* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     */
 /* Library General Public License for more details.        */
 /*                     */
 /* You should have received a copy of the GNU Library General Public     */
 /* License along with this progam; if not, write to the        */
 /* Free Software Foundation, Inc., 59 Temple Place - Suite 330,      */
 /* Boston, MA 02111-1307, USA.               */
 /*                     */
 /***************************************************************************/
 // changes made by Lorn Potter <llornkcor@handhelds.org>
 // 
 #if defined(__unix__) || defined(__VMS)
 #include <unistd.h>
 #endif
 #if defined(_WIN32)
 #include <windows.h>
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <ctype.h>
 
 #if defined(__unix__)
 
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <arpa/inet.h>
 
 #elif defined(VMS)
 
 #include <types.h>
 #include <socket.h>
 #include <in.h>
 #include <netdb.h>
 #include <inet.h>
 
 #elif defined(_WIN32)
 
 #include <winsock.h>
 
 #endif
 
 #define BUILDING_LIBRARY
 #include "ftplib.h"
 
 #if defined(_WIN32)
 #define SETSOCKOPT_OPTVAL_TYPE (const char *)
 #else
 #define SETSOCKOPT_OPTVAL_TYPE (void *)
 #endif
 
 #define FTPLIB_BUFSIZ 8192
 #define ACCEPT_TIMEOUT 10
 
 #define FTPLIB_CONTROL 0
 #define FTPLIB_READ 1
 #define FTPLIB_WRITE 2
 
 #if !defined FTPLIB_DEFMODE
 #define FTPLIB_DEFMODE FTPLIB_PASSIVE
 #endif
 
 struct NetBuf {
     char *cput,*cget;
     int handle;
     int cavail,cleft;
     char *buf;
     int dir;
     netbuf *ctrl;
     netbuf *data;    
     int cmode;
     struct timeval idletime;
     FtpCallback idlecb;
     void *idlearg;
     int xfered;
     int cbbytes;
     int xfered1;
     char response[256];
 };
 
 static char *version =
 "ftplib Release 3.1-1 9/16/00, copyright 1996-2000 Thomas Pfau";
 
 GLOBALDEF int ftplib_debug = 0;
 
 #if defined(__unix__) || defined(VMS)
 #define net_read read
 #define net_write write
 #define net_close close
 #elif defined(_WIN32)
 #define net_read(x,y,z) recv(x,y,z,0)
 #define net_write(x,y,z) send(x,y,z,0)
 #define net_close closesocket
 #endif
 
 #if defined(NEED_MEMCCPY)
 /*
  * VAX C does not supply a memccpy routine so I provide my own
  */
 void *memccpy(void *dest, const void *src, int c, size_t n)
 {
     int i=0;
     const unsigned char *ip=src;
     unsigned char *op=dest;
 
     while (i < n)
       {
           if ((*op++ = *ip++) == c)
               break;
           i++;
       }
     if (i == n)
         return NULL;
     return op;
 }
 #endif
 #if defined(NEED_STRDUP)
 /*
  * strdup - return a malloc'ed copy of a string
  */
 char *strdup(const char *src)
 {
     int l = strlen(src) + 1;
     char *dst = malloc(l);
     if (dst)
         strcpy(dst,src);
     return dst;
 }
 #endif
 
 /*
  * socket_wait - wait for socket to receive or flush data
  *
  * return 1 if no user callback, otherwise, return value returned by
  * user callback
  */
 static int socket_wait(netbuf *ctl)
 {
     fd_set fd,*rfd = NULL,*wfd = NULL;
     struct timeval tv;
     int rv = 0;
     if ((ctl->dir == FTPLIB_CONTROL) || (ctl->idlecb == NULL))
         return 1;
     if (ctl->dir == FTPLIB_WRITE)
         wfd = &fd;
     else
         rfd = &fd;
     FD_ZERO(&fd);
     do
       {
           FD_SET(ctl->handle,&fd);
           tv = ctl->idletime;
           rv = select(ctl->handle+1, rfd, wfd, NULL, &tv);
           if (rv == -1)
             {
                 rv = 0;
                 strncpy(ctl->ctrl->response, strerror(errno),
                         sizeof(ctl->ctrl->response));
                 break;
             }
           else if (rv > 0)
             {
                 rv = 1;
                 break;
             }
       }
     while ((rv = ctl->idlecb(ctl, ctl->xfered, ctl->idlearg)));
     return rv;
 }
 
 /*
  * read a line of text
  *
  * return -1 on error or bytecount
  */
 static int readline(char *buf,int max,netbuf *ctl)
 {
     int x,retval = 0;
     char *end,*bp=buf;
     int eof = 0;
 
     if ((ctl->dir != FTPLIB_CONTROL) && (ctl->dir != FTPLIB_READ))
         return -1;
     if (max == 0)
         return 0;
     do
       {
           if (ctl->cavail > 0)
             {
                 x = (max >= ctl->cavail) ? ctl->cavail : max-1;
                 end = memccpy(bp,ctl->cget,'\n',x);
                 if (end != NULL)
                     x = end - bp;
                 retval += x;
                 bp += x;
                 *bp = '\0';
                 max -= x;
                 ctl->cget += x;
                 ctl->cavail -= x;
                 if (end != NULL)
                   {
                       bp -= 2;
                       if (strcmp(bp,"\r\n") == 0)
                         {
                             *bp++ = '\n';
                             *bp++ = '\0';
                             --retval;
                         }
                       break;
                   }
             }
           if (max == 1)
             {
                 *buf = '\0';
                 break;
             }
           if (ctl->cput == ctl->cget)
             {
                 ctl->cput = ctl->cget = ctl->buf;
                 ctl->cavail = 0;
                 ctl->cleft = FTPLIB_BUFSIZ;
             }
           if (eof)
             {
                 if (retval == 0)
                     retval = -1;
                 break;
             }
           if (!socket_wait(ctl))
               return retval;
           if ((x = net_read(ctl->handle,ctl->cput,ctl->cleft)) == -1)
             {
                 perror("read");
                 retval = -1;
                 break;
             }
           if (x == 0)
               eof = 1;
           ctl->cleft -= x;
           ctl->cavail += x;
           ctl->cput += x;
       }
     while (1);
     return retval;
 }
 
 /*
  * write lines of text
  *
  * return -1 on error or bytecount
  */
 static int writeline(char *buf, int len, netbuf *nData)
 {
     int x, nb=0, w;
     char *ubp = buf, *nbp;
     char lc=0;
 
     if (nData->dir != FTPLIB_WRITE)
         return -1;
     nbp = nData->buf;
     for (x=0; x < len; x++)
       {
           if ((*ubp == '\n') && (lc != '\r'))
             {
                 if (nb == FTPLIB_BUFSIZ)
                   {
                       if (!socket_wait(nData))
                           return x;
                       w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
                       if (w != FTPLIB_BUFSIZ)
                         {
                             printf("net_write(1) returned %d, errno = %d\n", w, errno);
                             return(-1);
                         }
                       nb = 0;
                   }
                 nbp[nb++] = '\r';
             }
           if (nb == FTPLIB_BUFSIZ)
             {
                 if (!socket_wait(nData))
                     return x;
                 w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
                 if (w != FTPLIB_BUFSIZ)
                   {
                       printf("net_write(2) returned %d, errno = %d\n", w, errno);
                       return(-1);
                   }
                 nb = 0;
             }
           nbp[nb++] = lc = *ubp++;
       }
     if (nb)
       {
           if (!socket_wait(nData))
               return x;
           w = net_write(nData->handle, nbp, nb);
           if (w != nb)
             {
                 printf("net_write(3) returned %d, errno = %d\n", w, errno);
                 return(-1);
             }
       }
     return len;
 }
 
 /*
  * read a response from the server
  *
  * return 0 if first char doesn't match
  * return 1 if first char matches
  */
 static int readresp(char c, netbuf *nControl)
 {
     char match[5];
     if (readline(nControl->response,256,nControl) == -1)
       {
           perror("Control socket read failed");
           return 0;
       }
     if (ftplib_debug > 1)
         fprintf(stderr,"%s",nControl->response);
     if (nControl->response[3] == '-')
       {
           strncpy(match,nControl->response,3);
           match[3] = ' ';
           match[4] = '\0';
           do
             {
                 if (readline(nControl->response,256,nControl) == -1)
                   {
                       perror("Control socket read failed");
                       return 0;
                   }
                 if (ftplib_debug > 1)
                     fprintf(stderr,"%s",nControl->response);
             }
           while (strncmp(nControl->response,match,4));
       }
     if (nControl->response[0] == c)
         return 1;
     return 0;
 }
 
 /*
  * FtpInit for stupid operating systems that require it (Windows NT)
  */
 GLOBALDEF void FtpInit(void)
 {
 #if defined(_WIN32)
     WORD wVersionRequested;
     WSADATA wsadata;
     int err;
     wVersionRequested = MAKEWORD(1,1);
     if ((err = WSAStartup(wVersionRequested,&wsadata)) != 0)
         fprintf(stderr,"Network failed to start: %d\n",err);
 #endif
 }
 
 /*
  * FtpLastResponse - return a pointer to the last response received
  */
 GLOBALDEF char *FtpLastResponse(netbuf *nControl)
 {
     if ((nControl) && (nControl->dir == FTPLIB_CONTROL))
         return nControl->response;
     return NULL;
 }
 
 /*
  * FtpConnect - connect to remote server
  *
  * return 1 if connected, 0 if not
  */
 GLOBALDEF int FtpConnect(const char *host, netbuf **nControl)
 {
     int sControl, stat, flags, oldflags;
     struct sockaddr_in sin;
     struct hostent *phe;
     struct servent *pse;
     int on=1;
     netbuf *ctrl;
     char *lhost;
     char *pnum;
     struct timeval tv;
     fd_set wr;
 
     memset(&sin,0,sizeof(sin));
     sin.sin_family = AF_INET;
     lhost = strdup(host);
     pnum = strchr(lhost,':');
     if (pnum == NULL)
       {
 #if defined(VMS)
           sin.sin_port = htons(21);
 #else
           if ((pse = getservbyname("ftp","tcp")) == NULL)
             {
                 perror("getservbyname");
                 return 0;
             }
           sin.sin_port = pse->s_port;
 #endif
       }
     else
       {
           *pnum++ = '\0';
           if (isdigit(*pnum))
               sin.sin_port = htons(atoi(pnum));
           else
             {
                 pse = getservbyname(pnum,"tcp");
                 sin.sin_port = pse->s_port;
             }
       }
     if ((sin.sin_addr.s_addr = inet_addr(lhost)) == -1)
       {
           if ((phe = gethostbyname(lhost)) == NULL)
             {
                 perror("gethostbyname");
                 return 0;
             }
 
           memcpy((char *)&sin.sin_addr, phe->h_addr, phe->h_length);
 
       }
     free(lhost);
 
     sControl = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
     if (sControl == -1)
       {
           perror("socket");
           return 0;
       }
 
     if ( setsockopt(sControl,SOL_SOCKET,SO_REUSEADDR,
                    SETSOCKOPT_OPTVAL_TYPE &on, sizeof(on)) == -1)
       {
           perror("setsockopt");
           net_close(sControl);
           return 0;
       }
 
      //set nonblocking for connection timeout
     flags = fcntl( sControl, F_GETFL,0);
     oldflags=flags;
     fcntl( sControl, F_SETFL, O_NONBLOCK|flags);
 
     stat=connect( sControl, (struct sockaddr *)&sin, sizeof(sin));
     if (stat < 0) 
       { 
           if (errno != EWOULDBLOCK && errno != EINPROGRESS) 
             { 
                 perror("connect");
                 net_close(sControl);
                 return 0;
             } 
       } 
 
     FD_ZERO(&wr); 
     FD_SET( sControl, &wr); 
 
     tv.tv_sec = ACCEPT_TIMEOUT;
     tv.tv_usec = 0; 
 
     stat = select(sControl+1, 0, &wr, 0, &tv);
 
     if (stat < 1)
       { 
             // time out has expired, 
             // or an error has ocurred
           perror("timeout");
           net_close(sControl);
           return 0;
       } 
 
     printf("connected\n");
 
       //set original flags
     fcntl( sControl, F_SETFL, oldflags);
 
     ctrl = calloc(1,sizeof(netbuf));
     if (ctrl == NULL)
       {
           perror("calloc");
           net_close(sControl);
           return 0;
       }
     ctrl->buf = malloc(FTPLIB_BUFSIZ);
     if (ctrl->buf == NULL)
       {
           perror("calloc");
           net_close(sControl);
           free(ctrl);
           return 0;
       }
     ctrl->handle = sControl;
     ctrl->dir = FTPLIB_CONTROL;
     ctrl->ctrl = NULL;
     ctrl->cmode = FTPLIB_DEFMODE;
     ctrl->idlecb = NULL;
     ctrl->idletime.tv_sec = ctrl->idletime.tv_usec = 0;
     ctrl->idlearg = NULL;
     ctrl->xfered = 0;
     ctrl->xfered1 = 0;
     ctrl->cbbytes = 0;
     if (readresp('2', ctrl) == 0)
       {
           net_close(sControl);
           free(ctrl->buf);
           free(ctrl);
           return 0;
       }
     *nControl = ctrl;
     return 1;
 }
 
 /*
  * FtpOptions - change connection options
  *
  * returns 1 if successful, 0 on error
  */
 GLOBALDEF int FtpOptions(int opt, long val, netbuf *nControl)
 {
     int v,rv=0;
     switch (opt)
       {
         case FTPLIB_CONNMODE:
             v = (int) val;
             if ((v == FTPLIB_PASSIVE) || (v == FTPLIB_PORT))
               {
                   nControl->cmode = v;
                   rv = 1;
               }
             break;
         case FTPLIB_CALLBACK:
             nControl->idlecb = (FtpCallback) val;
             rv = 1;
             break;
         case FTPLIB_IDLETIME:
             v = (int) val;
             rv = 1;
             nControl->idletime.tv_sec = v / 1000;
             nControl->idletime.tv_usec = (v % 1000) * 1000;
             break;
         case FTPLIB_CALLBACKARG:
             rv = 1;
             nControl->idlearg = (void *) val;
             break;
         case FTPLIB_CALLBACKBYTES:
             rv = 1;
             nControl->cbbytes = (int) val;
             break;
       }
     return rv;
 }
 
 /*
  * FtpSendCmd - send a command and wait for expected response
  *
  * return 1 if proper response received, 0 otherwise
  */
 static int FtpSendCmd(const char *cmd, char expresp, netbuf *nControl)
 {
     char buf[256];
     if (nControl->dir != FTPLIB_CONTROL)
         return 0;
     if (ftplib_debug > 2)
         fprintf(stderr,"%s\n",cmd);
     if ((strlen(cmd) + 3) > sizeof(buf))
         return 0;
     sprintf(buf,"%s\r\n",cmd);
     if (net_write(nControl->handle,buf,strlen(buf)) <= 0)
       {
           perror("write");
           return 0;
       }
     return readresp(expresp, nControl);
 }
 
 /*
  * FtpLogin - log in to remote server
  *
  * return 1 if logged in, 0 otherwise
  */
 GLOBALDEF int FtpLogin(const char *user, const char *pass, netbuf *nControl)
 {
     char tempbuf[64];
 
     if (((strlen(user) + 7) > sizeof(tempbuf)) ||
         ((strlen(pass) + 7) > sizeof(tempbuf)))
         return 0;
     sprintf(tempbuf,"USER %s",user);
     if (!FtpSendCmd(tempbuf,'3',nControl))
       {
           if (nControl->response[0] == '2')
               return 1;
           return 0;
       }
     sprintf(tempbuf,"PASS %s",pass);
     return FtpSendCmd(tempbuf,'2',nControl);
 }
 
 /*
  * FtpOpenPort - set up data connection
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpOpenPort(netbuf *nControl, netbuf **nData, int mode, int dir)
 {
     int sData;
     union {
         struct sockaddr sa;
         struct sockaddr_in in;
     } sin;
     struct linger lng = { 0, 0 };
     unsigned int l;
     int on=1;
     netbuf *ctrl;
     char *cp;
     unsigned int v[6];
     char buf[256];
 
     if (nControl->dir != FTPLIB_CONTROL)
         return -1;
     if ((dir != FTPLIB_READ) && (dir != FTPLIB_WRITE))
       {
           sprintf(nControl->response, "Invalid direction %d\n", dir);
           return -1;
       }
     if ((mode != FTPLIB_ASCII) && (mode != FTPLIB_IMAGE))
       {
           sprintf(nControl->response, "Invalid mode %c\n", mode);
           return -1;
       }
     l = sizeof(sin);
     if (nControl->cmode == FTPLIB_PASSIVE)
       {
           memset(&sin, 0, l);
           sin.in.sin_family = AF_INET;
           if (!FtpSendCmd("PASV",'2',nControl))
               return -1;
           cp = strchr(nControl->response,'(');
           if (cp == NULL)
               return -1;
           cp++;
           sscanf(cp,"%u,%u,%u,%u,%u,%u",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
           sin.sa.sa_data[2] = v[2];
           sin.sa.sa_data[3] = v[3];
           sin.sa.sa_data[4] = v[4];
           sin.sa.sa_data[5] = v[5];
           sin.sa.sa_data[0] = v[0];
           sin.sa.sa_data[1] = v[1];
       }
     else
       {
           if (getsockname(nControl->handle, &sin.sa, &l) < 0)
             {
                 perror("getsockname");
                 return 0;
             }
       }
     sData = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
     if (sData == -1)
       {
           perror("socket");
           return -1;
       }
     if (setsockopt(sData,SOL_SOCKET,SO_REUSEADDR,
                    SETSOCKOPT_OPTVAL_TYPE &on,sizeof(on)) == -1)
       {
           perror("setsockopt");
           net_close(sData);
           return -1;
       }
     if (setsockopt(sData,SOL_SOCKET,SO_LINGER,
                    SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
       {
           perror("setsockopt");
           net_close(sData);
           return -1;
       }
     if (nControl->cmode == FTPLIB_PASSIVE)
       {
           if (connect(sData, &sin.sa, sizeof(sin.sa)) == -1)
             {
                 perror("connect");
                 net_close(sData);
                 return -1;
             }
       }
     else
       {
           sin.in.sin_port = 0;
           if (bind(sData, &sin.sa, sizeof(sin)) == -1)
             {
                 perror("bind");
                 net_close(sData);
                 return 0;
             }
           if (listen(sData, 1) < 0)
             {
                 perror("listen");
                 net_close(sData);
                 return 0;
             }
           if (getsockname(sData, &sin.sa, &l) < 0)
               return 0;
           sprintf(buf, "PORT %d,%d,%d,%d,%d,%d",
                   (unsigned char) sin.sa.sa_data[2],
                   (unsigned char) sin.sa.sa_data[3],
                   (unsigned char) sin.sa.sa_data[4],
                   (unsigned char) sin.sa.sa_data[5],
                   (unsigned char) sin.sa.sa_data[0],
                   (unsigned char) sin.sa.sa_data[1]);
           if (!FtpSendCmd(buf,'2',nControl))
             {
                 net_close(sData);
                 return 0;
             }
       }
     ctrl = calloc(1,sizeof(netbuf));
     if (ctrl == NULL)
       {
           perror("calloc");
           net_close(sData);
           return -1;
       }
     if ((mode == 'A') && ((ctrl->buf = malloc(FTPLIB_BUFSIZ)) == NULL))
       {
           perror("calloc");
           net_close(sData);
           free(ctrl);
           return -1;
       }
     ctrl->handle = sData;
     ctrl->dir = dir;
     ctrl->idletime = nControl->idletime;
     ctrl->idlearg = nControl->idlearg;
     ctrl->xfered = 0;
     ctrl->xfered1 = 0;
     ctrl->cbbytes = nControl->cbbytes;
     if (ctrl->idletime.tv_sec || ctrl->idletime.tv_usec || ctrl->cbbytes)
         ctrl->idlecb = nControl->idlecb;
     else
         ctrl->idlecb = NULL;
     *nData = ctrl;
     return 1;
 }
 
 /*
  * FtpAcceptConnection - accept connection from server
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpAcceptConnection(netbuf *nData, netbuf *nControl)
 {
     int sData;
     struct sockaddr addr;
     unsigned int l;
     int i;
     struct timeval tv;
     fd_set mask;
-    int rv;
+    int rv = 1;
 
     FD_ZERO(&mask);
     FD_SET(nControl->handle, &mask);
     FD_SET(nData->handle, &mask);
     tv.tv_usec = 0;
     tv.tv_sec = ACCEPT_TIMEOUT;
     printf("<<<<<<<<<<<<<<<<%d\n",ACCEPT_TIMEOUT);
     i = nControl->handle;
     if (i < nData->handle)
         i = nData->handle;
     i = select(i+1, &mask, NULL, NULL, &tv);
     if (i == -1)
       {
           strncpy(nControl->response, strerror(errno),
                   sizeof(nControl->response));
           net_close(nData->handle);
           nData->handle = 0;
           rv = 0;
       }
     else if (i == 0)
       {
           strcpy(nControl->response, "timed out waiting for connection");
           net_close(nData->handle);
           nData->handle = 0;
           rv = 0;
       }
     else
       {
           if (FD_ISSET(nData->handle, &mask))
             {
                 l = sizeof(addr);
                 sData = accept(nData->handle, &addr, &l);
                 i = errno;
                 net_close(nData->handle);
                 if (sData > 0)
                   {
                       rv = 1;
                       nData->handle = sData;
                   }
                 else
                   {
                       strncpy(nControl->response, strerror(i),
                               sizeof(nControl->response));
                       nData->handle = 0;
                       rv = 0;
                   }
             }
           else if (FD_ISSET(nControl->handle, &mask))
             {
                 net_close(nData->handle);
                 nData->handle = 0;
                 readresp('2', nControl);
                 rv = 0;
             }
       }
     return rv;  
 }
 
 /*
  * FtpAccess - return a handle for a data stream
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpAccess(const char *path, int typ, int mode, netbuf *nControl,
                         netbuf **nData)
 {
     char buf[256];
     int dir;
     if ((path == NULL) &&
         ((typ == FTPLIB_FILE_WRITE) || (typ == FTPLIB_FILE_READ)))
       {
           sprintf(nControl->response,
                   "Missing path argument for file transfer\n");
           return 0;
       }
     sprintf(buf, "TYPE %c", mode);
     if (!FtpSendCmd(buf, '2', nControl))
         return 0;
     switch (typ)
       {
         case FTPLIB_DIR:
             strcpy(buf,"NLST");
             dir = FTPLIB_READ;
             break;
         case FTPLIB_DIR_VERBOSE:
             strcpy(buf,"LIST");
             dir = FTPLIB_READ;
             break;
         case FTPLIB_FILE_READ:
             strcpy(buf,"RETR");
             dir = FTPLIB_READ;
             break;
         case FTPLIB_FILE_WRITE:
             strcpy(buf,"STOR");
             dir = FTPLIB_WRITE;
             break;
         default:
             sprintf(nControl->response, "Invalid open type %d\n", typ);
             return 0;
       }
     if (path != NULL)
       {
           int i = strlen(buf);
           buf[i++] = ' ';
           if ((strlen(path) + i) >= sizeof(buf))
               return 0;
           strcpy(&buf[i],path);
       }
     if (FtpOpenPort(nControl, nData, mode, dir) == -1)
         return 0;
     if (!FtpSendCmd(buf, '1', nControl))
       {
           FtpClose(*nData);
           *nData = NULL;
           return 0;
       }
     (*nData)->ctrl = nControl;
     nControl->data = *nData;
     if (nControl->cmode == FTPLIB_PORT)
       {
           if (!FtpAcceptConnection(*nData,nControl))
             {
                 FtpClose(*nData);
                 *nData = NULL;
                 nControl->data = NULL;
                 return 0;
             }
       }
     return 1;
 }
 
 /*
  * FtpRead - read from a data connection
  */
 GLOBALDEF int FtpRead(void *buf, int max, netbuf *nData)
 {
     int i;
     if (nData->dir != FTPLIB_READ)
         return 0;
     if (nData->buf)
         i = readline(buf, max, nData);
     else
       {
           i = socket_wait(nData);
           if (i != 1)
               return 0;
           i = net_read(nData->handle, buf, max);
       }
     if (i == -1)
         return 0;
     nData->xfered += i;
     if (nData->idlecb && nData->cbbytes)
       {
           nData->xfered1 += i;
           if (nData->xfered1 > nData->cbbytes)
             {
                 if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
                     return 0;
                 nData->xfered1 = 0;
             }
       }
     return i;
 }
 
 /*
  * FtpWrite - write to a data connection
  */
 GLOBALDEF int FtpWrite(void *buf, int len, netbuf *nData)
 {
     int i;
     if (nData->dir != FTPLIB_WRITE)
         return 0;
     if (nData->buf)
         i = writeline(buf, len, nData);
     else
       {
           if (socket_wait(nData) < 0)
               fprintf(stderr, "FtpWrite: socket_wait failed with %s\n", nData->ctrl->response);
           i = net_write(nData->handle, buf, len);
       }
     if (i == -1)
         return 0;
     nData->xfered += i;
     if (nData->idlecb && nData->cbbytes)
       {
           nData->xfered1 += i;
           if (nData->xfered1 > nData->cbbytes)
             {
                 nData->idlecb(nData, nData->xfered, nData->idlearg);
                 nData->xfered1 = 0;
             }
       }
     return i;
 }
 
 /*
  * FtpClose - close a data connection
  */
 GLOBALDEF int FtpClose(netbuf *nData)
 {
     netbuf *ctrl;
     switch (nData->dir)
       {
         case FTPLIB_WRITE:
               /* potential problem - if buffer flush fails, how to notify user? */
             if (nData->buf != NULL)
                 writeline(NULL, 0, nData);
         case FTPLIB_READ:
             if (nData->buf)
                 free(nData->buf);
             shutdown(nData->handle,2);
             net_close(nData->handle);
             ctrl = nData->ctrl;
             free(nData);
             if (ctrl)
               {
                   ctrl->data = NULL;
                   return(readresp('2', ctrl));
               }
             return 1;
         case FTPLIB_CONTROL:
             if (nData->data)
               {
                   nData->ctrl = NULL;
                   FtpClose(nData);
               }
             net_close(nData->handle);
             free(nData);
             return 0;
       }
     return 1;
 }
 
 /*
  * FtpSite - send a SITE command
  *
  * return 1 if command successful, 0 otherwise
  */
 GLOBALDEF int FtpSite(const char *cmd, netbuf *nControl)
 {
     char buf[256];
     
     if ((strlen(cmd) + 7) > sizeof(buf))
         return 0;
     sprintf(buf,"SITE %s",cmd);
     if (!FtpSendCmd(buf,'2',nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpSysType - send a SYST command
  *
  * Fills in the user buffer with the remote system type.  If more
  * information from the response is required, the user can parse
  * it out of the response buffer returned by FtpLastResponse().
  *
  * return 1 if command successful, 0 otherwise
  */
 GLOBALDEF int FtpSysType(char *buf, int max, netbuf *nControl)
 {
     int l = max;
     char *b = buf;
     char *s;
     if (!FtpSendCmd("SYST",'2',nControl))
         return 0;
     s = &nControl->response[4];
     while ((--l) && (*s != ' '))
         *b++ = *s++;
     *b++ = '\0';
     return 1;
 }
 
 /*
  * FtpMkdir - create a directory at server
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpMkdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"MKD %s",path);
     if (!FtpSendCmd(buf,'2', nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpChdir - change path at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpChdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"CWD %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpCDUp - move to parent directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpCDUp(netbuf *nControl)
 {
     if (!FtpSendCmd("CDUP",'2',nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpRmdir - remove directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpRmdir(const char *path, netbuf *nControl)
 {
     char buf[256];
 
     if ((strlen(path) + 6) > sizeof(buf))
         return 0;
     sprintf(buf,"RMD %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpPwd - get working directory at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpPwd(char *path, int max, netbuf *nControl)
 {
     int l = max;
     char *b = path;
     char *s;
     if (!FtpSendCmd("PWD",'2',nControl))
         return 0;
     s = strchr(nControl->response, '"');
     if (s == NULL)
         return 0;
     s++;
     while ((--l) && (*s) && (*s != '"'))
         *b++ = *s++;
     *b++ = '\0';
     return 1;
 }
 
 /*
  * FtpXfer - issue a command and transfer data
  *
  * return 1 if successful, 0 otherwise
  */
 static int FtpXfer(const char *localfile, const char *path,
                    netbuf *nControl, int typ, int mode)
 {
     int l,c;
     char *dbuf;
     FILE *local = NULL;
     netbuf *nData;
     int rv=1;
 
     if (localfile != NULL)
       {
           char ac[4] = "w";
           if (typ == FTPLIB_FILE_WRITE)
               ac[0] = 'r';
           if (mode == FTPLIB_IMAGE)
               ac[1] = 'b';
           local = fopen(localfile, ac);
           if (local == NULL)
             {
                 strncpy(nControl->response, strerror(errno),
                         sizeof(nControl->response));
                 return 0;
             }
       }
     if (local == NULL)
         local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
     if (!FtpAccess(path, typ, mode, nControl, &nData))
       {
         if (localfile != NULL)
             fclose(local);
         return 0;
       }
     dbuf = malloc(FTPLIB_BUFSIZ);
     if (typ == FTPLIB_FILE_WRITE)
       {
           while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
               if ((c = FtpWrite(dbuf, l, nData)) < l)
                 {
                     printf("short write: passed %d, wrote %d\n", l, c);
                     rv = 0;
                     break;
                 }
       }
     else
       {
           while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0)
               if (fwrite(dbuf, 1, l, local) <= 0)
                 {
                     perror("localfile write");
                     rv = 0;
                     break;
                 }
       }
     free(dbuf);
     fflush(local);
     if (localfile != NULL)
         fclose(local);
     FtpClose(nData);
     return rv;
 }
 
 /*
  * FtpNlst - issue an NLST command and write response to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpNlst(const char *outputfile, const char *path,
                       netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_DIR, FTPLIB_ASCII);
 }
 
 /*
  * FtpDir - issue a LIST command and write response to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpDir(const char *outputfile, const char *path, netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_DIR_VERBOSE, FTPLIB_ASCII);
 }
 
 /*
  * FtpSize - determine the size of a remote file
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpSize(const char *path, int *size, char mode, netbuf *nControl)
 {
     char cmd[256];
     int resp,sz,rv=1;
 
     if ((strlen(path) + 7) > sizeof(cmd))
         return 0;
     sprintf(cmd, "TYPE %c", mode);
     if (!FtpSendCmd(cmd, '2', nControl))
         return 0;
     sprintf(cmd,"SIZE %s",path);
     if (!FtpSendCmd(cmd,'2',nControl))
         rv = 0;
     else
       {
           if (sscanf(nControl->response, "%d %d", &resp, &sz) == 2)
               *size = sz;
           else
               rv = 0;
       }   
     return rv;
 }
 
 /*
  * FtpModDate - determine the modification date of a remote file
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpModDate(const char *path, char *dt, int max, netbuf *nControl)
 {
     char buf[256];
     int rv = 1;
 
     if ((strlen(path) + 7) > sizeof(buf))
         return 0;
     sprintf(buf,"MDTM %s",path);
     if (!FtpSendCmd(buf,'2',nControl))
         rv = 0;
     else
         strncpy(dt, &nControl->response[4], max);
     return rv;
 }
 
 /*
  * FtpGet - issue a GET command and write received data to output
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpGet(const char *outputfile, const char *path,
                      char mode, netbuf *nControl)
 {
     return FtpXfer(outputfile, path, nControl, FTPLIB_FILE_READ, mode);
 }
 
 /*
  * FtpPut - issue a PUT command and send data from input
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpPut(const char *inputfile, const char *path, char mode,
                      netbuf *nControl)
 {
     return FtpXfer(inputfile, path, nControl, FTPLIB_FILE_WRITE, mode);
 }
 
 /*
  * FtpRename - rename a file at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpRename(const char *src, const char *dst, netbuf *nControl)
 {
     char cmd[256];
 
     if (((strlen(src) + 7) > sizeof(cmd)) ||
         ((strlen(dst) + 7) > sizeof(cmd)))
         return 0;
     sprintf(cmd,"RNFR %s",src);
     if (!FtpSendCmd(cmd,'3',nControl))
         return 0;
     sprintf(cmd,"RNTO %s",dst);
     if (!FtpSendCmd(cmd,'2',nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpDelete - delete a file at remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF int FtpDelete(const char *fnm, netbuf *nControl)
 {
     char cmd[256];
 
     if ((strlen(fnm) + 7) > sizeof(cmd))
         return 0;
     sprintf(cmd,"DELE %s",fnm);
     if (!FtpSendCmd(cmd,'2', nControl))
         return 0;
     return 1;
 }
 
 /*
  * FtpQuit - disconnect from remote
  *
  * return 1 if successful, 0 otherwise
  */
 GLOBALDEF void FtpQuit(netbuf *nControl)
 {
     if (nControl->dir != FTPLIB_CONTROL)
         return;
     if (FtpSendCmd("QUIT",'2',nControl) == 1) {
         if (ftplib_debug > 2)
             fprintf(stderr, "FtpQuit: FtpSendCmd(QUIT) failed\n");
     }
     net_close(nControl->handle);
     free(nControl->buf);
     free(nControl);
 }
diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c
index 07fd1c0..5426157 100644
--- a/noncore/settings/sysinfo/contrib/dhry.c
+++ b/noncore/settings/sysinfo/contrib/dhry.c
@@ -1,1010 +1,1010 @@
 /*****************************************************/
 /* Various timer routines.                           */
 /* Al Aburto, aburto@nosc.mil, 18 Feb 1997           */
 /*                                                   */
 /* t = dtime() outputs the current time in seconds.  */
 /* Use CAUTION as some of these routines will mess   */
 /* up when timing across the hour mark!!!            */
 /*                                                   */
 /* For timing I use the 'user' time whenever         */
 /* possible. Using 'user+sys' time is a separate     */
 /* issue.                                            */
 /*                                                   */
 /* Example Usage:                                    */
 /* [timer options added here]                        */
 /* main()                                            */
 /* {                                                 */
 /* double starttime,benchtime,dtime();               */
 /*                                                   */
 /* starttime = dtime();                              */
 /* [routine to time]                                 */
 /* benchtime = dtime() - starttime;                  */
 /* }                                                 */
 /*                                                   */
 /* [timer code below added here]                     */
 /*****************************************************/
 
 /***************************************************************/
 /* Timer options. You MUST uncomment one of the options below  */
 /* or compile, for example, with the '-DUNIX' option.          */
 /***************************************************************/
 /* #define Amiga       */
 /* #define UNIX        */
 /* #define UNIX_Old    */
 /* #define VMS         */
 /* #define BORLAND_C   */
 /* #define MSC         */
 /* #define MAC         */
 /* #define IPSC        */
 /* #define FORTRAN_SEC */
 /* #define GTODay      */
 /* #define CTimer      */
 /* #define UXPM        */
 /* #define MAC_TMgr    */
 /* #define PARIX       */
 /* #define POSIX       */
 /* #define WIN32       */
 /* #define POSIX1      */
 /***********************/
 
 /*********************************/
 /* Timer code.                   */
 /*********************************/
 /*******************/
 /*  Amiga dtime()  */
 /*******************/
 #ifdef Amiga
 #include <ctype.h>
 #define HZ 50
 
 double dtime()
 {
  double q;
 
  struct tt
        {
         long  days;
         long  minutes;
         long  ticks;
        } tt;
 
  DateStamp(&tt);
 
  q = ((double)(tt.ticks + (tt.minutes * 60L * 50L))) / (double)HZ;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /*  UNIX dtime(). This is the preferred UNIX timer.  */
 /*  Provided by: Markku Kolkka, mk59200@cc.tut.fi    */
 /*  HP-UX Addition by: Bo Thide', bt@irfu.se         */
 /*****************************************************/
 #ifdef UNIX
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #ifdef hpux
 #include <sys/syscall.h>
 #define getrusage(a,b) syscall(SYS_getrusage,a,b)
 #endif
 
 struct rusage rusage;
 
 double dtime()
 {
  double q;
 
  getrusage(RUSAGE_SELF,&rusage);
 
  q = (double)(rusage.ru_utime.tv_sec);
  q = q + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
 
  return q;
 }
 #endif
 
 /***************************************************/
 /*  UNIX_Old dtime(). This is the old UNIX timer.  */
 /*  Make sure HZ is properly defined in param.h !! */
 /***************************************************/
 #ifdef UNIX_Old
 #include <sys/types.h>
 #include <sys/times.h>
 #include <sys/param.h>
 
 #ifndef HZ
 #define HZ 60
 #endif
 
 struct tms tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.tms_utime) / (double)HZ;
 
  return q;
 }
 #endif
 
 /*********************************************************/
 /*  VMS dtime() for VMS systems.                         */
 /*  Provided by: RAMO@uvphys.phys.UVic.CA                */
 /*  Some people have run into problems with this timer.  */
 /*********************************************************/
 #ifdef VMS
 #include time
 
 #ifndef HZ
 #define HZ 100
 #endif
 
 struct tbuffer_t
       {
        int proc_user_time;
        int proc_system_time;
        int child_user_time;
        int child_system_time;
       };
 
 struct tbuffer_t tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.proc_user_time) / (double)HZ;
 
  return q;
 }
 #endif
 
 /******************************/
 /*  BORLAND C dtime() for DOS */
 /******************************/
 #ifdef BORLAND_C
 #include <ctype.h>
 #include <dos.h>
 #include <time.h>
 
 #define HZ 100
 struct time tnow;
 
 double dtime()
 {
  double q;
 
  gettime(&tnow);
 
  q = 60.0 * (double)(tnow.ti_min);
  q = q + (double)(tnow.ti_sec);
  q = q + (double)(tnow.ti_hund)/(double)HZ;
 
  return q;
 }
 #endif
 
 /**************************************/
 /*  Microsoft C (MSC) dtime() for DOS */
 /**************************************/
 #ifdef MSC
 #include <time.h>
 #include <ctype.h>
 
 #define HZ CLOCKS_PER_SEC
 clock_t tnow;
 
 double dtime()
 {
  double q;
 
  tnow = clock();
 
  q = (double)tnow / (double)HZ;
 
  return q;
 }
 #endif
 
 /*************************************/
 /*  Macintosh (MAC) Think C dtime()  */
 /*************************************/
 #ifdef MAC
 #include <time.h>
 
 #define HZ 60
 
 double dtime()
 {
  double q;
 
  q = (double)clock() / (double)HZ;
 
  return q;
 }
 #endif
 
 /************************************************************/
 /*  iPSC/860 (IPSC) dtime() for i860.                       */
 /*  Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU  */
 /************************************************************/
 #ifdef IPSC
 extern double dclock();
 
 double dtime()
 {
  double q;
 
  q = dclock();
 
  return q;
 }
 #endif
 
 /**************************************************/
 /*  FORTRAN dtime() for Cray type systems.        */
 /*  This is the preferred timer for Cray systems. */
 /**************************************************/
 #ifdef FORTRAN_SEC
 
 fortran double second();
 
 double dtime()
 {
  double q;
 
  second(&q);
 
  return q;
 }
 #endif
 
 /***********************************************************/
 /*  UNICOS C dtime() for Cray UNICOS systems.  Don't use   */
 /*  unless absolutely necessary as returned time includes  */
 /*  'user+system' time.  Provided by: R. Mike Dority,      */
 /*  dority@craysea.cray.com                                */
 /***********************************************************/
 #ifdef CTimer
 #include <time.h>
 
 double dtime()
 {
  double    q;
  clock_t   clock(void);
 
  q = (double)clock() / (double)CLOCKS_PER_SEC;
 
  return q;
 }
 #endif
 
 /********************************************/
 /* Another UNIX timer using gettimeofday(). */
 /* However, getrusage() is preferred.       */
 /********************************************/
 #ifdef GTODay
 #include <sys/time.h>
 
 struct timeval tnow;
 
 double dtime()
 {
  double q;
 
  gettimeofday(&tnow,NULL);
  q = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /*  Fujitsu UXP/M timer.                             */
 /*  Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
 /*****************************************************/
 #ifdef UXPM
 #include <sys/types.h>
 #include <sys/timesu.h>
 struct tmsu rusage;
 
 double dtime()
 {
  double q;
 
  timesu(&rusage);
 
  q = (double)(rusage.tms_utime) * 1.0e-06;
 
  return q;
 }
 #endif
 
 /**********************************************/
 /*    Macintosh (MAC_TMgr) Think C dtime()    */
 /*   requires Think C Language Extensions or  */
 /*    #include <MacHeaders> in the prefix     */
 /*  provided by Francis H Schiffer 3rd (fhs)  */
 /*         skipschiffer@genie.geis.com        */
 /**********************************************/
 #ifdef MAC_TMgr
 #include <Timer.h>
 #include <stdlib.h>
 
 static TMTask   mgrTimer;
 static Boolean  mgrInited = false;
 static double   mgrClock;
 
 #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
 #define MAX_TIME  1800000000L
 /* MAX_TIME limits time between calls to */
 /* dtime( ) to no more than 30 minutes   */
 /* this limitation could be removed by   */
 /* creating a completion routine to sum  */
 /* 30 minute segments (fhs 1994 feb 9)   */
 
 static void Remove_timer( )
 {
  RMV_TIMER;
  mgrInited = false;
 }
 
 double  dtime( )
 {
  if( mgrInited ) {
    RMV_TIMER;
    mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
  } else {
    if( _atexit( &Remove_timer ) == 0 ) mgrInited = true;
    mgrClock = 0.0;
  }
 
  if ( mgrInited )
    {
     mgrTimer.tmAddr = NULL;
     mgrTimer.tmCount = 0;
     mgrTimer.tmWakeUp = 0;
     mgrTimer.tmReserved = 0;
     InsTime( (QElemPtr)&mgrTimer );
     PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
    }
  return( mgrClock );
 }
 #endif
 
 /***********************************************************/
 /*  Parsytec GCel timer.                                   */
 /*  Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
 /***********************************************************/
 #ifdef PARIX
 #include <sys/time.h>
 
 double dtime()
 {
  double q;
 
  q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
 
  return q;
 }
 #endif
 
 /************************************************/
 /*  Sun Solaris POSIX dtime() routine           */
 /*  Provided by: Case Larsen, CTLarsen.lbl.gov  */
 /************************************************/
 #ifdef POSIX
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/rusage.h>
 
 #ifdef __hpux
 #include <sys/syscall.h>
 #endif
 
 struct rusage rusage;
 
 double dtime()
 {
  double q;
 
  getrusage(RUSAGE_SELF,&rusage);
 
  q = (double)(rusage.ru_utime.tv_sec);
  q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
 
  return q;
 }
 #endif
 
 
 /****************************************************/
 /*  Windows NT (32 bit) dtime() routine             */
 /*  Provided by: Piers Haken, piersh@microsoft.com  */
 /****************************************************/
 #ifdef WIN32
 #include <windows.h>
 
 double dtime(void)
 {
  double q;
 
  q = (double)GetTickCount() * 1.0e-03;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /* Time according to POSIX.1  -  <J.Pelan@qub.ac.uk> */
 /* Ref: "POSIX Programmer's Guide"  O'Reilly & Assoc.*/
 /*****************************************************/
 #ifdef POSIX1
 #define _POSIX_SOURCE 1
 #include <unistd.h>
 #include <limits.h>
 #include <sys/times.h>
 
 struct tms tms;
 
 double dtime()
 {
  double q;
  times(&tms);
  q = (double)tms.tms_utime / (double)CLK_TCK;
  return q;
 }
 #endif
 /*
  *************************************************************************
  *
  *                   "DHRYSTONE" Benchmark Program
  *                   -----------------------------
  *
  *  Version:    C, Version 2.1
  *
  *  File:       dhry_1.c (part 2 of 3)
  *
  *  Date:       May 25, 1988
  *
  *  Author:     Reinhold P. Weicker
  *
  *************************************************************************
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "dhry.h"
 
 /* Global Variables: */
 
 Rec_Pointer     Ptr_Glob,
                 Next_Ptr_Glob;
 int             Int_Glob;
 Boolean         Bool_Glob;
 char            Ch_1_Glob,
                 Ch_2_Glob;
 int             Arr_1_Glob [50];
 int             Arr_2_Glob [50] [50];
 
 char Reg_Define[32] = "Register option selected.";
 
 //extern char     *malloc ();
 Enumeration     Func_1 ();
   /*
   forward declaration necessary since Enumeration may not simply be int
   */
 
 #ifndef ROPT
 #define REG
         /* REG becomes defined as empty */
         /* i.e. no register variables   */
 #else
 #define REG register
 #endif
 
 
 /* variables for time measurement: */
 
 #define Too_Small_Time 2
                 /* Measurements should last at least 2 seconds */
 
 double          Begin_Time,
                 End_Time,
                 User_Time;
 
 double          Microseconds,
                 Dhrystones_Per_Second,
                 Vax_Mips;
 
 /* end of variables for time measurement */
 
 /**********************************************************************************************/
 
 
 Proc_1 (Ptr_Val_Par)
 /******************/
 
 REG Rec_Pointer Ptr_Val_Par;
     /* executed once */
 {
   REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
                                         /* == Ptr_Glob_Next */
   /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
   /* corresponds to "rename" in Ada, "with" in Pascal           */
 
   structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
   Ptr_Val_Par->variant.var_1.Int_Comp = 5;
   Next_Record->variant.var_1.Int_Comp
         = Ptr_Val_Par->variant.var_1.Int_Comp;
   Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
   Proc_3 (&Next_Record->Ptr_Comp);
     /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
                         == Ptr_Glob->Ptr_Comp */
   if (Next_Record->Discr == Ident_1)
     /* then, executed */
   {
     Next_Record->variant.var_1.Int_Comp = 6;
     Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
            &Next_Record->variant.var_1.Enum_Comp);
     Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
     Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
            &Next_Record->variant.var_1.Int_Comp);
   }
   else /* not executed */
     structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
 } /* Proc_1 */
 
 
 Proc_2 (Int_Par_Ref)
 /******************/
     /* executed once */
     /* *Int_Par_Ref == 1, becomes 4 */
 
 One_Fifty   *Int_Par_Ref;
 {
   One_Fifty  Int_Loc;
-  Enumeration   Enum_Loc;
+  Enumeration   Enum_Loc = Ident_2;
 
   Int_Loc = *Int_Par_Ref + 10;
   do /* executed once */
     if (Ch_1_Glob == 'A')
       /* then, executed */
     {
       Int_Loc -= 1;
       *Int_Par_Ref = Int_Loc - Int_Glob;
       Enum_Loc = Ident_1;
     } /* if */
   while (Enum_Loc != Ident_1); /* true */
 } /* Proc_2 */
 
 
 Proc_3 (Ptr_Ref_Par)
 /******************/
     /* executed once */
     /* Ptr_Ref_Par becomes Ptr_Glob */
 
 Rec_Pointer *Ptr_Ref_Par;
 
 {
   if (Ptr_Glob != Null)
     /* then, executed */
     *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
   Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
 } /* Proc_3 */
 
 
 Proc_4 () /* without parameters */
 /*******/
     /* executed once */
 {
   Boolean Bool_Loc;
 
   Bool_Loc = Ch_1_Glob == 'A';
   Bool_Glob = Bool_Loc | Bool_Glob;
   Ch_2_Glob = 'B';
 } /* Proc_4 */
 
 
 Proc_5 () /* without parameters */
 /*******/
     /* executed once */
 {
   Ch_1_Glob = 'A';
   Bool_Glob = false;
 } /* Proc_5 */
 
 
         /* Procedure for the assignment of structures,          */
         /* if the C compiler doesn't support this feature       */
 #ifdef  NOSTRUCTASSIGN
 memcpy (d, s, l)
 register char   *d;
 register char   *s;
 register int    l;
 {
         while (l--) *d++ = *s++;
 }
 #endif
 
 
 Proc_6 (Enum_Val_Par, Enum_Ref_Par)
 /*********************************/
     /* executed once */
     /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
 
 Enumeration  Enum_Val_Par;
 Enumeration *Enum_Ref_Par;
 {
   *Enum_Ref_Par = Enum_Val_Par;
   if (! Func_3 (Enum_Val_Par))
     /* then, not executed */
     *Enum_Ref_Par = Ident_4;
   switch (Enum_Val_Par)
   {
     case Ident_1:
       *Enum_Ref_Par = Ident_1;
       break;
     case Ident_2:
       if (Int_Glob > 100)
         /* then */
       *Enum_Ref_Par = Ident_1;
       else *Enum_Ref_Par = Ident_4;
       break;
     case Ident_3: /* executed */
       *Enum_Ref_Par = Ident_2;
       break;
     case Ident_4: break;
     case Ident_5:
       *Enum_Ref_Par = Ident_3;
       break;
   } /* switch */
 } /* Proc_6 */
 
 
 Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
 /**********************************************/
     /* executed three times                                      */
     /* first call:      Int_1_Par_Val == 2, Int_2_Par_Val == 3,  */
     /*                  Int_Par_Ref becomes 7                    */
     /* second call:     Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
     /*                  Int_Par_Ref becomes 17                   */
     /* third call:      Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
     /*                  Int_Par_Ref becomes 18                   */
 One_Fifty       Int_1_Par_Val;
 One_Fifty       Int_2_Par_Val;
 One_Fifty      *Int_Par_Ref;
 {
   One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 2;
   *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
 } /* Proc_7 */
 
 
 Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
 /*********************************************************************/
     /* executed once      */
     /* Int_Par_Val_1 == 3 */
     /* Int_Par_Val_2 == 7 */
 Arr_1_Dim       Arr_1_Par_Ref;
 Arr_2_Dim       Arr_2_Par_Ref;
 int             Int_1_Par_Val;
 int             Int_2_Par_Val;
 {
   REG One_Fifty Int_Index;
   REG One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 5;
   Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
   Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
   Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
   for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
     Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
   Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
   Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
   Int_Glob = 5;
 } /* Proc_8 */
 
 
 Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
 /*************************************************/
     /* executed three times                                         */
     /* first call:      Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R'    */
     /* second call:     Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C'    */
     /* third call:      Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C'    */
 
 Capital_Letter   Ch_1_Par_Val;
 Capital_Letter   Ch_2_Par_Val;
 {
   Capital_Letter        Ch_1_Loc;
   Capital_Letter        Ch_2_Loc;
 
   Ch_1_Loc = Ch_1_Par_Val;
   Ch_2_Loc = Ch_1_Loc;
   if (Ch_2_Loc != Ch_2_Par_Val)
     /* then, executed */
     return (Ident_1);
   else  /* not executed */
   {
     Ch_1_Glob = Ch_1_Loc;
     return (Ident_2);
    }
 } /* Func_1 */
 
 
 Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
 /*************************************************/
     /* executed once */
     /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
     /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
 
 Str_30  Str_1_Par_Ref;
 Str_30  Str_2_Par_Ref;
 {
   REG One_Thirty        Int_Loc;
       Capital_Letter    Ch_Loc;
 
   Int_Loc = 2;
   while (Int_Loc <= 2) /* loop body executed once */
     if (Func_1 (Str_1_Par_Ref[Int_Loc],
                 Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
       /* then, executed */
     {
       Ch_Loc = 'A';
       Int_Loc += 1;
     } /* if, while */
   if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
     /* then, not executed */
     Int_Loc = 7;
   if (Ch_Loc == 'R')
     /* then, not executed */
     return (true);
   else /* executed */
   {
     if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
       /* then, not executed */
     {
       Int_Loc += 7;
       Int_Glob = Int_Loc;
       return (true);
     }
     else /* executed */
       return (false);
   } /* if Ch_Loc */
 } /* Func_2 */
 
 
 Boolean Func_3 (Enum_Par_Val)
 /***************************/
     /* executed once        */
     /* Enum_Par_Val == Ident_3 */
 Enumeration Enum_Par_Val;
 {
   Enumeration Enum_Loc;
 
   Enum_Loc = Enum_Par_Val;
   if (Enum_Loc == Ident_3)
     /* then, executed */
     return (true);
   else /* not executed */
     return (false);
 } /* Func_3 */
 
 /*********************************************************************************/
 
 double dhry_main( int n )
 /*****/
 
   /* main program, corresponds to procedures        */
   /* Main and Proc_0 in the Ada version             */
 {
         One_Fifty       Int_1_Loc;
   REG   One_Fifty       Int_2_Loc;
         One_Fifty       Int_3_Loc;
   REG   char            Ch_Index;
         Enumeration     Enum_Loc;
         Str_30          Str_1_Loc;
         Str_30          Str_2_Loc;
   REG   int             Run_Index;
   REG   int             Number_Of_Runs;
 
         FILE            *Ap;
 
   /* Initializations */
 
 /*  if ((Ap = fopen("dhry.res","a+")) == NULL)
     {
        printf("Can not open dhry.res\n\n");
        exit(1);
     }
 */
   Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
   Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
 
   Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
   Ptr_Glob->Discr                       = Ident_1;
   Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
   Ptr_Glob->variant.var_1.Int_Comp      = 40;
   strcpy (Ptr_Glob->variant.var_1.Str_Comp,
           "DHRYSTONE PROGRAM, SOME STRING");
   strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
 
   Arr_2_Glob [8][7] = 10;
         /* Was missing in published program. Without this statement,    */
         /* Arr_2_Glob [8][7] would have an undefined value.             */
         /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */
         /* overflow may occur for this array element.                   */
 
 /*
   if (Reg)
   {
     printf ("Program compiled with 'register' attribute\n");
     printf ("\n");
   }
   else
   {
     printf ("Program compiled without 'register' attribute\n");
     printf ("\n");
   }
 */
   Number_Of_Runs = n;
 
   /***************/
   /* Start timer */
   /***************/
 
   Begin_Time = dtime();
 
   for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
   {
 
     Proc_5();
     Proc_4();
       /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
     Int_1_Loc = 2;
     Int_2_Loc = 3;
     strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
     Enum_Loc = Ident_2;
     Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
       /* Bool_Glob == 1 */
     while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
     {
       Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
         /* Int_3_Loc == 7 */
       Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
         /* Int_3_Loc == 7 */
       Int_1_Loc += 1;
     } /* while */
       /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
     Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
       /* Int_Glob == 5 */
     Proc_1 (Ptr_Glob);
     for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
                              /* loop body executed twice */
     {
       if (Enum_Loc == Func_1 (Ch_Index, 'C'))
           /* then, not executed */
         {
         Proc_6 (Ident_1, &Enum_Loc);
         strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
         Int_2_Loc = Run_Index;
         Int_Glob = Run_Index;
         }
     }
       /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
     Int_2_Loc = Int_2_Loc * Int_1_Loc;
     Int_1_Loc = Int_2_Loc / Int_3_Loc;
     Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
       /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
     Proc_2 (&Int_1_Loc);
       /* Int_1_Loc == 5 */
 
   } /* loop "for Run_Index" */
 
   /**************/
   /* Stop timer */
   /**************/
 
   End_Time = dtime();
 
 /*
   printf ("Execution ends\n");
   printf ("\n");
   printf ("Final values of the variables used in the benchmark:\n");
   printf ("\n");
   printf ("Int_Glob:            %d\n", Int_Glob);
   printf ("        should be:   %d\n", 5);
   printf ("Bool_Glob:           %d\n", Bool_Glob);
   printf ("        should be:   %d\n", 1);
   printf ("Ch_1_Glob:           %c\n", Ch_1_Glob);
   printf ("        should be:   %c\n", 'A');
   printf ("Ch_2_Glob:           %c\n", Ch_2_Glob);
   printf ("        should be:   %c\n", 'B');
   printf ("Arr_1_Glob[8]:       %d\n", Arr_1_Glob[8]);
   printf ("        should be:   %d\n", 7);
   printf ("Arr_2_Glob[8][7]:    %d\n", Arr_2_Glob[8][7]);
   printf ("        should be:   Number_Of_Runs + 10\n");
   printf ("Ptr_Glob->\n");
   printf ("  Ptr_Comp:          %d\n", (int) Ptr_Glob->Ptr_Comp);
   printf ("        should be:   (implementation-dependent)\n");
   printf ("  Discr:             %d\n", Ptr_Glob->Discr);
   printf ("        should be:   %d\n", 0);
   printf ("  Enum_Comp:         %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
   printf ("        should be:   %d\n", 2);
   printf ("  Int_Comp:          %d\n", Ptr_Glob->variant.var_1.Int_Comp);
   printf ("        should be:   %d\n", 17);
   printf ("  Str_Comp:          %s\n", Ptr_Glob->variant.var_1.Str_Comp);
   printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
   printf ("Next_Ptr_Glob->\n");
   printf ("  Ptr_Comp:          %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
   printf ("        should be:   (implementation-dependent), same as above\n");
   printf ("  Discr:             %d\n", Next_Ptr_Glob->Discr);
   printf ("        should be:   %d\n", 0);
   printf ("  Enum_Comp:         %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
   printf ("        should be:   %d\n", 1);
   printf ("  Int_Comp:          %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
   printf ("        should be:   %d\n", 18);
   printf ("  Str_Comp:          %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp);
   printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
   printf ("Int_1_Loc:           %d\n", Int_1_Loc);
   printf ("        should be:   %d\n", 5);
   printf ("Int_2_Loc:           %d\n", Int_2_Loc);
   printf ("        should be:   %d\n", 13);
   printf ("Int_3_Loc:           %d\n", Int_3_Loc);
   printf ("        should be:   %d\n", 7);
   printf ("Enum_Loc:            %d\n", Enum_Loc);
   printf ("        should be:   %d\n", 1);
   printf ("Str_1_Loc:           %s\n", Str_1_Loc);
   printf ("        should be:   DHRYSTONE PROGRAM, 1'ST STRING\n");
   printf ("Str_2_Loc:           %s\n", Str_2_Loc);
   printf ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
   printf ("\n");
 */
   User_Time = End_Time - Begin_Time;
 
   if (User_Time < Too_Small_Time) return -1;
   else
   {
     Microseconds = User_Time * Mic_secs_Per_Second
                         / (double) Number_Of_Runs;
     Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
     Vax_Mips = Dhrystones_Per_Second / 1757.0;
 
 #ifdef ROPT
     //printf ("Register option selected?  YES\n");
 #else
     //printf ("Register option selected?  NO\n");
     strncpy(Reg_Define, "Register option not selected.", 30);
 #endif
     printf ("Microseconds for one run through Dhrystone: ");
     printf ("%7.1lf \n", Microseconds);
     printf ("Dhrystones per Second:                      ");
     printf ("%10.1lf \n", Dhrystones_Per_Second);
     printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips);
     printf ("\n");
 
     return Dhrystones_Per_Second;
 
 /*
 
   fprintf(Ap,"\n");
   fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n");
   fprintf(Ap,"%s\n",Reg_Define);
   fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds);
   fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second);
   fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips);
   fclose(Ap);
 */
 
   }
 
 }