1 files changed, 1 insertions, 3 deletions

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 );
 }