Every file in this commit makes a call to a function which returns a value.

Each file also didn't check the return value.

This commit changes it so that every single non-checked call in these files
is checked.

14 files changed, 109 insertions, 92 deletions

diff --git a/core/multimedia/opieplayer/om3u.cpp b/core/multimedia/opieplayer/om3u.cpp
index 48aa47e..68ea015 100644
--- a/core/multimedia/opieplayer/om3u.cpp
+++ b/core/multimedia/opieplayer/om3u.cpp
@@ -1,163 +1,164 @@
 /*
                              This file is part of the Opie Project
 
                              Copyright (C) 2002 L. Potter <ljp@llornkcor.com>
               =.
             .=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 "om3u.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 
 
 static inline QString fullBaseName ( const QFileInfo &fi )
 {
   QString str = fi. fileName ( );
   return str. left ( str. findRev ( '.' ));
 }
 
 
 //extern PlayListWidget *playList;
 
 Om3u::Om3u( const QString &filePath, int mode)
       : QStringList (){
 //odebug << "<<<<<<<new m3u "+filePath << oendl;
   f.setName(filePath);
-  f.open(mode);
+  if ( !f.open(mode) )
+      owarn << "Failed to open file " << f.name() << oendl;
 }
 
 Om3u::~Om3u(){}
 
 void Om3u::readM3u() {
 //    odebug << "<<<<<<reading m3u "+f.name() << oendl;
    QTextStream t(&f);
      t.setEncoding(QTextStream::UnicodeUTF8);
    QString s;
    while ( !t.atEnd() ) {
       s=t.readLine();
       //                odebug << s << oendl;
       if( s.find( "#", 0, TRUE) == -1 ) {
          if( s.left(2) == "E:" || s.left(2) == "P:" ) {
             s = s.right( s.length() -2 );
             QFileInfo f( s );
             QString name = fullBaseName ( f );
             name = name.right( name.length() - name.findRev( "\\", -1, TRUE )  -1 );
             s=s.replace( QRegExp( "\\" ), "/" );
             append(s);
             //                    odebug << s << oendl;
          } else { // is url
             s.replace( QRegExp( "%20" )," " );
             QString name;
             //                     if( name.left( 4 ) == "http" ) {
             //                         name = s.right( s.length() - 7 );
             //                     } else {
             name = s;
             //                     }
             append(name);
             //                    odebug << name << oendl;
          }
       }
    }
 }
 
 void Om3u::readPls() { //it's a pls file
         QTextStream t( &f );
                 t.setEncoding(QTextStream::UnicodeUTF8);
         QString s;
         while ( !t.atEnd() ) {
             s = t.readLine();
             if( s.left(4)  == "File" ) {
                 s = s.right( s.length() - 6 );
                 s.replace( QRegExp( "%20" )," ");
 //                odebug << "adding " + s + " to playlist" << oendl;
                 // numberofentries=2
                 // File1=http
                 // Title
                 // Length
                 // Version
                 // File2=http
                 s = s.replace( QRegExp( "\\" ), "/" );
                 QFileInfo f( s );
                 QString name = fullBaseName ( f );
                 if( name.left( 4 ) == "http" ) {
                     name = s.right( s.length() - 7);
                 }  else {
                     name = s;
                 }
                 name = name.right( name.length() - name.findRev( "\\", -1, TRUE) - 1 );
                 if( s.at( s.length() - 4) == '.') // if this is probably a file
                 append(s);
                 else { //if its a url
                     if( name.right( 1 ).find( '/' ) == -1) {
                         s += "/";
                     }
                     append(s);
                 }
             }
         }
 }
 
 void Om3u::write() { //writes list to m3u file
   QString list;
     QTextStream t(&f);
   t.setEncoding(QTextStream::UnicodeUTF8);
   if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
        //      odebug << *it << oendl;
                 t << *it << "\n";
     }
   }
 //    f.close();
 }
 
 void Om3u::add(const QString &filePath) { //adds to m3u file
     append(filePath);
 }
 
 void Om3u::remove(const QString &filePath) { //removes from m3u list
   QString list, currentFile;
   if(count()>0) {
     for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) {
       currentFile=*it;
       //        odebug << *it << oendl;
 
       if( filePath != currentFile)
         list += currentFile+"\n";
     }
     f.writeBlock( list, list.length() );
   }
 }
 
 void Om3u::deleteFile(const QString &) {//deletes m3u file
      f.close();
      f.remove();
 
 }
 
 void Om3u::close() { //closes m3u file
     f.close();
 }
diff --git a/libopie2/opiemm/opieexif.cpp b/libopie2/opiemm/opieexif.cpp
index de49937..653216c 100644
--- a/libopie2/opiemm/opieexif.cpp
+++ b/libopie2/opiemm/opieexif.cpp
@@ -16,385 +16,385 @@
 #include <math.h>
 #include <time.h>
 
 #include <qstring.h>
 #include <qfile.h>
 #include <qimage.h>
 
 //static int HaveAll;
 
 //--------------------------------------------------------------------------
 // Table of Jpeg encoding process names
 
 #define M_SOF0  0xC0            // Start Of Frame N
 #define M_SOF1  0xC1            // N indicates which compression process
 #define M_SOF2  0xC2            // Only SOF0-SOF2 are now in common use
 #define M_SOF3  0xC3
 #define M_SOF5  0xC5            // NB: codes C4 and CC are NOT SOF markers
 #define M_SOF6  0xC6
 #define M_SOF7  0xC7
 #define M_SOF9  0xC9
 #define M_SOF10 0xCA
 #define M_SOF11 0xCB
 #define M_SOF13 0xCD
 #define M_SOF14 0xCE
 #define M_SOF15 0xCF
 #define M_SOI   0xD8            // Start Of Image (beginning of datastream)
 #define M_EOI   0xD9            // End Of Image (end of datastream)
 #define M_SOS   0xDA            // Start Of Scan (begins compressed data)
 #define M_JFIF  0xE0            // Jfif marker
 #define M_EXIF  0xE1            // Exif marker
 #define M_COM   0xFE            // COMment
 
 
 //--------------------------------------------------------------------------
 // Describes format descriptor
 static int BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
 #define NUM_FORMATS 12
 
 #define FMT_BYTE       1
 #define FMT_STRING     2
 #define FMT_USHORT     3
 #define FMT_ULONG      4
 #define FMT_URATIONAL  5
 #define FMT_SBYTE      6
 #define FMT_UNDEFINED  7
 #define FMT_SSHORT     8
 #define FMT_SLONG      9
 #define FMT_SRATIONAL 10
 #define FMT_SINGLE    11
 #define FMT_DOUBLE    12
 
 //--------------------------------------------------------------------------
 // Describes tag values
 
 #define TAG_EXIF_OFFSET       0x8769
 #define TAG_INTEROP_OFFSET    0xa005
 
 #define TAG_MAKE              0x010F
 #define TAG_MODEL             0x0110
 #define TAG_ORIENTATION       0x0112
 
 #define TAG_EXPOSURETIME      0x829A
 #define TAG_FNUMBER           0x829D
 
 #define TAG_SHUTTERSPEED      0x9201
 #define TAG_APERTURE          0x9202
 #define TAG_MAXAPERTURE       0x9205
 #define TAG_FOCALLENGTH       0x920A
 
 #define TAG_DATETIME_ORIGINAL 0x9003
 #define TAG_USERCOMMENT       0x9286
 
 #define TAG_SUBJECT_DISTANCE  0x9206
 #define TAG_FLASH             0x9209
 
 #define TAG_FOCALPLANEXRES    0xa20E
 #define TAG_FOCALPLANEUNITS   0xa210
 #define TAG_EXIF_IMAGEWIDTH   0xA002
 #define TAG_EXIF_IMAGELENGTH  0xA003
 
 // the following is added 05-jan-2001 vcs
 #define TAG_EXPOSURE_BIAS     0x9204
 #define TAG_WHITEBALANCE      0x9208
 #define TAG_METERING_MODE     0x9207
 #define TAG_EXPOSURE_PROGRAM  0x8822
 #define TAG_ISO_EQUIVALENT    0x8827
 #define TAG_COMPRESSION_LEVEL 0x9102
 
 #define TAG_THUMBNAIL_OFFSET  0x0201
 #define TAG_THUMBNAIL_LENGTH  0x0202
 
 
 
 namespace Opie {
 
 namespace MM {
 
 class FatalError {
     const char* ex;
 public:
     FatalError(const char* s) { ex = s; }
     void debug_print() const { owarn << "exception: " << ex << "" << oendl;  }
 };
 
 ExifData::TagTable_t ProcessTable[] = {
     { M_SOF0,   "Baseline"},
     { M_SOF1,   "Extended sequential"},
     { M_SOF2,   "Progressive"},
     { M_SOF3,   "Lossless"},
     { M_SOF5,   "Differential sequential"},
     { M_SOF6,   "Differential progressive"},
     { M_SOF7,   "Differential lossless"},
     { M_SOF9,   "Extended sequential, arithmetic coding"},
     { M_SOF10,  "Progressive, arithmetic coding"},
     { M_SOF11,  "Lossless, arithmetic coding"},
     { M_SOF13,  "Differential sequential, arithmetic coding"},
     { M_SOF14,  "Differential progressive, arithmetic coding"},
     { M_SOF15,  "Differential lossless, arithmetic coding"},
     { 0,        "Unknown"}
 };
 
 //--------------------------------------------------------------------------
 // Parse the marker stream until SOS or EOI is seen;
 //--------------------------------------------------------------------------
 int ExifData::ReadJpegSections (QFile & infile, ReadMode_t ReadMode)
 {
     int a;
 
     a = infile.getch();
 
     if (a != 0xff || infile.getch() != M_SOI) {
         SectionsRead = 0;
         return false;
     }
     for(SectionsRead = 0; SectionsRead < MAX_SECTIONS-1; ){
         int marker = 0;
         int got;
         unsigned int ll,lh;
         unsigned int itemlen;
         uchar * Data;
 
         for (a=0;a<7;a++){
             marker = infile.getch();
             if (marker != 0xff) break;
 
             if (a >= 6){
 
                 owarn << "too many padding bytes" << oendl;
                 return false;
 
             }
         }
 
         if (marker == 0xff){
             // 0xff is legal padding, but if we get that many, something's wrong.
             return false;
         }
 
         Sections[SectionsRead].Type = marker;
 
         // Read the length of the section.
         lh = (uchar) infile.getch();
         ll = (uchar) infile.getch();
 
         itemlen = (lh << 8) | ll;
 
         if (itemlen < 2) {
             return false;;
         }
 
         Sections[SectionsRead].Size = itemlen;
 
         Data = (uchar *)malloc(itemlen+1); // Add 1 to allow sticking a 0 at the end.
         Sections[SectionsRead].Data = Data;
 
         // Store first two pre-read bytes.
         Data[0] = (uchar)lh;
         Data[1] = (uchar)ll;
 
         got = infile.readBlock((char*)Data+2, itemlen-2); // Read the whole section.
         if (( unsigned ) got != itemlen-2){
             return false;
         }
         SectionsRead++;
 
         switch(marker){
 
             case M_SOS:   // stop before hitting compressed data
                 // If reading entire image is requested, read the rest of the data.
                 if (ReadMode & READ_IMAGE){
                     unsigned long size;
 
-                    size = QMAX( 0ul, infile.size()-infile.at() );
+                    size = infile.size()-infile.at();
                     Data = (uchar *)malloc(size);
                     if (Data == NULL){
                         return false;
                     }
 
                     got = infile.readBlock((char*)Data,  size);
                     if (( unsigned ) got != size){
                         return false;
                     }
 
                     Sections[SectionsRead].Data = Data;
                     Sections[SectionsRead].Size = size;
                     Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
                     SectionsRead ++;
                     //HaveAll = 1;
                 }
                 return true;
 
             case M_EOI:   // in case it's a tables-only JPEG stream
                 owarn << "No image in jpeg!" << oendl;
                 return false;
 
             case M_COM: // Comment section
         // pieczy 2002-02-12
         // now the User comment goes to UserComment
         // so we can store a Comment section also in READ_EXIF mode
         process_COM(Data, itemlen);
                 break;
 
             case M_JFIF:
                 // Regular jpegs always have this tag, exif images have the exif
                 // marker instead, althogh ACDsee will write images with both markers.
                 // this program will re-create this marker on absence of exif marker.
                 // hence no need to keep the copy from the file.
                 free(Sections[--SectionsRead].Data);
                 break;
 
             case M_EXIF:
                 // Seen files from some 'U-lead' software with Vivitar scanner
                 // that uses marker 31 for non exif stuff.  Thus make sure
                 // it says 'Exif' in the section before treating it as exif.
                 if ((ReadMode & READ_EXIF) && memcmp(Data+2, "Exif", 4) == 0){
                     process_EXIF((uchar *)Data, itemlen);
                 }else{
                     // Discard this section.
                     free(Sections[--SectionsRead].Data);
                 }
                 break;
 
             case M_SOF0:
             case M_SOF1:
             case M_SOF2:
             case M_SOF3:
             case M_SOF5:
             case M_SOF6:
             case M_SOF7:
             case M_SOF9:
             case M_SOF10:
             case M_SOF11:
             case M_SOF13:
             case M_SOF14:
             case M_SOF15:
                 process_SOFn(Data, marker);
             default:
                 break;
                 break;
         }
     }
     return true;
 }
 
 //--------------------------------------------------------------------------
 // Discard read data.
 //--------------------------------------------------------------------------
 void ExifData::DiscardData(void)
 {
     for (int a=0; a < SectionsRead; a++)
         free(Sections[a].Data);
     SectionsRead = 0;
 }
 
 //--------------------------------------------------------------------------
 // Convert a 16 bit unsigned value from file's native byte order
 //--------------------------------------------------------------------------
 int ExifData::Get16u(void * Short)
 {
     if (MotorolaOrder){
         return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
     }else{
         return (((uchar *)Short)[1] << 8) | ((uchar *)Short)[0];
     }
 }
 
 //--------------------------------------------------------------------------
 // Convert a 32 bit signed value from file's native byte order
 //--------------------------------------------------------------------------
 int ExifData::Get32s(void * Long)
 {
     if (MotorolaOrder){
         return  ((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16)
               | (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 );
     }else{
         return  ((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16)
               | (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 );
     }
 }
 
 //--------------------------------------------------------------------------
 // Convert a 32 bit unsigned value from file's native byte order
 //--------------------------------------------------------------------------
 unsigned ExifData::Get32u(void * Long)
 {
     return (unsigned)Get32s(Long) & 0xffffffff;
 }
 
 //--------------------------------------------------------------------------
 // Evaluate number, be it int, rational, or float from directory.
 //--------------------------------------------------------------------------
 double ExifData::ConvertAnyFormat(void * ValuePtr, int Format)
 {
     double Value;
     Value = 0;
 
     switch(Format){
         case FMT_SBYTE:     Value = *(signed char *)ValuePtr;  break;
         case FMT_BYTE:      Value = *(uchar *)ValuePtr;        break;
 
         case FMT_USHORT:    Value = Get16u(ValuePtr);          break;
 
         case FMT_ULONG:     Value = Get32u(ValuePtr);          break;
 
         case FMT_URATIONAL:
         case FMT_SRATIONAL:
             {
                 int Num,Den;
                 Num = Get32s(ValuePtr);
                 Den = Get32s(4+(char *)ValuePtr);
                 if (Den == 0){
                     Value = 0;
                 }else{
                     Value = (double)Num/Den;
                 }
                 break;
             }
 
         case FMT_SSHORT:    Value = (signed short)Get16u(ValuePtr);  break;
         case FMT_SLONG:     Value = Get32s(ValuePtr);                break;
 
         // Not sure if this is correct (never seen float used in Exif format)
         case FMT_SINGLE:    Value = (double)*(float *)ValuePtr;      break;
         case FMT_DOUBLE:    Value = *(double *)ValuePtr;             break;
     }
     return Value;
 }
 
 //--------------------------------------------------------------------------
 // Process one of the nested EXIF directories.
 //--------------------------------------------------------------------------
 void ExifData::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength)
 {
     int de;
     int a;
     int NumDirEntries;
     unsigned ThumbnailOffset = 0;
     unsigned ThumbnailSize = 0;
 
     NumDirEntries = Get16u(DirStart);
     #define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
 
     {
         unsigned char * DirEnd;
         DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
         if (DirEnd+4 > (OffsetBase+ExifLength)){
             if (DirEnd+2 == OffsetBase+ExifLength || DirEnd == OffsetBase+ExifLength){
                 // Version 1.3 of jhead would truncate a bit too much.
                 // This also caught later on as well.
             }else{
                 // Note: Files that had thumbnails trimmed with jhead 1.3 or earlier
                 // might trigger this.
                 return;
             }
         }
         if (DirEnd < LastExifRefd) LastExifRefd = DirEnd;
     }
 
     for (de=0;de<NumDirEntries;de++){
         int Tag, Format, Components;
         unsigned char * ValuePtr;
         int ByteCount;
         char * DirEntry;
         DirEntry = (char *)DIR_ENTRY_ADDR(DirStart, de);
 
@@ -620,385 +620,389 @@ void ExifData::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBa
                 SubdirStart = OffsetBase + Offset;
                 if (SubdirStart > OffsetBase+ExifLength){
                     if (SubdirStart < OffsetBase+ExifLength+20){
                         // Jhead 1.3 or earlier would crop the whole directory!
                         // As Jhead produces this form of format incorrectness,
                         // I'll just let it pass silently
                         owarn << "Thumbnail removed with Jhead 1.3 or earlier" << oendl;
                     }else{
                         return;
                     }
                 }else{
                     if (SubdirStart <= OffsetBase+ExifLength){
                         ProcessExifDir(SubdirStart, OffsetBase, ExifLength);
                     }
                 }
             }
         }else{
             // The exif header ends before the last next directory pointer.
         }
     }
 
     if (ThumbnailSize && ThumbnailOffset){
         if (ThumbnailSize + ThumbnailOffset <= ExifLength){
             // The thumbnail pointer appears to be valid.  Store it.
         Thumbnail.loadFromData(OffsetBase + ThumbnailOffset, ThumbnailSize, "JPEG");
         }
     }
 }
 
 //--------------------------------------------------------------------------
 // Process a COM marker.  We want to leave the bytes unchanged.  The
 // progam that displays this text may decide to remove blanks, convert
 // newlines, or otherwise modify the text.  In particular we want to be
 // safe for passing utf-8 text.
 //--------------------------------------------------------------------------
 void ExifData::process_COM (const uchar * Data, int length)
 {
     QChar ch;
     int a;
 
     for (a=2;a<length;a++){
         ch = Data[a];
         if (ch == '\000') continue;                     // Remove nulls
         Comment.append(ch);
     }
 }
 
 
 //--------------------------------------------------------------------------
 // Process a SOFn marker.  This is useful for the image dimensions
 //--------------------------------------------------------------------------
 void ExifData::process_SOFn (const uchar * Data, int marker)
 {
     int data_precision, num_components;
 
     data_precision = Data[2];
     ExifData::Height = Get16m(Data+3);
     ExifData::Width = Get16m(Data+5);
     num_components = Data[7];
 
     if (num_components == 3){
         ExifData::IsColor = 1;
     }else{
         ExifData::IsColor = 0;
     }
 
     ExifData::Process = marker;
 
 }
 
 //--------------------------------------------------------------------------
 // Get 16 bits motorola order (always) for jpeg header stuff.
 //--------------------------------------------------------------------------
 int ExifData::Get16m(const void * Short)
 {
     return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
 }
 
 
 //--------------------------------------------------------------------------
 // Process a EXIF marker
 // Describes all the drivel that most digital cameras include...
 //--------------------------------------------------------------------------
 void ExifData::process_EXIF(unsigned char * CharBuf, unsigned int length)
 {
     ExifData::FlashUsed = 0; // If it s from a digicam, and it used flash, it says so.
 
     FocalplaneXRes = 0;
     FocalplaneUnits = 0;
     ExifImageWidth = 0;
     ExifImageLength = 0;
 
     {   // Check the EXIF header component
         static const uchar ExifHeader[] = "Exif\0\0";
         if (memcmp(CharBuf+2, ExifHeader,6)){
             return;
         }
     }
 
     if (memcmp(CharBuf+8,"II",2) == 0){
         // printf("Exif section in Intel order\n");
         MotorolaOrder = 0;
     }else{
         if (memcmp(CharBuf+8,"MM",2) == 0){
             // printf("Exif section in Motorola order\n");
             MotorolaOrder = 1;
         }else{
             return;
         }
     }
 
     // Check the next two values for correctness.
     if (Get16u(CharBuf+10) != 0x2a
       || Get32u(CharBuf+12) != 0x08){
         return;
     }
 
     LastExifRefd = CharBuf;
 
     // First directory starts 16 bytes in.  Offsets start at 8 bytes in.
     ProcessExifDir(CharBuf+16, CharBuf+8, length-6);
 
     // This is how far the interesting (non thumbnail) part of the exif went.
     ExifSettingsLength = LastExifRefd - CharBuf;
 
     // Compute the CCD width, in milimeters.
     if (FocalplaneXRes != 0){
         ExifData::CCDWidth = (float)(ExifImageWidth * FocalplaneUnits / FocalplaneXRes);
     }
 }
 
 //--------------------------------------------------------------------------
 // Convert exif time to Unix time structure
 //--------------------------------------------------------------------------
 int ExifData::Exif2tm(struct ::tm * timeptr, char * ExifTime)
 {
     int a;
 
     timeptr->tm_wday = -1;
 
     // Check for format: YYYY:MM:DD HH:MM:SS format.
     a = sscanf(ExifTime, "%d:%d:%d %d:%d:%d",
             &timeptr->tm_year, &timeptr->tm_mon, &timeptr->tm_mday,
             &timeptr->tm_hour, &timeptr->tm_min, &timeptr->tm_sec);
 
     if (a == 6){
         timeptr->tm_isdst = -1;
         timeptr->tm_mon -= 1;      // Adjust for unix zero-based months
         timeptr->tm_year -= 1900;  // Adjust for year starting at 1900
         return true; // worked.
     }
 
     return false; // Wasn't in Exif date format.
 }
 
 //--------------------------------------------------------------------------
 // Contructor for initialising
 //--------------------------------------------------------------------------
 ExifData::ExifData()
 {
     ExifData::Whitebalance = -1;
     ExifData::MeteringMode = -1;
     ExifData::FlashUsed = -1;
     Orientation = 0;
     Height = 0;
     Width = 0;
     IsColor = 0;
     Process = 0;
     FocalLength = 0;
     ExposureTime = 0;
     ApertureFNumber = 0;
     Distance = 0;
     CCDWidth = 0;
     ExposureBias = 0;
     ExposureProgram = 0;
     ISOequivalent = 0;
     CompressionLevel = 0;
     MotorolaOrder = 0;
 }
 
 ExifData::~ExifData()
 {
 }
 
 //--------------------------------------------------------------------------
 // process a EXIF jpeg file
 //--------------------------------------------------------------------------
 bool ExifData::scan(const QString & path)
 {
     int ret;
 
     QFile f(path);
-    f.open(IO_ReadOnly);
+    if ( !f.open(IO_ReadOnly) ) {
+	owarn << "Unable to open file " << f.name() << " readonly" << oendl;
+	DiscardData();
+	return false;
+    }
 
     // Scan the JPEG headers.
     ret = ReadJpegSections(f, READ_EXIF);
 
     if (ret == false){
         owarn << "Not JPEG file!" << oendl;
         DiscardData();
         f.close();
         return false;
     }
     f.close();
     DiscardData();
 
     //now make the strings clean,
     // for exmaple my Casio is a "QV-4000   "
     CameraMake = CameraMake.stripWhiteSpace();
     CameraModel = CameraModel.stripWhiteSpace();
     UserComment = UserComment.stripWhiteSpace();
     Comment = Comment.stripWhiteSpace();
     return true;
 }
 
 //--------------------------------------------------------------------------
 // Does the embedded thumbnail match the jpeg image?
 //--------------------------------------------------------------------------
 #ifndef JPEG_TOL
 #define JPEG_TOL 0.02
 #endif
 bool ExifData::isThumbnailSane() {
   if (Thumbnail.isNull()) return false;
 
   // check whether thumbnail dimensions match the image
   // not foolproof, but catches some altered images (jpegtran -rotate)
   if (ExifImageLength != 0 && ExifImageLength != Height) return false;
   if (ExifImageWidth != 0 && ExifImageWidth != Width) return false;
   if (Thumbnail.width() == 0 || Thumbnail.height() == 0) return false;
   if (Height == 0 || Width == 0) return false;
   double d = (double)Height/Width*Thumbnail.width()/Thumbnail.height();
   return (1-JPEG_TOL < d) && (d < 1+JPEG_TOL);
 }
 
 
 
 static QImage flip_image( const QImage& img );
 static QImage rotate_90( const QImage& img );
 static QImage rotate_180( const QImage& );
 static QImage rotate_270( const QImage& );
 
 //--------------------------------------------------------------------------
 // return a thumbnail that respects the orientation flag
 // only if it seems sane
 //--------------------------------------------------------------------------
 QImage ExifData::getThumbnail() {
   if (!isThumbnailSane()) return NULL;
   if (!Orientation || Orientation == 1) return Thumbnail;
 
   // now fix orientation
 
   QImage dest = Thumbnail;
   switch (Orientation) {  // notice intentional fallthroughs
     case 2: dest = flip_image( dest ); break;
     case 4: dest = flip_image( dest );
     case 3: dest =rotate_180( dest ); break;
     case 5: dest = flip_image( dest );
     case 6: dest = rotate_90( dest ); break;
     case 7: dest = flip_image( dest );
     case 8: dest = rotate_270( dest ); break;
     default: break; // should never happen
   }
   return dest;
 }
 
 
 /*
  *
  */
 static QImage flip_image( const QImage& img ) {
     return img.mirror( TRUE, FALSE );
 }
 
 
 static QImage dest;
 static int x, y;
 static unsigned int  *srcData, *destData; // we're not threaded anyway
 static unsigned char *srcData8, *destData8; // 8 bit is char
 static unsigned int *srcTable,  *destTable; // destination table
 
 
 static QImage rotate_90_8( const QImage &img ) {
     dest.create(img.height(), img.width(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData8 = (unsigned char *)dest.scanLine(x);
             destData8[img.height()-y-1] = srcData8[x];
         }
     }
     return dest;
 }
 
 static QImage rotate_90_all(  const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     for ( y=0; y < img.height(); ++y )    {
         srcData = (unsigned int *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ) {
             destData = (unsigned int *)dest.scanLine(x);
             destData[img.height()-y-1] = srcData[x];
         }
     }
 
     return dest;
 }
 
 
 static QImage  rotate_90( const QImage & img ) {
     if ( img.depth() > 8)
         return rotate_90_all( img );
     else
         return rotate_90_8( img );
 }
 
 static QImage rotate_180_all( const QImage& img ) {
     dest.create(img.width(), img.height(), img.depth());
     for ( y=0; y < img.height(); ++y ){
         srcData = (unsigned int *)img.scanLine(y);
         destData = (unsigned int *)dest.scanLine(img.height()-y-1);
         for ( x=0; x < img.width(); ++x )
             destData[img.width()-x-1] = srcData[x];
     }
     return dest;
 }
 
 static QImage rotate_180_8( const QImage& img ) {
     dest.create(img.width(), img.height(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         destData8 = (unsigned char *)dest.scanLine(img.height()-y-1);
         for ( x=0; x < img.width(); ++x )
             destData8[img.width()-x-1] = srcData8[x];
     }
     return dest;
 }
 
 static QImage rotate_180( const QImage& img ) {
     if ( img.depth() > 8 )
         return rotate_180_all( img );
     else
         return rotate_180_8( img );
 }
 
 
 static QImage rotate_270_8( const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData8 = (unsigned char *)dest.scanLine(img.width()-x-1);
             destData8[y] = srcData8[x];
         }
     }
 
     return dest;
 }
 
 static QImage rotate_270_all( const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     for ( y=0; y < img.height(); ++y ){
         srcData = (unsigned int *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData = (unsigned int *)dest.scanLine(img.width()-x-1);
             destData[y] = srcData[x];
         }
     }
     return dest;
 }
 
 static QImage rotate_270( const QImage& img ) {
diff --git a/noncore/apps/opie-console/filereceive.cpp b/noncore/apps/opie-console/filereceive.cpp
index 452be60..41e6888 100644
--- a/noncore/apps/opie-console/filereceive.cpp
+++ b/noncore/apps/opie-console/filereceive.cpp
@@ -1,162 +1,164 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <errno.h>
 
+#include <opie2/odebug.h>
 #include <qsocketnotifier.h>
 
 #include "io_layer.h"
 #include "procctl.h"
 #include "filereceive.h"
 
 FileReceive::FileReceive( Type t, IOLayer* lay, const QString& dir )
     : ReceiveLayer(lay, dir ), m_type( t )
 {
     m_fd = -1;
     m_not = 0l;
     m_proc = 0l;
 }
 FileReceive::~FileReceive() {
 }
 void FileReceive::receive() {
     receive( currentDir() );
 }
 void FileReceive::receive( const QString& dir ) {
     m_prog = -1;
     m_fd = layer()->rawIO();
     m_curDir = dir;
 
     if (pipe( m_comm ) < 0 )
         m_comm[0] = m_comm[1] = 0;
     if (pipe( m_info ) < 0 )
         m_info[0] = m_info[1] = 0;
 
     m_pid = fork();
     switch( m_pid ) {
     case -1:
         //emit error
         slotExec();
         break;
         /* child */
     case 0: {
         setupChild();
         char* typus =  NULL;
         switch(m_type ) {
         case SZ:
             break;
         case SX:
             typus = "-X";
             break;
         case SY:
             typus = "--ymodem";
             break;
         }
 
         /* we should never return from here */
         if( m_type == SX )
             // FIXME: file name should be configurable - currently we ensure it
             // doesn't get overwritten by -E (--rename)
             execlp("rz", "rz",  typus, "--overwrite", QObject::tr("SynchronizedFile").latin1(), NULL );
         else
             execlp("rz", "rz",  typus, "--overwrite", NULL );
 
         char resultByte = 1;
         if (m_info[1] )
             ::write(m_info[1], &resultByte, 1 );
 
         _exit( -1 );
         break;
     }
     default: {
         if ( m_info[1] )
             close( m_info[1] );
 
         if ( m_info[0] ) for (;;) {
             char resultByte; int len;
             len = read(m_info[0], &resultByte, 1 );
             /* len == 1 start up failed */
             if ( len == 1 ) {
                 emit error( StartError, tr("Could not start") );
                 return;
             }
             if ( len == -1 )
                 if ( (errno == ECHILD ) || (errno == EINTR ) )
                     continue;
 
             // len == 0 or something like this
             break;
         }
 
         if ( m_info[0] )
             close( m_info[0] );
 
         m_not = new QSocketNotifier(m_comm[0],  QSocketNotifier::Read );
         connect(m_not, SIGNAL(activated(int) ),
                 this, SLOT(slotRead() ) );
         if ( pipe(m_term) < 0 )
             m_term[0] = m_term[1] = 0;
 
         ProcCtl::self()->add(m_pid, m_term[1] );
         m_proc = new QSocketNotifier(m_term[0], QSocketNotifier::Read );
         connect(m_proc, SIGNAL(activated(int) ),
                 this, SLOT(slotExec() ) );
 
     }
         break;
 
     }
 
 }
 void FileReceive::cancel() {
     ::kill(m_pid, 9 );
 }
 void FileReceive::setupChild() {
     changeDir( currentDir() );
         /*
      * we do not want to read from our
      * information channel
      */
     if (m_info[0] )
         close(m_info[0] );
     /*
      * FD_CLOEXEC will close the
      * fd on successful exec
      */
     if (m_info[1] )
         fcntl(m_info[1], F_SETFD, FD_CLOEXEC );
 
     if (m_comm[0] )
         close( m_comm[0] );
     /*
      * now set the communication
      * m_fd STDIN_FILENO
      *      STDOUT_FILENO
      *      STDERR_FILENO
      */
     dup2( m_fd, STDIN_FILENO );
     dup2( m_fd, STDOUT_FILENO );
     dup2( m_comm[1], STDERR_FILENO );
 }
 void FileReceive::slotRead() {
     QByteArray ar(4096);
     int len = read(m_comm[0], ar.data(), 4096 );
     for (int i = 0; i < len; i++ ) {
         // printf("%c", ar[i] );
     }
     ar.resize( len );
     QString str( ar );
 }
 void FileReceive::slotExec() {
     char buf[2];
-    ::read(m_term[0], buf, 1 );
+    if (::read(m_term[0], buf, 1 ) == -1)
+	owarn << "read of m_term[0] failed" << oendl;
     delete m_proc;
     delete m_not;
     m_not = m_proc = 0l;
     close( m_term[0] );
     close( m_term[1] );
     close( m_comm[0] );
     close( m_comm[1] );
     layer()->closeRawIO(m_fd);
     emit received(QString::null);
 
 }
diff --git a/noncore/apps/opie-console/filetransfer.cpp b/noncore/apps/opie-console/filetransfer.cpp
index 7eebc65..6e2d2d5 100644
--- a/noncore/apps/opie-console/filetransfer.cpp
+++ b/noncore/apps/opie-console/filetransfer.cpp
@@ -1,248 +1,250 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <opie2/odebug.h>
 #include <qsocketnotifier.h>
 
 #include "procctl.h"
 #include "filetransfer.h"
 
 
 FileTransfer::FileTransfer( Type t, IOLayer* lay )
     : FileTransferLayer( lay ), m_type( t ), m_pid ( 0 ) {
     signal(SIGPIPE,  SIG_IGN );
 
     m_pid = 0;
     m_not = 0l;
     m_proc = 0l;
 }
 FileTransfer::~FileTransfer() {
 }
 
 /**
  * now we will send the file.
  *
  * we request an fd. The IOLayer should be closed
  * then we will setup a pipe for progress communication
  * then we will dup2 the m_fd in the forked process
  * to do direct IO from and to the fd
  */
 void FileTransfer::sendFile( const QString& file ) {
     m_prog =-1;
     m_fd = layer()->rawIO();
 //
 //    m_fd = ::open("/dev/ttyS0", O_RDWR);
 
     m_file = file;
     if ( pipe( m_comm ) < 0 )
         m_comm[0] = m_comm[1] = 0;
     if ( pipe( m_info ) < 0 )
         m_info[0] = m_info[1] = 0;
 
 
     m_pid = fork();
     switch( m_pid ) {
     case -1:
         emit error( StartError, tr("Was not able to fork") );
         slotExec();
         break;
     case 0:{
         setupChild();
         /* exec */
         char* verbose = "-vv";
         char* binray = "-b";
 
 
         char* typus;
         switch(m_type ) {
         default:
         case SZ:
             typus = "";
             break;
         case SX:
             typus = "-X";
             break;
         case SY:
             typus = "--ymodem";
             break;
         }
 
         /* we should never return from here */
         execlp("sz", "sz", verbose,  binray, file.latin1(), typus, NULL );
 
         /* communication for error!*/
         char resultByte =1;
         if (m_info[1] )
             write(m_info[1], &resultByte, 1 );
         _exit( -1 );
         break;
     }
     default:{
         if ( m_info[1] )
             close( m_info[1] );
         if ( m_info[0] ) for (;;) {
             char resultByte; int len;
             len = read(m_info[0], &resultByte, 1 );
             /* len == 1 start up failed */
             if ( len == 1 ) {
                 emit error( StartError, tr("Could not start") );
                 return;
             }
             if ( len == -1 )
                 if ( (errno == ECHILD ) || (errno == EINTR ) )
                     continue;
 
             // len == 0 or something like this
             break;
         }
         if ( m_info[0] )
             close( m_info[0] );
 
 
 
         /* replace by QSocketNotifier!!! */
         m_not = new QSocketNotifier(m_comm[0],  QSocketNotifier::Read );
         connect(m_not, SIGNAL(activated(int) ),
                 this, SLOT(slotRead() ) );
         if ( pipe(m_term) < 0 )
             m_term[0] = m_term[1] = 0;
 
         ProcCtl::self()->add(m_pid, m_term[1] );
         m_proc = new QSocketNotifier(m_term[0], QSocketNotifier::Read );
         connect(m_proc, SIGNAL(activated(int) ),
                 this, SLOT(slotExec() ) );
 
     }
         break;
     }
 }
 /*
  * let's call the one with the filename
  */
 void FileTransfer::sendFile( const QFile& file ) {
     sendFile( file.name() );
 }
 
 /*
  * setting up communication
  * between parent child and ioLayer
  */
 void FileTransfer::setupChild() {
     /*
      * we do not want to read from our
      * information channel
      */
     if (m_info[0] )
         close(m_info[0] );
     /*
      * FD_CLOEXEC will close the
      * fd on successful exec
      */
     if (m_info[1] )
         fcntl(m_info[1], F_SETFD, FD_CLOEXEC );
 
     if (m_comm[0] )
         close( m_comm[0] );
     /*
      * now set the communication
      * m_fd STDIN_FILENO
      *      STDOUT_FILENO
      *      STDERR_FILENO
      */
     dup2( m_fd, STDIN_FILENO );
     dup2( m_fd, STDOUT_FILENO );
     dup2( m_comm[1], STDERR_FILENO );
 }
 
 /*
  * read from the stderr of the child
  * process
  */
 void FileTransfer::slotRead() {
     QByteArray ar(4096);
     int len = read(m_comm[0], ar.data(), 4096 );
     for (int i = 0; i < len; i++ ) {
         // printf("%c", ar[i] );
     }
     ar.resize( len );
     QString str( ar );
     QStringList lis = QStringList::split(' ', str );
     /*
      * Transfer finished.. either complete or incomplete
      */
     if ( lis[0].simplifyWhiteSpace() == "Transfer" ) {
         return;
     }
     /*
      * do progress reading
      */
     slotProgress( lis );
 
 
 }
 /*
  * find the progress
  */
 void FileTransfer::slotProgress( const QStringList& list ) {
     if ( m_type != SZ )
         return;
     bool complete = true;
     int min, sec;
     int bps;
     unsigned long sent, total;
 
     min = sec = bps = -1;
     sent = total = 0;
 
     // Data looks like this
     //  0      1         2          3      4     5
     // Bytes Sent 65536/11534336 BPS:7784 ETA 24:33
     QStringList progi = QStringList::split('/', list[2].simplifyWhiteSpace()  );
     sent  = progi[0].toULong(&complete );
     if (!complete ) return;
 
     total = progi[1].toULong(&complete );
     if (!complete || total == 0) {
         return;
     }
 
 
     double pro = (double)sent/total;
     int prog = pro * 100;
 
     // speed
     progi = QStringList::split(':', list[3].simplifyWhiteSpace() );
     bps = progi[1].toInt();
 
     // time
     progi = QStringList::split(':', list[5].simplifyWhiteSpace() );
     min = progi[0].toInt();
     sec = progi[1].toInt();
 
 
     if ( prog > m_prog ) {
         m_prog = prog;
         emit progress(m_file, m_prog, bps, -1, min , sec );
     }
 
 }
 void FileTransfer::cancel() {
     if(m_pid > 0) ::kill(m_pid,9 );
 
 }
 void FileTransfer::slotExec() {
     char buf[2];
-    ::read(m_term[0], buf, 1 );
+    if (::read(m_term[0], buf, 1 ) == -1)
+	owarn << "read of m_term[0] failed" << oendl;
     delete m_proc;
     delete m_not;
     m_proc = m_not = 0l;
     close( m_term[0] );
     close( m_term[1] );
     close( m_comm[0] );
     close( m_comm[1] );
     layer()->closeRawIO( m_fd );
     emit sent();
     m_pid = 0;
 }
diff --git a/noncore/apps/opie-console/logger.cpp b/noncore/apps/opie-console/logger.cpp
index 6620faf..0fdeca0 100644
--- a/noncore/apps/opie-console/logger.cpp
+++ b/noncore/apps/opie-console/logger.cpp
@@ -1,20 +1,22 @@
 #include <qfile.h>
 #include <qtextstream.h>
+#include <opie2/odebug.h>
 
 #include "logger.h"
 
 
 Logger::Logger() {}
 
 Logger::Logger(const QString fileName) {
 	m_file.setName(fileName);
-	m_file.open(IO_ReadWrite);
+	if ( !m_file.open(IO_ReadWrite) )
+	    owarn << "failed to open " << m_file.name() << oendl;
 }
 
 Logger::~Logger() {
 	m_file.close();
 }
 
 void Logger::append(QByteArray ar) {
 	m_file.writeBlock(ar);
 }
diff --git a/noncore/apps/opie-console/mainwindow.cpp b/noncore/apps/opie-console/mainwindow.cpp
index 18c0434..aba7244 100644
--- a/noncore/apps/opie-console/mainwindow.cpp
+++ b/noncore/apps/opie-console/mainwindow.cpp
@@ -635,200 +635,201 @@ void MainWindow::slotSessionChanged( Session* ses ) {
         } 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;
 
     Config cfg( "Konsole" );
     cfg.setGroup("ScrollBar");
     if(index == sm_none)
     {
 		loc = 0;
     }
     else if(index == sm_left)
     {
 		loc = 1;
     }
     else if(index == sm_right)
     {
 		loc = 2;
     }
 	
 	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);
-    file.open(IO_WriteOnly );
+    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-console/script.cpp b/noncore/apps/opie-console/script.cpp
index faea412..8d35776 100644
--- a/noncore/apps/opie-console/script.cpp
+++ b/noncore/apps/opie-console/script.cpp
@@ -1,29 +1,31 @@
 #include <qfile.h>
 #include "script.h"
 
 Script::Script() {
 }
 
 Script::Script(const QString fileName) {
     QFile file(fileName);
-    file.open(IO_ReadOnly );
+    if ( !file.open(IO_ReadOnly ) )
+	return;
     m_script = file.readAll();
 }
 
 void Script::saveTo(const QString fileName) const {
     QFile file(fileName);
-    file.open(IO_WriteOnly);
+    if ( !file.open(IO_WriteOnly) )
+	return;
     file.writeBlock(m_script);
     file.close();
 }
 
 
 void Script::append(const QByteArray &data) {
     int size = m_script.size();
     m_script.resize(size + data.size());
     memcpy(m_script.data() + size, data.data(), data.size());
 }
 
 QByteArray Script::script() const {
     return m_script;
 }
diff --git a/noncore/apps/opie-gutenbrowser/gutenbrowser.cpp b/noncore/apps/opie-gutenbrowser/gutenbrowser.cpp
index 733db17..8b02f9f 100644
--- a/noncore/apps/opie-gutenbrowser/gutenbrowser.cpp
+++ b/noncore/apps/opie-gutenbrowser/gutenbrowser.cpp
@@ -656,400 +656,394 @@ void Gutenbrowser::setBookmark() {
 				cfg.writeEntry("Title", title);
 
 				int row =  Lview->topRow();// Lview->Top();
 				cfg.writeEntry("LineNumber",QString::number(row) );
 
 				cfg.setGroup(title);
 				cfg.writeEntry("File Name",file_name);
 				cfg.writeEntry( "LineNumber", QString::number( row));
 				cfg.writeEntry( "PagePosition", QString::number( pageStopArray[i_pageNum - 1]));
 				cfg.writeEntry( "Page Number", QString::number( i_pageNum) );
 				cfg.write();
 				bookmarksMenu->insertItem( title);
 		}
 } //end setBookmark
 
 
   /* goes to last set bookmark*/
 void Gutenbrowser::Bookmark( int itemId) {
 
 			//    qApp->processEvents();
 		Config config("Gutenbrowser");
 		config.setGroup( "Bookmarks" );
 
 		odebug << "<<<<<< " << Lview->PageSize() << ", " << Lview->lastRow() - Lview->topRow() << "" << oendl;
 
 		QString itemString;
 
 		odebug << "menu item " << itemId << "" << oendl;
 		QString tempTitle;
 		QString s_Bmrkrow;
 		QString s_pageNum;
 		int Bmrkrow=0;
 		int bookmarkPosition = 0;
 
 			//    qApp->processEvents();
 		config.setGroup( "Bookmarks" );
 		title = config.readEntry("Title", "");
 		file_name = config.readEntry("File Name", "");
 		i_pageNum = config.readNumEntry("Page Number", 0);
 		bookmarkPosition = config.readNumEntry( "PagePosition",0);
 		Bmrkrow = config.readNumEntry("LineNumber",0);
 		if( !file_name.contains("/")) {
 				file_name = local_library + file_name;
 		}
 
 			//    getTitle(file_name);
 			//    qApp->processEvents();
 			//    Lview->setFocus();
 		this->setFocus();
 
 		Lview->clear();
 
 		if(!load(file_name)) return;
 
 		int pageSize = Lview->PageSize();
 		f.at(0);
 			//    Lview->clear();
 		QString s;
 		int lineNo=0;
 		int lastPage=1;
 		while ( !f.atEnd() ) {
 				f.readLine(s, 256);
 				lineNo++;
 				currentFilePos = f.at();
 
 				i_pageNum = lineNo/pageSize;
 				if(lastPage < i_pageNum) {
 						pageStopArray.resize(i_pageNum + 1);
 						pageStopArray[i_pageNum ] = currentFilePos;
 //												odebug << "new page number " << i_pageNum << ", found at " << currentFilePos << "" << oendl;
 				}
 				if(currentFilePos == bookmarkPosition)
 						break;
 		}
 		if(f.atEnd())
 				f.at(0);
 		else
 				f.at( bookmarkPosition);
 
 		for(int fd=0; fd < pageSize - 1;fd++) {
 				f.readLine(s, 256);
 				lineNo++;
 				if(useWrap)
 						s.replace(QRegExp("\n"),"");
 				Lview->insertLine( s, -1);
 				currentLine++;
 		}
 
 		i_pageNum = lineNo/pageSize;
 		pageStopArray.resize(i_pageNum + 1);
 
 		if(showMainList) {
 				showMainList=FALSE;
 				mainList->hide();
 				Lview->show();
 					//        qApp->processEvents();
 		}
 
 		odebug << "bookmark loaded" << oendl;
 		setCaption(title);
 }
 
 
 bool Gutenbrowser::load( const char *fileName) {
 
 			//    QCopEnvelope ( "QPE/System", "busy()" );
 		odebug << "Title is already set as "+title << oendl;
 		odebug << "sizeHint " << sizeHint().height() << " pageSize " << Lview->PageSize() << "" << oendl;
 //				pointSize = Lview->fontInfo().pointSize();
 //				odebug << "sizeHint " << sizeHint().height() << " point size " << pointSize << "" << oendl;
 		if( Lview->PageSize() < 4) {
 
 					//	Lview->setMaximumHeight( sizeHint().height() );
 				Lview->setMinimumHeight( sizeHint().height() );
 				pointSize = Lview->fontInfo().pointSize();
 				odebug << "sizeHint " << sizeHint().height() << " point size " << pointSize << "" << oendl;
 				if(pointSize < 15)
 						Lview->setFixedVisibleLines(19);
 				else
 						Lview->setFixedVisibleLines( ( (sizeHint().height() / pointSize ) * 2) -2);
 		}
 
 		Config cfg("Gutenbrowser");
 		cfg.setGroup("General");
 		cfg.writeEntry("Current",fileName);
 		cfg.write();
 		currentLine=0;
 
 		file_name=fileName;
 		QString o_file = fileName;
 
 			//  if (i_pageNum < 1) {
 		i_pageNum = 1;
 			//  }
 		odebug << "ready to open "+o_file << oendl;
 
 		if(f.isOpen()) f.close();
 		f.setName( o_file);
 
 		if ( !f.open( IO_ReadOnly)) {
 				QMessageBox::message( (tr("Note")), (tr("File not opened sucessfully.\n" +o_file)) );
 				return  false;
 		}
 		currentFilePos = 0;
 		pageStopArray.resize(3);
 		pageStopArray[0] = currentFilePos;
 
 		fileHandle = f.handle();
 		QString insertString;
 		QTextStream t(&f);
 		QString s;
 		for(int fd=0; fd < Lview->PageSize() ;fd++) {
 				s=t.readLine();
 					//      insertString+=s;
 				if(useWrap)
 						s.replace(QRegExp("\n"),"");
 					//    s.replace(QRegExp("\r"),"");
 				Lview->insertLine( s,-1);
 				currentLine++;
 		}
 
 			//    int length = Lview->length();
 		currentFilePos = f.at();
 
 		pageStopArray[1] = currentFilePos;
 
 		odebug << "<<<<<<<<<<<" << currentFilePos << " current page is number " << i_pageNum
 					 << ", length " << Lview->length() << ", current " << pageStopArray[i_pageNum]
 					 << ", pageSize " << Lview->PageSize() << oendl;
 
 		Lview->setMaxLines(Lview->PageSize()*2);
 //        odebug << "Gulped " << currentLine << "" << oendl;
 		setCaption(title);
 		Lview->setAutoUpdate( TRUE);
 
 //        Lview->setCursorPosition(0,0,FALSE);
 
 			//    pages = (int)(( Lview->numLines() / Lview->editSize() ) / 2 ) +1;
 			//odebug << "number of pages " << pages << "" << oendl;
 
 		loadCheck = true;
 		enableButtons(true);
 		if( donateMenu->count() == 3) {
 				donateMenu->insertItem("Current Title", this, SLOT( InfoBarClick() ));
 		}
 		Lview->setFocus();
 
 			//   QCopEnvelope("QPE/System", "notBusy()" );
 		return true;
 } // end load
 
 void Gutenbrowser::Search() {
-
-			//    if( searchDlg->isHidden())
-		{
-				odebug << "Starting search dialog" << oendl;
-				searchDlg = new SearchDialog( this, "Etext Search", true);
-				searchDlg->setCaption( tr( "Etext Search" ));
-					//        searchDlg->setLabel( "- searches etext");
-				connect( searchDlg,SIGNAL( search_signal()),this,SLOT( search_slot()));
-				connect( searchDlg,SIGNAL( search_done_signal()),this,SLOT( searchdone_slot()));
-
-				QString resultString;
-				QString string = searchDlg->searchString;
-				Lview->deselect();
-				searchDlg->show();
-				searchDlg->result();
-		}
+	odebug << "Starting search dialog" << oendl;
+	searchDlg = new SearchDialog( this, "Etext Search", true);
+	searchDlg->setCaption( tr( "Etext Search" ));
+	connect( searchDlg,SIGNAL( search_signal()),this,SLOT( search_slot()));
+	connect( searchDlg,SIGNAL( search_done_signal()),this,SLOT( searchdone_slot()));
+
+	QString resultString;
+	QString string = searchDlg->searchString;
+	Lview->deselect();
+	searchDlg->show();
 }
 
 void Gutenbrowser::search_slot( ) {
     int line, col;
     if (!searchDlg /*&& !loadCheck */)
 				return;
 
     Lview->getCursorPosition(&line,&col);
     QString to_find_string=searchDlg->get_text();
 
 			// searchDlg->get_direction();// is true if searching backward
     if ( last_search != 0 && searchDlg->get_direction() ){
 				col = col  - pattern.length() - 1 ;
     }
   again:
     int  result = doSearch( to_find_string , /* searchDlg->case_sensitive()*/ TRUE, searchDlg->forward_search(), line, col);
     if(result == 0){
 				if(!searchDlg->get_direction()){ // forward search
 						int query = QMessageBox::information( searchDlg, "Find",
 																									"End of document reached.\nContinue from the beginning?",
 																									"Yes", "No", "", 0,1);
 						if (query == 0){
 								line = 0;
 								col = 0;
 								goto again;
 						}
 				} else { //backward search
 						int query = QMessageBox::information( searchDlg, "Find",
 																									"End of document reached.\nContinue from the beginning?",
 																									"Yes", "No", "", 0,1);
 						if (query == 0){
 								QString string = Lview->textLine( Lview->numLines() - 1 );
 								line = Lview->numLines() - 1;
 								lineCheck = line;
 								col  = string.length();
 								last_search = -1; //BACKWARD;
 								goto again;
 						}
 				}
     } else {
 
 					////    emit CursorPositionChanged(); textLine
     }
 }
 
 int Gutenbrowser::doSearch( const QString &s_pattern , bool case_sensitive,  bool forward, int line, int col ) {
 		int i, length;
 		int pos = -1;
 		if(forward) {
 				QString string;
 				for(i = line; i < Lview->numLines(); i++) {
 
 						string = Lview->textLine(i);
 						pos = string.find(s_pattern, i == line ? col : 0, case_sensitive);
 						if( pos != -1) {
 								int top = Lview->Top();
 								length = s_pattern.length();
 								if( i > Lview->lastRow() ) {
 //                                        Lview->setCursorPosition(i,pos,FALSE);
 										for(int l = 0 ; l < length; l++) {
 												Lview->cursorRight(TRUE);
 										}
 //                                        Lview->setCursorPosition( i , pos + length, TRUE );
 										int newTop = Lview->Top();
 										if(Lview->lastRow() > i)
 												Lview->ScrollUp( newTop - top);
 											//                    AdjustStatus();
 								} else {
 //                                        Lview->setCursorPosition(i,pos,FALSE);
 										for(int l = 0 ; l < length; l++) {
 												Lview->cursorRight(TRUE);
 										}
 //                                        Lview->setCursorPosition( i , pos + length, TRUE );
 											//                    AdjustStatus();
 								}
 								pattern = s_pattern;
 								last_search = 1; //FORWARD;
 								return 1;
 						}
 				}
 		} else { //////////////// searching backwards
 				QString string;
 				for( i = line; i >= 0; i--) {
 						string = Lview->textLine(i);
 						int line_length = string.length();
 						pos = string.findRev(s_pattern, line == i ? col : line_length , case_sensitive);
 						if (pos != -1) {
 									//                int top = Lview->Top();
 								length = s_pattern.length();
 								if( i <  Lview->Top() ) {
 										Lview->ScrollDown( Lview->PageSize() );
 										Lview->MultiLine_Ex::pageUp( FALSE );
 										if( ! (line == i && pos > col ) ) {
 //                                                Lview->setCursorPosition( i ,pos ,FALSE );
 												for(int l = 0 ; l < length; l++) {
 														Lview->cursorRight(TRUE);
 												}
 //                                                Lview->setCursorPosition(i ,pos + length ,TRUE );
 													//                        int newTop = Lview->Top();
 													/*                        if(useSplitter) Rview->ScrollUp( newTop - top);
 													 */                    }
 								} else {
 										if( ! (line == i && pos > col ) ) {
 //                                                Lview->setCursorPosition( i, pos, FALSE );
 												for( int l = 0 ; l < length; l++) {
 														Lview->cursorRight( TRUE);
 												}
 //                                                Lview->setCursorPosition( i, pos + length, TRUE );
 										}
 										pattern = s_pattern;
 										last_search = -1;
 										return 1;
 								}
 						}
 				}
 		}
 		return 0;
 }
 
 void Gutenbrowser::LibraryBtn() {
 
 		QString newestLibraryFile ="pgwhole.zip";
 		QString zipFile;
 			//    odebug << "Local Library is " << local_library << " " << oendl;
 		zipFile="/usr/bin/unzip";
 			//    odebug << "newestLibraryFile is " << newestLibraryFile << " " << oendl;
 		if( QFile::exists( local_library+newestLibraryFile)) {
 				if( QFile::exists(zipFile) ) {
 						UnZipIt(newestLibraryFile);
 				}
 				else
 						QMessageBox::message( "Note",( tr("Please install unzip")) );
 		}
 			//    LibraryDlg = new LibraryDialog( this, "Library Index");
 		LibraryDlg->setCaption( tr( "Gutenberg Library"));
 		Config config("Gutenbrowser");
 		config.setGroup("General");
 
 		if(useSplitter)
 				LibraryDlg->useSmallInterface=FALSE;
 
 		LibraryDlg->showMaximized();
 
 		if( LibraryDlg->exec() != 0 ) {
 				listItemNumber = LibraryDlg->DlglistItemNumber;
 				listItemFile =  LibraryDlg->DlglistItemFile;
 				listItemYear = LibraryDlg->DlglistItemYear;
 				listItemTitle = LibraryDlg->DlglistItemTitle;
 				file_name = LibraryDlg->File_Name;
 					//        odebug << "title is being set as "+title << oendl;
 				title = listItemTitle;
 
 					//                  config.setGroup( "Proxy" );
 					//              if( LibraryDlg->checked == 1) {
 					//                  config.writeEntry("IsChecked", "TRUE");
 					//                  } else {
 					//                  config.writeEntry("IsChecked", "FALSE");
 					//              }
 					//                  config.write();
 					//            config.read();
 				if ( listItemNumber.isNull()) {
 				} else {
 						i_pageNum = 1;
 						if( file_name !="Error" && file_name.length() >2 && !file_name.isEmpty() ) {
 									//replace .zip with txt for opening it.
 									//                    printf("\nFile name is now\n");
 									//                    printf(file_name);
 									//                    printf("\n");
 									//
 								if( file_name.find(".zip"))
 									{
 											odebug << "Found zip file\n" << oendl;
 												//              QStringList args;
 												//              args="unzip";
 												//              args+="-o";
 												//              args+=local_library+file_name;
 												//              args+="-d";
 												//              args+=local_library;
 											QString cmd = "/usr/bin/unzip -o " + local_library+file_name + " -d " + local_library;
 											odebug << "Issuing the command "+ cmd << oendl;
 												//  unzipProc=new QProcess( this, "unzipProc" );  /// fark that idea!
 												//  unzipProc->start();
 											system(cmd);
 											remove( file_name);
 
 									}
 									//  //
 									//                    file_name = file_name.left(4)+ ".txt";
 								if( LibraryDlg)
 										delete LibraryDlg;
 								setTitle();
 									//    QCopEnvelope ( "QPE/System", "busy()" );
diff --git a/noncore/apps/opie-gutenbrowser/helpwindow.cpp b/noncore/apps/opie-gutenbrowser/helpwindow.cpp
index 4bdac02..f444a2e 100644
--- a/noncore/apps/opie-gutenbrowser/helpwindow.cpp
+++ b/noncore/apps/opie-gutenbrowser/helpwindow.cpp
@@ -4,330 +4,328 @@
 ** 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.
 **
     copyright            : (C) 2000 -2004 by llornkcor
     email                : ljp@llornkcor.com
 *****************************************************************************/
 
 #include "helpwindow.h"
 
 #include <qpe/global.h>
 
 #include <qstatusbar.h>
 
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qtoolbutton.h>
 #include <qcombobox.h>
 
 #ifndef QT_NO_FILEDIALOG
 #include <qfiledialog.h>
 #endif
 
 #include <ctype.h>
 
 HelpWindow::HelpWindow( const QString& home_, const QString&, QWidget* parent, const char *name )
     : QMainWindow( parent, name, WDestructiveClose ), pathCombo( 0 ), selectedURL()
 {
    QString local_library = Global::applicationFileName("gutenbrowser", QString::null);
 //        readHistory();
 //        readBookmarks();
 
     browser = new QTextBrowser( this );
     QStringList Strlist;
     Strlist.append( home_);
     browser->mimeSourceFactory()->setFilePath( Strlist );
 
     browser->setFrameStyle( QFrame::Panel | QFrame::Sunken );
 
     connect(browser,SIGNAL(textChanged()),this,SLOT(textChanged()));
 
     setCentralWidget( browser );
 
     if ( !home_.isEmpty() )
 
 ////////////////////////////////
         browser->setSource( home_ );
 
 ////////////////////////////////
     connect( browser, SIGNAL( highlighted( const QString&) ),
        statusBar(), SLOT( message( const QString&)) );
 
 //    resize( 640,600 );
 #ifdef Q_WS_QWS
     setGeometry( 0,0,236,280);
 #else
     setGeometry( 10,30,520,420 );
 //  resize(520,420);
 #endif
 
     QPopupMenu* file = new QPopupMenu( this );
 //    file->insertItem( tr("&New Window"), this, SLOT( newWindow() ), ALT | Key_N );
     file->insertItem( tr("&Open File"), this, SLOT( openFile() ), ALT | Key_O );
 //    file->insertItem( tr("&Print"), this, SLOT( print() ), ALT | Key_P );
     file->insertSeparator();
     file->insertItem( tr("&Close"), this, SLOT( close() ), ALT | Key_Q );
 //    file->insertItem( tr("E&xit"), qApp, SLOT( closeAllWindows() ), ALT | Key_X );
 
     // The same three icons are used twice each.
 ////F FIXME
     QString pixs=(QDir::homeDirPath ()) +"/Applications/gutenbrowser/pix/";
     QIconSet icon_back( QPixmap(pixs+"back.png") );
     QIconSet icon_forward( QPixmap(pixs+"forward.png") );
     QIconSet icon_home( QPixmap(pixs+"home.png") );
 
     QPopupMenu* go = new QPopupMenu( this );
     backwardId = go->insertItem( icon_back, tr("&Backward"), browser, SLOT( backward() ), ALT | Key_Left );
     forwardId = go->insertItem( icon_forward, tr("&Forward"), browser, SLOT( forward() ), ALT | Key_Right );
     go->insertItem( icon_home, tr("&Home"), browser, SLOT( home() ) );
 
 //      QPopupMenu* help = new QPopupMenu( this );
 //      help->insertItem( tr("&About ..."), this, SLOT( about() ) );
 //    help->insertItem( tr("About &Qt ..."), this, SLOT( aboutQt() ) );
 
 
     hist = new QPopupMenu( this );
     QStringList::Iterator it = history.begin();
     for ( ; it != history.end(); ++it )
   mHistory[ hist->insertItem( *it ) ] = *it;
     connect( hist, SIGNAL( activated( int ) ), this, SLOT( histChosen( int ) ) );
 
     bookm = new QPopupMenu( this );
     bookm->insertItem( tr( "Add Bookmark" ), this, SLOT( addBookmark() ) );
     bookm->insertSeparator();
 
     QStringList::Iterator it2 = bookmarks.begin();
     for ( ; it2 != bookmarks.end(); ++it2 )
   mBookmarks[ bookm->insertItem( *it2 ) ] = *it2;
     connect( bookm, SIGNAL( activated( int ) ),
        this, SLOT( bookmChosen( int ) ) );
 
     menuBar()->insertItem( tr("&File"), file );
     menuBar()->insertItem( tr("&Go"), go );
     menuBar()->insertItem( tr( "History" ), hist );
     menuBar()->insertItem( tr( "Bookmarks" ), bookm );
 //      menuBar()->insertSeparator();
 //      menuBar()->insertItem( tr("&Help"), help );
 
     menuBar()->setItemEnabled( forwardId, FALSE);
     menuBar()->setItemEnabled( backwardId, FALSE);
     connect( browser, SIGNAL( backwardAvailable( bool ) ), this, SLOT( setBackwardAvailable( bool ) ) );
     connect( browser, SIGNAL( forwardAvailable( bool ) ), this, SLOT( setForwardAvailable( bool ) ) );
 
 
     QToolBar* toolbar = new QToolBar( this );
     addToolBar( toolbar, "Toolbar");
     QToolButton* button;
 
     button = new QToolButton( icon_back, tr("Backward"), "", browser, SLOT(backward()), toolbar );
     connect( browser, SIGNAL( backwardAvailable(bool) ), button, SLOT( setEnabled(bool) ) );
     button->setEnabled( FALSE );
     button = new QToolButton( icon_forward, tr("Forward"), "", browser, SLOT(forward()), toolbar );
     connect( browser, SIGNAL( forwardAvailable(bool) ), button, SLOT( setEnabled(bool) ) );
     button->setEnabled( FALSE );
     button = new QToolButton( icon_home, tr("Home"), "", browser, SLOT(home()), toolbar );
 
     toolbar->addSeparator();
 
     pathCombo = new QComboBox( TRUE, toolbar );
     connect( pathCombo, SIGNAL( activated( const QString & ) ), this, SLOT( pathSelected( const QString & ) ) );
     toolbar->setStretchableWidget( pathCombo );
 
 //    pathCombo->setMaximumWidth(190);
 //     setRightJustification( TRUE );
 //      setDockEnabled( Left, FALSE );
 //      setDockEnabled( Right, FALSE );
 
     pathCombo->insertItem( home_ );
 
     browser->setFocus();
 
 
 }
 
 
 void HelpWindow::setBackwardAvailable( bool b)
 {
     menuBar()->setItemEnabled( backwardId, b);
 }
 
 void HelpWindow::setForwardAvailable( bool b)
 {
     menuBar()->setItemEnabled( forwardId, b);
 }
 
 
 void HelpWindow::textChanged()
 {
     if ( browser->documentTitle().isNull() ) {
   setCaption( "Gutenbrowser - Helpviewer - " + browser->context() );
   selectedURL = browser->context();
     }
     else {
   setCaption( "Gutenbrowser - Helpviewer - " + browser->documentTitle() ) ;
   selectedURL = browser->documentTitle();
     }
 
     if ( !selectedURL.isEmpty() && pathCombo ) {
   bool exists = FALSE;
   int i;
   for ( i = 0; i < pathCombo->count(); ++i ) {
       if ( pathCombo->text( i ) == selectedURL ) {
     exists = TRUE;
     break;
       }
   }
   if ( !exists ) {
       pathCombo->insertItem( selectedURL, 0 );
       pathCombo->setCurrentItem( 0 );
       mHistory[ hist->insertItem( selectedURL ) ] = selectedURL;
   } else
       pathCombo->setCurrentItem( i );
   selectedURL = QString::null;
     }
 }
 
 HelpWindow::~HelpWindow()
 {
     history.clear();
     QMap<int, QString>::Iterator it = mHistory.begin();
     for ( ; it != mHistory.end(); ++it )
-  history.append( *it );
+        history.append( *it );
 
     QFile f( QDir::currentDirPath() + "/.history" );
-    f.open( IO_WriteOnly );
-    QDataStream s( &f );
-    s << history;
-    f.close();
+    if ( f.open( IO_WriteOnly ) ) {
+        QDataStream s( &f );
+        s << history;
+        f.close();
+    }
 
     bookmarks.clear();
     QMap<int, QString>::Iterator it2 = mBookmarks.begin();
     for ( ; it2 != mBookmarks.end(); ++it2 )
-  bookmarks.append( *it2 );
+        bookmarks.append( *it2 );
 
     QFile f2( QDir::currentDirPath() + "/.bookmarks" );
-    f2.open( IO_WriteOnly );
+    if ( !f2.open( IO_WriteOnly ) )
+	return;
+
     QDataStream s2( &f2 );
     s2 << bookmarks;
     f2.close();
 }
 
-//  void HelpWindow::about()
-//  {
-//      QMessageBox::about( this, "Gutenbrowser", "<p>Thanks to Trolltech for this</p>" );
-//  }
-
-//  void HelpWindow::aboutQt()
-//  {
-//      QMessageBox::aboutQt( this, "QBrowser" );
-//  }
-
 void HelpWindow::openFile()
 {
 #ifndef QT_NO_FILEDIALOG
     QString fn = QFileDialog::getOpenFileName( QString::null, QString::null, this );
     if ( !fn.isEmpty() )
   browser->setSource( fn );
 #endif
 }
 
 void HelpWindow::newWindow()
 {
     ( new HelpWindow(browser->source(), "qbrowser") )->show();
 }
 
 void HelpWindow::print()
 {
 #ifndef QT_NO_PRINTER
     QPrinter printer;
     printer.setFullPage(TRUE);
     if ( printer.setup() ) {
   QPainter p( &printer );
   QPaintDeviceMetrics metrics(p.device());
   int dpix = metrics.logicalDpiX();
   int dpiy = metrics.logicalDpiY();
   const int margin = 72; // pt
   QRect body(margin*dpix/72, margin*dpiy/72,
        metrics.width()-margin*dpix/72*2,
        metrics.height()-margin*dpiy/72*2 );
   QFont font("times", 10);
   QSimpleRichText richText( browser->text(), font, browser->context(), browser->styleSheet(),
           browser->mimeSourceFactory(), body.height() );
   richText.setWidth( &p, body.width() );
   QRect view( body );
   int page = 1;
   do {
       p.setClipRect( body );
       richText.draw( &p, body.left(), body.top(), view, colorGroup() );
       p.setClipping( FALSE );
       view.moveBy( 0, body.height() );
       p.translate( 0 , -body.height() );
       p.setFont( font );
       p.drawText( view.right() - p.fontMetrics().width( QString::number(page) ),
       view.bottom() + p.fontMetrics().ascent() + 5, QString::number(page) );
       if ( view.top()  >= richText.height() )
     break;
       printer.newPage();
       page++;
   } while (TRUE);
     }
 #endif
 }
 
 void HelpWindow::pathSelected( const QString &_path )
 {
     browser->setSource( _path );
     QMap<int, QString>::Iterator it = mHistory.begin();
     bool exists = FALSE;
     for ( ; it != mHistory.end(); ++it ) {
   if ( *it == _path ) {
       exists = TRUE;
       break;
   }
     }
     if ( !exists )
   mHistory[ hist->insertItem( _path ) ] = _path;
 }
 
 void HelpWindow::readHistory()
 {
-    if ( QFile::exists( QDir::currentDirPath() + "/.history" ) ) {
-  QFile f( QDir::currentDirPath() + "/.history" );
-  f.open( IO_ReadOnly );
-  QDataStream s( &f );
-  s >> history;
-  f.close();
-  while ( history.count() > 20 )
-      history.remove( history.begin() );
-    }
+    if ( !QFile::exists( QDir::currentDirPath() + "/.history" ) )
+	return;
+
+    QFile f( QDir::currentDirPath() + "/.history" );
+    if ( !f.open( IO_ReadOnly ) )
+	return;
+
+    QDataStream s( &f );
+    s >> history;
+    f.close();
+    while ( history.count() > 20 )
+        history.remove( history.begin() );
 }
 
 void HelpWindow::readBookmarks()
 {
-    if ( QFile::exists( QDir::currentDirPath() + "/.bookmarks" ) ) {
-  QFile f( QDir::currentDirPath() + "/.bookmarks" );
-  f.open( IO_ReadOnly );
-  QDataStream s( &f );
-  s >> bookmarks;
-  f.close();
-    }
+    if ( !QFile::exists( QDir::currentDirPath() + "/.bookmarks" ) )
+	return;
+
+    QFile f( QDir::currentDirPath() + "/.bookmarks" );
+    if ( !f.open( IO_ReadOnly ) )
+        return;
+    QDataStream s( &f );
+    s >> bookmarks;
+    f.close();
 }
 
 void HelpWindow::histChosen( int i )
 {
     if ( mHistory.contains( i ) )
   browser->setSource( mHistory[ i ] );
 }
 
 void HelpWindow::bookmChosen( int i )
 {
     if ( mBookmarks.contains( i ) )
   browser->setSource( mBookmarks[ i ] );
 }
 
 void HelpWindow::addBookmark()
 {
     mBookmarks[ bookm->insertItem( caption() ) ] = caption();
 }
 
diff --git a/noncore/graphics/opie-eye/slave/bmp_slave.cpp b/noncore/graphics/opie-eye/slave/bmp_slave.cpp
index 2fa825f..0efadac 100644
--- a/noncore/graphics/opie-eye/slave/bmp_slave.cpp
+++ b/noncore/graphics/opie-eye/slave/bmp_slave.cpp
@@ -1,175 +1,173 @@
 #include  "bmp_slave.h"
 
 #include "thumbnailtool.h"
 
 #include <qimage.h>
 #include <qobject.h>
 #include <qfile.h>
 #include <qpixmap.h>
 #include <qstring.h>
 
 PHUNK_VIEW_INTERFACE( "Bmp", BmpSlave );
 namespace {
 
     struct pBmpHeader {
         // file header of bmp
         char type[2]; // must be "BM" otherwise it is no bmp
         Q_INT32 hSize;
         Q_INT32 reserved1,reserved2;
 
         Q_INT16  Planes;
         Q_INT16  BitCount;
         Q_INT32  Size;
         Q_INT32  Width;
         Q_INT32  Height;
         Q_INT32  Compression;
         Q_INT32  SizeImage;
         Q_INT32  XPerMeter;
         Q_INT32  YPerMeter;
         Q_INT32  ClrUsed;
         Q_INT32  ClrImportant;
     };
 
     class BmpHeader {
     protected:
         void read_data();
         QString _name;
         QFile _inputfile;
         pBmpHeader m_Header;
 
         static const int OLD = 12;
         static const int WIN = 40;
         static const int OS2 = 64;
         static const int RGB = 0;
         static const int RLE8 = 1;
         static const int RLE4 = 2;
 
     public:
         BmpHeader(const QString&fname);
         virtual ~BmpHeader();
         bool isBmp()const{return qstrncmp(m_Header.type,"BM",2)==0;}
         bool isCompressed()const{return m_Header.Compression != 0;}
         QSize imageSize(){return QSize(m_Header.Width,m_Header.Height);}
         QString imageCompression()const;
         int bitsPixel()const{return m_Header.BitCount;}
         int Size()const{return m_Header.hSize;}
         int compressedSize()const{return m_Header.SizeImage;}
         int ColorsUsed()const{return m_Header.ClrUsed;}
         int XPix()const{return m_Header.XPerMeter;}
         int YPix()const{return m_Header.YPerMeter;}
     };
 
     QString BmpHeader::imageCompression()const
     {
         switch (m_Header.Compression) {
             case RLE8:
                 return "8Bit RLE Encoding";
                 break;
             case RLE4:
                 return "4Bit RLE Encoding";
                 break;
             case RGB:
             default:
                 return "No encoding";
         }
     }
 
     BmpHeader::BmpHeader(const QString&fname)
         : _name(fname),_inputfile(_name)
     {
         read_data();
     }
 
     void BmpHeader::read_data() {
         memset(&m_Header,0,sizeof(pBmpHeader));
-        _inputfile.open(IO_Raw|IO_ReadOnly);
-        if (!_inputfile.isOpen()) {
+        if (!_inputfile.open(IO_Raw|IO_ReadOnly))
             return;
-        }
         QDataStream s(&_inputfile);
         s.setByteOrder( QDataStream::LittleEndian );
         s.readRawBytes(m_Header.type,2);
         if (!isBmp()) {
             _inputfile.close();
             return;
         }
         s >> m_Header.hSize;
         s >> m_Header.reserved1 >> m_Header.reserved2;
         s >> m_Header.Size;
         if ( m_Header.Size == BmpHeader::WIN || m_Header.Size == BmpHeader::OS2 ) {
             s >> m_Header.Width >> m_Header.Height >> m_Header.Planes >> m_Header.BitCount;
             s >> m_Header.Compression >> m_Header.SizeImage;
             s >> m_Header.XPerMeter >> m_Header.YPerMeter;
             s >> m_Header.ClrUsed >> m_Header.ClrImportant;
         } else {
             Q_INT16 w, h;
             s >> w >> h >> m_Header.Planes >> m_Header.BitCount;
             m_Header.Width  = w;
             m_Header.Height = h;
             m_Header.Compression = BmpHeader::RGB;
             m_Header.SizeImage = 0;
             m_Header.XPerMeter = m_Header.YPerMeter = 0;
             m_Header.ClrUsed = m_Header.ClrImportant = 0;
         }
         _inputfile.close();
     }
 
     BmpHeader::~BmpHeader() {
     }
 }
 
 
 BmpSlave::BmpSlave()
     : SlaveInterface(QStringList("bmp"))
 {}
 
 BmpSlave::~BmpSlave() {
 
 }
 
 QString BmpSlave::iconViewName(const QString& str) {
     QString st;
     BmpHeader bh(str);
     if (!bh.isBmp()) {
         st.append("No bmp file");
         return st;
     }
     QSize isize = bh.imageSize();
     st+=QObject::tr("Dimensions: %1 x %2\n").arg(isize.width()).arg(isize.height());
     st+=QObject::tr("Size: %1\n").arg(bh.Size());
     st+=QObject::tr("Depth: %1\n").arg(bh.bitsPixel());
     return st;
 }
 
 QString BmpSlave::fullImageInfo( const QString& str) {
     QString st = "<qt>";
     BmpHeader bh(str);
     if (!bh.isBmp()) {
         st.append("No bmp file");
         st.append(  "</qt>" );
         return st;
     }
     QSize isize = bh.imageSize();
     st+=QObject::tr("Dimensions: %1 x %2\n").arg(isize.width()).arg(isize.height());
     st+=QObject::tr("Size: %1\n").arg(bh.Size());
     st+=QObject::tr("Compression: %1\n").arg(bh.imageCompression());
     if (bh.isCompressed()) {
         st+=QObject::tr("Compressed size: %1").arg(bh.compressedSize());
     }
     st+=QObject::tr("Depth: %1\n").arg(bh.bitsPixel());
     st+=QObject::tr("used colors: %1\n").arg(bh.ColorsUsed());
     st+=QObject::tr("Resolution: %1 x %2\n").arg(bh.XPix()).arg(bh.YPix());
     st.append(  "</qt>" );
     return st;
 }
 
 QPixmap BmpSlave::pixmap(const QString& path, int width, int height ) {
     static QImage img;
     img.load( path );
     if ( img.isNull() ) {
         QPixmap pix;
         return pix;
     }
 
     return ThumbNailTool::scaleImage( img, width,height );
 }
diff --git a/noncore/net/ftplib/ftplib.c b/noncore/net/ftplib/ftplib.c
index 421f855..efcd6f0 100644
--- a/noncore/net/ftplib/ftplib.c
+++ b/noncore/net/ftplib/ftplib.c
@@ -769,578 +769,582 @@ static int FtpOpenPort(netbuf *nControl, netbuf **nData, int mode, int dir)
 }
 
 /*
  * 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;
 
     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
       {
-          socket_wait(nData);
+          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))
         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;
-    FtpSendCmd("QUIT",'2',nControl);
+    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/todayplugins/stockticker/stockticker/helpwindow.cpp b/noncore/todayplugins/stockticker/stockticker/helpwindow.cpp
index 410d642..2498bf9 100644
--- a/noncore/todayplugins/stockticker/stockticker/helpwindow.cpp
+++ b/noncore/todayplugins/stockticker/stockticker/helpwindow.cpp
@@ -1,271 +1,275 @@
 /****************************************************************************
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of an example program for Qt.  This example
 ** program may be used, distributed and modified without limitation.
 **
 *****************************************************************************/
 
 #include "helpwindow.h"
 #include <qstatusbar.h>
 
 #include <qmenubar.h>
 #include <qtoolbar.h>
 #include <qtoolbutton.h>
 #include <qcombobox.h>
 
 #ifndef QT_NO_FILEDIALOG
 #include <qfiledialog.h>
 #endif
 
 #include <ctype.h>
 
 HelpWindow::HelpWindow( const QString& home_, const QString& _path, QWidget* parent, const char *name )
     : QMainWindow( parent, name, WDestructiveClose ), pathCombo( 0 ), selectedURL()
 {
     readHistory();
     readBookmarks();
 
     browser = new QTextBrowser( this );
     QStringList Strlist;
     Strlist.append( home_);
     
     browser->mimeSourceFactory()->setFilePath( Strlist );
 
     browser->setFrameStyle( QFrame::Panel | QFrame::Sunken );
 
     connect( browser, SIGNAL( textChanged() ),
 
              this, SLOT( textChanged() ) );
 
     setCentralWidget( browser );
 
     if ( !home_.isEmpty() )
 
 ////////////////////////////////
         browser->setSource( home_ );
 
 ////////////////////////////////
     connect( browser, SIGNAL( highlighted(const QString&) ),
        statusBar(), SLOT( message(const QString&)) );
 
     setGeometry( 0,0,236,280);
 
     QPopupMenu* file = new QPopupMenu( this );
 //    file->insertItem( tr("&New Window"), this, SLOT( newWindow() ), ALT | Key_N );
     file->insertItem( tr("&Open File"), this, SLOT( openFile() ), ALT | Key_O );
 //    file->insertItem( tr("&Print"), this, SLOT( print() ), ALT | Key_P );
     file->insertSeparator();
     file->insertItem( tr("&Close"), this, SLOT( close() ), ALT | Key_Q );
 //    file->insertItem( tr("E&xit"), qApp, SLOT( closeAllWindows() ), ALT | Key_X );
 
     // The same three icons are used twice each.
 ////F FIXME
     QString pixs=(QDir::homeDirPath ()) +"/Applications/gutenbrowser/pix/";
     QIconSet icon_back( QPixmap(pixs+"back.png") );
     QIconSet icon_forward( QPixmap(pixs+"forward.png") );
     QIconSet icon_home( QPixmap(pixs+"home.png") );
 
     QPopupMenu* go = new QPopupMenu( this );
     backwardId = go->insertItem( icon_back, tr("&Backward"), browser, SLOT( backward() ), ALT | Key_Left );
     forwardId = go->insertItem( icon_forward, tr("&Forward"), browser, SLOT( forward() ), ALT | Key_Right );
     go->insertItem( icon_home, tr("&Home"), browser, SLOT( home() ) );
 
 
     hist = new QPopupMenu( this );
     QStringList::Iterator it = history.begin();
     for ( ; it != history.end(); ++it )
     mHistory[ hist->insertItem( *it ) ] = *it;
     connect( hist, SIGNAL( activated(int) ), this, SLOT( histChosen(int) ) );
 
     bookm = new QPopupMenu( this );
     bookm->insertItem( tr( "Add Bookmark" ), this, SLOT( addBookmark() ) );
     bookm->insertSeparator();
 
     QStringList::Iterator it2 = bookmarks.begin();
     for ( ; it2 != bookmarks.end(); ++it2 )
    mBookmarks[ bookm->insertItem( *it2 ) ] = *it2;
     connect( bookm, SIGNAL( activated(int) ),
        this, SLOT( bookmChosen(int) ) );
 
     menuBar()->insertItem( tr("&File"), file );
     menuBar()->insertItem( tr("&Go"), go );
     menuBar()->insertItem( tr( "History" ), hist );
     menuBar()->insertItem( tr( "Bookmarks" ), bookm );
 //      menuBar()->insertSeparator();
 //      menuBar()->insertItem( tr("&Help"), help );
 
     menuBar()->setItemEnabled( forwardId, FALSE);
     menuBar()->setItemEnabled( backwardId, FALSE);
     connect( browser, SIGNAL( backwardAvailable(bool) ), this, SLOT( setBackwardAvailable(bool) ) );
     connect( browser, SIGNAL( forwardAvailable(bool) ), this, SLOT( setForwardAvailable(bool) ) );
 
 
     QToolBar* toolbar = new QToolBar( this );
     addToolBar( toolbar, "Toolbar");
     QToolButton* button;
 
     button = new QToolButton( icon_back, tr("Backward"), "", browser, SLOT(backward()), toolbar );
     connect( browser, SIGNAL( backwardAvailable(bool) ), button, SLOT( setEnabled(bool) ) );
     button->setEnabled( FALSE );
     button = new QToolButton( icon_forward, tr("Forward"), "", browser, SLOT(forward()), toolbar );
     connect( browser, SIGNAL( forwardAvailable(bool) ), button, SLOT( setEnabled(bool) ) );
     button->setEnabled( FALSE );
     button = new QToolButton( icon_home, tr("Home"), "", browser, SLOT(home()), toolbar );
 
     toolbar->addSeparator();
 
     pathCombo = new QComboBox( TRUE, toolbar );
     connect( pathCombo, SIGNAL( activated(const QString&) ), this, SLOT( pathSelected(const QString&) ) );
     toolbar->setStretchableWidget( pathCombo );
 
 //    pathCombo->setMaximumWidth(190);
 //     setRightJustification( TRUE );
 //      setDockEnabled( Left, FALSE );
 //      setDockEnabled( Right, FALSE );
 
     pathCombo->insertItem( home_ );
 
     browser->setFocus();
 
 
 }
 
 
 void HelpWindow::setBackwardAvailable( bool b)
 {
     menuBar()->setItemEnabled( backwardId, b);
 }
 
 void HelpWindow::setForwardAvailable( bool b)
 {
     menuBar()->setItemEnabled( forwardId, b);
 }
 
 
 void HelpWindow::textChanged()
 {
     if ( browser->documentTitle().isNull() ) {
   setCaption( "Stockticker Lookup - " + browser->context() );
   selectedURL = browser->context();
     }
     else {
   setCaption( "Stockticker Lookup - " + browser->documentTitle() ) ;
   selectedURL = browser->documentTitle();
     }
 
     if ( !selectedURL.isEmpty() && pathCombo ) {
   bool exists = FALSE;
   int i;
   for ( i = 0; i < pathCombo->count(); ++i ) {
       if ( pathCombo->text( i ) == selectedURL ) {
     exists = TRUE;
     break;
       }
   }
   if ( !exists ) {
       pathCombo->insertItem( selectedURL, 0 );
       pathCombo->setCurrentItem( 0 );
       mHistory[ hist->insertItem( selectedURL ) ] = selectedURL;
   } else
       pathCombo->setCurrentItem( i );
   selectedURL = QString::null;
     }
 }
 
 HelpWindow::~HelpWindow()
 {
     history.clear();
     QMap<int, QString>::Iterator it = mHistory.begin();
     for ( ; it != mHistory.end(); ++it )
-  history.append( *it );
+        history.append( *it );
 
     QFile f( QDir::currentDirPath() + "/.history" );
-    f.open( IO_WriteOnly );
-    QDataStream s( &f );
-    s << history;
-    f.close();
+    if ( f.open( IO_WriteOnly ) ) {
+        QDataStream s( &f );
+        s << history;
+        f.close();
+    }
 
     bookmarks.clear();
     QMap<int, QString>::Iterator it2 = mBookmarks.begin();
     for ( ; it2 != mBookmarks.end(); ++it2 )
-  bookmarks.append( *it2 );
+        bookmarks.append( *it2 );
 
     QFile f2( QDir::currentDirPath() + "/.bookmarks" );
-    f2.open( IO_WriteOnly );
+    if ( !f2.open( IO_WriteOnly ) )
+	return;
     QDataStream s2( &f2 );
     s2 << bookmarks;
     f2.close();
 }
 
 void HelpWindow::openFile()
 {
 #ifndef QT_NO_FILEDIALOG
     QString fn = QFileDialog::getOpenFileName( QString::null, QString::null, this );
     if ( !fn.isEmpty() )
   browser->setSource( fn );
 #endif
 }
 
 void HelpWindow::newWindow()
 {
     ( new HelpWindow(browser->source(), "qbrowser") )->show();
 }
 
 void HelpWindow::pathSelected( const QString &_path )
 {
     browser->setSource( _path );
     QMap<int, QString>::Iterator it = mHistory.begin();
     bool exists = FALSE;
     for ( ; it != mHistory.end(); ++it ) {
   if ( *it == _path ) {
       exists = TRUE;
       break;
   }
     }
     if ( !exists )
   mHistory[ hist->insertItem( _path ) ] = _path;
 }
 
 void HelpWindow::readHistory()
 {
     if ( QFile::exists( QDir::currentDirPath() + "/.history" ) ) {
-  QFile f( QDir::currentDirPath() + "/.history" );
-  f.open( IO_ReadOnly );
-  QDataStream s( &f );
-  s >> history;
-  f.close();
-  while ( history.count() > 20 )
-      history.remove( history.begin() );
+        QFile f( QDir::currentDirPath() + "/.history" );
+        if ( !f.open( IO_ReadOnly ) )
+	    return;
+        QDataStream s( &f );
+        s >> history;
+        f.close();
+        while ( history.count() > 20 )
+            history.remove( history.begin() );
     }
 }
 
 void HelpWindow::readBookmarks()
 {
     if ( QFile::exists( QDir::currentDirPath() + "/.bookmarks" ) ) {
-  QFile f( QDir::currentDirPath() + "/.bookmarks" );
-  f.open( IO_ReadOnly );
-  QDataStream s( &f );
-  s >> bookmarks;
-  f.close();
+        QFile f( QDir::currentDirPath() + "/.bookmarks" );
+            if ( !f.open( IO_ReadOnly ) )
+                return;
+        QDataStream s( &f );
+        s >> bookmarks;
+        f.close();
     }
 }
 
 void HelpWindow::histChosen( int i )
 {
     if ( mHistory.contains( i ) )
   browser->setSource( mHistory[ i ] );
 }
 
 void HelpWindow::bookmChosen( int i )
 {
     if ( mBookmarks.contains( i ) )
   browser->setSource( mBookmarks[ i ] );
 }
 
 void HelpWindow::addBookmark()
 {
     mBookmarks[ bookm->insertItem( caption() ) ] = caption();
 }
 
diff --git a/noncore/todayplugins/weather/weatherpluginwidget.cpp b/noncore/todayplugins/weather/weatherpluginwidget.cpp
index fe54051..27624c5 100644
--- a/noncore/todayplugins/weather/weatherpluginwidget.cpp
+++ b/noncore/todayplugins/weather/weatherpluginwidget.cpp
@@ -1,320 +1,321 @@
 /*
                      This file is part of the OPIE Project
                =.
       .=l.            Copyright (c)  2002 Dan Williams <williamsdr@acm.org>
      .>+-=
 _;:,   .>  :=|.         This file is free software; you can
 .> <`_,  > .  <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.--  :           the terms of the GNU 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 file 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 General
 ..}^=.=    =    ;      Public License for more details.
 ++=  -.   .`   .:
 :   = ...= . :.=-        You should have received a copy of the GNU
 -.  .:....=;==+<;          General Public License along with this file;
  -_. . .  )=. =           see the file COPYING. If not, write to the
   --    :-=`           Free Software Foundation, Inc.,
                              59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <opie2/oprocess.h>
 
 #include <opie2/oresource.h>
 
 #include <qpe/config.h>
 
 #include <qfile.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpixmap.h>
 #include <qtextstream.h>
 
 #include "weatherpluginwidget.h"
 
 using namespace Opie::Core;
 WeatherPluginWidget::WeatherPluginWidget( QWidget *parent,  const char* name )
 	: QWidget( parent,  name )
 {
 	QHBoxLayout *layout = new QHBoxLayout( this, 1, 2 );
 	layout->setAutoAdd( true );
 
 	weatherIcon = new QLabel( this );
 	weatherIcon->setPixmap( Opie::Core::OResource::loadPixmap( "Clock", Opie::Core::OResource::SmallIcon ) );
 
 	weatherLabel = new QLabel( tr( "Retreiving current weather information." ), this );
 	weatherLabel->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred ) );
 
     weatherIcon->setFixedSize( weatherLabel->height(), weatherLabel->height() );
 
 	startTimer(1000);
 }
 
 WeatherPluginWidget::~WeatherPluginWidget()
 {
 	QFile file( localFile );
 	if ( file.exists() )
 	{
 		file.remove();
 	}
 }
 
 void WeatherPluginWidget::timerEvent( QTimerEvent *e )
 {
 	killTimer( e->timerId() );
 	retreiveData();
 }
 
 
 
 void WeatherPluginWidget::retreiveData()
 {
 	Config config( "todayweatherplugin");
 	config.setGroup( "Config" );
 
 	location = config.readEntry( "Location", "" );
 	useMetric = config.readBoolEntry( "Metric", true );
 	frequency = config.readNumEntry( "Frequency", 5 );
 
 	startTimer( frequency * 60000 );
 
 	localFile = "/tmp/";
 	localFile.append( location );
 	localFile.append( ".TXT" );
 
 	remoteFile = "http://weather.noaa.gov/pub/data/observations/metar/stations/";
 	remoteFile.append( location );
 	remoteFile.append( ".TXT" );
 
 	QFile file( localFile );
 	if ( file.exists() )
 	{
 		file.remove();
 	}
 
 	OProcess *proc = new OProcess;
 
 	*proc << "wget" << "-q" << remoteFile << "-O" << localFile;
 	connect( proc, SIGNAL( processExited(Opie::Core::OProcess*) ), this, SLOT( dataRetrieved(Opie::Core::OProcess*) ) );
-	proc->start();
+	if ( !proc->start() )
+	    weatherLabel->setText( tr( "Could not start wget process." ) );
 }
 
 void WeatherPluginWidget::displayWeather()
 {
 	weatherData = QString::null;
 
 	QFile file( localFile );
 
 	if ( file.size() > 0 && file.open( IO_ReadOnly ) )
 	{
 		QTextStream data( &file );
 		while ( !data.eof() )
 		{
 			weatherData.append( data.readLine() );
 		}
 		file.close();
 		weatherData = weatherData.simplifyWhiteSpace();
 
 		QString tmpstr;
 
 		tmpstr.append( tr( "Temp: " ) );
 		getTemp( weatherData );
 		tmpstr.append( dataStr );
 
 		tmpstr.append( tr( "  Wind: " ) );
 		getWind( weatherData );
 		tmpstr.append( dataStr );
 
 		tmpstr.append( tr( "\nPres: " ) );
 		getPressure( weatherData );
 		tmpstr.append( dataStr );
 
 		weatherLabel->setText( tmpstr );
 
 		tmpstr = "todayweatherplugin/";
 		getIcon( weatherData );
 		tmpstr.append( dataStr );
-        weatherIcon->setPixmap( Opie::Core::OResource::loadPixmap( tmpstr, Opie::Core::OResource::SmallIcon ) );
+        	weatherIcon->setPixmap( Opie::Core::OResource::loadPixmap( tmpstr, Opie::Core::OResource::SmallIcon ) );
 	}
 	else
 	{
 		weatherLabel->setText( tr( "Current weather data not available." ) );
 	}
 }
 
 void WeatherPluginWidget::getTemp( const QString &data )
 {
 	int value;
 	bool ok;
 
 	int pos = data.find( QRegExp( "M?[0-9]+/M?[0-9]+" ), 20 );
 	if ( pos > -1 )
 	{
 		if ( data.at( pos ) == 'M' )
 		{
 			value = -1 * data.mid( pos + 1, 2 ).toInt( &ok );
 		}
 		else
 		{
 			value = data.mid( pos, 2 ).toInt( &ok );
 		}
 		if ( useMetric )
 		{
 			dataStr = QString::number( value );
 			dataStr.append( 'C' );
 		}
 		else
 		{
 			dataStr = QString::number( ( value * 9 / 5 ) + 32 );
 			dataStr.append( 'F' );
 		}
 	}
 	else
 	{
 		dataStr = tr( "n/a" );
 	}
 }
 
 void WeatherPluginWidget::getWind( const QString &data )
 {
 	int value;
 	bool ok;
 
 	int pos = data.find( QRegExp( "[0-9]*G*[0-9]*KT" ), 20 );
 	if ( pos > -1 )
 	{
 		if ( data.mid( pos, 3 ) != "VRB" )
 		{
 			value = data.mid( pos, 3 ).toInt( &ok );
 			if ( ( value >= 0 && value < 23 ) || ( value >= 239 && value <= 360 ) )
 				dataStr = tr("E " );
 			else if ( value >= 23 && value < 69 )
 				dataStr = tr( "NE " );
 			else if ( value >= 69 && value < 113 )
 				dataStr = tr( "N " );
 			else if ( value >= 113 && value < 157 )
 				dataStr = tr( "NW " );
 			else if ( value >= 157 && value < 203 )
 				dataStr = tr( "W " );
 			else if ( value >= 203 && value < 248 )
 				dataStr = tr( "SW " );
 			else if ( value >= 248 && value < 294 )
 				dataStr = tr( "S " );
 			else if ( value >= 294 && value < 238 )
 				dataStr = tr( "SE " );
 		}
 		if ( data.mid( pos + 5, 1) == "G" ||
 			 data.mid( pos + 5, 1) == "K" )
 		{
 			value = data.mid( pos + 3, 2 ).toInt( &ok );
 		}
 		else
 		{
 			value = data.mid( pos + 3, 3 ).toInt( &ok );
 		}
 		if ( useMetric )
 		{
 			value = value * 3.6 / 1.94;
 			dataStr.append( QString::number( value ) );
 			dataStr.append( tr( " KPH" ) );
 		}
 		else
 		{
 			value = value * 2.24 / 1.94;
 			dataStr.append( QString::number( value ) );
 			dataStr.append( tr( " MPH" ) );
 		}
 	}
 	else
 	{
 		dataStr = tr( "n/a" );
 	}
 }
 
 void WeatherPluginWidget::getPressure( const QString &data )
 {
 	float value;
 	bool ok;
 
 	int pos = data.find( QRegExp( "[AQ][0-9]+" ), 20 );
 	if ( pos > -1 )
 	{
 		value = data.mid( pos + 1, 4 ).toFloat( &ok );
 		if ( useMetric )
 		{
 			if ( data.mid( pos, 1 ) == "A" )
 				value *= 33.8639 / 100;
 			dataStr = QString::number( value, 'f', 2 );
 			dataStr.append( tr( " kPa" ) );
 		}
 		else
 		{
 			if ( data.mid( pos, 1 ) == "Q" )
 				value /= 33.8639;
 			else
 				value /= 100;
 			dataStr = QString::number( value, 'f', 2 );
 			dataStr.append( tr( " Hg" ) );
 		}
 	}
 	else
 	{
 		dataStr = tr( "n/a" );
 	}
 }
 
 void WeatherPluginWidget::getIcon(const QString &data )
 {
 	dataStr = "psunny";
 	if ( data.find( "CLR ", 20  ) > -1 ||
 		 data.find( "SKC ", 20  ) > -1 ||
 		 data.find( "CAVOK ", 20  ) > -1 )
 	{
 		dataStr = "sunny";
 	}
 	else if ( data.find( "SH ", 20 ) > -1 ||
 			  data.find( "DZ ", 20 ) > -1 ||
 			  data.find( "RA ", 20 ) > -1 ||
 			  data.find( "UP ", 20 ) > -1 ||
 			  data.find( "BR ", 20 ) > -1 )
 	{
 		dataStr = "shower";
 	}
 	else if ( data.find( "TS ", 20 ) > -1 )
 	{
 		dataStr = "tstorm";
 	}
 	else if ( data.find( "SN ", 20 ) > -1 ||
 			  data.find( "SG ", 20 ) > -1 )
 	{
 		dataStr = "snow";
 	}
 	else if ( data.find( "FZ ", 20 ) > -1 ||
 			  data.find( "GR ", 20 ) > -1 ||
 			  data.find( "GS ", 20 ) > -1 ||
 			  data.find( "PE ", 20 ) > -1 ||
 			  data.find( "IC ", 20 ) > -1 )
 	{
 		dataStr = "sleet";
 	}
 }
 
 void WeatherPluginWidget::dataRetrieved( OProcess *process )
 {
 	if ( process->normalExit() )
 	{
 		displayWeather();
 	}
 	else
 	{
 		weatherLabel->setText( tr( "Current weather data not available." ) );
 	}
 }
diff --git a/noncore/tools/opie-sh/inputdialog.cpp b/noncore/tools/opie-sh/inputdialog.cpp
index 8046795..1dd8bf7 100644
--- a/noncore/tools/opie-sh/inputdialog.cpp
+++ b/noncore/tools/opie-sh/inputdialog.cpp
@@ -1,124 +1,128 @@
 /*
 Opie-sh.  convinience app to allow you to use qdialogs in scripts (mainly shell scripts)
 Copyright (C) 2002 Thomas Stephens
 
 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.
 
 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 General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "inputdialog.h"
 
 InputDialog::InputDialog(int w, int h, int newtype, QString labelString, QString title, QString filename, bool edit, QWidget *parent, const char *name, bool modal, WFlags f):QDialog(parent, name, modal, f)
 {
 	type = newtype;
 	QHBoxLayout *layout = new QHBoxLayout(this);
 	layout->addStrut(32);
 	QLabel *label = new QLabel(labelString, this, "label");
 	setCaption(title);
 	int x, y;
 
 	layout->addSpacing(5);
 	layout->addWidget(label);
 	layout->addSpacing(5);
 
 	switch(type)
 	{
 	case 0:
 		lineEdit = new QLineEdit(this, "line edit");
 		layout->addWidget(lineEdit);
 		break;
 	case 1:
 		comboBox = new QComboBox(edit, this, "combo box");
 		layout->addWidget(comboBox);
 		if(!filename.isNull())
 		{
 			QFile file(filename);
-			file.open(IO_ReadOnly);
-			QTextStream stream(&file);
-			QString string = stream.read();
+			if (file.open(IO_ReadOnly))
+			{
+				QTextStream stream(&file);
+				QString string = stream.read();
 
-			comboBox->insertStringList(QStringList::split('\n', string));
+				comboBox->insertStringList(QStringList::split('\n', string));
+			}
 		}
 		else
 		{
 			QFile file;
 			file.open(IO_ReadOnly, 0);
 			QTextStream stream(&file);
 			QString string = stream.read();
 
 			comboBox->insertStringList(QStringList::split('\n', string));
 		}
 		break;
 	case 2:
 		listBox = new QListBox(this, "list box");
 		listBox->setSelectionMode(QListBox::Multi);
 		layout->addWidget(listBox);
 		if(!filename.isNull())
 		{
 			QFile file(filename);
-			file.open(IO_ReadOnly);
-			QTextStream stream(&file);
-			QString string = stream.read();
+			if (file.open(IO_ReadOnly))
+			{
+				QTextStream stream(&file);
+				QString string = stream.read();
 
-			listBox->insertStringList(QStringList::split('\n', string));
+				listBox->insertStringList(QStringList::split('\n', string));
+			}
 		}
 		else
 		{
 			QFile file;
 			file.open(IO_ReadOnly, 0);
 			QTextStream stream(&file);
 			QString string = stream.read();
 
 			listBox->insertStringList(QStringList::split('\n', string));
 		}
 		break;
 	case 3:
 		lineEdit = new QLineEdit(this, "line edit");
 		lineEdit->setEchoMode(QLineEdit::Password);
 		layout->addWidget(lineEdit);
 		break;
 	}
 	layout->addSpacing(5);
 
 	x=(w/2)-(width()/2);
 	y=(h/2)-(height()/2);
 
 	move(x,y);
 }
 
 QString InputDialog::getString()
 {
 	switch (type)
 	{
 	case 0:
 	case 3:
 		return ((QLineEdit *)child("line edit"))->text();
 		break;
 	case 1:
 		return ((QComboBox *)child("combo box"))->currentText();
 		break;
 	case 2:
 		QString string;
 		int i;
 		for(i = 0; i < listBox->count(); i++)
 		{
 			if(listBox->isSelected(i))
 			{
 				string+=listBox->text(i)+'\n';
 			}
 		}
 		if(string[string.length()-1] == '\n')
 		{
 			string.truncate(string.length()-1);
 		}
 		return string;
 	}
 	return QString::null;
 }