- remove

  QString getCfPath();
  QString getSdPath();
  QString getMmcPath();

2 files changed, 0 insertions, 64 deletions

diff --git a/library/storage.cpp b/library/storage.cpp
index 657fb71..d98139b 100644
--- a/library/storage.cpp
+++ b/library/storage.cpp
@@ -221,245 +221,185 @@ void StorageInfo::update()
                 humanname = tr("Internal Storage") + " " + disk;
             else if ( disk.left(5) == "tmpfs" ) //ipaqs /mnt/ramfs
                 humanname = tr("Internal Memory");
             FileSystem *fs = new FileSystem( disk, *fsit, humanname, removable, opts );
             mFileSystems.append( fs );
         }
         emit disksChanged();
     }
     else
     {
         // just update them
         for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
             i.current()->update();
     }
 #endif
 }
 
 bool deviceTab( const char *device)
 {
     QString name = device;
     bool hasDevice=false;
 
 #ifdef Q_OS_MACX
     // Darwin (MacOS X)
     struct statfs** mntbufp;
     int count = 0;
     if ( ( count = getmntinfo( mntbufp, MNT_WAIT ) ) == 0 )
     {
         qWarning("deviceTab: Error in getmntinfo(): %s",strerror( errno ) );
         hasDevice = false;
     }
     for( int i = 0; i < count; i++ )
     {
         QString deviceName = mntbufp[i]->f_mntfromname;
         qDebug(deviceName);
         if( deviceName.left( name.length() ) == name )
             hasDevice = true;
     }
 #else
     // Linux
     struct mntent *me;
     FILE *mntfp = setmntent( "/etc/mtab", "r" );
     if ( mntfp )
     {
         while ( (me = getmntent( mntfp )) != 0 )
         {
             QString deviceName = me->mnt_fsname;
             //          qDebug(deviceName);
             if( deviceName.left(name.length()) == name)
             {
                 hasDevice = true;
             }
         }
     }
     endmntent( mntfp );
 #endif /* Q_OS_MACX */
 
 
     return hasDevice;
 }
 
 /*!
  * @fn static bool StorageInfo::hasCf()
  * @brief returns whether device has Cf mounted
  *
  */
 bool StorageInfo::hasCf()
 {
     return deviceTab("/dev/hd");
 }
 
 /*!
  * @fn static bool StorageInfo::hasSd()
  * @brief returns whether device has SD mounted
  *
  */
 bool StorageInfo::hasSd()
 {
     return deviceTab("/dev/mmcd");
 }
 
 /*!
  * @fn static bool StorageInfo::hasMmc()
  * @brief returns whether device has mmc mounted
  *
  */
 bool StorageInfo::hasMmc()
 {
     bool hasMmc=false;
     if( deviceTab("/dev/mmc/part"))
         hasMmc=true;
     if( deviceTab("/dev/mmcd"))
         hasMmc=true;
     return hasMmc;
 }
 
-/*!
-* @fn QString StorageInfo::getCfPath()
-* @brief returns the Mount-Path of Cf Card
-*
-*/
-QString StorageInfo::getCfPath()
-{
-    QString r = "";
-
-    for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
-    {
-        if ( (*i)->disk().left( 8 ) == "/dev/hda"  )
-        {
-            r = (*i)->path();
-            break;
-        }
-    }
-    return r;
-}
-
-/*!
-* @fn QString StorageInfo::getSdPath()
-* @brief returns the Mount-Path of Sd Card
-*
-*/
-QString StorageInfo::getSdPath()
-{
-    QString r = "";
-
-    for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
-    {
-        if ( (*i)->disk().left( 9 ) == "/dev/mmcd" )
-        {
-            r = (*i)->path();
-            break;
-        }
-    }
-    return r;
-}
-
-/*!
-* @fn QString StorageInfo::getMmcPath()
-* @brief returns the Mount-Path of Mmc Card
-*
-*/
-QString StorageInfo::getMmcPath()
-{
-    QString r = "";
-
-    for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
-    {
-        if ( (*i)->disk().left( 14 ) == "/dev/mmc/part1" )
-        {
-            r = (*i)->path();
-            break;
-        }
-    }
-    return r;
-}
-
 /*! \fn const QList<FileSystem> &StorageInfo::fileSystems() const
   Returns a list of all available mounted file systems.
 
   \warning This may change in Qtopia 3.x to return only relevant Qtopia file systems (and ignore mount points such as /tmp)
 */
 
 /*! \fn void StorageInfo::disksChanged()
   Gets emitted when a disk has been mounted or unmounted, such as when
   a CF c
 */
 //---------------------------------------------------------------------------
 
 FileSystem::FileSystem( const QString &disk, const QString &path, const QString &name, bool rem, const QString &o )
         : fsdisk( disk ), fspath( path ), humanname( name ), blkSize(512), totalBlks(0), availBlks(0), removable( rem ), opts( o )
 {
     update();
 }
 
 void FileSystem::update()
 {
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
     struct statfs fs;
     if ( !statfs( fspath.latin1(), &fs ) )
     {
         blkSize = fs.f_bsize;
         totalBlks = fs.f_blocks;
         availBlks = fs.f_bavail;
     }
     else
     {
         blkSize = 0;
         totalBlks = 0;
         availBlks = 0;
     }
 #endif
 }
 
 /*! \class FileSystem storage.h
   \brief The FileSystem class describes a single mount point.
  
   This class simply returns information about a mount point, including
   file system name, mount point, human readable name, size information
   and mount options information.
   \ingroup qtopiaemb
  
   \sa StorageInfo
 */
 
 /*! \fn const QString &FileSystem::disk() const
   Returns the file system name, such as /dev/hda3
 */
 
 /*! \fn const QString &FileSystem::path() const
   Returns the mount path, such as /home
 */
 
 /*! \fn const QString &FileSystem::name() const
   Returns the translated, human readable name for the mount directory.
 */
 
 /*! \fn const QString &FileSystem::options() const
   Returns the mount options
 */
 
 /*! \fn long FileSystem::blockSize() const
   Returns the size of each block on the file system.
 */
 
 /*! \fn long FileSystem::totalBlocks() const
   Returns the total number of blocks on the file system
 */
 
 /*! \fn long FileSystem::availBlocks() const
   Returns the number of available blocks on the file system
  */
 
 /*! \fn bool FileSystem::isRemovable() const
   Returns flag whether the file system can be removed, such as a CF card
   would be removable, but the internal memory wouldn't
 */
 
 /*! \fn bool FileSystem::isWritable() const
   Returns flag whether the file system is mounted as writable or read-only.
   Returns FALSE if read-only, TRUE if read and write.
 */
 
 /*! \fn QStringList StorageInfo::fileSystemNames() const
   Returns a list of filesystem names.
 */
diff --git a/library/storage.h b/library/storage.h
index 35a1109..4c29288 100644
--- a/library/storage.h
+++ b/library/storage.h
@@ -1,86 +1,82 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef __storage_h__
 #define __storage_h__
 
 #include <qobject.h>
 #include <qlist.h>
 
 class FileSystem;
 class QCopChannel;
 
 class StorageInfo : public QObject
 {
     Q_OBJECT
 public:
     StorageInfo( QObject *parent=0 );
 
     const QList<FileSystem> &fileSystems() const { return mFileSystems; }
     const FileSystem *fileSystemOf( const QString &filename );
     static bool hasCf();
     static bool hasSd();
     static bool hasMmc();
-
-    QString getCfPath();
-    QString getSdPath();
-    QString getMmcPath();
 signals:
     void disksChanged();
 
 public slots:
     void update();
 
 private slots:
     void cardMessage( const QCString& msg, const QByteArray& data );
 private:
     QList<FileSystem> mFileSystems;
     QCopChannel *channel;
 };
 
 class FileSystem
 {
 public:
     const QString &disk() const { return fsdisk; }
     const QString &path() const { return fspath; }
     const QString &name() const { return humanname; }
     const QString &options() const { return opts; }
     long blockSize() const { return blkSize; }
     long totalBlocks() const { return totalBlks; }
     long availBlocks() const { return availBlks; }
     bool isRemovable() const { return removable; }
     bool isWritable() const { return opts.contains("rw"); }
 
 private:
     friend class StorageInfo;
     FileSystem( const QString &disk, const QString &path, const QString &humanname, bool rem, const QString &opts );
     void update();
 
     QString fsdisk;
     QString fspath;
     QString humanname;
     long blkSize;
     long totalBlks;
     long availBlks;
     bool removable;
     QString opts;
 };
 
 
 #endif